400 Error, on transport polling. Cannot connect on transport websocket while using dev server

[BKOHelix]

Nuxt: 3.11.2
Nitro: 2.9.6

my entry.dev.ts preset file

import "#internal/nitro/virtual/polyfill";
import { Server as SocketServer } from "socket.io";
import { Server } from "node:http";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { mkdirSync } from "node:fs";
import { threadId, parentPort } from "node:worker_threads";
import { isWindows, provider } from "std-env";
import { toNodeListener } from "h3";
import { trapUnhandledNodeErrors } from "#internal/nitro/utils";
import { consola } from "consola";
import socketHandler from "~/server/sockets/handler";
import discordHandler from "~/server/discord/handler";

const nitroApp = useNitroApp();
const server = new Server(toNodeListener(nitroApp.h3App));

const getAddress = () => {
  if (provider === "stackblitz" || process.env.NITRO_NO_UNIX_SOCKET || process.versions.bun) {
    return 0;
  }

  const socketName = `worker-${process.pid}-${threadId}.sock`;
  if (isWindows) {
    return join("\\\\.\\pipe\\nitro", socketName);
  } else {
    const socketDir = join(tmpdir(), "nitro");
    mkdirSync(socketDir, { recursive: true });
    return join(socketDir, socketName);
  }
};

const listenAddress = getAddress();
const listener = server.listen(listenAddress, () => {
  const _address = server.address()!;
  parentPort?.postMessage({
    event: "listen",
    address: typeof _address === "string" ? { socketPath: _address } : { host: "localhost", port: _address.port },
  });
  consola.success(`Launching server...`);
});

/**
 * SETUP SOCKET IO HANDLER/SERVER
 */

const io = new SocketServer(server, {
  cors: { origin: ["*"] },
  transports: ["polling"],
});

socketHandler(io);

nitroApp.hooks.hook("request", (event) => {
  event["_socket"] = io;
});

trapUnhandledNodeErrors();

/**
 * SETUP DISCORD HANDLER
 */
discordHandler();

/**
 * SETUP GRACEFUL SHUTDOWN
 */
const onShutdown = async (signal?: NodeJS.Signals) => {
  await nitroApp.hooks.callHook("close");
};

parentPort?.on("message", async (msg) => {
  if (msg && msg.event === "shutdown") {
    await onShutdown();
    parentPort?.postMessage({ event: "exit" });
  }
});

when I'm using transport I get a 400 error, when I try using web sockets, I get an error saying I can't connect.

I am using custom middleware:

import { Session, User, verifyRequestOrigin } from "lucia";
import { lucia } from "~/lucia";

declare module "h3" {
  interface H3EventContext {
    user: User | null;
    session: Session | null;
  }
}

export default defineEventHandler(async (event) => {
  if (event.method !== "GET") {
    const originHeader = getHeader(event, "Origin") ?? null;
    const hostHeader = getHeader(event, "Host") ?? null;
    if (!originHeader || !hostHeader || !verifyRequestOrigin(originHeader, [hostHeader])) {
      return event.node.res.writeHead(403).end();
    }
  }

  const sessionId = getCookie(event, lucia.sessionCookieName) ?? null;

  if (!sessionId) {
    event.context.session = null;
    event.context.user = null;
    return;
  }

  const { session, user } = await lucia.validateSession(sessionId);

  if (session && session.fresh) {
    appendHeader(event, "Set-Cookie", lucia.createSessionCookie(session.id).serialize());
  }

  if (!session) {
    appendHeader(event, "Set-Cookie", lucia.createBlankSessionCookie().serialize());
  }

  event.context.session = session;
  event.context.user = user;
});

Not sure if that might be messing with the socket connection (it shouldn't).