bun-types 0.0.78 → 0.1.2

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`
@@ -192,6 +192,178 @@ declare module "bun" {
     syscall?: string | undefined;
   }
 
+  /**
+   * Concatenate an array of typed arrays into a single `ArrayBuffer`. This is a fast path.
+   *
+   * You can do this manually if you'd like, but this function will generally
+   * be a little faster.
+   *
+   * If you want a `Uint8Array` instead, consider `Buffer.concat`.
+   *
+   * @param buffers An array of typed arrays to concatenate.
+   * @returns An `ArrayBuffer` with the data from all the buffers.
+   *
+   * Here is similar code to do it manually, except about 30% slower:
+   * ```js
+   *   var chunks = [...];
+   *   var size = 0;
+   *   for (const chunk of chunks) {
+   *     size += chunk.byteLength;
+   *   }
+   *   var buffer = new ArrayBuffer(size);
+   *   var view = new Uint8Array(buffer);
+   *   var offset = 0;
+   *   for (const chunk of chunks) {
+   *     view.set(chunk, offset);
+   *     offset += chunk.byteLength;
+   *   }
+   *   return buffer;
+   * ```
+   *
+   * This function is faster because it uses uninitialized memory when copying. Since the entire
+   * length of the buffer is known, it is safe to use uninitialized memory.
+   */
+  export function concatArrayBuffers(
+    buffers: Array<ArrayBufferView | ArrayBufferLike>
+  ): ArrayBuffer;
+
+  /**
+   * Consume all data from a {@link ReadableStream} until it closes or errors.
+   *
+   * Concatenate the chunks into a single {@link ArrayBuffer}.
+   *
+   * Each chunk must be a TypedArray or an ArrayBuffer. If you need to support
+   * chunks of different types, consider {@link readableStreamToBlob}
+   *
+   * @param stream The stream to consume.
+   * @returns A promise that resolves with the concatenated chunks or the concatenated chunks as an `ArrayBuffer`.
+   */
+  export function readableStreamToArrayBuffer(
+    stream: ReadableStream
+  ): Promise<ArrayBuffer> | ArrayBuffer;
+
+  /**
+   * Consume all data from a {@link ReadableStream} until it closes or errors.
+   *
+   * Concatenate the chunks into a single {@link Blob}.
+   *
+   * @param stream The stream to consume.
+   * @returns A promise that resolves with the concatenated chunks as a {@link Blob}.
+   */
+  export function readableStreamToBlob(stream: ReadableStream): Promise<Blob>;
+
+  /**
+   * Consume all data from a {@link ReadableStream} until it closes or errors.
+   *
+   * Concatenate the chunks into a single string. Chunks must be a TypedArray or an ArrayBuffer. If you need to support chunks of different types, consider {@link readableStreamToBlob}.
+   *
+   * @param stream The stream to consume.
+   * @returns A promise that resolves with the concatenated chunks as a {@link String}.
+   */
+  export function readableStreamToText(stream: ReadableStream): Promise<string>;
+
+  /**
+   * Consume all data from a {@link ReadableStream} until it closes or errors.
+   *
+   * Concatenate the chunks into a single string and parse as JSON. Chunks must be a TypedArray or an ArrayBuffer. If you need to support chunks of different types, consider {@link readableStreamToBlob}.
+   *
+   * @param stream The stream to consume.
+   * @returns A promise that resolves with the concatenated chunks as a {@link String}.
+   */
+  export function readableStreamToJSON(stream: ReadableStream): Promise<any>;
+
+  /**
+   * Consume all data from a {@link ReadableStream} until it closes or errors.
+   *
+   * @param stream The stream to consume
+   * @returns A promise that resolves with the chunks as an array
+   *
+   */
+  export function readableStreamToArray<T>(
+    stream: ReadableStream
+  ): Promise<T[]> | T[];
+
+  /**
+   * Escape the following characters in a string:
+   *
+   * - `"` becomes `"&quot;"`
+   * - `&` becomes `"&amp;"`
+   * - `'` becomes `"&#x27;"`
+   * - `<` becomes `"&lt;"`
+   * - `>` becomes `"&gt;"`
+   *
+   * This function is optimized for large input. On an M1X, it processes 480 MB/s -
+   * 20 GB/s, depending on how much data is being escaped and whether there is non-ascii
+   * text.
+   *
+   * Non-string types will be converted to a string before escaping.
+   */
+  export function escapeHTML(input: string | object | number | boolean): string;
+
+  /**
+   * Convert a filesystem path to a file:// URL.
+   *
+   * @param path The path to convert.
+   * @returns A {@link URL} with the file:// scheme.
+   *
+   * @example
+   * ```js
+   * const url = Bun.pathToFileURL("/foo/bar.txt");
+   * console.log(url.href); // "file:///foo/bar.txt"
+   *```
+   *
+   * Internally, this function uses WebKit's URL API to
+   * convert the path to a file:// URL.
+   */
+  export function pathToFileURL(path: string): URL;
+
+  /**
+   * Convert a {@link URL} to a filesystem path.
+   * @param url The URL to convert.
+   * @returns A filesystem path.
+   * @throws If the URL is not a URL.
+   * @example
+   * ```js
+   * const path = Bun.fileURLToPath(new URL("file:///foo/bar.txt"));
+   * console.log(path); // "/foo/bar.txt"
+   * ```
+   */
+  export function fileURLToPath(url: URL): string;
+
+  /**
+   * Fast incremental writer that becomes an `ArrayBuffer` on end().
+   */
+  export class ArrayBufferSink {
+    constructor();
+
+    start(options?: {
+      asUint8Array?: boolean;
+      /**
+       * Preallocate an internal buffer of this size
+       * This can significantly improve performance when the chunk size is small
+       */
+      highWaterMark?: number;
+      /**
+       * On {@link ArrayBufferSink.flush}, return the written data as a `Uint8Array`.
+       * Writes will restart from the beginning of the buffer.
+       */
+      stream?: boolean;
+    }): void;
+
+    write(chunk: string | ArrayBufferView | ArrayBuffer): number;
+    /**
+     * Flush the internal buffer
+     *
+     * If {@link ArrayBufferSink.start} was passed a `stream` option, this will return a `ArrayBuffer`
+     * If {@link ArrayBufferSink.start} was passed a `stream` option and `asUint8Array`, this will return a `Uint8Array`
+     * Otherwise, this will return the number of bytes written since the last flush
+     *
+     * This API might change later to separate Uint8ArraySink and ArrayBufferSink
+     */
+    flush(): number | Uint8Array | ArrayBuffer;
+    end(): ArrayBuffer | Uint8Array;
+  }
+
   /**
    * [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) powered by the fastest system calls available for operating on files.
    *
@@ -365,7 +537,17 @@ declare module "bun" {
      *    const query = UserQuery;
      *    ```
      */
