bun-types 0.0.78 → 0.0.79

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bun-types",
-  "version": "0.0.78",
+  "version": "0.0.79",
   "description": "Type definitions for bun.js",
   "types": "types.d.ts",
   "files": [

package/types.d.ts

@@ -66,7 +66,7 @@ declare module "bun" {
    * });
    * ```
    */
-  export function serve(options: Serve): void;
+  export function serve(options: Serve): Server;
 
   /**
    * Synchronously resolve a `moduleId` as though it were imported from `parent`
@@ -521,9 +521,10 @@ declare module "bun" {
      * Respond to {@link Request} objects with a {@link Response} object.
      *
      */
-    fetch(request: Request): Response | Promise<Response>;
+    fetch(this: Server, request: Request): Response | Promise<Response>;
 
     error?: (
+      this: Server,
       request: Errorlike
     ) => Response | Promise<Response> | undefined | Promise<undefined>;
   }
@@ -571,6 +572,41 @@ declare module "bun" {
       serverNames: Record<string, SSLOptions & SSLAdvancedOptions>;
     };
 
+  /**
+   * HTTP & HTTPS Server
+   *
+   * To start the server, see {@link serve}
+   *
+   * Often, you don't need to interact with this object directly. It exists to help you with the following tasks:
+   * - Stop the server
+   * - How many requests are currently being handled?
+   *
+   * For performance, Bun pre-allocates most of the data for 2048 concurrent requests.
+   * That means starting a new server allocates about 500 KB of memory. Try to
+   * avoid starting and stopping the server often (unless it's a new instance of bun).
+   *
+   * Powered by a fork of [uWebSockets](https://github.com/uNetworking/uWebSockets). Thank you @alexhultman.
+   *
+   */
+  interface Server {
+    /**
+     * Stop listening to prevent new connections from being accepted.
+     *
+     * It does not close existing connections.
+     *
+     * It may take a second or two to actually stop.
+     */
+    stop(): void;
+
+    /**
+     * How many requests are in-flight right now?
+     */
+    readonly pendingRequests: number;
+    readonly port: number;
+    readonly hostname: string;
+    readonly development: boolean;
+  }
+
   export type Serve = SSLServeOptions | ServeOptions;
 
   /**
@@ -730,6 +766,8 @@ declare module "bun" {
   }
   export const unsafe: unsafe;
 
+  type DigestEncoding = "hex" | "base64";
+
   /**
    * Are ANSI colors enabled for stdin and stdout?
    *
@@ -779,6 +817,16 @@ declare module "bun" {
     edgeNames: string[];
   }
 
+  /**
+   * Nanoseconds since Bun.js was started as an integer.
+   *
+   * This uses a high-resolution monotonic system timer.
+   *
+   * After 14 weeks of consecutive uptime, this function
+   * returns a `bigint` to prevent overflow
+   */
+  export function nanoseconds(): number | bigint;
+
   /**
    * Generate a heap snapshot for seeing where the heap is being used
    */
@@ -801,6 +849,163 @@ declare module "bun" {
     line?: number;
     column?: number;
   }
+
+  /**
+   * This class only exists in types
+   */
+  abstract class CryptoHashInterface<T> {
+    /**
+     * Update the hash with data
+     *
+     * @param data
+     */
+    update(data: StringOrBuffer): T;
+
+    /**
+     * Finalize the hash
+     *
+     * @param encoding `DigestEncoding` to return the hash in. If none is provided, it will return a `Uint8Array`.
+     */
+    digest(encoding: DigestEncoding): string;
+
+    /**
+     * Finalize the hash
+     *
+     * @param hashInto `TypedArray` to write the hash into. Faster than creating a new one each time
+     */
+    digest(hashInto?: TypedArray): TypedArray;
+
+    /**
+     * Run the hash over the given data
+     *
+     * @param input `string`, `Uint8Array`, or `ArrayBuffer` to hash. `Uint8Array` or `ArrayBuffer` is faster.
+     *
+     * @param hashInto `TypedArray` to write the hash into. Faster than creating a new one each time
+     */
+    static hash(input: StringOrBuffer, hashInto?: TypedArray): TypedArray;
+
+    /**
+     * Run the hash over the given data
+     *
+     * @param input `string`, `Uint8Array`, or `ArrayBuffer` to hash. `Uint8Array` or `ArrayBuffer` is faster.
+     *
+     * @param encoding `DigestEncoding` to return the hash in
+     */
+    static hash(input: StringOrBuffer, encoding: DigestEncoding): string;
+  }
+
+  /**
+   *
+   * Hash `input` using [SHA-2 512/256](https://en.wikipedia.org/wiki/SHA-2#Comparison_of_SHA_functions)
+   *
+   * @param input `string`, `Uint8Array`, or `ArrayBuffer` to hash. `Uint8Array` or `ArrayBuffer` will be faster
+   * @param hashInto optional `Uint8Array` to write the hash to. 32 bytes minimum.
+   *
+   * This hashing function balances speed with cryptographic strength. This does not encrypt or decrypt data.
+   *
+   * The implementation uses [BoringSSL](https://boringssl.googlesource.com/boringssl) (used in Chromium & Go)
+   *
+   * The equivalent `openssl` command is:
+   *
+   * ```bash
+   * # You will need OpenSSL 3 or later
+   * openssl sha512-256 /path/to/file
+   *```
+   */
+  export function sha(input: StringOrBuffer, hashInto?: Uint8Array): Uint8Array;
+
+  /**
+   *
+   * Hash `input` using [SHA-2 512/256](https://en.wikipedia.org/wiki/SHA-2#Comparison_of_SHA_functions)
+   *
+   * @param input `string`, `Uint8Array`, or `ArrayBuffer` to hash. `Uint8Array` or `ArrayBuffer` will be faster
+   * @param encoding `DigestEncoding` to return the hash in
+   *
+   * This hashing function balances speed with cryptographic strength. This does not encrypt or decrypt data.
+   *
+   * The implementation uses [BoringSSL](https://boringssl.googlesource.com/boringssl) (used in Chromium & Go)
+   *
+   * The equivalent `openssl` command is:
+   *
+   * ```bash
+   * # You will need OpenSSL 3 or later
+   * openssl sha512-256 /path/to/file
+   *```
+   */
+  export function sha(input: StringOrBuffer, encoding: DigestEncoding): string;
+
+  /**
+   * This is not the default because it's not cryptographically secure and it's slower than {@link SHA512}
+   *
+   * Consider using the ugly-named {@link SHA512_256} instead
+   */
+  export class SHA1 extends CryptoHashInterface<SHA1> {
+    constructor();
+
+    /**
+     * The number of bytes the hash will produce
+     */
+    static readonly byteLength: 20;
+  }
+  export class MD5 extends CryptoHashInterface<MD5> {
+    constructor();
+
+    /**
+     * The number of bytes the hash will produce
+     */
+    static readonly byteLength: 16;
+  }
+  export class MD4 extends CryptoHashInterface<MD4> {
+    constructor();
+
+    /**
+     * The number of bytes the hash will produce
+     */
+    static readonly byteLength: 16;
+  }
+  export class SHA224 extends CryptoHashInterface<SHA224> {
+    constructor();
+
+    /**
+     * The number of bytes the hash will produce
+     */
+    static readonly byteLength: 28;
+  }
+  export class SHA512 extends CryptoHashInterface<SHA512> {
+    constructor();
+
+    /**
+     * The number of bytes the hash will produce
+     */
+    static readonly byteLength: 64;
+  }
+  export class SHA384 extends CryptoHashInterface<SHA384> {
+    constructor();
+
+    /**
+     * The number of bytes the hash will produce
+     */
+    static readonly byteLength: 48;
+  }
+  export class SHA256 extends CryptoHashInterface<SHA256> {
+    constructor();
+
+    /**
+     * The number of bytes the hash will produce
+     */
+    static readonly byteLength: 32;
+  }
+  /**
+   * See also {@link sha}
+   */
+  export class SHA512_256 extends CryptoHashInterface<SHA512_256> {
+    constructor();
+
+    /**
+     * The number of bytes the hash will produce
+     */
+    static readonly byteLength: 32;
+  }
 }
 
 type TypedArray =
@@ -836,6 +1041,645 @@ interface BufferEncodingOption {
 declare var Bun: typeof import("bun");
 
 
+// ./ffi.d.ts
+
+/**
+ * `bun:ffi` lets you efficiently call C functions & FFI functions from JavaScript
+ *  without writing bindings yourself.
+ *
+ * ```js
+ * import {dlopen, CString, ptr} from 'bun:ffi';
+ *
+ * const lib = dlopen('libsqlite3', {
+ * });
+ * ```
+ *
+ * This is powered by just-in-time compiling C wrappers
+ * that convert JavaScript types to C types and back. Internally,
+ * bun uses [tinycc](https://github.com/TinyCC/tinycc), so a big thanks
+ * goes to Fabrice Bellard and TinyCC maintainers for making this possible.
+ *
+ */
+declare module "bun:ffi" {
+  export enum FFIType {
+    char = 0,
+    /**
+     * 8-bit signed integer
+     *
+     * Must be a value between -127 and 127
+     *
+     * When passing to a FFI function (C ABI), type coercsion is not performed.
+     *
+     * In C:
+     * ```c
+     * signed char
+     * char // on x64 & aarch64 macOS
+     * ```
+     *
+     * In JavaScript:
+     * ```js
+     * var num = 0;
+     * ```
+     */
+    int8_t = 1,
+    /**
+     * 8-bit signed integer
+     *
+     * Must be a value between -127 and 127
+     *
+     * When passing to a FFI function (C ABI), type coercsion is not performed.
+     *
+     * In C:
+     * ```c
+     * signed char
+     * char // on x64 & aarch64 macOS
+     * ```
+     *
+     * In JavaScript:
+     * ```js
+     * var num = 0;
+     * ```
+     */
+    i8 = 1,
+
+    /**
+     * 8-bit unsigned integer
+     *
+     * Must be a value between 0 and 255
+     *
+     * When passing to a FFI function (C ABI), type coercsion is not performed.
+     *
+     * In C:
+     * ```c
+     * unsigned char
+     * ```
+     *
+     * In JavaScript:
+     * ```js
+     * var num = 0;
+     * ```
+     */
+    uint8_t = 2,
+    /**
+     * 8-bit unsigned integer
+     *
+     * Must be a value between 0 and 255
+     *
+     * When passing to a FFI function (C ABI), type coercsion is not performed.
+     *
+     * In C:
+     * ```c
+     * unsigned char
+     * ```
+     *
+     * In JavaScript:
+     * ```js
+     * var num = 0;
+     * ```
+     */
+    u8 = 2,
+
+    /**
+     * 16-bit signed integer
+     *
+     * Must be a value between -32768 and 32767
+     *
+     * When passing to a FFI function (C ABI), type coercsion is not performed.
+     *
+     * In C:
+     * ```c
+     * in16_t
+     * short // on arm64 & x64
+     * ```
+     *
+     * In JavaScript:
+     * ```js
+     * var num = 0;
+     * ```
+     */
+    int16_t = 3,
+    /**
+     * 16-bit signed integer
+     *
+     * Must be a value between -32768 and 32767
+     *
+     * When passing to a FFI function (C ABI), type coercsion is not performed.
+     *
+     * In C:
+     * ```c
+     * in16_t
+     * short // on arm64 & x64
+     * ```
+     *
+     * In JavaScript:
+     * ```js
+     * var num = 0;
+     * ```
+     */
+    i16 = 3,
+
+    /**
+     * 16-bit unsigned integer
+     *
+     * Must be a value between 0 and 65535, inclusive.
+     *
+     * When passing to a FFI function (C ABI), type coercsion is not performed.
+     *
+     * In C:
+     * ```c
+     * uint16_t
+     * unsigned short // on arm64 & x64
+     * ```
+     *
+     * In JavaScript:
+     * ```js
+     * var num = 0;
+     * ```
+     */
+    uint16_t = 4,
+    /**
+     * 16-bit unsigned integer
+     *
+     * Must be a value between 0 and 65535, inclusive.
+     *
+     * When passing to a FFI function (C ABI), type coercsion is not performed.
+     *
+     * In C:
+     * ```c
+     * uint16_t
+     * unsigned short // on arm64 & x64
+     * ```
+     *
+     * In JavaScript:
+     * ```js
+     * var num = 0;
+     * ```
+     */
+    u16 = 4,
+
+    /**
+     * 32-bit signed integer
+     *
+     */
+    int32_t = 5,
+
+    /**
+     * 32-bit signed integer
+     *
+     * Alias of {@link FFIType.int32_t}
+     */
+    i32 = 5,
+    /**
+     * 32-bit signed integer
+     *
+     * The same as `int` in C
+     *
+     * ```c
+     * int
+     * ```
+     */
+    int = 5,
+
+    /**
+     * 32-bit unsigned integer
+     *
+     * The same as `unsigned int` in C (on x64 & arm64)
+     *
+     * C:
+     * ```c
+     * unsigned int
+     * ```
+     * JavaScript:
+     * ```js
+     * ptr(new Uint32Array(1))
+     * ```
+     */
+    uint32_t = 6,
+    /**
+     * 32-bit unsigned integer
+     *
+     * Alias of {@link FFIType.uint32_t}
+     */
+    u32 = 6,
+
+    /**
+     * int64 is a 64-bit signed integer
+     *
+     * This is not implemented yet!
+     */
+    int64_t = 7,
+    /**
+     * i64 is a 64-bit signed integer
+     *
+     * This is not implemented yet!
+     */
+    i64 = 7,
+
+    /**
+     * 64-bit unsigned integer
+     *
+     * This is not implemented yet!
+     */
+    uint64_t = 8,
+    /**
+     * 64-bit unsigned integer
+     *
+     * This is not implemented yet!
+     */
+    u64 = 8,
+
+    /**
+     * Doubles are not supported yet!
+     */
+    double = 9,
+    /**
+     * Doubles are not supported yet!
+     */
+    f64 = 9,
+    /**
+     * Floats are not supported yet!
+     */
+    float = 10,
+    /**
+     * Floats are not supported yet!
+     */
+    f32 = 10,
+
+    /**
+     * Booelan value
+     *
+     * Must be `true` or `false`. `0` and `1` type coercion is not supported.
+     *
+     * In C, this corresponds to:
+     * ```c
+     * bool
+     * _Bool
+     * ```
+     *
+     *
+     */
+    bool = 11,
+
+    /**
+     * Pointer value
+     *
+     * See {@link Bun.FFI.ptr} for more information
+     *
+     * In C:
+     * ```c
+     * void*
+     * ```
+     *
+     * In JavaScript:
+     * ```js
+     * ptr(new Uint8Array(1))
+     * ```
+     */
+    ptr = 12,
+    /**
+     * Pointer value
+     *
+     * alias of {@link FFIType.ptr}
+     */
+    pointer = 12,
+
+    /**
+     * void value
+     *
+     * void arguments are not supported
+     *
+     * void return type is the default return type
+     *
+     * In C:
+     * ```c
+     * void
+     * ```
+     *
+     */
+    void = 13,
+
+    /**
+     * When used as a `returns`, this will automatically become a {@link CString}.
+     *
+     * When used in `args` it is equivalent to {@link FFIType.pointer}
+     *
+     */
+    cstring = 14,
+
+    /**
+     * Attempt to coerce `BigInt` into a `Number` if it fits. This improves performance
+     * but means you might get a `BigInt` or you might get a `number`.
+     *
+     * In C, this always becomes `int64_t`
+     *
+     * In JavaScript, this could be number or it could be BigInt, depending on what
+     * value is passed in.
+     *
+     */
+    i64_fast = 15,
+
+    /**
+     * Attempt to coerce `BigInt` into a `Number` if it fits. This improves performance
+     * but means you might get a `BigInt` or you might get a `number`.
+     *
+     * In C, this always becomes `uint64_t`
+     *
+     * In JavaScript, this could be number or it could be BigInt, depending on what
+     * value is passed in.
+     *
+     */
+    u64_fast = 16,
+  }
+  export type FFITypeOrString =
+    | FFIType
+    | "char"
+    | "int8_t"
+    | "i8"
+    | "uint8_t"
+    | "u8"
+    | "int16_t"
+    | "i16"
+    | "uint16_t"
+    | "u16"
+    | "int32_t"
+    | "i32"
+    | "int"
+    | "uint32_t"
+    | "u32"
+    | "int64_t"
+    | "i64"
+    | "uint64_t"
+    | "u64"
+    | "double"
+    | "f64"
+    | "float"
+    | "f32"
+    | "bool"
+    | "ptr"
+    | "pointer"
+    | "void"
+    | "cstring";
+
+  interface FFIFunction {
+    /**
+     * Arguments to a FFI function (C ABI)
+     *
+     * Defaults to an empty array, which means no arguments.
+     *
+     * To pass a pointer, use "ptr" or "pointer" as the type name. To get a pointer, see {@link ptr}.
+     *
+     * @example
+     * From JavaScript:
+     * ```js
+     * const lib = dlopen('add', {
+     *    // FFIType can be used or you can pass string labels.
+     *    args: [FFIType.i32, "i32"],
+     *    returns: "i32",
+     * });
+     * lib.symbols.add(1, 2)
+     * ```
+     * In C:
+     * ```c
+     * int add(int a, int b) {
+     *   return a + b;
+     * }
+     * ```
+     */
+    args?: FFITypeOrString[];
+    /**
+     * Return type to a FFI function (C ABI)
+     *
+     * Defaults to {@link FFIType.void}
+     *
+     * To pass a pointer, use "ptr" or "pointer" as the type name. To get a pointer, see {@link ptr}.
+     *
+     * @example
+     * From JavaScript:
+     * ```js
+     * const lib = dlopen('z', {
+     *    version: {
+     *      returns: "ptr",
+     *   }
+     * });
+     * console.log(new CString(lib.symbols.version()));
+     * ```
+     * In C:
+     * ```c
+     * char* version()
+     * {
+     *  return "1.0.0";
+     * }
+     * ```
+     */
+    returns?: FFITypeOrString;
+  }
+
+  type Symbols = Record<string, FFIFunction>;
+
+  // /**
+  //  * Compile a callback function
+  //  *
+  //  * Returns a function pointer
+  //  *
+  //  */
+  // export function callback(ffi: FFIFunction, cb: Function): number;
+
+  export interface Library {
+    symbols: Record<
+      string,
+      CallableFunction & {
+        /**
+         * The function without a wrapper
+         */
+        native: CallableFunction;
+      }
+    >;
+
+    /**
+     * `dlclose` the library, unloading the symbols and freeing allocated memory.
+     *
+     * Once called, the library is no longer usable.
+     *
+     * Calling a function from a library that has been closed is undefined behavior.
+     */
+    close(): void;
+  }
+
+  export function dlopen(libraryName: string, symbols: Symbols): Library;
+
+  /**
+   * Read a pointer as a {@link Buffer}
+   *
+   * If `byteLength` is not provided, the pointer is assumed to be 0-terminated.
+   *
+   * @param ptr The memory address to read
+   * @param byteOffset bytes to skip before reading
+   * @param byteLength bytes to read
+   *
+   * While there are some checks to catch invalid pointers, this is a difficult
+   * thing to do safely. Passing an invalid pointer can crash the program and
+   * reading beyond the bounds of the pointer will crash the program or cause
+   * undefined behavior. Use with care!
+   *
+   */
+  export function toBuffer(
+    ptr: number,
+    byteOffset?: number,
+    byteLength?: number
+  ): Buffer;
+
+  /**
+   * Read a pointer as an {@link ArrayBuffer}
+   *
+   * If `byteLength` is not provided, the pointer is assumed to be 0-terminated.
+   *
+   * @param ptr The memory address to read
+   * @param byteOffset bytes to skip before reading
+   * @param byteLength bytes to read
+   *
+   * While there are some checks to catch invalid pointers, this is a difficult
+   * thing to do safely. Passing an invalid pointer can crash the program and
+   * reading beyond the bounds of the pointer will crash the program or cause
+   * undefined behavior. Use with care!
+   */
+  export function toArrayBuffer(
+    ptr: number,
+    byteOffset?: number,
+    byteLength?: number
+  ): ArrayBuffer;
+
+  /**
+   * Get the pointer backing a {@link TypedArray} or {@link ArrayBuffer}
+   *
+   * Use this to pass {@link TypedArray} or {@link ArrayBuffer} to C functions.
+   *
+   * This is for use with FFI functions. For performance reasons, FFI will
+   * not automatically convert typed arrays to C pointers.
+   *
+   * @param {TypedArray|ArrayBuffer|DataView} view the typed array or array buffer to get the pointer for
+   * @param {number} byteOffset optional offset into the view in bytes
+   *
+   * @example
+   *
+   * From JavaScript:
+   * ```js
+   * const array = new Uint8Array(10);
+   * const rawPtr = ptr(array);
+   * myFFIFunction(rawPtr);
+   * ```
+   * To C:
+   * ```c
+   * void myFFIFunction(char* rawPtr) {
+   *  // Do something with rawPtr
+   * }
+   * ```
+   *
+   */
+  export function ptr(
+    view: TypedArray | ArrayBufferLike | DataView,
+    byteOffset?: number
+  ): number;
+
+  /**
+   * Get a string from a UTF-8 encoded C string
+   * If `byteLength` is not provided, the string is assumed to be null-terminated.
+   *
+   * @example
+   * ```js
+   * var ptr = lib.symbols.getVersion();
+   * console.log(new CString(ptr));
+   * ```
+   *
+   * @example
+   * ```js
+   * var ptr = lib.symbols.getVersion();
+   * // print the first 4 characters
+   * console.log(new CString(ptr, 0, 4));
+   * ```
+   *
+   * While there are some checks to catch invalid pointers, this is a difficult
+   * thing to do safely. Passing an invalid pointer can crash the program and
+   * reading beyond the bounds of the pointer will crash the program or cause
+   * undefined behavior. Use with care!
+   */
+
+  export class CString extends String {
+    /**
+     * Get a string from a UTF-8 encoded C string
+     * If `byteLength` is not provided, the string is assumed to be null-terminated.
+     *
+     * @param ptr The pointer to the C string
+     * @param byteOffset bytes to skip before reading
+     * @param byteLength bytes to read
+     *
+     *
+     * @example
+     * ```js
+     * var ptr = lib.symbols.getVersion();
+     * console.log(new CString(ptr));
+     * ```
+     *
+     * @example
+     * ```js
+     * var ptr = lib.symbols.getVersion();
+     * // print the first 4 characters
+     * console.log(new CString(ptr, 0, 4));
+     * ```
+     *
+     * While there are some checks to catch invalid pointers, this is a difficult
+     * thing to do safely. Passing an invalid pointer can crash the program and
+     * reading beyond the bounds of the pointer will crash the program or cause
+     * undefined behavior. Use with care!
+     */
+    constructor(ptr: number, byteOffset?: number, byteLength?: number);
+
+    /**
+     * The ptr to the C string
+     *
+     * This `CString` instance is a clone of the string, so it
+     * is safe to continue using this instance after the `ptr` has been
+     * freed.
+     */
+    ptr: number;
+    byteOffset?: number;
+    byteLength?: number;
+
+    /**
+     * Get the {@link ptr} as an `ArrayBuffer`
+     *
+     * `null` or empty ptrs returns an `ArrayBuffer` with `byteLength` 0
+     */
+    get arrayBuffer(): ArrayBuffer;
+  }
+
+  /**
+   * View the generated C code for FFI bindings
+   *
+   * You probably won't need this unless there's a bug in the FFI bindings
+   * generator or you're just curious.
+   */
+  export function viewSource(symbols: Symbols, is_callback?: false): string[];
+  export function viewSource(callback: FFIFunction, is_callback: true): string;
+
+  /**
+   * Platform-specific file extension name for dynamic libraries
+   *
+   * "." is not included
+   *
+   * @example
+   * ```js
+   * "dylib" // macOS
+   * ```
+   *
+   * @example
+   * ```js
+   * "so" // linux
+   * ```
+   */
+  export const suffix: string;
+}
+
+
 // ./fs.d.ts
 
 /**
@@ -4724,7 +5568,7 @@ interface Process {
   setuid(id: number | string): void;
 }
 
-declare let process: Process;
+declare var process: Process;
 
 interface BlobInterface {
   text(): Promise<string>;
@@ -4765,7 +5609,7 @@ interface Headers {
   ): void;
 }
 
-declare let Headers: {
+declare var Headers: {
   prototype: Headers;
   new (init?: HeadersInit): Headers;
 };
@@ -5223,7 +6067,7 @@ interface Crypto {
   randomUUID(): string;
 }
 
-declare let crypto: Crypto;
+declare var crypto: Crypto;
 
 /**
  * [`atob`](https://developer.mozilla.org/en-US/docs/Web/API/atob) converts ascii text into base64.
@@ -5603,7 +6447,7 @@ interface EventTarget {
   ): void;
 }
 
-declare let EventTarget: {
+declare var EventTarget: {
   prototype: EventTarget;
   new (): EventTarget;
 };
@@ -5707,7 +6551,7 @@ interface Event {
   readonly NONE: number;
 }
 
-declare let Event: {
+declare var Event: {
   prototype: Event;
   new (type: string, eventInitDict?: EventInit): Event;
   readonly AT_TARGET: number;
@@ -5727,7 +6571,7 @@ interface ErrorEvent extends Event {
   readonly message: string;
 }
 
-declare let ErrorEvent: {
+declare var ErrorEvent: {
   prototype: ErrorEvent;
   new (type: string, eventInitDict?: ErrorEventInit): ErrorEvent;
 };
@@ -5775,7 +6619,7 @@ interface URLSearchParams {
   ): void;
 }
 
-declare let URLSearchParams: {
+declare var URLSearchParams: {
   prototype: URLSearchParams;
   new (
     init?: string[][] | Record<string, string> | string | URLSearchParams
@@ -5783,7 +6627,7 @@ declare let URLSearchParams: {
   toString(): string;
 };
 
-declare let URL: {
+declare var URL: {
   prototype: URL;
   new (url: string | URL, base?: string | URL): URL;
   /** Not implemented yet */
@@ -5802,7 +6646,7 @@ interface EventListenerObject {
   handleEvent(object: Event): void;
 }
 
-declare let AbortController: {
+declare var AbortController: {
   prototype: AbortController;
   new (): AbortController;
 };
@@ -5859,7 +6703,7 @@ interface AbortSignal extends EventTarget {
   ): void;
 }
 
-declare let AbortSignal: {
+declare var AbortSignal: {
   prototype: AbortSignal;
   new (): AbortSignal;
 };
@@ -5878,6 +6722,111 @@ type DOMHighResTimeStamp = number;
 // type EpochTimeStamp = number;
 type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
 
+/**
+ * Low-level JavaScriptCore API for accessing the native ES Module loader (not a Bun API)
+ *
+ * Before using this, be aware of a few things:
+ *
+ * **Using this incorrectly will crash your application**.
+ *
+ * This API may change any time JavaScriptCore is updated.
+ *
+ * Bun may rewrite ESM import specifiers to point to bundled code. This will
+ * be confusing when using this API, as it will return a string like
+ * "/node_modules.server.bun".
+ *
+ * Bun may inject additional imports into your code. This usually has a `bun:` prefix.
+ *
+ */
+declare var Loader: {
+  /**
+   * ESM module registry
+   *
+   * This lets you implement live reload in Bun. If you
+   * delete a module specifier from this map, the next time it's imported, it
+   * will be re-transpiled and loaded again.
+   *
+   * The keys are the module specifiers and the
+   * values are metadata about the module.
+   *
+   * The keys are an implementation detail for Bun that will change between
+   * versions.
+   *
+   * - Userland modules are an absolute file path
+   * - Virtual modules have a `bun:` prefix or `node:` prefix
+   * - JS polyfills start with `"/bun-vfs/"`. `"buffer"` is an example of a JS polyfill
+   * - If you have a `node_modules.bun` file, many modules will point to that file
+   *
+   * Virtual modules and JS polyfills are embedded in bun's binary. They don't
+   * point to anywhere in your local filesystem.
+   *
+   *
+   */
+  registry: Map<
+    string,
+    {
+      /**
+       * This refers to the state the ESM module is in
+       *
+       * TODO: make an enum for this number
+       *
+       *
+       */
+      state: number;
+      dependencies: string[];
+      /**
+       * Your application will probably crash if you mess with this.
+       */
+      module: any;
+    }
+  >;
+  /**
+   * For an already-evaluated module, return the dependencies as module specifiers
+   *
+   * This list is already sorted and uniqued.
+   *
+   * @example
+   *
+   * For this code:
+   * ```js
+   * // /foo.js
+   * import classNames from 'classnames';
+   * import React from 'react';
+   * import {createElement} from 'react';
+   * ```
+   *
+   * This would return:
+   * ```js
+   * Loader.dependencyKeysIfEvaluated("/foo.js")
+   * ["bun:wrap", "/path/to/node_modules/classnames/index.js", "/path/to/node_modules/react/index.js"]
+   * ```
+   *
+   * @param specifier - module specifier as it appears in transpiled source code
+   *
+   */
+  dependencyKeysIfEvaluated: (specifier: string) => string[];
+  /**
+   * The function JavaScriptCore internally calls when you use an import statement.
+   *
+   * This may return a path to `node_modules.server.bun`, which will be confusing.
+   *
+   * Consider {@link Bun.resolve} or {@link ImportMeta.resolve}
+   * instead.
+   *
+   * @param specifier - module specifier as it appears in transpiled source code
+   */
+  resolve: (specifier: string) => Promise<string>;
+  /**
+   * Synchronously resolve a module specifier
+   *
+   * This may return a path to `node_modules.server.bun`, which will be confusing.
+   *
+   * Consider {@link Bun.resolveSync}
+   * instead.
+   */
+  resolveSync: (specifier: string, from: string) => string;
+};
+
 
 // ./path.d.ts