It's starting to work

6 files changed, 89 insertions, 49 deletions

diff --git a/src/bun.js/bindings/bindings.zig b/src/bun.js/bindings/bindings.zig
index 7fdb8db95..c28bb01ee 100644
--- a/src/bun.js/bindings/bindings.zig
+++ b/src/bun.js/bindings/bindings.zig
@@ -2793,7 +2793,7 @@ pub const JSGlobalObject = extern struct {
     pub fn queueMicrotask(
         this: *JSGlobalObject,
         function: JSValue,
-        args: []JSC.JSValue,
+        args: []const JSC.JSValue,
     ) void {
         this.queueMicrotaskJob(
             function,
diff --git a/src/bun.js/bindings/structure.cpp b/src/bun.js/bindings/structure.cpp
index 82358abf8..83f5ea767 100644
--- a/src/bun.js/bindings/structure.cpp
+++ b/src/bun.js/bindings/structure.cpp
@@ -10,10 +10,10 @@ using namespace JSC;
 extern "C" EncodedJSValue JSC__createStructure(JSC::JSGlobalObject* globalObject, unsigned int inlineCapacity, BunString* names)
 {
     auto& vm = globalObject->vm();
-    JSC::Structure* structure = globalObject->structureCache().emptyObjectStructureConcurrently(globalObject->objectPrototype(), inlineCapacity);
+    Structure* structure = globalObject->structureCache().emptyObjectStructureForPrototype(globalObject, globalObject->objectPrototype(), inlineCapacity);
     PropertyOffset offset = 0;
     for (unsigned i = 0; i < inlineCapacity; i++) {
-        const Identifier& ident = JSC::Identifier::fromString(vm, Bun::toWTFString(names[i]));
+        Identifier ident = JSC::Identifier::fromString(vm, Bun::toWTFString(names[i]));
         structure = structure->addPropertyTransition(vm, structure, JSC::PropertyName(ident), 0, offset);
     }
 
diff --git a/src/deps/uws.zig b/src/deps/uws.zig
index a16d677d1..a479cc283 100644
--- a/src/deps/uws.zig
+++ b/src/deps/uws.zig
@@ -677,6 +677,13 @@ pub const AnySocket = union(enum) {
     SocketTCP: SocketTCP,
     SocketTLS: SocketTLS,
 
+    pub fn setTimeout(this: AnySocket, seconds: c_uint) void {
+        switch (this) {
+            .SocketTCP => this.SocketTCP.setTimeout(seconds),
+            .SocketTLS => this.SocketTLS.setTimeout(seconds),
+        }
+    }
+
     pub fn shutdown(this: AnySocket) void {
         debug("us_socket_shutdown({d})", .{@intFromPtr(this.socket())});
         return us_socket_shutdown(
diff --git a/src/js/bun/sql.ts b/src/js/bun/sql.ts
index f142162f4..9844d7529 100644
--- a/src/js/bun/sql.ts
+++ b/src/js/bun/sql.ts
@@ -126,7 +126,10 @@ class Query extends PublicPromise {
 }
 Object.defineProperty(Query, Symbol.species, { value: PublicPromise });
 Object.defineProperty(Query, Symbol.toStringTag, { value: "Query" });
-init(Query.prototype.resolve, Query.prototype.reject);
+init(
+  (query, result) => query.resolve(result),
+  (query, reject) => query.reject(reject),
+);
 
 function createConnection({ hostname, port, username, password, tls, query, database }, onConnected, onClose) {
   return new PostgresSQLConnection(
@@ -263,7 +266,7 @@ function SQL(o) {
   }
 
   function connectedSQL(strings, values) {
-    return new Query(createQuery(normalizeStrings(strings), values), closedConnectionHandler);
+    return new Query(createQuery(normalizeStrings(strings), values), connectedHandler);
   }
 
   function closedSQL(strings, values) {
diff --git a/src/js/out/InternalModuleRegistryConstants.h b/src/js/out/InternalModuleRegistryConstants.h
index 119beaef5..1ce2a4482 100644
--- a/src/js/out/InternalModuleRegistryConstants.h
+++ b/src/js/out/InternalModuleRegistryConstants.h
@@ -10,7 +10,7 @@ static constexpr ASCIILiteral BunFFICode = "(function (){\"use strict\";// src/j
 //
 
 //
-static constexpr ASCIILiteral BunSqlCode = "(function (){\"use strict\";// src/js/out/tmp/bun/sql.ts\nvar createConnection = function({ hostname, port, username, password, tls, query, database }, onConnected, onClose) {\n  return new PostgresSQLConnection(hostname, Number(port), username || \"\", password || \"\", database || \"\", tls || null, query || \"\", onConnected, onClose);\n}, normalizeStrings = function(strings) {\n  if (@isJSArray(strings))\n    return strings.join(\"\?\");\n  return strings + \"\";\n}, loadOptions = function(o) {\n  var hostname, port, username, password, database, tls, url, query, adapter;\n  const env = Bun.env;\n  if (typeof o === \"undefined\" || typeof o === \"string\" && o.length === 0) {\n    const urlString = env.POSTGRES_URL || env.DATABASE_URL || env.PGURL || env.PG_URL;\n    if (urlString)\n      url = new URL(urlString), o = {};\n  } else if (o && typeof o === \"object\") {\n    if (o instanceof URL)\n      url = o;\n    else if (o\?.url) {\n      const _url = o.url;\n      if (typeof _url === \"string\")\n        url = new URL(_url);\n      else if (_url && typeof _url === \"object\" && _url instanceof URL)\n        url = _url;\n    }\n  } else if (typeof o === \"string\")\n    url = new URL(o);\n  if (url) {\n    if ({ hostname, port, username, password, protocol: adapter } = o = url, adapter[adapter.length - 1] === \":\")\n      adapter = adapter.slice(0, -1);\n    const queryObject = url.searchParams.toJSON();\n    query = \"\";\n    for (let key in queryObject)\n      query += `${encodeURIComponent(key)}=${encodeURIComponent(queryObject[key])} `;\n    query = query.trim();\n  }\n  if (!o)\n    o = {};\n  if (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\", database ||= o.database || o.db || (url\?.pathname \?\? \"\").slice(1) || env.PGDATABASE || username, password ||= o.password || o.pass || env.PGPASSWORD || \"\", tls ||= o.tls || o.ssl, adapter ||= o.adapter || \"postgres\", port = Number(port), !Number.isSafeInteger(port) || port < 1 || port > 65535)\n    throw new Error(`Invalid port: ${port}`);\n  if (adapter && !(adapter === \"postgres\" || adapter === \"postgresql\"))\n    throw new Error(`Unsupported adapter: ${adapter}. Only \\\"postgres\\\" is supported for now`);\n  return { hostname, port, username, password, database, tls, query };\n}, SQL = function(o) {\n  var connection, connected = !1, connecting = !1, closed = !1, onConnect = [], connectionInfo = loadOptions(o);\n  function connectedHandler(query, handle, err) {\n    if (err)\n      return query.reject(err);\n    if (!connected)\n      return query.reject(new Error(\"Not connected\"));\n    if (query.cancelled)\n      return query.reject(new Error(\"Query cancelled\"));\n    handle.run(connection, query);\n  }\n  function pendingConnectionHandler(query, handle) {\n    if (onConnect.push((err) => connectedHandler(query, handle, err)), !connecting)\n      connecting = !0, connection = createConnection(connectionInfo, onConnected, onClose);\n  }\n  function closedConnectionHandler(query, handle) {\n    query.reject(new Error(\"Connection closed\"));\n  }\n  function onConnected(err) {\n    connected = !err;\n    for (let handler of onConnect)\n      handler(err);\n    onConnect = [];\n  }\n  function onClose(err) {\n    closed = !0, onConnected(err);\n  }\n  function connectedSQL(strings, values) {\n    return new Query(createQuery(normalizeStrings(strings), values), closedConnectionHandler);\n  }\n  function closedSQL(strings, values) {\n    return new Query(@undefined, closedConnectionHandler);\n  }\n  function pendingSQL(strings, values) {\n    return new Query(createQuery(normalizeStrings(strings), values), pendingConnectionHandler);\n  }\n  function sql(strings, ...values) {\n    if (closed)\n      return closedSQL(strings, values);\n    if (connected)\n      return connectedSQL(strings, values);\n    return pendingSQL(strings, values);\n  }\n  return sql.connect = () => {\n    if (closed)\n      return @Promise.reject(new Error(\"Connection closed\"));\n    if (connected)\n      return @Promise.resolve(sql);\n    var { resolve, reject, promise } = @Promise.withResolvers();\n    if (onConnect.push((err) => err \? reject(err) : resolve(sql)), !connecting)\n      connecting = !0, connection = createConnection(connectionInfo, onConnected, onClose);\n    return promise;\n  }, sql.close = () => {\n    if (closed)\n      return @Promise.resolve();\n    var { resolve, promise } = @Promise.withResolvers();\n    return onConnect.push(resolve), connection.close(), promise;\n  }, sql.flush = () => {\n    if (closed || !connected)\n      return;\n    connection.flush();\n  }, sql;\n}, queryStatus_active = 1 << 1, queryStatus_cancelled = 1 << 2, queryStatus_error = 1 << 3, queryStatus_executed = 1 << 4;\nvar _resolve = Symbol(\"resolve\"), _reject = Symbol(\"reject\"), _handle = Symbol(\"handle\"), _run = Symbol(\"run\"), _queryStatus = Symbol(\"status\"), _handler = Symbol(\"handler\"), PublicPromise = @Promise, { createQuery, PostgresSQLConnection, init } = @lazy(\"bun:sql\");\n\nclass Query extends PublicPromise {\n  [_resolve];\n  [_reject];\n  [_handle];\n  [_handler];\n  [_queryStatus] = 0;\n  constructor(handle, handler) {\n    var resolve_, reject_;\n    super((resolve, reject) => {\n      resolve_ = resolve, reject_ = reject;\n    });\n    this[_resolve] = resolve_, this[_reject] = reject_, this[_handle] = handle, this[_handler] = handler, this[_queryStatus] = handle \? 0 : queryStatus_cancelled;\n  }\n  async[_run]() {\n    const { [_handle]: handle, [_handler]: handler, [_queryStatus]: status } = this;\n    if (status & (queryStatus_executed | queryStatus_cancelled))\n      return;\n    return this[_queryStatus] |= queryStatus_executed, await 1, handler(this, handle);\n  }\n  get active() {\n    return (this[_queryStatus] & queryStatus_active) !== 0;\n  }\n  set active(value) {\n    if (this[_queryStatus] & (queryStatus_cancelled | queryStatus_error))\n      return;\n    if (value)\n      this[_queryStatus] |= queryStatus_active;\n    else\n      this[_queryStatus] &= ~queryStatus_active;\n  }\n  get cancelled() {\n    return (this[_queryStatus] & queryStatus_cancelled) !== 0;\n  }\n  resolve(x) {\n    return this[_queryStatus] &= ~queryStatus_active, this[_resolve](x);\n  }\n  reject(x) {\n    return this[_queryStatus] &= ~queryStatus_active, this[_queryStatus] |= queryStatus_error, this[_reject](x);\n  }\n  cancel() {\n    var status = this[_queryStatus];\n    if (status & queryStatus_cancelled)\n      return this;\n    if (this[_queryStatus] |= queryStatus_cancelled, status & queryStatus_executed)\n      this[_handle].cancel();\n    return this;\n  }\n  execute() {\n    return this[_run](), this;\n  }\n  raw() {\n    return this[_handle].raw = 2, this;\n  }\n  values() {\n    return this[_handle].raw = 1, this;\n  }\n  then() {\n    return this[_run](), super.@then.@apply(this, arguments);\n  }\n  catch() {\n    return this[_run](), super.@catch.@apply(this, arguments);\n  }\n  finally() {\n    return this[_run](), super.@finally.@apply(this, arguments);\n  }\n}\nObject.defineProperty(Query, Symbol.species, { value: PublicPromise });\nObject.defineProperty(Query, Symbol.toStringTag, { value: \"Query\" });\ninit(Query.prototype.resolve, Query.prototype.reject);\nvar lazyDefaultSQL, defaultSQLObject = function sql(strings, ...values) {\n  if (!lazyDefaultSQL)\n    lazyDefaultSQL = SQL(@undefined), Object.assign(defaultSQLObject, lazyDefaultSQL), exportsObject.default = exportsObject.sql = lazyDefaultSQL;\n  return lazyDefaultSQL(strings, ...values);\n}, exportsObject = {\n  sql: defaultSQLObject,\n  default: defaultSQLObject,\n  SQL,\n  Query\n};\nreturn exportsObject})\n"_s;
+static constexpr ASCIILiteral BunSqlCode = "(function (){\"use strict\";// src/js/out/tmp/bun/sql.ts\nvar createConnection = function({ hostname, port, username, password, tls, query, database }, onConnected, onClose) {\n  return new PostgresSQLConnection(hostname, Number(port), username || \"\", password || \"\", database || \"\", tls || null, query || \"\", onConnected, onClose);\n}, normalizeStrings = function(strings) {\n  if (@isJSArray(strings))\n    return strings.join(\"\?\");\n  return strings + \"\";\n}, loadOptions = function(o) {\n  var hostname, port, username, password, database, tls, url, query, adapter;\n  const env = Bun.env;\n  if (typeof o === \"undefined\" || typeof o === \"string\" && o.length === 0) {\n    const urlString = env.POSTGRES_URL || env.DATABASE_URL || env.PGURL || env.PG_URL;\n    if (urlString)\n      url = new URL(urlString), o = {};\n  } else if (o && typeof o === \"object\") {\n    if (o instanceof URL)\n      url = o;\n    else if (o\?.url) {\n      const _url = o.url;\n      if (typeof _url === \"string\")\n        url = new URL(_url);\n      else if (_url && typeof _url === \"object\" && _url instanceof URL)\n        url = _url;\n    }\n  } else if (typeof o === \"string\")\n    url = new URL(o);\n  if (url) {\n    if ({ hostname, port, username, password, protocol: adapter } = o = url, adapter[adapter.length - 1] === \":\")\n      adapter = adapter.slice(0, -1);\n    const queryObject = url.searchParams.toJSON();\n    query = \"\";\n    for (let key in queryObject)\n      query += `${encodeURIComponent(key)}=${encodeURIComponent(queryObject[key])} `;\n    query = query.trim();\n  }\n  if (!o)\n    o = {};\n  if (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\", database ||= o.database || o.db || (url\?.pathname \?\? \"\").slice(1) || env.PGDATABASE || username, password ||= o.password || o.pass || env.PGPASSWORD || \"\", tls ||= o.tls || o.ssl, adapter ||= o.adapter || \"postgres\", port = Number(port), !Number.isSafeInteger(port) || port < 1 || port > 65535)\n    throw new Error(`Invalid port: ${port}`);\n  if (adapter && !(adapter === \"postgres\" || adapter === \"postgresql\"))\n    throw new Error(`Unsupported adapter: ${adapter}. Only \\\"postgres\\\" is supported for now`);\n  return { hostname, port, username, password, database, tls, query };\n}, SQL = function(o) {\n  var connection, connected = !1, connecting = !1, closed = !1, onConnect = [], connectionInfo = loadOptions(o);\n  function connectedHandler(query, handle, err) {\n    if (err)\n      return query.reject(err);\n    if (!connected)\n      return query.reject(new Error(\"Not connected\"));\n    if (query.cancelled)\n      return query.reject(new Error(\"Query cancelled\"));\n    handle.run(connection, query);\n  }\n  function pendingConnectionHandler(query, handle) {\n    if (onConnect.push((err) => connectedHandler(query, handle, err)), !connecting)\n      connecting = !0, connection = createConnection(connectionInfo, onConnected, onClose);\n  }\n  function closedConnectionHandler(query, handle) {\n    query.reject(new Error(\"Connection closed\"));\n  }\n  function onConnected(err) {\n    connected = !err;\n    for (let handler of onConnect)\n      handler(err);\n    onConnect = [];\n  }\n  function onClose(err) {\n    closed = !0, onConnected(err);\n  }\n  function connectedSQL(strings, values) {\n    return new Query(createQuery(normalizeStrings(strings), values), connectedHandler);\n  }\n  function closedSQL(strings, values) {\n    return new Query(@undefined, closedConnectionHandler);\n  }\n  function pendingSQL(strings, values) {\n    return new Query(createQuery(normalizeStrings(strings), values), pendingConnectionHandler);\n  }\n  function sql(strings, ...values) {\n    if (closed)\n      return closedSQL(strings, values);\n    if (connected)\n      return connectedSQL(strings, values);\n    return pendingSQL(strings, values);\n  }\n  return sql.connect = () => {\n    if (closed)\n      return @Promise.reject(new Error(\"Connection closed\"));\n    if (connected)\n      return @Promise.resolve(sql);\n    var { resolve, reject, promise } = @Promise.withResolvers();\n    if (onConnect.push((err) => err \? reject(err) : resolve(sql)), !connecting)\n      connecting = !0, connection = createConnection(connectionInfo, onConnected, onClose);\n    return promise;\n  }, sql.close = () => {\n    if (closed)\n      return @Promise.resolve();\n    var { resolve, promise } = @Promise.withResolvers();\n    return onConnect.push(resolve), connection.close(), promise;\n  }, sql.flush = () => {\n    if (closed || !connected)\n      return;\n    connection.flush();\n  }, sql;\n}, queryStatus_active = 1 << 1, queryStatus_cancelled = 1 << 2, queryStatus_error = 1 << 3, queryStatus_executed = 1 << 4;\nvar _resolve = Symbol(\"resolve\"), _reject = Symbol(\"reject\"), _handle = Symbol(\"handle\"), _run = Symbol(\"run\"), _queryStatus = Symbol(\"status\"), _handler = Symbol(\"handler\"), PublicPromise = @Promise, { createQuery, PostgresSQLConnection, init } = @lazy(\"bun:sql\");\n\nclass Query extends PublicPromise {\n  [_resolve];\n  [_reject];\n  [_handle];\n  [_handler];\n  [_queryStatus] = 0;\n  constructor(handle, handler) {\n    var resolve_, reject_;\n    super((resolve, reject) => {\n      resolve_ = resolve, reject_ = reject;\n    });\n    this[_resolve] = resolve_, this[_reject] = reject_, this[_handle] = handle, this[_handler] = handler, this[_queryStatus] = handle \? 0 : queryStatus_cancelled;\n  }\n  async[_run]() {\n    const { [_handle]: handle, [_handler]: handler, [_queryStatus]: status } = this;\n    if (status & (queryStatus_executed | queryStatus_cancelled))\n      return;\n    return this[_queryStatus] |= queryStatus_executed, await 1, handler(this, handle);\n  }\n  get active() {\n    return (this[_queryStatus] & queryStatus_active) !== 0;\n  }\n  set active(value) {\n    if (this[_queryStatus] & (queryStatus_cancelled | queryStatus_error))\n      return;\n    if (value)\n      this[_queryStatus] |= queryStatus_active;\n    else\n      this[_queryStatus] &= ~queryStatus_active;\n  }\n  get cancelled() {\n    return (this[_queryStatus] & queryStatus_cancelled) !== 0;\n  }\n  resolve(x) {\n    return this[_queryStatus] &= ~queryStatus_active, this[_resolve](x);\n  }\n  reject(x) {\n    return this[_queryStatus] &= ~queryStatus_active, this[_queryStatus] |= queryStatus_error, this[_reject](x);\n  }\n  cancel() {\n    var status = this[_queryStatus];\n    if (status & queryStatus_cancelled)\n      return this;\n    if (this[_queryStatus] |= queryStatus_cancelled, status & queryStatus_executed)\n      this[_handle].cancel();\n    return this;\n  }\n  execute() {\n    return this[_run](), this;\n  }\n  raw() {\n    return this[_handle].raw = 2, this;\n  }\n  values() {\n    return this[_handle].raw = 1, this;\n  }\n  then() {\n    return this[_run](), super.@then.@apply(this, arguments);\n  }\n  catch() {\n    return this[_run](), super.@catch.@apply(this, arguments);\n  }\n  finally() {\n    return this[_run](), super.@finally.@apply(this, arguments);\n  }\n}\nObject.defineProperty(Query, Symbol.species, { value: PublicPromise });\nObject.defineProperty(Query, Symbol.toStringTag, { value: \"Query\" });\ninit((query, result) => query.resolve(result), (query, reject) => query.reject(reject));\nvar lazyDefaultSQL, defaultSQLObject = function sql(strings, ...values) {\n  if (!lazyDefaultSQL)\n    lazyDefaultSQL = SQL(@undefined), Object.assign(defaultSQLObject, lazyDefaultSQL), exportsObject.default = exportsObject.sql = lazyDefaultSQL;\n  return lazyDefaultSQL(strings, ...values);\n}, exportsObject = {\n  sql: defaultSQLObject,\n  default: defaultSQLObject,\n  SQL,\n  Query\n};\nreturn exportsObject})\n"_s;
 //
 
 //
@@ -263,7 +263,7 @@ static constexpr ASCIILiteral BunFFICode = "(function (){\"use strict\";// src/j
 //
 
 //
-static constexpr ASCIILiteral BunSqlCode = "(function (){\"use strict\";// src/js/out/tmp/bun/sql.ts\nvar createConnection = function({ hostname, port, username, password, tls, query, database }, onConnected, onClose) {\n  return new PostgresSQLConnection(hostname, Number(port), username || \"\", password || \"\", database || \"\", tls || null, query || \"\", onConnected, onClose);\n}, normalizeStrings = function(strings) {\n  if (@isJSArray(strings))\n    return strings.join(\"\?\");\n  return strings + \"\";\n}, loadOptions = function(o) {\n  var hostname, port, username, password, database, tls, url, query, adapter;\n  const env = Bun.env;\n  if (typeof o === \"undefined\" || typeof o === \"string\" && o.length === 0) {\n    const urlString = env.POSTGRES_URL || env.DATABASE_URL || env.PGURL || env.PG_URL;\n    if (urlString)\n      url = new URL(urlString), o = {};\n  } else if (o && typeof o === \"object\") {\n    if (o instanceof URL)\n      url = o;\n    else if (o\?.url) {\n      const _url = o.url;\n      if (typeof _url === \"string\")\n        url = new URL(_url);\n      else if (_url && typeof _url === \"object\" && _url instanceof URL)\n        url = _url;\n    }\n  } else if (typeof o === \"string\")\n    url = new URL(o);\n  if (url) {\n    if ({ hostname, port, username, password, protocol: adapter } = o = url, adapter[adapter.length - 1] === \":\")\n      adapter = adapter.slice(0, -1);\n    const queryObject = url.searchParams.toJSON();\n    query = \"\";\n    for (let key in queryObject)\n      query += `${encodeURIComponent(key)}=${encodeURIComponent(queryObject[key])} `;\n    query = query.trim();\n  }\n  if (!o)\n    o = {};\n  if (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\", database ||= o.database || o.db || (url\?.pathname \?\? \"\").slice(1) || env.PGDATABASE || username, password ||= o.password || o.pass || env.PGPASSWORD || \"\", tls ||= o.tls || o.ssl, adapter ||= o.adapter || \"postgres\", port = Number(port), !Number.isSafeInteger(port) || port < 1 || port > 65535)\n    throw new Error(`Invalid port: ${port}`);\n  if (adapter && !(adapter === \"postgres\" || adapter === \"postgresql\"))\n    throw new Error(`Unsupported adapter: ${adapter}. Only \\\"postgres\\\" is supported for now`);\n  return { hostname, port, username, password, database, tls, query };\n}, SQL = function(o) {\n  var connection, connected = !1, connecting = !1, closed = !1, onConnect = [], connectionInfo = loadOptions(o);\n  function connectedHandler(query, handle, err) {\n    if (err)\n      return query.reject(err);\n    if (!connected)\n      return query.reject(new Error(\"Not connected\"));\n    if (query.cancelled)\n      return query.reject(new Error(\"Query cancelled\"));\n    handle.run(connection, query);\n  }\n  function pendingConnectionHandler(query, handle) {\n    if (onConnect.push((err) => connectedHandler(query, handle, err)), !connecting)\n      connecting = !0, connection = createConnection(connectionInfo, onConnected, onClose);\n  }\n  function closedConnectionHandler(query, handle) {\n    query.reject(new Error(\"Connection closed\"));\n  }\n  function onConnected(err) {\n    connected = !err;\n    for (let handler of onConnect)\n      handler(err);\n    onConnect = [];\n  }\n  function onClose(err) {\n    closed = !0, onConnected(err);\n  }\n  function connectedSQL(strings, values) {\n    return new Query(createQuery(normalizeStrings(strings), values), closedConnectionHandler);\n  }\n  function closedSQL(strings, values) {\n    return new Query(@undefined, closedConnectionHandler);\n  }\n  function pendingSQL(strings, values) {\n    return new Query(createQuery(normalizeStrings(strings), values), pendingConnectionHandler);\n  }\n  function sql(strings, ...values) {\n    if (closed)\n      return closedSQL(strings, values);\n    if (connected)\n      return connectedSQL(strings, values);\n    return pendingSQL(strings, values);\n  }\n  return sql.connect = () => {\n    if (closed)\n      return @Promise.reject(new Error(\"Connection closed\"));\n    if (connected)\n      return @Promise.resolve(sql);\n    var { resolve, reject, promise } = @Promise.withResolvers();\n    if (onConnect.push((err) => err \? reject(err) : resolve(sql)), !connecting)\n      connecting = !0, connection = createConnection(connectionInfo, onConnected, onClose);\n    return promise;\n  }, sql.close = () => {\n    if (closed)\n      return @Promise.resolve();\n    var { resolve, promise } = @Promise.withResolvers();\n    return onConnect.push(resolve), connection.close(), promise;\n  }, sql.flush = () => {\n    if (closed || !connected)\n      return;\n    connection.flush();\n  }, sql;\n}, queryStatus_active = 1 << 1, queryStatus_cancelled = 1 << 2, queryStatus_error = 1 << 3, queryStatus_executed = 1 << 4;\nvar _resolve = Symbol(\"resolve\"), _reject = Symbol(\"reject\"), _handle = Symbol(\"handle\"), _run = Symbol(\"run\"), _queryStatus = Symbol(\"status\"), _handler = Symbol(\"handler\"), PublicPromise = @Promise, { createQuery, PostgresSQLConnection, init } = @lazy(\"bun:sql\");\n\nclass Query extends PublicPromise {\n  [_resolve];\n  [_reject];\n  [_handle];\n  [_handler];\n  [_queryStatus] = 0;\n  constructor(handle, handler) {\n    var resolve_, reject_;\n    super((resolve, reject) => {\n      resolve_ = resolve, reject_ = reject;\n    });\n    this[_resolve] = resolve_, this[_reject] = reject_, this[_handle] = handle, this[_handler] = handler, this[_queryStatus] = handle \? 0 : queryStatus_cancelled;\n  }\n  async[_run]() {\n    const { [_handle]: handle, [_handler]: handler, [_queryStatus]: status } = this;\n    if (status & (queryStatus_executed | queryStatus_cancelled))\n      return;\n    return this[_queryStatus] |= queryStatus_executed, await 1, handler(this, handle);\n  }\n  get active() {\n    return (this[_queryStatus] & queryStatus_active) !== 0;\n  }\n  set active(value) {\n    if (this[_queryStatus] & (queryStatus_cancelled | queryStatus_error))\n      return;\n    if (value)\n      this[_queryStatus] |= queryStatus_active;\n    else\n      this[_queryStatus] &= ~queryStatus_active;\n  }\n  get cancelled() {\n    return (this[_queryStatus] & queryStatus_cancelled) !== 0;\n  }\n  resolve(x) {\n    return this[_queryStatus] &= ~queryStatus_active, this[_resolve](x);\n  }\n  reject(x) {\n    return this[_queryStatus] &= ~queryStatus_active, this[_queryStatus] |= queryStatus_error, this[_reject](x);\n  }\n  cancel() {\n    var status = this[_queryStatus];\n    if (status & queryStatus_cancelled)\n      return this;\n    if (this[_queryStatus] |= queryStatus_cancelled, status & queryStatus_executed)\n      this[_handle].cancel();\n    return this;\n  }\n  execute() {\n    return this[_run](), this;\n  }\n  raw() {\n    return this[_handle].raw = 2, this;\n  }\n  values() {\n    return this[_handle].raw = 1, this;\n  }\n  then() {\n    return this[_run](), super.@then.@apply(this, arguments);\n  }\n  catch() {\n    return this[_run](), super.@catch.@apply(this, arguments);\n  }\n  finally() {\n    return this[_run](), super.@finally.@apply(this, arguments);\n  }\n}\nObject.defineProperty(Query, Symbol.species, { value: PublicPromise });\nObject.defineProperty(Query, Symbol.toStringTag, { value: \"Query\" });\ninit(Query.prototype.resolve, Query.prototype.reject);\nvar lazyDefaultSQL, defaultSQLObject = function sql(strings, ...values) {\n  if (!lazyDefaultSQL)\n    lazyDefaultSQL = SQL(@undefined), Object.assign(defaultSQLObject, lazyDefaultSQL), exportsObject.default = exportsObject.sql = lazyDefaultSQL;\n  return lazyDefaultSQL(strings, ...values);\n}, exportsObject = {\n  sql: defaultSQLObject,\n  default: defaultSQLObject,\n  SQL,\n  Query\n};\nreturn exportsObject})\n"_s;
+static constexpr ASCIILiteral BunSqlCode = "(function (){\"use strict\";// src/js/out/tmp/bun/sql.ts\nvar createConnection = function({ hostname, port, username, password, tls, query, database }, onConnected, onClose) {\n  return new PostgresSQLConnection(hostname, Number(port), username || \"\", password || \"\", database || \"\", tls || null, query || \"\", onConnected, onClose);\n}, normalizeStrings = function(strings) {\n  if (@isJSArray(strings))\n    return strings.join(\"\?\");\n  return strings + \"\";\n}, loadOptions = function(o) {\n  var hostname, port, username, password, database, tls, url, query, adapter;\n  const env = Bun.env;\n  if (typeof o === \"undefined\" || typeof o === \"string\" && o.length === 0) {\n    const urlString = env.POSTGRES_URL || env.DATABASE_URL || env.PGURL || env.PG_URL;\n    if (urlString)\n      url = new URL(urlString), o = {};\n  } else if (o && typeof o === \"object\") {\n    if (o instanceof URL)\n      url = o;\n    else if (o\?.url) {\n      const _url = o.url;\n      if (typeof _url === \"string\")\n        url = new URL(_url);\n      else if (_url && typeof _url === \"object\" && _url instanceof URL)\n        url = _url;\n    }\n  } else if (typeof o === \"string\")\n    url = new URL(o);\n  if (url) {\n    if ({ hostname, port, username, password, protocol: adapter } = o = url, adapter[adapter.length - 1] === \":\")\n      adapter = adapter.slice(0, -1);\n    const queryObject = url.searchParams.toJSON();\n    query = \"\";\n    for (let key in queryObject)\n      query += `${encodeURIComponent(key)}=${encodeURIComponent(queryObject[key])} `;\n    query = query.trim();\n  }\n  if (!o)\n    o = {};\n  if (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\", database ||= o.database || o.db || (url\?.pathname \?\? \"\").slice(1) || env.PGDATABASE || username, password ||= o.password || o.pass || env.PGPASSWORD || \"\", tls ||= o.tls || o.ssl, adapter ||= o.adapter || \"postgres\", port = Number(port), !Number.isSafeInteger(port) || port < 1 || port > 65535)\n    throw new Error(`Invalid port: ${port}`);\n  if (adapter && !(adapter === \"postgres\" || adapter === \"postgresql\"))\n    throw new Error(`Unsupported adapter: ${adapter}. Only \\\"postgres\\\" is supported for now`);\n  return { hostname, port, username, password, database, tls, query };\n}, SQL = function(o) {\n  var connection, connected = !1, connecting = !1, closed = !1, onConnect = [], connectionInfo = loadOptions(o);\n  function connectedHandler(query, handle, err) {\n    if (err)\n      return query.reject(err);\n    if (!connected)\n      return query.reject(new Error(\"Not connected\"));\n    if (query.cancelled)\n      return query.reject(new Error(\"Query cancelled\"));\n    handle.run(connection, query);\n  }\n  function pendingConnectionHandler(query, handle) {\n    if (onConnect.push((err) => connectedHandler(query, handle, err)), !connecting)\n      connecting = !0, connection = createConnection(connectionInfo, onConnected, onClose);\n  }\n  function closedConnectionHandler(query, handle) {\n    query.reject(new Error(\"Connection closed\"));\n  }\n  function onConnected(err) {\n    connected = !err;\n    for (let handler of onConnect)\n      handler(err);\n    onConnect = [];\n  }\n  function onClose(err) {\n    closed = !0, onConnected(err);\n  }\n  function connectedSQL(strings, values) {\n    return new Query(createQuery(normalizeStrings(strings), values), connectedHandler);\n  }\n  function closedSQL(strings, values) {\n    return new Query(@undefined, closedConnectionHandler);\n  }\n  function pendingSQL(strings, values) {\n    return new Query(createQuery(normalizeStrings(strings), values), pendingConnectionHandler);\n  }\n  function sql(strings, ...values) {\n    if (closed)\n      return closedSQL(strings, values);\n    if (connected)\n      return connectedSQL(strings, values);\n    return pendingSQL(strings, values);\n  }\n  return sql.connect = () => {\n    if (closed)\n      return @Promise.reject(new Error(\"Connection closed\"));\n    if (connected)\n      return @Promise.resolve(sql);\n    var { resolve, reject, promise } = @Promise.withResolvers();\n    if (onConnect.push((err) => err \? reject(err) : resolve(sql)), !connecting)\n      connecting = !0, connection = createConnection(connectionInfo, onConnected, onClose);\n    return promise;\n  }, sql.close = () => {\n    if (closed)\n      return @Promise.resolve();\n    var { resolve, promise } = @Promise.withResolvers();\n    return onConnect.push(resolve), connection.close(), promise;\n  }, sql.flush = () => {\n    if (closed || !connected)\n      return;\n    connection.flush();\n  }, sql;\n}, queryStatus_active = 1 << 1, queryStatus_cancelled = 1 << 2, queryStatus_error = 1 << 3, queryStatus_executed = 1 << 4;\nvar _resolve = Symbol(\"resolve\"), _reject = Symbol(\"reject\"), _handle = Symbol(\"handle\"), _run = Symbol(\"run\"), _queryStatus = Symbol(\"status\"), _handler = Symbol(\"handler\"), PublicPromise = @Promise, { createQuery, PostgresSQLConnection, init } = @lazy(\"bun:sql\");\n\nclass Query extends PublicPromise {\n  [_resolve];\n  [_reject];\n  [_handle];\n  [_handler];\n  [_queryStatus] = 0;\n  constructor(handle, handler) {\n    var resolve_, reject_;\n    super((resolve, reject) => {\n      resolve_ = resolve, reject_ = reject;\n    });\n    this[_resolve] = resolve_, this[_reject] = reject_, this[_handle] = handle, this[_handler] = handler, this[_queryStatus] = handle \? 0 : queryStatus_cancelled;\n  }\n  async[_run]() {\n    const { [_handle]: handle, [_handler]: handler, [_queryStatus]: status } = this;\n    if (status & (queryStatus_executed | queryStatus_cancelled))\n      return;\n    return this[_queryStatus] |= queryStatus_executed, await 1, handler(this, handle);\n  }\n  get active() {\n    return (this[_queryStatus] & queryStatus_active) !== 0;\n  }\n  set active(value) {\n    if (this[_queryStatus] & (queryStatus_cancelled | queryStatus_error))\n      return;\n    if (value)\n      this[_queryStatus] |= queryStatus_active;\n    else\n      this[_queryStatus] &= ~queryStatus_active;\n  }\n  get cancelled() {\n    return (this[_queryStatus] & queryStatus_cancelled) !== 0;\n  }\n  resolve(x) {\n    return this[_queryStatus] &= ~queryStatus_active, this[_resolve](x);\n  }\n  reject(x) {\n    return this[_queryStatus] &= ~queryStatus_active, this[_queryStatus] |= queryStatus_error, this[_reject](x);\n  }\n  cancel() {\n    var status = this[_queryStatus];\n    if (status & queryStatus_cancelled)\n      return this;\n    if (this[_queryStatus] |= queryStatus_cancelled, status & queryStatus_executed)\n      this[_handle].cancel();\n    return this;\n  }\n  execute() {\n    return this[_run](), this;\n  }\n  raw() {\n    return this[_handle].raw = 2, this;\n  }\n  values() {\n    return this[_handle].raw = 1, this;\n  }\n  then() {\n    return this[_run](), super.@then.@apply(this, arguments);\n  }\n  catch() {\n    return this[_run](), super.@catch.@apply(this, arguments);\n  }\n  finally() {\n    return this[_run](), super.@finally.@apply(this, arguments);\n  }\n}\nObject.defineProperty(Query, Symbol.species, { value: PublicPromise });\nObject.defineProperty(Query, Symbol.toStringTag, { value: \"Query\" });\ninit((query, result) => query.resolve(result), (query, reject) => query.reject(reject));\nvar lazyDefaultSQL, defaultSQLObject = function sql(strings, ...values) {\n  if (!lazyDefaultSQL)\n    lazyDefaultSQL = SQL(@undefined), Object.assign(defaultSQLObject, lazyDefaultSQL), exportsObject.default = exportsObject.sql = lazyDefaultSQL;\n  return lazyDefaultSQL(strings, ...values);\n}, exportsObject = {\n  sql: defaultSQLObject,\n  default: defaultSQLObject,\n  SQL,\n  Query\n};\nreturn exportsObject})\n"_s;
 //
 
 //
@@ -517,7 +517,7 @@ static constexpr ASCIILiteral BunFFICode = "(function (){\"use strict\";// src/j
 //
 
 //
-static constexpr ASCIILiteral BunSqlCode = "(function (){\"use strict\";// src/js/out/tmp/bun/sql.ts\nvar createConnection = function({ hostname, port, username, password, tls, query, database }, onConnected, onClose) {\n  return new PostgresSQLConnection(hostname, Number(port), username || \"\", password || \"\", database || \"\", tls || null, query || \"\", onConnected, onClose);\n}, normalizeStrings = function(strings) {\n  if (@isJSArray(strings))\n    return strings.join(\"\?\");\n  return strings + \"\";\n}, loadOptions = function(o) {\n  var hostname, port, username, password, database, tls, url, query, adapter;\n  const env = Bun.env;\n  if (typeof o === \"undefined\" || typeof o === \"string\" && o.length === 0) {\n    const urlString = env.POSTGRES_URL || env.DATABASE_URL || env.PGURL || env.PG_URL;\n    if (urlString)\n      url = new URL(urlString), o = {};\n  } else if (o && typeof o === \"object\") {\n    if (o instanceof URL)\n      url = o;\n    else if (o\?.url) {\n      const _url = o.url;\n      if (typeof _url === \"string\")\n        url = new URL(_url);\n      else if (_url && typeof _url === \"object\" && _url instanceof URL)\n        url = _url;\n    }\n  } else if (typeof o === \"string\")\n    url = new URL(o);\n  if (url) {\n    if ({ hostname, port, username, password, protocol: adapter } = o = url, adapter[adapter.length - 1] === \":\")\n      adapter = adapter.slice(0, -1);\n    const queryObject = url.searchParams.toJSON();\n    query = \"\";\n    for (let key in queryObject)\n      query += `${encodeURIComponent(key)}=${encodeURIComponent(queryObject[key])} `;\n    query = query.trim();\n  }\n  if (!o)\n    o = {};\n  if (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\", database ||= o.database || o.db || (url\?.pathname \?\? \"\").slice(1) || env.PGDATABASE || username, password ||= o.password || o.pass || env.PGPASSWORD || \"\", tls ||= o.tls || o.ssl, adapter ||= o.adapter || \"postgres\", port = Number(port), !Number.isSafeInteger(port) || port < 1 || port > 65535)\n    throw new Error(`Invalid port: ${port}`);\n  if (adapter && !(adapter === \"postgres\" || adapter === \"postgresql\"))\n    throw new Error(`Unsupported adapter: ${adapter}. Only \\\"postgres\\\" is supported for now`);\n  return { hostname, port, username, password, database, tls, query };\n}, SQL = function(o) {\n  var connection, connected = !1, connecting = !1, closed = !1, onConnect = [], connectionInfo = loadOptions(o);\n  function connectedHandler(query, handle, err) {\n    if (err)\n      return query.reject(err);\n    if (!connected)\n      return query.reject(new Error(\"Not connected\"));\n    if (query.cancelled)\n      return query.reject(new Error(\"Query cancelled\"));\n    handle.run(connection, query);\n  }\n  function pendingConnectionHandler(query, handle) {\n    if (onConnect.push((err) => connectedHandler(query, handle, err)), !connecting)\n      connecting = !0, connection = createConnection(connectionInfo, onConnected, onClose);\n  }\n  function closedConnectionHandler(query, handle) {\n    query.reject(new Error(\"Connection closed\"));\n  }\n  function onConnected(err) {\n    connected = !err;\n    for (let handler of onConnect)\n      handler(err);\n    onConnect = [];\n  }\n  function onClose(err) {\n    closed = !0, onConnected(err);\n  }\n  function connectedSQL(strings, values) {\n    return new Query(createQuery(normalizeStrings(strings), values), closedConnectionHandler);\n  }\n  function closedSQL(strings, values) {\n    return new Query(@undefined, closedConnectionHandler);\n  }\n  function pendingSQL(strings, values) {\n    return new Query(createQuery(normalizeStrings(strings), values), pendingConnectionHandler);\n  }\n  function sql(strings, ...values) {\n    if (closed)\n      return closedSQL(strings, values);\n    if (connected)\n      return connectedSQL(strings, values);\n    return pendingSQL(strings, values);\n  }\n  return sql.connect = () => {\n    if (closed)\n      return @Promise.reject(new Error(\"Connection closed\"));\n    if (connected)\n      return @Promise.resolve(sql);\n    var { resolve, reject, promise } = @Promise.withResolvers();\n    if (onConnect.push((err) => err \? reject(err) : resolve(sql)), !connecting)\n      connecting = !0, connection = createConnection(connectionInfo, onConnected, onClose);\n    return promise;\n  }, sql.close = () => {\n    if (closed)\n      return @Promise.resolve();\n    var { resolve, promise } = @Promise.withResolvers();\n    return onConnect.push(resolve), connection.close(), promise;\n  }, sql.flush = () => {\n    if (closed || !connected)\n      return;\n    connection.flush();\n  }, sql;\n}, queryStatus_active = 1 << 1, queryStatus_cancelled = 1 << 2, queryStatus_error = 1 << 3, queryStatus_executed = 1 << 4;\nvar _resolve = Symbol(\"resolve\"), _reject = Symbol(\"reject\"), _handle = Symbol(\"handle\"), _run = Symbol(\"run\"), _queryStatus = Symbol(\"status\"), _handler = Symbol(\"handler\"), PublicPromise = @Promise, { createQuery, PostgresSQLConnection, init } = @lazy(\"bun:sql\");\n\nclass Query extends PublicPromise {\n  [_resolve];\n  [_reject];\n  [_handle];\n  [_handler];\n  [_queryStatus] = 0;\n  constructor(handle, handler) {\n    var resolve_, reject_;\n    super((resolve, reject) => {\n      resolve_ = resolve, reject_ = reject;\n    });\n    this[_resolve] = resolve_, this[_reject] = reject_, this[_handle] = handle, this[_handler] = handler, this[_queryStatus] = handle \? 0 : queryStatus_cancelled;\n  }\n  async[_run]() {\n    const { [_handle]: handle, [_handler]: handler, [_queryStatus]: status } = this;\n    if (status & (queryStatus_executed | queryStatus_cancelled))\n      return;\n    return this[_queryStatus] |= queryStatus_executed, await 1, handler(this, handle);\n  }\n  get active() {\n    return (this[_queryStatus] & queryStatus_active) !== 0;\n  }\n  set active(value) {\n    if (this[_queryStatus] & (queryStatus_cancelled | queryStatus_error))\n      return;\n    if (value)\n      this[_queryStatus] |= queryStatus_active;\n    else\n      this[_queryStatus] &= ~queryStatus_active;\n  }\n  get cancelled() {\n    return (this[_queryStatus] & queryStatus_cancelled) !== 0;\n  }\n  resolve(x) {\n    return this[_queryStatus] &= ~queryStatus_active, this[_resolve](x);\n  }\n  reject(x) {\n    return this[_queryStatus] &= ~queryStatus_active, this[_queryStatus] |= queryStatus_error, this[_reject](x);\n  }\n  cancel() {\n    var status = this[_queryStatus];\n    if (status & queryStatus_cancelled)\n      return this;\n    if (this[_queryStatus] |= queryStatus_cancelled, status & queryStatus_executed)\n      this[_handle].cancel();\n    return this;\n  }\n  execute() {\n    return this[_run](), this;\n  }\n  raw() {\n    return this[_handle].raw = 2, this;\n  }\n  values() {\n    return this[_handle].raw = 1, this;\n  }\n  then() {\n    return this[_run](), super.@then.@apply(this, arguments);\n  }\n  catch() {\n    return this[_run](), super.@catch.@apply(this, arguments);\n  }\n  finally() {\n    return this[_run](), super.@finally.@apply(this, arguments);\n  }\n}\nObject.defineProperty(Query, Symbol.species, { value: PublicPromise });\nObject.defineProperty(Query, Symbol.toStringTag, { value: \"Query\" });\ninit(Query.prototype.resolve, Query.prototype.reject);\nvar lazyDefaultSQL, defaultSQLObject = function sql(strings, ...values) {\n  if (!lazyDefaultSQL)\n    lazyDefaultSQL = SQL(@undefined), Object.assign(defaultSQLObject, lazyDefaultSQL), exportsObject.default = exportsObject.sql = lazyDefaultSQL;\n  return lazyDefaultSQL(strings, ...values);\n}, exportsObject = {\n  sql: defaultSQLObject,\n  default: defaultSQLObject,\n  SQL,\n  Query\n};\nreturn exportsObject})\n"_s;
+static constexpr ASCIILiteral BunSqlCode = "(function (){\"use strict\";// src/js/out/tmp/bun/sql.ts\nvar createConnection = function({ hostname, port, username, password, tls, query, database }, onConnected, onClose) {\n  return new PostgresSQLConnection(hostname, Number(port), username || \"\", password || \"\", database || \"\", tls || null, query || \"\", onConnected, onClose);\n}, normalizeStrings = function(strings) {\n  if (@isJSArray(strings))\n    return strings.join(\"\?\");\n  return strings + \"\";\n}, loadOptions = function(o) {\n  var hostname, port, username, password, database, tls, url, query, adapter;\n  const env = Bun.env;\n  if (typeof o === \"undefined\" || typeof o === \"string\" && o.length === 0) {\n    const urlString = env.POSTGRES_URL || env.DATABASE_URL || env.PGURL || env.PG_URL;\n    if (urlString)\n      url = new URL(urlString), o = {};\n  } else if (o && typeof o === \"object\") {\n    if (o instanceof URL)\n      url = o;\n    else if (o\?.url) {\n      const _url = o.url;\n      if (typeof _url === \"string\")\n        url = new URL(_url);\n      else if (_url && typeof _url === \"object\" && _url instanceof URL)\n        url = _url;\n    }\n  } else if (typeof o === \"string\")\n    url = new URL(o);\n  if (url) {\n    if ({ hostname, port, username, password, protocol: adapter } = o = url, adapter[adapter.length - 1] === \":\")\n      adapter = adapter.slice(0, -1);\n    const queryObject = url.searchParams.toJSON();\n    query = \"\";\n    for (let key in queryObject)\n      query += `${encodeURIComponent(key)}=${encodeURIComponent(queryObject[key])} `;\n    query = query.trim();\n  }\n  if (!o)\n    o = {};\n  if (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\", database ||= o.database || o.db || (url\?.pathname \?\? \"\").slice(1) || env.PGDATABASE || username, password ||= o.password || o.pass || env.PGPASSWORD || \"\", tls ||= o.tls || o.ssl, adapter ||= o.adapter || \"postgres\", port = Number(port), !Number.isSafeInteger(port) || port < 1 || port > 65535)\n    throw new Error(`Invalid port: ${port}`);\n  if (adapter && !(adapter === \"postgres\" || adapter === \"postgresql\"))\n    throw new Error(`Unsupported adapter: ${adapter}. Only \\\"postgres\\\" is supported for now`);\n  return { hostname, port, username, password, database, tls, query };\n}, SQL = function(o) {\n  var connection, connected = !1, connecting = !1, closed = !1, onConnect = [], connectionInfo = loadOptions(o);\n  function connectedHandler(query, handle, err) {\n    if (err)\n      return query.reject(err);\n    if (!connected)\n      return query.reject(new Error(\"Not connected\"));\n    if (query.cancelled)\n      return query.reject(new Error(\"Query cancelled\"));\n    handle.run(connection, query);\n  }\n  function pendingConnectionHandler(query, handle) {\n    if (onConnect.push((err) => connectedHandler(query, handle, err)), !connecting)\n      connecting = !0, connection = createConnection(connectionInfo, onConnected, onClose);\n  }\n  function closedConnectionHandler(query, handle) {\n    query.reject(new Error(\"Connection closed\"));\n  }\n  function onConnected(err) {\n    connected = !err;\n    for (let handler of onConnect)\n      handler(err);\n    onConnect = [];\n  }\n  function onClose(err) {\n    closed = !0, onConnected(err);\n  }\n  function connectedSQL(strings, values) {\n    return new Query(createQuery(normalizeStrings(strings), values), connectedHandler);\n  }\n  function closedSQL(strings, values) {\n    return new Query(@undefined, closedConnectionHandler);\n  }\n  function pendingSQL(strings, values) {\n    return new Query(createQuery(normalizeStrings(strings), values), pendingConnectionHandler);\n  }\n  function sql(strings, ...values) {\n    if (closed)\n      return closedSQL(strings, values);\n    if (connected)\n      return connectedSQL(strings, values);\n    return pendingSQL(strings, values);\n  }\n  return sql.connect = () => {\n    if (closed)\n      return @Promise.reject(new Error(\"Connection closed\"));\n    if (connected)\n      return @Promise.resolve(sql);\n    var { resolve, reject, promise } = @Promise.withResolvers();\n    if (onConnect.push((err) => err \? reject(err) : resolve(sql)), !connecting)\n      connecting = !0, connection = createConnection(connectionInfo, onConnected, onClose);\n    return promise;\n  }, sql.close = () => {\n    if (closed)\n      return @Promise.resolve();\n    var { resolve, promise } = @Promise.withResolvers();\n    return onConnect.push(resolve), connection.close(), promise;\n  }, sql.flush = () => {\n    if (closed || !connected)\n      return;\n    connection.flush();\n  }, sql;\n}, queryStatus_active = 1 << 1, queryStatus_cancelled = 1 << 2, queryStatus_error = 1 << 3, queryStatus_executed = 1 << 4;\nvar _resolve = Symbol(\"resolve\"), _reject = Symbol(\"reject\"), _handle = Symbol(\"handle\"), _run = Symbol(\"run\"), _queryStatus = Symbol(\"status\"), _handler = Symbol(\"handler\"), PublicPromise = @Promise, { createQuery, PostgresSQLConnection, init } = @lazy(\"bun:sql\");\n\nclass Query extends PublicPromise {\n  [_resolve];\n  [_reject];\n  [_handle];\n  [_handler];\n  [_queryStatus] = 0;\n  constructor(handle, handler) {\n    var resolve_, reject_;\n    super((resolve, reject) => {\n      resolve_ = resolve, reject_ = reject;\n    });\n    this[_resolve] = resolve_, this[_reject] = reject_, this[_handle] = handle, this[_handler] = handler, this[_queryStatus] = handle \? 0 : queryStatus_cancelled;\n  }\n  async[_run]() {\n    const { [_handle]: handle, [_handler]: handler, [_queryStatus]: status } = this;\n    if (status & (queryStatus_executed | queryStatus_cancelled))\n      return;\n    return this[_queryStatus] |= queryStatus_executed, await 1, handler(this, handle);\n  }\n  get active() {\n    return (this[_queryStatus] & queryStatus_active) !== 0;\n  }\n  set active(value) {\n    if (this[_queryStatus] & (queryStatus_cancelled | queryStatus_error))\n      return;\n    if (value)\n      this[_queryStatus] |= queryStatus_active;\n    else\n      this[_queryStatus] &= ~queryStatus_active;\n  }\n  get cancelled() {\n    return (this[_queryStatus] & queryStatus_cancelled) !== 0;\n  }\n  resolve(x) {\n    return this[_queryStatus] &= ~queryStatus_active, this[_resolve](x);\n  }\n  reject(x) {\n    return this[_queryStatus] &= ~queryStatus_active, this[_queryStatus] |= queryStatus_error, this[_reject](x);\n  }\n  cancel() {\n    var status = this[_queryStatus];\n    if (status & queryStatus_cancelled)\n      return this;\n    if (this[_queryStatus] |= queryStatus_cancelled, status & queryStatus_executed)\n      this[_handle].cancel();\n    return this;\n  }\n  execute() {\n    return this[_run](), this;\n  }\n  raw() {\n    return this[_handle].raw = 2, this;\n  }\n  values() {\n    return this[_handle].raw = 1, this;\n  }\n  then() {\n    return this[_run](), super.@then.@apply(this, arguments);\n  }\n  catch() {\n    return this[_run](), super.@catch.@apply(this, arguments);\n  }\n  finally() {\n    return this[_run](), super.@finally.@apply(this, arguments);\n  }\n}\nObject.defineProperty(Query, Symbol.species, { value: PublicPromise });\nObject.defineProperty(Query, Symbol.toStringTag, { value: \"Query\" });\ninit((query, result) => query.resolve(result), (query, reject) => query.reject(reject));\nvar lazyDefaultSQL, defaultSQLObject = function sql(strings, ...values) {\n  if (!lazyDefaultSQL)\n    lazyDefaultSQL = SQL(@undefined), Object.assign(defaultSQLObject, lazyDefaultSQL), exportsObject.default = exportsObject.sql = lazyDefaultSQL;\n  return lazyDefaultSQL(strings, ...values);\n}, exportsObject = {\n  sql: defaultSQLObject,\n  default: defaultSQLObject,\n  SQL,\n  Query\n};\nreturn exportsObject})\n"_s;
 //
 
 //
diff --git a/src/sql/postgres.zig b/src/sql/postgres.zig
index 7c561cf7e..039452d5c 100644
--- a/src/sql/postgres.zig
+++ b/src/sql/postgres.zig
@@ -1633,14 +1633,8 @@ pub const PostgresSQLQuery = struct {
 
         this.deref();
         var vm = JSC.VirtualMachine.get();
-        // TODO: error handling
-        _ = vm.rareData().postgresql_context.onQueryResolveFn.get().?.callWithThis(
-            globalObject,
-            targetValue,
-            &[_]JSC.JSValue{
-                JSC.JSValue.undefined,
-            },
-        );
+        const function = vm.rareData().postgresql_context.onQueryResolveFn.get().?;
+        globalObject.queueMicrotask(function, &[_]JSC.JSValue{ targetValue, JSC.JSValue.undefined });
     }
     pub fn onError(this: *@This(), err: protocol.ErrorResponse, globalObject: *JSC.JSGlobalObject) void {
         const thisValue = this.thisValue;
@@ -1671,13 +1665,9 @@ pub const PostgresSQLQuery = struct {
 
         this.deref();
         // TODO: error handling
-        _ = JSC.VirtualMachine.get().rareData().postgresql_context.onQueryRejectFn.get().?.callWithThis(
-            globalObject,
-            targetValue,
-            &[_]JSC.JSValue{
-                instance,
-            },
-        );
+        var vm = JSC.VirtualMachine.get();
+        const function = vm.rareData().postgresql_context.onQueryRejectFn.get().?;
+        globalObject.queueMicrotask(function, &[_]JSC.JSValue{ targetValue, instance });
     }
 
     pub fn onSuccess(this: *@This(), _: []const u8, globalObject: *JSC.JSGlobalObject) void {
@@ -1692,14 +1682,9 @@ pub const PostgresSQLQuery = struct {
         this.status = .success;
         this.deref();
 
-        // TODO: error handling
-        _ = JSC.VirtualMachine.get().rareData().postgresql_context.onQueryResolveFn.get().?.callWithThis(
-            globalObject,
-            targetValue,
-            &[_]JSC.JSValue{
-                pending_value,
-            },
-        );
+        var vm = JSC.VirtualMachine.get();
+        const function = vm.rareData().postgresql_context.onQueryResolveFn.get().?;
+        globalObject.queueMicrotask(function, &[_]JSC.JSValue{ targetValue, pending_value });
     }
 
     pub fn constructor(globalThis: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(.C) ?*PostgresSQLQuery {
@@ -1773,18 +1758,38 @@ pub const PostgresSQLQuery = struct {
         this.target = query;
         this.thisValue = callframe.this();
         const binding_value = PostgresSQLQuery.bindingGetCached(callframe.this()) orelse .zero;
+        var query_str = this.query.toUTF8(bun.default_allocator);
+        defer query_str.deinit();
+
+        var signature = Signature.generate(globalObject, query_str.slice(), binding_value) catch |err| {
+            globalObject.throwError(err, "failed to generate signature");
+            return .zero;
+        };
 
         var writer = connection.writer();
-        if (this.statement) |stmt| {
-            PostgresRequest.bindAndExecute(globalObject, stmt, binding_value, PostgresSQLConnection.Writer, writer) catch |err| {
+
+        var entry = connection.statements.getOrPut(bun.default_allocator, bun.hash(signature.name)) catch |err| {
+            globalObject.throwError(err, "failed to allocate statement");
+            signature.deinit();
+            return .zero;
+        };
+        if (entry.found_existing) {
+            this.statement = entry.value_ptr.*;
+            this.statement.?.ref();
+            signature.deinit();
+
+            PostgresRequest.bindAndExecute(globalObject, this.statement.?, binding_value, PostgresSQLConnection.Writer, writer) catch |err| {
                 globalObject.throwError(err, "failed to bind and execute query");
+
                 return .zero;
             };
         } else {
-            const signature = PostgresRequest.prepareAndQuery(globalObject, this.query, binding_value, PostgresSQLConnection.Writer, writer) catch |err| {
-                globalObject.throwError(err, "failed to prepare query");
+            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;
             };
+
             var stmt = bun.default_allocator.create(PostgresSQLStatement) catch |err| {
                 globalObject.throwError(err, "failed to allocate statement");
                 return .zero;
@@ -1792,16 +1797,19 @@ pub const PostgresSQLQuery = struct {
 
             stmt.* = .{
                 .signature = signature,
+                .ref_count = 2,
             };
             this.statement = stmt;
+            entry.value_ptr.* = stmt;
         }
 
-        connection.flushData();
-
         connection.requests.writeItem(this) catch {};
         this.ref();
         this.status = .running;
 
+        if (connection.is_ready_for_query)
+            connection.flushData();
+
         return .undefined;
     }
 
@@ -1957,6 +1965,27 @@ pub const PostgresRequest = struct {
         }
     }
 
+    pub fn prepareAndQueryWithSignature(
+        globalObject: *JSC.JSGlobalObject,
+        query: []const u8,
+        array_value: JSC.JSValue,
+        comptime Context: type,
+        writer: protocol.NewWriter(Context),
+        signature: *Signature,
+    ) !void {
+        try writeQuery(query, signature.name, signature.fields, Context, writer);
+        try writeBind(signature.name, bun.String.empty, globalObject, array_value, Context, writer);
+        var exec = protocol.Execute{
+            .p = .{
+                .prepared_statement = signature.name,
+            },
+        };
+        try exec.writeInternal(Context, writer);
+
+        try writer.write(&protocol.Flush);
+        try writer.write(&protocol.Sync);
+    }
+
     pub fn prepareAndQuery(
         globalObject: *JSC.JSGlobalObject,
         query: bun.String,
@@ -1971,16 +2000,7 @@ pub const PostgresRequest = struct {
             signature.deinit();
         }
 
-        try writeQuery(query_.slice(), signature.name, signature.fields, Context, writer);
-        try writeBind(signature.name, bun.String.empty, globalObject, array_value, Context, writer);
-        var exec = protocol.Execute{
-            .p = .{
-                .prepared_statement = signature.name,
-            },
-        };
-        try exec.writeInternal(Context, writer);
-
-        try writer.write(&protocol.Flush);
+        try prepareAndQueryWithSignature(globalObject, query_.slice(), array_value, Context, writer, &signature);
 
         return signature;
     }
@@ -2001,6 +2021,7 @@ pub const PostgresRequest = struct {
         try exec.writeInternal(Context, writer);
 
         try writer.write(&protocol.Flush);
+        try writer.write(&protocol.Sync);
     }
 
     pub fn onData(
@@ -2157,6 +2178,8 @@ pub const PostgresSQLConnection = struct {
     }
 
     pub fn onClose(this: *PostgresSQLConnection) void {
+        var vm = this.globalObject.bunVM();
+        defer vm.drainMicrotasks();
         this.fail("Connection closed", error.ConnectionClosed);
     }
 
@@ -2176,15 +2199,20 @@ pub const PostgresSQLConnection = struct {
     }
 
     pub fn onTimeout(this: *PostgresSQLConnection) void {
-        _ = this;
+        var vm = this.globalObject.bunVM();
+        defer vm.drainMicrotasks();
         debug("onTimeout", .{});
     }
 
     pub fn onDrain(this: *PostgresSQLConnection) void {
+        var vm = this.globalObject.bunVM();
+        defer vm.drainMicrotasks();
         this.flushData();
     }
 
     pub fn onData(this: *PostgresSQLConnection, data: []const u8) void {
+        var vm = this.globalObject.bunVM();
+        defer vm.drainMicrotasks();
         if (this.read_buffer.remaining().len == 0) {
             var consumed: usize = 0;
             var offset: usize = 0;
@@ -2615,6 +2643,7 @@ pub const PostgresSQLConnection = struct {
 
                 this.setStatus(.connected);
                 this.is_ready_for_query = true;
+                this.socket.setTimeout(300);
 
                 this.flushData();
             },
@@ -2637,7 +2666,8 @@ pub const PostgresSQLConnection = struct {
             },
             .ParseComplete => {
                 try reader.eatMessage(protocol.ParseComplete);
-                _ = this.current() orelse return error.ExpectedRequest;
+                var request = this.current() orelse return error.ExpectedRequest;
+                _ = request;
             },
             .ParameterDescription => {
                 var description: protocol.ParameterDescription = undefined;