-    macros: MacroMap;
+    macros?: MacroMap;
+
+    autoImportJSX?: boolean;
+    allowBunRuntime?: boolean;
+    exports?: {
+      eliminate?: string[];
+      replace?: Record<string, string>;
+    };
+    treeShaking?: boolean;
+    trimUnusedImports?: boolean;
+    jsxOptimizationInline?: boolean;
   }
 
   /**
@@ -403,7 +585,27 @@ declare module "bun" {
      * @param code The code to transpile
      *
      */
-    transformSync(code: StringOrBuffer, loader?: JavaScriptLoader): string;
+    transformSync(
+      code: StringOrBuffer,
+      loader: JavaScriptLoader,
+      ctx: object
+    ): string;
+    /**
+     * Transpile code from TypeScript or JSX into valid JavaScript.
+     * This function does not resolve imports.
+     * @param code The code to transpile
+     * @param ctx An object to pass to macros
+     *
+     */
+    transformSync(code: StringOrBuffer, ctx: object): string;
+
+    /**
+     * Transpile code from TypeScript or JSX into valid JavaScript.
+     * This function does not resolve imports.
+     * @param code The code to transpile
+     *
+     */
+    transformSync(code: StringOrBuffer, loader: JavaScriptLoader): string;
 
     /**
      * Get a list of import paths and paths from a TypeScript, JSX, TSX, or JavaScript file.
@@ -521,9 +723,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 +774,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 +968,8 @@ declare module "bun" {
   }
   export const unsafe: unsafe;
 
+  type DigestEncoding = "hex" | "base64";
+
   /**
    * Are ANSI colors enabled for stdin and stdout?
    *
@@ -747,94 +987,1779 @@ declare module "bun" {
   export const main: string;
 
   /**
-   * Manually trigger the garbage collector
-   *
-   * This does two things:
-   * 1. It tells JavaScriptCore to run the garbage collector
-   * 2. It tells [mimalloc](https://github.com/microsoft/mimalloc) to clean up fragmented memory. Mimalloc manages the heap not used in JavaScriptCore.
+   * Manually trigger the garbage collector
+   *
+   * This does two things:
+   * 1. It tells JavaScriptCore to run the garbage collector
+   * 2. It tells [mimalloc](https://github.com/microsoft/mimalloc) to clean up fragmented memory. Mimalloc manages the heap not used in JavaScriptCore.
+   *
+   * @param force Synchronously run the garbage collector
+   */
+  export function gc(force: boolean): void;
+
+  /**
+   * JavaScriptCore engine's internal heap snapshot
+   *
+   * I don't know how to make this something Chrome or Safari can read.
+   *
+   * If you have any ideas, please file an issue https://github.com/Jarred-Sumner/bun
+   */
+  interface HeapSnapshot {
+    /** "2" */
+    version: string;
+
+    /** "Inspector" */
+    type: string;
+
+    nodes: number[];
+
+    nodeClassNames: string[];
+    edges: number[];
+    edgeTypes: string[];
+    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
+   * wraps
+   */
+  export function nanoseconds(): number;
+
+  /**
+   * Generate a heap snapshot for seeing where the heap is being used
+   */
+  export function generateHeapSnapshot(): HeapSnapshot;
+
+  /**
+   * The next time JavaScriptCore is idle, clear unused memory and attempt to reduce the heap size.
+   */
+  export function shrink(): void;
+
+  /**
+   * Open a file in your local editor. Auto-detects via `$VISUAL` || `$EDITOR`
+   *
+   * @param path path to open
+   */
+  export function openInEditor(path: string, options?: EditorOptions): void;
+
+  interface EditorOptions {
+    editor?: "vscode" | "subl";
+    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 =
+  | Uint8Array
+  | Int8Array
+  | Uint8ClampedArray
+  | Int16Array
+  | Uint16Array
+  | Int32Array
+  | Uint32Array
+  | Float32Array
+  | Float64Array;
+type TimeLike = string | number | Date;
+type StringOrBuffer = string | TypedArray | ArrayBufferLike;
+type PathLike = string | TypedArray | ArrayBufferLike;
+type PathOrFileDescriptor = PathLike | number;
+type NoParamCallback = VoidFunction;
+type BufferEncoding =
+  | "buffer"
+  | "utf8"
+  | "utf-8"
+  | "ascii"
+  | "utf16le"
+  | "ucs2"
+  | "ucs-2"
+  | "latin1"
+  | "binary";
+
+interface BufferEncodingOption {
+  encoding?: BufferEncoding;
+}
+
+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;
+
+    /**
+     * Function pointer to the native function
+     *
+     * If provided, instead of using dlsym() to lookup the function, Bun will use this instead.
+     * This pointer should not be null (0).
+     *
+     * This is useful if the library has already been loaded
+     * or if the module is also using Node-API.
+     */
+    ptr?: number | bigint;
+  }
+
+  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;
+  }
+
+  /**
+   * Open a library using `"bun:ffi"`
+   *
+   * @param name The name of the library or file path. This will be passed to `dlopen()`
+   * @param symbols Map of symbols to load where the key is the symbol name and the value is the {@link FFIFunction}
+   *
+   * @example
+   *
+   * ```js
+   * import {dlopen} from 'bun:ffi';
+   *
+   * const lib = dlopen("duckdb.dylib", {
+   *   get_version: {
+   *     returns: "cstring",
+   *     args: [],
+   *   },
+   * });
+   * lib.symbols.get_version();
+   * // "1.0.0"
+   * ```
+   *
+   * 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.
+   *
+   */
+  export function dlopen(name: string, symbols: Symbols): Library;
+
+  /**
+   * Turn a native library's function pointer into a JavaScript function
+   *
+   * Libraries using Node-API & bun:ffi in the same module could use this to skip an extra dlopen() step.
+   *
+   * @param fn {@link FFIFunction} declaration. `ptr` is required
+   *
+   * @example
+   *
+   * ```js
+   * import {CFunction} from 'bun:ffi';
+   *
+   * const getVersion = new CFunction({
+   *   returns: "cstring",
+   *   args: [],
+   *   ptr: myNativeLibraryGetVersion,
+   * });
+   * getVersion();
+   * getVersion.close();
+   * ```
+   *
+   * 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.
+   *
+   */
+  export function CFunction(
+    fn: FFIFunction & { ptr: number | bigint }
+  ): CallableFunction & {
+    /**
+     * Free the memory allocated by the wrapping function
+     */
+    close(): void;
+  };
+
+  /**
+   * Link a map of symbols to JavaScript functions
+   *
+   * This lets you use native libraries that were already loaded somehow. You usually will want {@link dlopen} instead.
+   *
+   * You could use this with Node-API to skip loading a second time.
+   *
+   * @param symbols Map of symbols to load where the key is the symbol name and the value is the {@link FFIFunction}
+   *
+   * @example
+   *
+   * ```js
+   * import { linkSymbols } from "bun:ffi";
+   *
+   * const [majorPtr, minorPtr, patchPtr] = getVersionPtrs();
+   *
+   * const lib = linkSymbols({
+   *   // Unlike with dlopen(), the names here can be whatever you want
+   *   getMajor: {
+   *     returns: "cstring",
+   *     args: [],
+   *
+   *     // Since this doesn't use dlsym(), you have to provide a valid ptr
+   *     // That ptr could be a number or a bigint
+   *     // An invalid pointer will crash your program.
+   *     ptr: majorPtr,
+   *   },
+   *   getMinor: {
+   *     returns: "cstring",
+   *     args: [],
+   *     ptr: minorPtr,
+   *   },
+   *   getPatch: {
+   *     returns: "cstring",
+   *     args: [],
+   *     ptr: patchPtr,
+   *   },
+   * });
+   *
+   * const [major, minor, patch] = [
+   *   lib.symbols.getMajor(),
+   *   lib.symbols.getMinor(),
+   *   lib.symbols.getPatch(),
+   * ];
+   * ```
+   *
+   * 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.
+   *
+   */
+  export function linkSymbols(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;
+}
+
+
+// ./sqlite.d.ts
+
+/**
+ * Fast SQLite3 driver for Bun.js
+ * @since v0.0.83
+ *
+ * @example
+ * ```ts
+ * import { Database } from 'bun:sqlite';
+ *
+ * var db = new Database('app.db');
+ * db.query('SELECT * FROM users WHERE name = ?').all('John');
+ * // => [{ id: 1, name: 'John' }]
+ * ```
+ *
+ * The following types can be used when binding parameters:
+ *
+ * | JavaScript type | SQLite type |
+ * | -------------- | ----------- |
+ * | `string` | `TEXT` |
+ * | `number` | `INTEGER` or `DECIMAL` |
+ * | `boolean` | `INTEGER` (1 or 0) |
+ * | `Uint8Array` | `BLOB` |
+ * | `Buffer` | `BLOB` |
+ * | `bigint` | `INTEGER` |
+ * | `null` | `NULL` |
+ */
+declare module "bun:sqlite" {
+  export class Database {
+    /**
+     * Open or create a SQLite3 database
+     *
+     * @param filename The filename of the database to open. Pass an empty string (`""` or undefined) or `":memory:"` for an in-memory database.
+     * @param options defaults to `{readwrite: true, create: true}`. If a number, then it's treated as `SQLITE_OPEN_*` constant flags.
+     *
+     * @example
+     *
+     * ```ts
+     * const db = new Database("mydb.sqlite");
+     * db.run("CREATE TABLE foo (bar TEXT)");
+     * db.run("INSERT INTO foo VALUES (?)", "baz");
+     * console.log(db.query("SELECT * FROM foo").all());
+     * ```
+     *
+     * @example
+     *
+     * Open an in-memory database
+     *
+     * ```ts
+     * const db = new Database(":memory:");
+     * db.run("CREATE TABLE foo (bar TEXT)");
+     * db.run("INSERT INTO foo VALUES (?)", "hiiiiii");
+     * console.log(db.query("SELECT * FROM foo").all());
+     * ```
+     *
+     * @example
+     *
+     * Open read-only
+     *
+     * ```ts
+     * const db = new Database("mydb.sqlite", {readonly: true});
+     * ```
+     */
+    constructor(
+      filename?: string,
+      options?:
+        | number
+        | {
+            /**
+             * Open the database as read-only (no write operations, no create).
+             *
+             * Equivalent to {@link constants.SQLITE_OPEN_READONLY}
+             */
+            readonly?: boolean;
+            /**
+             * Allow creating a new database
+             *
+             * Equivalent to {@link constants.SQLITE_OPEN_CREATE}
+             */
+            create?: boolean;
+            /**
+             * Open the database as read-write
+             *
+             * Equivalent to {@link constants.SQLITE_OPEN_READWRITE}
+             */
+            readwrite?: boolean;
+          }
+    );
+
+    /**
+     * This is an alias of `new Database()`
+     *
+     * See {@link Database}
+     */
+    static open(
+      filename: string,
+      options?:
+        | number
+        | {
+            /**
+             * Open the database as read-only (no write operations, no create).
+             *
+             * Equivalent to {@link constants.SQLITE_OPEN_READONLY}
+             */
+            readonly?: boolean;
+            /**
+             * Allow creating a new database
+             *
+             * Equivalent to {@link constants.SQLITE_OPEN_CREATE}
+             */
+            create?: boolean;
+            /**
+             * Open the database as read-write
+             *
+             * Equivalent to {@link constants.SQLITE_OPEN_READWRITE}
+             */
+            readwrite?: boolean;
+          }
+    ): Database;
+
+    /**
+     * Execute a SQL query **without returning any results**.
+     *
+     * This does not cache the query, so if you want to run a query multiple times, you should use {@link prepare} instead.
+     *
+     * @example
+     * ```ts
+     * db.run("CREATE TABLE foo (bar TEXT)");
+     * db.run("INSERT INTO foo VALUES (?)", "baz");
+     * ```
+     *
+     * Useful for queries like:
+     * - `CREATE TABLE`
+     * - `INSERT INTO`
+     * - `UPDATE`
+     * - `DELETE FROM`
+     * - `DROP TABLE`
+     * - `PRAGMA`
+     * - `ATTACH DATABASE`
+     * - `DETACH DATABASE`
+     * - `REINDEX`
+     * - `VACUUM`
+     * - `EXPLAIN ANALYZE`
+     * - `CREATE INDEX`
+     * - `CREATE TRIGGER`
+     * - `CREATE VIEW`
+     * - `CREATE VIRTUAL TABLE`
+     * - `CREATE TEMPORARY TABLE`
+     *
+     * @param sql The SQL query to run
+     *
+     * @param bindings Optional bindings for the query
+     *
+     * @returns `Database` instance
+     *
+     * Under the hood, this calls `sqlite3_prepare_v3` followed by `sqlite3_step` and `sqlite3_finalize`.
+     *
+     *  * The following types can be used when binding parameters:
+     *
+     * | JavaScript type | SQLite type |
+     * | -------------- | ----------- |
+     * | `string` | `TEXT` |
+     * | `number` | `INTEGER` or `DECIMAL` |
+     * | `boolean` | `INTEGER` (1 or 0) |
+     * | `Uint8Array` | `BLOB` |
+     * | `Buffer` | `BLOB` |
+     * | `bigint` | `INTEGER` |
+     * | `null` | `NULL` |
+     */
+    run<ParamsType = SQLQueryBindings>(
+      sqlQuery: string,
+      ...bindings: ParamsType[]
+    ): void;
+    /** 
+        This is an alias of {@link Database.prototype.run}
+     */
+    exec<ParamsType = SQLQueryBindings>(
+      sqlQuery: string,
+      ...bindings: ParamsType[]
+    ): void;
+
+    /**
+     * Compile a SQL query and return a {@link Statement} object. This is the
+     * same as {@link prepare} except that it caches the compiled query.
+     *
+     * This **does not execute** the query, but instead prepares it for later
+     * execution and caches the compiled query if possible.
+     *
+     * @example
+     * ```ts
+     * // compile the query
+     * const stmt = db.query("SELECT * FROM foo WHERE bar = ?");
+     * // run the query
+     * stmt.all("baz");
+     *
+     * // run the query again
+     * stmt.all();
+     * ```
+     *
+     * @param sql The SQL query to compile
+     *
+     * @returns `Statment` instance
+     *
+     * Under the hood, this calls `sqlite3_prepare_v3`.
+     *
+     */
+    query<ParamsType = SQLQueryBindings, ReturnType = any>(
+      sqlQuery: string
+    ): Statement<ParamsType, ReturnType>;
+
+    /**
+     * Compile a SQL query and return a {@link Statement} object.
+     *
+     * This does not cache the compiled query and does not execute the query.
+     *
+     * @example
+     * ```ts
+     * // compile the query
+     * const stmt = db.query("SELECT * FROM foo WHERE bar = ?");
+     * // run the query
+     * stmt.all("baz");
+     * ```
+     *
+     * @param sql The SQL query to compile
+     * @param params Optional bindings for the query
+     *
+     * @returns `Statment` instance
+     *
+     * Under the hood, this calls `sqlite3_prepare_v3`.
+     *
+     */
+    prepare<ParamsType = SQLQueryBindings, ReturnType = any>(
+      sql: string,
+      ...params: ParamsType[]
+    ): Statement<ParamsType, ReturnType>;
+
+    /**
+     * Is the database in a transaction?
+     *
+     * @returns `true` if the database is in a transaction, `false` otherwise
+     *
+     * @example
+     * ```ts
+     * db.run("CREATE TABLE foo (bar TEXT)");
+     * db.run("INSERT INTO foo VALUES (?)", "baz");
+     * db.run("BEGIN");
+     * db.run("INSERT INTO foo VALUES (?)", "qux");
+     * console.log(db.inTransaction());
+     * ```
+     */
+    get inTransaction(): boolean;
+
+    /**
+     * Close the database connection.
+     *
+     * It is safe to call this method multiple times. If the database is already
+     * closed, this is a no-op. Running queries after the database has been
+     * closed will throw an error.
+     *
+     * @example
+     * ```ts
+     * db.close();
+     * ```
+     * This is called automatically when the database instance is garbage collected.
+     *
+     * Internally, this calls `sqlite3_close_v2`.
+     */
+    close(): void;
+
+    /**
+     * The filename passed when `new Database()` was called
+     * @example
+     * ```ts
+     * const db = new Database("mydb.sqlite");
+     * console.log(db.filename);
+     * // => "mydb.sqlite"
+     * ```
+     */
+    readonly filename: string;
+
+    /**
+     * The underlying `sqlite3` database handle
+     *
+     * In native code, this is not a file descriptor, but an index into an array of database handles
+     */
+    readonly handle: number;
+
+    /**
+     * Load a SQLite3 extension
+     *
+     * macOS requires a custom SQLite3 library to be linked because the Apple build of SQLite for macOS disables loading extensions. See {@link Database.setCustomSQLite}
+     *
+     * Bun chooses the Apple build of SQLite on macOS because it brings a ~50% performance improvement.
+     *
+     * @param extension name/path of the extension to load
+     * @param entryPoint optional entry point of the extension
+     */
+    loadExtension(extension, entryPoint?: string): void;
+
+    /**
+     * Change the dynamic library path to SQLite
+     *
+     * @note macOS-only
+     *
+     * This only works before SQLite is loaded, so
+     * that's before you call `new Database()`.
+     *
+     * It can only be run once because this will load
+     * the SQLite library into the process.
+     *
+     * @param path The path to the SQLite library
+     *
+     */
+    static setCustomSQLite(path: string): boolean;
+
+    /**
+     * Creates a function that always runs inside a transaction. When the
+     * function is invoked, it will begin a new transaction. When the function
+     * returns, the transaction will be committed. If an exception is thrown,
+     * the transaction will be rolled back (and the exception will propagate as
+     * usual).
+     *
+     * @param insideTransaction The callback which runs inside a transaction
+     *
+     * @example
+     * ```ts
+     * // setup
+     * import { Database } from "bun:sqlite";
+     * const db = Database.open(":memory:");
+     * db.exec(
+     *   "CREATE TABLE cats (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT UNIQUE, age INTEGER)"
+     * );
+     *
+     * const insert = db.prepare("INSERT INTO cats (name, age) VALUES ($name, $age)");
+     * const insertMany = db.transaction((cats) => {
+     *   for (const cat of cats) insert.run(cat);
+     * });
+     *
+     * insertMany([
+     *   { $name: "Joey", $age: 2 },
+     *   { $name: "Sally", $age: 4 },
+     *   { $name: "Junior", $age: 1 },
+     * ]);
+     * ```
+     */
+    transaction(insideTransaction: (...args: any) => void): CallableFunction & {
+      /**
+       * uses "BEGIN DEFERRED"
+       */
+      deferred: (...args: any) => void;
+      /**
+       * uses "BEGIN IMMEDIATE"
+       */
+      immediate: (...args: any) => void;
+      /**
+       * uses "BEGIN EXCLUSIVE"
+       */
+      exclusive: (...args: any) => void;
+    };
+  }
+
+  /**
+   * A prepared statement.
+   *
+   * This is returned by {@link Database.prepare} and {@link Database.query}.
+   *
+   * @example
+   * ```ts
+   * const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?");
+   * stmt.all("baz");
+   * // => [{bar: "baz"}]
+   * ```
+   *
+   * @example
+   * ```ts
+   * const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?");
+   * stmt.get("baz");
+   * // => {bar: "baz"}
+   * ```
+   *
+   * @example
+   * ```ts
+   * const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?");
+   * stmt.run("baz");
+   * // => undefined
+   * ```
+   */
+  export class Statement<ParamsType = SQLQueryBindings, ReturnType = any> {
+    /**
+     * Creates a new prepared statement from native code.
+     *
+     * This is used internally by the {@link Database} class. Probably you don't need to call this yourself.
+     */
+    constructor(nativeHandle: any);
+
+    /**
+     * Execute the prepared statement and return all results as objects.
+     *
+     * @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.
+     *
+     * @example
+     * ```ts
+     * const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?");
+     *
+     * stmt.all("baz");
+     * // => [{bar: "baz"}]
+     *
+     * stmt.all();
+     * // => [{bar: "baz"}]
+     *
+     * stmt.all("foo");
+     * // => [{bar: "foo"}]
+     * ```
+     */
+    all(...params: ParamsType[]): ReturnType[];
+
+    /**
+     * Execute the prepared statement and return **the first** result.
+     *
+     * If no result is returned, this returns `null`.
+     *
+     * @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.
+     *
+     * @example
+     * ```ts
+     * const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?");
+     *
+     * stmt.all("baz");
+     * // => [{bar: "baz"}]
+     *
+     * stmt.all();
+     * // => [{bar: "baz"}]
+     *
+     * stmt.all("foo");
+     * // => [{bar: "foo"}]
+     * ```
+     *
+     * The following types can be used when binding parameters:
+     *
+     * | JavaScript type | SQLite type |
+     * | -------------- | ----------- |
+     * | `string` | `TEXT` |
+     * | `number` | `INTEGER` or `DECIMAL` |
+     * | `boolean` | `INTEGER` (1 or 0) |
+     * | `Uint8Array` | `BLOB` |
+     * | `Buffer` | `BLOB` |
+     * | `bigint` | `INTEGER` |
+     * | `null` | `NULL` |
+     *
+     */
+    get(...params: ParamsType[]): ReturnType | null;
+
+    /**
+     * Execute the prepared statement. This returns `undefined`.
+     *
+     * @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.
+     *
+     * @example
+     * ```ts
+     * const stmt = db.prepare("UPDATE foo SET bar = ?");
+     * stmt.run("baz");
+     * // => undefined
+     *
+     * stmt.run();
+     * // => undefined
+     *
+     * stmt.run("foo");
+     * // => undefined
+     * ```
+     *
+     * The following types can be used when binding parameters:
+     *
+     * | JavaScript type | SQLite type |
+     * | -------------- | ----------- |
+     * | `string` | `TEXT` |
+     * | `number` | `INTEGER` or `DECIMAL` |
+     * | `boolean` | `INTEGER` (1 or 0) |
+     * | `Uint8Array` | `BLOB` |
+     * | `Buffer` | `BLOB` |
+     * | `bigint` | `INTEGER` |
+     * | `null` | `NULL` |
+     *
+     */
+    run(...params: ParamsType[]): void;
+
+    /**
+     * Execute the prepared statement and return the results as an array of arrays.
+     *
+     * This is a little faster than {@link all}.
+     *
+     * @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.
+     *
+     * @example
+     * ```ts
+     * const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?");
+     *
+     * stmt.values("baz");
+     * // => [['baz']]
+     *
+     * stmt.values();
+     * // => [['baz']]
+     *
+     * stmt.values("foo");
+     * // => [['foo']]
+     * ```
+     *
+     * The following types can be used when binding parameters:
+     *
+     * | JavaScript type | SQLite type |
+     * | -------------- | ----------- |
+     * | `string` | `TEXT` |
+     * | `number` | `INTEGER` or `DECIMAL` |
+     * | `boolean` | `INTEGER` (1 or 0) |
+     * | `Uint8Array` | `BLOB` |
+     * | `Buffer` | `BLOB` |
+     * | `bigint` | `INTEGER` |
+     * | `null` | `NULL` |
+     *
+     */
+    values(
+      ...params: ParamsType[]
+    ): Array<Array<string | bigint | number | boolean | Uint8Array>>;
+
+    /**
+     * The names of the columns returned by the prepared statement.
+     * @example
+     * ```ts
+     * const stmt = db.prepare("SELECT bar FROM foo WHERE bar = ?");
+     *
+     * console.log(stmt.columnNames);
+     * // => ["bar"]
+     * ```
+     */
+    readonly columnNames: string[];
+
+    /**
+     * The number of parameters expected in the prepared statement.
+     * @example
+     * ```ts
+     * const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?");
+     * console.log(stmt.paramsCount);
+     * // => 1
+     * ```
+     * @example
+     * ```ts
+     * const stmt = db.prepare("SELECT * FROM foo WHERE bar = ? AND baz = ?");
+     * console.log(stmt.paramsCount);
+     * // => 2
+     * ```
+     *
+     */
+    readonly paramsCount: number;
+
+    /**
+     * Finalize the prepared statement, freeing the resources used by the
+     * statement and preventing it from being executed again.
+     *
+     * This is called automatically when the prepared statement is garbage collected.
+     *
+     * It is safe to call this multiple times. Calling this on a finalized
+     * statement has no effect.
+     *
+     * Internally, this calls `sqlite3_finalize`.
+     */
+    finalize(): void;
+
+    /**
+     * Return the expanded SQL string for the prepared statement.
+     *
+     * Internally, this calls `sqlite3_expanded_sql()` on the underlying `sqlite3_stmt`.
+     *
+     * @example
+     * ```ts
+     * const stmt = db.prepare("SELECT * FROM foo WHERE bar = ?", "baz");
+     * console.log(stmt.toString());
+     * // => "SELECT * FROM foo WHERE bar = 'baz'"
+     * console.log(stmt);
+     * // => "SELECT * FROM foo WHERE bar = 'baz'"
+     * ```
+     */
+    toString(): string;
+
+    /**
+     * Native object representing the underlying `sqlite3_stmt`
+     *
+     * This is left untyped because the ABI of the native bindings may change at any time.
+     */
+    readonly native: any;
+  }
+
+  /**
+   * Constants from `sqlite3.h`
+   *
+   * This list isn't exhaustive, but some of the ones which are relevant
+   */
+  export const constants: {
+    /**
+     * Open the database as read-only (no write operations, no create).
+     * @value 0x00000001
+     */
+    SQLITE_OPEN_READONLY: number;
+    /**
+     * Open the database for reading and writing
+     * @value 0x00000002
+     */
+    SQLITE_OPEN_READWRITE: number;
+    /**
+     * Allow creating a new database
+     * @value 0x00000004
+     */
+    SQLITE_OPEN_CREATE: number;
+    /**
+     *
+     * @value 0x00000008
+     */
+    SQLITE_OPEN_DELETEONCLOSE: number;
+    /**
+     *
+     * @value 0x00000010
+     */
+    SQLITE_OPEN_EXCLUSIVE: number;
+    /**
+     *
+     * @value 0x00000020
+     */
+    SQLITE_OPEN_AUTOPROXY: number;
+    /**
+     *
+     * @value 0x00000040
+     */
+    SQLITE_OPEN_URI: number;
+    /**
+     *
+     * @value 0x00000080
+     */
+    SQLITE_OPEN_MEMORY: number;
+    /**
+     *
+     * @value 0x00000100
+     */
+    SQLITE_OPEN_MAIN_DB: number;
+    /**
+     *
+     * @value 0x00000200
+     */
+    SQLITE_OPEN_TEMP_DB: number;
+    /**
+     *
+     * @value 0x00000400
+     */
+    SQLITE_OPEN_TRANSIENT_DB: number;
+    /**
+     *
+     * @value 0x00000800
+     */
+    SQLITE_OPEN_MAIN_JOURNAL: number;
+    /**
+     *
+     * @value 0x00001000
+     */
+    SQLITE_OPEN_TEMP_JOURNAL: number;
+    /**
+     *
+     * @value 0x00002000
+     */
+    SQLITE_OPEN_SUBJOURNAL: number;
+    /**
+     *
+     * @value 0x00004000
+     */
+    SQLITE_OPEN_SUPER_JOURNAL: number;
+    /**
+     *
+     * @value 0x00008000
+     */
+    SQLITE_OPEN_NOMUTEX: number;
+    /**
+     *
+     * @value 0x00010000
+     */
+    SQLITE_OPEN_FULLMUTEX: number;
+    /**
+     *
+     * @value 0x00020000
+     */
+    SQLITE_OPEN_SHAREDCACHE: number;
+    /**
+     *
+     * @value 0x00040000
+     */
+    SQLITE_OPEN_PRIVATECACHE: number;
+    /**
+     *
+     * @value 0x00080000
+     */
+    SQLITE_OPEN_WAL: number;
+    /**
+     *
+     * @value 0x01000000
+     */
+    SQLITE_OPEN_NOFOLLOW: number;
+    /**
+     *
+     * @value 0x02000000
+     */
+    SQLITE_OPEN_EXRESCODE: number;
+    /**
+     *
+     * @value 0x01
+     */
+    SQLITE_PREPARE_PERSISTENT: number;
+    /**
+     *
+     * @value 0x02
+     */
+    SQLITE_PREPARE_NORMALIZE: number;
+    /**
+     *
+     * @value 0x04
+     */
+    SQLITE_PREPARE_NO_VTAB: number;
+  };
+
+  /**
+   * The native module implementing the sqlite3 C bindings
    *
-   * @param force Synchronously run the garbage collector
-   */
-  export function gc(force: boolean): void;
-
-  /**
-   * JavaScriptCore engine's internal heap snapshot
+   * It is lazily-initialized, so this will return `undefined` until the first
+   * call to new Database().
    *
-   * I don't know how to make this something Chrome or Safari can read.
+   * The native module makes no gurantees about ABI stability, so it is left
+   * untyped
    *
-   * If you have any ideas, please file an issue https://github.com/Jarred-Sumner/bun
-   */
-  interface HeapSnapshot {
-    /** "2" */
-    version: string;
-
-    /** "Inspector" */
-    type: string;
-
-    nodes: number[];
-
-    nodeClassNames: string[];
-    edges: number[];
-    edgeTypes: string[];
-    edgeNames: string[];
-  }
-
-  /**
-   * Generate a heap snapshot for seeing where the heap is being used
-   */
-  export function generateHeapSnapshot(): HeapSnapshot;
-
-  /**
-   * The next time JavaScriptCore is idle, clear unused memory and attempt to reduce the heap size.
-   */
-  export function shrink(): void;
-
-  /**
-   * Open a file in your local editor. Auto-detects via `$VISUAL` || `$EDITOR`
+   * If you need to use it directly for some reason, please let us know because
+   * that probably points to a deficiency in this API.
    *
-   * @param path path to open
    */
-  export function openInEditor(path: string, options?: EditorOptions): void;
-
-  interface EditorOptions {
-    editor?: "vscode" | "subl";
-    line?: number;
-    column?: number;
-  }
-}
+  export var native: any;
 
-type TypedArray =
-  | Uint8Array
-  | Int8Array
-  | Uint8ClampedArray
-  | Int16Array
-  | Uint16Array
-  | Int32Array
-  | Uint32Array
-  | Float32Array
-  | Float64Array;
-type TimeLike = string | number | Date;
-type StringOrBuffer = string | TypedArray | ArrayBufferLike;
-type PathLike = string | TypedArray | ArrayBufferLike;
-type PathOrFileDescriptor = PathLike | number;
-type NoParamCallback = VoidFunction;
-type BufferEncoding =
-  | "buffer"
-  | "utf8"
-  | "utf-8"
-  | "ascii"
-  | "utf16le"
-  | "ucs2"
-  | "ucs-2"
-  | "latin1"
-  | "binary";
+  export type SQLQueryBindings =
+    | string
+    | bigint
+    | TypedArray
+    | number
+    | boolean
+    | null
+    | Record<string, string | bigint | TypedArray | number | boolean | null>;
 
-interface BufferEncodingOption {
-  encoding?: BufferEncoding;
+  export default Database;
 }
 
-declare var Bun: typeof import("bun");
-
 
 // ./fs.d.ts
 
@@ -4724,7 +6649,7 @@ interface Process {
   setuid(id: number | string): void;
 }
 
-declare let process: Process;
+declare var process: Process;
 
 interface BlobInterface {
   text(): Promise<string>;
@@ -4765,7 +6690,7 @@ interface Headers {
   ): void;
 }
 
-declare let Headers: {
+declare var Headers: {
   prototype: Headers;
   new (init?: HeadersInit): Headers;
 };
@@ -5009,8 +6934,13 @@ type ReferrerPolicy =
   | "unsafe-url";
 type RequestInfo = Request | string;
 
-type BodyInit = XMLHttpRequestBodyInit;
+type BodyInit = ReadableStream | XMLHttpRequestBodyInit;
 type XMLHttpRequestBodyInit = Blob | BufferSource | string;
+type ReadableStreamController<T> = ReadableStreamDefaultController<T>;
+type ReadableStreamDefaultReadResult<T> =
+  | ReadableStreamDefaultReadValueResult<T>
+  | ReadableStreamDefaultReadDoneResult;
+type ReadableStreamReader<T> = ReadableStreamDefaultReader<T>;
 
 interface RequestInit {
   /**
@@ -5223,7 +7153,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 +7533,7 @@ interface EventTarget {
   ): void;
 }
 
-declare let EventTarget: {
+declare var EventTarget: {
   prototype: EventTarget;
   new (): EventTarget;
 };
@@ -5707,7 +7637,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 +7657,7 @@ interface ErrorEvent extends Event {
   readonly message: string;
 }
 
-declare let ErrorEvent: {
+declare var ErrorEvent: {
   prototype: ErrorEvent;
   new (type: string, eventInitDict?: ErrorEventInit): ErrorEvent;
 };
@@ -5775,7 +7705,7 @@ interface URLSearchParams {
   ): void;
 }
 
-declare let URLSearchParams: {
+declare var URLSearchParams: {
   prototype: URLSearchParams;
   new (
     init?: string[][] | Record<string, string> | string | URLSearchParams
@@ -5783,7 +7713,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 +7732,7 @@ interface EventListenerObject {
   handleEvent(object: Event): void;
 }
 
-declare let AbortController: {
+declare var AbortController: {
   prototype: AbortController;
   new (): AbortController;
 };
@@ -5859,7 +7789,7 @@ interface AbortSignal extends EventTarget {
   ): void;
 }
 
-declare let AbortSignal: {
+declare var AbortSignal: {
   prototype: AbortSignal;
   new (): AbortSignal;
 };
@@ -5878,6 +7808,409 @@ 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;
+};
+
+/** This Streams API interface represents a readable stream of byte data. The Fetch API offers a concrete instance of a ReadableStream through the body property of a Response object. */
+interface ReadableStream<R = any> {
+  readonly locked: boolean;
+  cancel(reason?: any): Promise<void>;
+  getReader(): ReadableStreamDefaultReader<R>;
+  pipeThrough<T>(
+    transform: ReadableWritablePair<T, R>,
+    options?: StreamPipeOptions
+  ): ReadableStream<T>;
+  pipeTo(
+    destination: WritableStream<R>,
+    options?: StreamPipeOptions
+  ): Promise<void>;
+  tee(): [ReadableStream<R>, ReadableStream<R>];
+  forEach(
+    callbackfn: (value: any, key: number, parent: ReadableStream<R>) => void,
+    thisArg?: any
+  ): void;
+}
+
+declare var ReadableStream: {
+  prototype: ReadableStream;
+  new <R = any>(
+    underlyingSource?: DirectUnderlyingSource<R> | UnderlyingSource<R>,
+    strategy?: QueuingStrategy<R>
+  ): ReadableStream<R>;
+};
+
+interface QueuingStrategy<T = any> {
+  highWaterMark?: number;
+  size?: QueuingStrategySize<T>;
+}
+
+interface QueuingStrategyInit {
+  /**
+   * Creates a new ByteLengthQueuingStrategy with the provided high water mark.
+   *
+   * Note that the provided high water mark will not be validated ahead of time. Instead, if it is negative, NaN, or not a number, the resulting ByteLengthQueuingStrategy will cause the corresponding stream constructor to throw.
+   */
+  highWaterMark: number;
+}
+
+/** This Streams API interface provides a built-in byte length queuing strategy that can be used when constructing streams. */
+interface ByteLengthQueuingStrategy extends QueuingStrategy<ArrayBufferView> {
+  readonly highWaterMark: number;
+  readonly size: QueuingStrategySize<ArrayBufferView>;
+}
+
+declare var ByteLengthQueuingStrategy: {
+  prototype: ByteLengthQueuingStrategy;
+  new (init: QueuingStrategyInit): ByteLengthQueuingStrategy;
+};
+
+interface ReadableStreamDefaultController<R = any> {
+  readonly desiredSize: number | null;
+  close(): void;
+  enqueue(chunk?: R): void;
+  error(e?: any): void;
+}
+
+interface ReadableStreamDirectController {
+  close(error?: Error): void;
+  write(data: ArrayBufferView | ArrayBuffer | string): number | Promise<number>;
+  end(): number | Promise<number>;
+  flush(): number | Promise<number>;
+  start(): void;
+}
+
+declare var ReadableStreamDefaultController: {
+  prototype: ReadableStreamDefaultController;
+  new (): ReadableStreamDefaultController;
+};
+
+interface ReadableStreamDefaultReader<R = any>
+  extends ReadableStreamGenericReader {
+  read(): Promise<ReadableStreamDefaultReadResult<R>>;
+  releaseLock(): void;
+}
+
+declare var ReadableStreamDefaultReader: {
+  prototype: ReadableStreamDefaultReader;
+  new <R = any>(stream: ReadableStream<R>): ReadableStreamDefaultReader<R>;
+};
+
+interface ReadableStreamGenericReader {
+  readonly closed: Promise<undefined>;
+  cancel(reason?: any): Promise<void>;
+}
+
+interface ReadableStreamDefaultReadDoneResult {
+  done: true;
+  value?: undefined;
+}
+
+interface ReadableStreamDefaultReadValueResult<T> {
+  done: false;
+  value: T;
+}
+
+interface ReadableWritablePair<R = any, W = any> {
+  readable: ReadableStream<R>;
+  /**
+   * Provides a convenient, chainable way of piping this readable stream through a transform stream (or any other { writable, readable } pair). It simply pipes the stream into the writable side of the supplied pair, and returns the readable side for further use.
+   *
+   * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
+   */
+  writable: WritableStream<W>;
+}
+
+/** This Streams API interface provides a standard abstraction for writing streaming data to a destination, known as a sink. This object comes with built-in backpressure and queuing. */
+interface WritableStream<W = any> {
+  readonly locked: boolean;
+  abort(reason?: any): Promise<void>;
+  close(): Promise<void>;
+  getWriter(): WritableStreamDefaultWriter<W>;
+}
+
+declare var WritableStream: {
+  prototype: WritableStream;
+  new <W = any>(
+    underlyingSink?: UnderlyingSink<W>,
+    strategy?: QueuingStrategy<W>
+  ): WritableStream<W>;
+};
+
+/** This Streams API interface represents a controller allowing control of a WritableStream's state. When constructing a WritableStream, the underlying sink is given a corresponding WritableStreamDefaultController instance to manipulate. */
+interface WritableStreamDefaultController {
+  error(e?: any): void;
+}
+
+declare var WritableStreamDefaultController: {
+  prototype: WritableStreamDefaultController;
+  new (): WritableStreamDefaultController;
+};
+
+/** This Streams API interface is the object returned by WritableStream.getWriter() and once created locks the < writer to the WritableStream ensuring that no other streams can write to the underlying sink. */
+interface WritableStreamDefaultWriter<W = any> {
+  readonly closed: Promise<undefined>;
+  readonly desiredSize: number | null;
+  readonly ready: Promise<undefined>;
+  abort(reason?: any): Promise<void>;
+  close(): Promise<void>;
+  releaseLock(): void;
+  write(chunk?: W): Promise<void>;
+}
+
+declare var WritableStreamDefaultWriter: {
+  prototype: WritableStreamDefaultWriter;
+  new <W = any>(stream: WritableStream<W>): WritableStreamDefaultWriter<W>;
+};
+
+interface TransformerFlushCallback<O> {
+  (controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
+}
+
+interface TransformerStartCallback<O> {
+  (controller: TransformStreamDefaultController<O>): any;
+}
+
+interface TransformerTransformCallback<I, O> {
+  (
+    chunk: I,
+    controller: TransformStreamDefaultController<O>
+  ): void | PromiseLike<void>;
+}
+
+interface UnderlyingSinkAbortCallback {
+  (reason?: any): void | PromiseLike<void>;
+}
+
+interface UnderlyingSinkCloseCallback {
+  (): void | PromiseLike<void>;
+}
+
+interface UnderlyingSinkStartCallback {
+  (controller: WritableStreamDefaultController): any;
+}
+
+interface UnderlyingSinkWriteCallback<W> {
+  (
+    chunk: W,
+    controller: WritableStreamDefaultController
+  ): void | PromiseLike<void>;
+}
+
+interface UnderlyingSourceCancelCallback {
+  (reason?: any): void | PromiseLike<void>;
+}
+
+interface UnderlyingSink<W = any> {
+  abort?: UnderlyingSinkAbortCallback;
+  close?: UnderlyingSinkCloseCallback;
+  start?: UnderlyingSinkStartCallback;
+  type?: undefined | "default" | "bytes";
+  write?: UnderlyingSinkWriteCallback<W>;
+}
+
+interface UnderlyingSource<R = any> {
+  cancel?: UnderlyingSourceCancelCallback;
+  pull?: UnderlyingSourcePullCallback<R>;
+  start?: UnderlyingSourceStartCallback<R>;
+  type?: undefined;
+}
+
+interface DirectUnderlyingSource<R = any> {
+  cancel?: UnderlyingSourceCancelCallback;
+  pull: (
+    controller: ReadableStreamDirectController
+  ) => void | PromiseLike<void>;
+  type: "direct";
+}
+
+interface UnderlyingSourcePullCallback<R> {
+  (controller: ReadableStreamController<R>): void | PromiseLike<void>;
+}
+
+interface UnderlyingSourceStartCallback<R> {
+  (controller: ReadableStreamController<R>): any;
+}
+
+interface GenericTransformStream {
+  readonly readable: ReadableStream;
+  readonly writable: WritableStream;
+}
+
+interface TransformStream<I = any, O = any> {
+  readonly readable: ReadableStream<O>;
+  readonly writable: WritableStream<I>;
+}
+
+declare var TransformStream: {
+  prototype: TransformStream;
+  new <I = any, O = any>(
+    transformer?: Transformer<I, O>,
+    writableStrategy?: QueuingStrategy<I>,
+    readableStrategy?: QueuingStrategy<O>
+  ): TransformStream<I, O>;
+};
+
+interface TransformStreamDefaultController<O = any> {
+  readonly desiredSize: number | null;
+  enqueue(chunk?: O): void;
+  error(reason?: any): void;
+  terminate(): void;
+}
+
+declare var TransformStreamDefaultController: {
+  prototype: TransformStreamDefaultController;
+  new (): TransformStreamDefaultController;
+};
+
+interface StreamPipeOptions {
+  preventAbort?: boolean;
+  preventCancel?: boolean;
+  /**
+   * Pipes this readable stream to a given writable stream destination. The way in which the piping process behaves under various error conditions can be customized with a number of passed options. It returns a promise that fulfills when the piping process completes successfully, or rejects if any errors were encountered.
+   *
+   * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
+   *
+   * Errors and closures of the source and destination streams propagate as follows:
+   *
+   * An error in this source readable stream will abort destination, unless preventAbort is truthy. The returned promise will be rejected with the source's error, or with any error that occurs during aborting the destination.
+   *
+   * An error in destination will cancel this source readable stream, unless preventCancel is truthy. The returned promise will be rejected with the destination's error, or with any error that occurs during canceling the source.
+   *
+   * When this source readable stream closes, destination will be closed, unless preventClose is truthy. The returned promise will be fulfilled once this process completes, unless an error is encountered while closing the destination, in which case it will be rejected with that error.
+   *
+   * If destination starts out closed or closing, this source readable stream will be canceled, unless preventCancel is true. The returned promise will be rejected with an error indicating piping to a closed stream failed, or with any error that occurs during canceling the source.
+   *
+   * The signal option can be set to an AbortSignal to allow aborting an ongoing pipe operation via the corresponding AbortController. In this case, this source readable stream will be canceled, and destination aborted, unless the respective options preventCancel or preventAbort are set.
+   */
+  preventClose?: boolean;
+  signal?: AbortSignal;
+}
+
+/** This Streams API interface provides a built-in byte length queuing strategy that can be used when constructing streams. */
+interface CountQueuingStrategy extends QueuingStrategy {
+  readonly highWaterMark: number;
+  readonly size: QueuingStrategySize;
+}
+
+declare var CountQueuingStrategy: {
+  prototype: CountQueuingStrategy;
+  new (init: QueuingStrategyInit): CountQueuingStrategy;
+};
+
+interface QueuingStrategySize<T = any> {
+  (chunk?: T): number;
+}
+
+interface Transformer<I = any, O = any> {
+  flush?: TransformerFlushCallback<O>;
+  readableType?: undefined;
+  start?: TransformerStartCallback<O>;
+  transform?: TransformerTransformCallback<I, O>;
+  writableType?: undefined;
+}
+
 
 // ./path.d.ts
 
@@ -6109,7 +8442,7 @@ declare module "node:path/win32" {
  */
 
 declare module "bun:test" {
-  export function describe(label: string, body: () => {}): any;
+  export function describe(label: string, body: () => void): any;
   export function it(label: string, test: () => void | Promise<any>): any;
   export function test(label: string, test: () => void | Promise<any>): any;
 
@@ -6126,3 +8459,67 @@ declare module "test" {
   export = BunTestModule;
 }
 
+
+// ./jsc.d.ts
+
+declare module "bun:jsc" {
+  export function describe(value: any): string;
+  export function describeArray(args: any[]): string;
+  export function gcAndSweep(): void;
+  export function fullGC(): void;
+  export function edenGC(): void;
+  export function heapSize(): number;
+  export function heapStats(): {
+    heapSize: number;
+    heapCapacity: number;
+    extraMemorySize: number;
+    objectCount: number;
+    protectedObjectCount: number;
+    globalObjectCount: number;
+    protectedGlobalObjectCount: number;
+    objectTypeCounts: Record<string, number>;
+    protectedObjectTypeCounts: Record<string, number>;
+  };
+  export function memoryUsage(): {
+    current: number;
+    peak: number;
+    currentCommit: number;
+    peakCommit: number;
+    pageFaults: number;
+  };
+  export function getRandomSeed(): number;
+  export function setRandomSeed(value: number): void;
+  export function isRope(input: string): boolean;
+  export function callerSourceOrigin(): string;
+  export function noFTL(func: Function): Function;
+  export function noOSRExitFuzzing(func: Function): Function;
+  export function optimizeNextInvocation(func: Function): Function;
+  export function numberOfDFGCompiles(func: Function): number;
+  export function releaseWeakRefs(): void;
+  export function totalCompileTime(func: Function): number;
+  export function reoptimizationRetryCount(func: Function): number;
+  export function drainMicrotasks(): void;
+
+  /**
+   * This returns objects which native code has explicitly protected from being
+   * garbage collected
+   *
+   * By calling this function you create another reference to the object, which
+   * will further prevent it from being garbage collected
+   *
+   * This function is mostly a debugging tool for bun itself.
+   *
+   * Warning: not all objects returned are supposed to be observable from JavaScript
+   */
+  export function getProtectedObjects(): any[];
+
+  /**
+   * Start a remote debugging socket server on the given port.
+   *
+   * This exposes JavaScriptCore's built-in debugging server.
+   *
+   * This is untested. May not be supported yet on macOS
+   */
+  export function startRemoteDebugger(host?: string, port?: number): void;
+}
+