bun-types 1.3.2-canary.20251105T140650 → 1.3.2

package/docs/{api/sqlite.md → runtime/sqlite.mdx}

@@ -1,11 +1,20 @@
+---
+title: SQLite
+description: Bun natively implements a high-performance SQLite3 driver.
+---
+
 Bun natively implements a high-performance [SQLite3](https://www.sqlite.org/) driver. To use it import from the built-in `bun:sqlite` module.
 
-```ts
+```ts db.ts icon="/icons/typescript.svg"
 import { Database } from "bun:sqlite";
 
 const db = new Database(":memory:");
 const query = db.query("select 'Hello world' as message;");
-query.get(); // => { message: "Hello world" }
+query.get();
+```
+
+```txt
+{ message: "Hello world" }
 ```
 
 The API is simple, synchronous, and fast. Credit to [better-sqlite3](https://github.com/JoshuaWise/better-sqlite3) and its contributors for inspiring the API of `bun:sqlite`.
@@ -23,13 +32,18 @@ Features include:
 
 The `bun:sqlite` module is roughly 3-6x faster than `better-sqlite3` and 8-9x faster than `deno.land/x/sqlite` for read queries. Each driver was benchmarked against the [Northwind Traders](https://github.com/jpwhite3/northwind-SQLite3/blob/46d5f8a64f396f87cd374d1600dbf521523980e8/Northwind_large.sqlite.zip) dataset. View and run the [benchmark source](https://github.com/oven-sh/bun/tree/main/bench/sqlite).
 
-{% image width="738" alt="SQLite benchmarks for Bun, better-sqlite3, and deno.land/x/sqlite" src="https://user-images.githubusercontent.com/709451/168459263-8cd51ca3-a924-41e9-908d-cf3478a3b7f3.png" caption="Benchmarked on an M1 MacBook Pro (64GB) running macOS 12.3.1" /%}
+<Frame caption="Benchmarked on an M1 MacBook Pro (64GB) running macOS 12.3.1">
+  ![SQLite benchmarks for Bun, better-sqlite3, and
+  deno.land/x/sqlite](https://user-images.githubusercontent.com/709451/168459263-8cd51ca3-a924-41e9-908d-cf3478a3b7f3.png)
+</Frame>
+
+---
 
 ## Database
 
 To open or create a SQLite3 database:
 
-```ts
+```ts db.ts icon="/icons/typescript.svg"
 import { Database } from "bun:sqlite";
 
 const db = new Database("mydb.sqlite");
@@ -37,7 +51,7 @@ const db = new Database("mydb.sqlite");
 
 To open an in-memory database:
 
-```ts
+```ts db.ts icon="/icons/typescript.svg"
 import { Database } from "bun:sqlite";
 
 // all of these do the same thing
@@ -48,64 +62,50 @@ const db = new Database("");
 
 To open in `readonly` mode:
 
-```ts
+```ts db.ts icon="/icons/typescript.svg" highlight={2}
 import { Database } from "bun:sqlite";
 const db = new Database("mydb.sqlite", { readonly: true });
 ```
 
 To create the database if the file doesn't exist:
 
-```ts
+```ts db.ts icon="/icons/typescript.svg" highlight={2}
 import { Database } from "bun:sqlite";
 const db = new Database("mydb.sqlite", { create: true });
 ```
 
 ### Strict mode
 
-{% callout %}
-Added in Bun v1.1.14
-{% /callout %}
-
 By default, `bun:sqlite` requires binding parameters to include the `$`, `:`, or `@` prefix, and does not throw an error if a parameter is missing.
 
 To instead throw an error when a parameter is missing and allow binding without a prefix, set `strict: true` on the `Database` constructor:
 
-<!-- prettier-ignore -->
-```ts
+```ts db.ts icon="/icons/typescript.svg" highlight={3}
 import { Database } from "bun:sqlite";
 
-const strict = new Database(
-  ":memory:",
-  { strict: true }
-);
+const strict = new Database(":memory:", { strict: true });
 
 // throws error because of the typo:
-const query = strict
-  .query("SELECT $message;")
-  .all({ message: "Hello world" });
+const query = strict.query("SELECT $message;").all({ message: "Hello world" });
 
-const notStrict = new Database(
-  ":memory:"
-);
+const notStrict = new Database(":memory:");
 // does not throw error:
-notStrict
-  .query("SELECT $message;")
-  .all({ message: "Hello world" });
+notStrict.query("SELECT $message;").all({ message: "Hello world" });
 ```
 
 ### Load via ES module import
 
 You can also use an import attribute to load a database.
 
-```ts
-import db from "./mydb.sqlite" with { "type": "sqlite" };
+```ts db.ts icon="/icons/typescript.svg" highlight={1}
+import db from "./mydb.sqlite" with { type: "sqlite" };
 
 console.log(db.query("select * from users LIMIT 1").get());
 ```
 
 This is equivalent to the following:
 
-```ts
+```ts db.ts icon="/icons/typescript.svg"
 import { Database } from "bun:sqlite";
 const db = new Database("./mydb.sqlite");
 ```
@@ -114,7 +114,7 @@ const db = new Database("./mydb.sqlite");
 
 To close a database connection, but allow existing queries to finish, call `.close(false)`:
 
-```ts
+```ts db.ts icon="/icons/typescript.svg" highlight={3}
 const db = new Database();
 // ... do stuff
 db.close(false);
@@ -122,33 +122,40 @@ db.close(false);
 
 To close the database and throw an error if there are any pending queries, call `.close(true)`:
 
-```ts
+```ts db.ts icon="/icons/typescript.svg" highlight={3}
 const db = new Database();
 // ... do stuff
 db.close(true);
 ```
 
-Note: `close(false)` is called automatically when the database is garbage collected. It is safe to call multiple times but has no effect after the first.
+<Note>
+  `close(false)` is called automatically when the database is garbage collected. It is safe to call multiple times but
+  has no effect after the first.
+</Note>
 
 ### `using` statement
 
 You can use the `using` statement to ensure that a database connection is closed when the `using` block is exited.
 
-```ts
+```ts db.ts icon="/icons/typescript.svg" highlight={4, 5}
 import { Database } from "bun:sqlite";
 
 {
   using db = new Database("mydb.sqlite");
   using query = db.query("select 'Hello world' as message;");
-  console.log(query.get()); // => { message: "Hello world" }
+  console.log(query.get());
 }
 ```
 
+```txt
+{ message: "Hello world" }
+```
+
 ### `.serialize()`
 
 `bun:sqlite` supports SQLite's built-in mechanism for [serializing](https://www.sqlite.org/c3ref/serialize.html) and [deserializing](https://www.sqlite.org/c3ref/deserialize.html) databases to and from memory.
 
-```ts
+```ts db.ts icon="/icons/typescript.svg" highlight={2}
 const olddb = new Database("mydb.sqlite");
 const contents = olddb.serialize(); // => Uint8Array
 const newdb = Database.deserialize(contents);
@@ -160,20 +167,21 @@ Internally, `.serialize()` calls [`sqlite3_serialize`](https://www.sqlite.org/c3
 
 Use the `db.query()` method on your `Database` instance to [prepare](https://www.sqlite.org/c3ref/prepare.html) a SQL query. The result is a `Statement` instance that will be cached on the `Database` instance. _The query will not be executed._
 
-```ts
+```ts db.ts icon="/icons/typescript.svg"
 const query = db.query(`select "Hello world" as message`);
 ```
 
-{% callout %}
+<Note>
+ Use the `.prepare()` method to prepare a query _without_ caching it on the `Database` instance.
 
-**Note** — Use the `.prepare()` method to prepare a query _without_ caching it on the `Database` instance.
+    ```ts
+    // compile the prepared statement
+    const query = db.prepare("SELECT * FROM foo WHERE bar = ?");
+    ```
 
-```ts
-// compile the prepared statement
-const query = db.prepare("SELECT * FROM foo WHERE bar = ?");
-```
+</Note>
 
-{% /callout %}
+---
 
 ## WAL mode
 
@@ -181,15 +189,18 @@ SQLite supports [write-ahead log mode](https://www.sqlite.org/wal.html) (WAL) wh
 
 To enable WAL mode, run this pragma query at the beginning of your application:
 
-```ts
+```ts db.ts icon="/icons/typescript.svg"
 db.exec("PRAGMA journal_mode = WAL;");
 ```
 
-{% details summary="What is WAL mode" %}
+<Accordion title="What is WAL mode?">
 In WAL mode, writes to the database are written directly to a separate file called the "WAL file" (write-ahead log). This file will be later integrated into the main database file. Think of it as a buffer for pending writes. Refer to the [SQLite docs](https://www.sqlite.org/wal.html) for a more detailed overview.
 
 On macOS, WAL files may be persistent by default. This is not a bug, it is how macOS configured the system version of SQLite.
-{% /details %}
+
+</Accordion>
+
+---
 
 ## Statements
 
@@ -197,13 +208,13 @@ A `Statement` is a _prepared query_, which means it's been parsed and compiled i
 
 Create a statement with the `.query` method on your `Database` instance.
 
-```ts
+```ts db.ts icon="/icons/typescript.svg"
 const query = db.query(`select "Hello world" as message`);
 ```
 
 Queries can contain parameters. These can be numerical (`?1`) or named (`$param` or `:param` or `@param`).
 
-```ts
+```ts db.ts icon="/icons/typescript.svg"
 const query = db.query(`SELECT ?1, ?2;`);
 const query = db.query(`SELECT $param1, $param2;`);
 ```
@@ -214,32 +225,28 @@ Values are bound to these parameters when the query is executed. A `Statement` c
 
 To bind values to a statement, pass an object to the `.all()`, `.get()`, `.run()`, or `.values()` method.
 
-```ts
+```ts db.ts icon="/icons/typescript.svg" highlight={2}
 const query = db.query(`select $message;`);
 query.all({ $message: "Hello world" });
 ```
 
 You can bind using positional parameters too:
 
-```ts
+```ts db.ts icon="/icons/typescript.svg"
 const query = db.query(`select ?1;`);
 query.all("Hello world");
 ```
 
 #### `strict: true` lets you bind values without prefixes
 
-{% callout %}
-Added in Bun v1.1.14
-{% /callout %}
-
 By default, the `$`, `:`, and `@` prefixes are **included** when binding values to named parameters. To bind without these prefixes, use the `strict` option in the `Database` constructor.
 
-```ts
+```ts db.ts icon="/icons/typescript.svg"
 import { Database } from "bun:sqlite";
 
 const db = new Database(":memory:", {
   // bind values without prefixes
-  strict: true,
+  strict: true, // [!code ++]
 });
 
 const query = db.query(`select $message;`);
@@ -255,10 +262,13 @@ query.all({ message: "Hello world" });
 
 Use `.all()` to run a query and get back the results as an array of objects.
 
-```ts
+```ts db.ts icon="/icons/typescript.svg" highlight={2}
 const query = db.query(`select $message;`);
 query.all({ $message: "Hello world" });
-// => [{ message: "Hello world" }]
+```
+
+```txt
+[{ message: "Hello world" }]
 ```
 
 Internally, this calls [`sqlite3_reset`](https://www.sqlite.org/capi3ref.html#sqlite3_reset) and repeatedly calls [`sqlite3_step`](https://www.sqlite.org/capi3ref.html#sqlite3_step) until it returns `SQLITE_DONE`.
@@ -267,10 +277,13 @@ Internally, this calls [`sqlite3_reset`](https://www.sqlite.org/capi3ref.html#sq
 
 Use `.get()` to run a query and get back the first result as an object.
 
-```ts
+```ts db.ts icon="/icons/typescript.svg" highlight={2}
 const query = db.query(`select $message;`);
 query.get({ $message: "Hello world" });
-// => { $message: "Hello world" }
+```
+
+```txt
+{ $message: "Hello world" }
 ```
 
 Internally, this calls [`sqlite3_reset`](https://www.sqlite.org/capi3ref.html#sqlite3_reset) followed by [`sqlite3_step`](https://www.sqlite.org/capi3ref.html#sqlite3_step) until it no longer returns `SQLITE_ROW`. If the query returns no rows, `undefined` is returned.
@@ -279,32 +292,27 @@ Internally, this calls [`sqlite3_reset`](https://www.sqlite.org/capi3ref.html#sq
 
 Use `.run()` to run a query and get back `undefined`. This is useful for schema-modifying queries (e.g. `CREATE TABLE`) or bulk write operations.
 
-```ts
+```ts db.ts icon="/icons/typescript.svg" highlight={2}
 const query = db.query(`create table foo;`);
 query.run();
-// {
-//   lastInsertRowid: 0,
-//   changes: 0,
-// }
 ```
 
-Internally, this calls [`sqlite3_reset`](https://www.sqlite.org/capi3ref.html#sqlite3_reset) and calls [`sqlite3_step`](https://www.sqlite.org/capi3ref.html#sqlite3_step) once. Stepping through all the rows is not necessary when you don't care about the results.
+```txt
+{
+  lastInsertRowid: 0,
+  changes: 0,
+}
+```
 
-{% callout %}
-Since Bun v1.1.14, `.run()` returns an object with two properties: `lastInsertRowid` and `changes`.
-{% /callout %}
+Internally, this calls [`sqlite3_reset`](https://www.sqlite.org/capi3ref.html#sqlite3_reset) and calls [`sqlite3_step`](https://www.sqlite.org/capi3ref.html#sqlite3_step) once. Stepping through all the rows is not necessary when you don't care about the results.
 
 The `lastInsertRowid` property returns the ID of the last row inserted into the database. The `changes` property is the number of rows affected by the query.
 
 ### `.as(Class)` - Map query results to a class
 
-{% callout %}
-Added in Bun v1.1.14
-{% /callout %}
-
 Use `.as(Class)` to run a query and get back the results as instances of a class. This lets you attach methods & getters/setters to results.
 
-```ts
+```ts db.ts icon="/icons/typescript.svg" highlight={10}
 class Movie {
   title: string;
   year: number;
@@ -317,8 +325,14 @@ class Movie {
 const query = db.query("SELECT title, year FROM movies").as(Movie);
 const movies = query.all();
 const first = query.get();
-console.log(movies[0].isMarvel); // => true
-console.log(first.isMarvel); // => true
+
+console.log(movies[0].isMarvel);
+console.log(first.isMarvel);
+```
+
+```txt
+true
+true
 ```
 
 As a performance optimization, the class constructor is not called, default initializers are not run, and private fields are not accessible. This is more like using `Object.create` than `new`. The class's prototype is assigned to the object, methods are attached, and getters/setters are set up, but the constructor is not called.
@@ -329,7 +343,7 @@ The database columns are set as properties on the class instance.
 
 Use `.iterate()` to run a query and incrementally return results. This is useful for large result sets that you want to process one row at a time without loading all the results into memory.
 
-```ts
+```ts db.ts icon="/icons/typescript.svg" highlight={2}
 const query = db.query("SELECT * FROM foo");
 for (const row of query.iterate()) {
   console.log(row);
@@ -338,7 +352,7 @@ for (const row of query.iterate()) {
 
 You can also use the `@@iterator` protocol:
 
-```ts
+```ts db.ts icon="/icons/typescript.svg" highlight={2}
 const query = db.query("SELECT * FROM foo");
 for (const row of query) {
   console.log(row);
@@ -351,16 +365,19 @@ This feature was added in Bun v1.1.31.
 
 Use `values()` to run a query and get back all results as an array of arrays.
 
-```ts
+```ts db.ts icon="/icons/typescript.svg" highlight={3, 4}
 const query = db.query(`select $message;`);
-query.values({ $message: "Hello world" });
 
+query.values({ $message: "Hello world" });
 query.values(2);
-// [
-//   [ "Iron Man", 2008 ],
-//   [ "The Avengers", 2012 ],
-//   [ "Ant-Man: Quantumania", 2023 ],
-// ]
+```
+
+```txt
+[
+  [ "Iron Man", 2008 ],
+  [ "The Avengers", 2012 ],
+  [ "Ant-Man: Quantumania", 2023 ],
+]
 ```
 
 Internally, this calls [`sqlite3_reset`](https://www.sqlite.org/capi3ref.html#sqlite3_reset) and repeatedly calls [`sqlite3_step`](https://www.sqlite.org/capi3ref.html#sqlite3_step) until it returns `SQLITE_DONE`.
@@ -369,7 +386,7 @@ Internally, this calls [`sqlite3_reset`](https://www.sqlite.org/capi3ref.html#sq
 
 Use `.finalize()` to destroy a `Statement` and free any resources associated with it. Once finalized, a `Statement` cannot be executed again. Typically, the garbage collector will do this for you, but explicit finalization may be useful in performance-sensitive applications.
 
-```ts
+```ts db.ts icon="/icons/typescript.svg" highlight={3}
 const query = db.query("SELECT title, year FROM movies");
 const movies = query.all();
 query.finalize();
@@ -379,7 +396,7 @@ query.finalize();
 
 Calling `toString()` on a `Statement` instance prints the expanded SQL query. This is useful for debugging.
 
-```ts
+```ts db.ts icon="/icons/typescript.svg" highlight={6, 9, 12}
 import { Database } from "bun:sqlite";
 
 // setup
@@ -400,42 +417,34 @@ Internally, this calls [`sqlite3_expanded_sql`](https://www.sqlite.org/capi3ref.
 
 Queries can contain parameters. These can be numerical (`?1`) or named (`$param` or `:param` or `@param`). Bind values to these parameters when executing the query:
 
-{% codetabs %}
-
-```ts#Query
+```ts title="query.ts" icon="/icons/typescript.svg"
 const query = db.query("SELECT * FROM foo WHERE bar = $bar");
 const results = query.all({
   $bar: "bar",
 });
 ```
 
-```json#Results
-[
-  { "$bar": "bar" }
-]
+```txt
+[{ "$bar": "bar" }]
 ```
 
-{% /codetabs %}
-
 Numbered (positional) parameters work too:
 
-{% codetabs %}
-
-```ts#Query
+```ts db.ts icon="/icons/typescript.svg"
 const query = db.query("SELECT ?1, ?2");
 const results = query.all("hello", "goodbye");
 ```
 
-```ts#Results
+```txt
 [
-  {
-    "?1": "hello",
-    "?2": "goodbye"
-  }
-]
+	{
+		"?1": "hello",
+		"?2": "goodbye",
+	},
+];
 ```
 
-{% /codetabs %}
+---
 
 ## Integers
 
@@ -447,26 +456,25 @@ By default, `bun:sqlite` returns integers as `number` types. If you need to hand
 
 ### `safeIntegers: true`
 
-{% callout %}
-Added in Bun v1.1.14
-{% /callout %}
-
 When `safeIntegers` is `true`, `bun:sqlite` will return integers as `bigint` types:
 
-```ts
+```ts db.ts icon="/icons/typescript.svg" highlight={3}
 import { Database } from "bun:sqlite";
 
 const db = new Database(":memory:", { safeIntegers: true });
-const query = db.query(
-  `SELECT ${BigInt(Number.MAX_SAFE_INTEGER) + 102n} as max_int`,
-);
+const query = db.query(`SELECT ${BigInt(Number.MAX_SAFE_INTEGER) + 102n} as max_int`);
 const result = query.get();
-console.log(result.max_int); // => 9007199254741093n
+
+console.log(result.max_int);
+```
+
+```txt
+9007199254741093n
 ```
 
 When `safeIntegers` is `true`, `bun:sqlite` will throw an error if a `bigint` value in a bound parameter exceeds 64 bits:
 
-```ts
+```ts db.ts icon="/icons/typescript.svg" highlight={3}
 import { Database } from "bun:sqlite";
 
 const db = new Database(":memory:", { safeIntegers: true });
@@ -477,30 +485,38 @@ const query = db.query("INSERT INTO test (value) VALUES ($value)");
 try {
   query.run({ $value: BigInt(Number.MAX_SAFE_INTEGER) ** 2n });
 } catch (e) {
-  console.log(e.message); // => BigInt value '81129638414606663681390495662081' is out of range
+  console.log(e.message);
 }
 ```
 
+```txt
+BigInt value '81129638414606663681390495662081' is out of range
+```
+
 ### `safeIntegers: false` (default)
 
 When `safeIntegers` is `false`, `bun:sqlite` will return integers as `number` types and truncate any bits beyond 53:
 
-```ts
+```ts db.ts icon="/icons/typescript.svg" highlight={3}
 import { Database } from "bun:sqlite";
 
 const db = new Database(":memory:", { safeIntegers: false });
-const query = db.query(
-  `SELECT ${BigInt(Number.MAX_SAFE_INTEGER) + 102n} as max_int`,
-);
+const query = db.query(`SELECT ${BigInt(Number.MAX_SAFE_INTEGER) + 102n} as max_int`);
 const result = query.get();
-console.log(result.max_int); // => 9007199254741092
+console.log(result.max_int);
+```
+
+```txt
+9007199254741092
 ```
 
+---
+
 ## Transactions
 
 Transactions are a mechanism for executing multiple queries in an _atomic_ way; that is, either all of the queries succeed or none of them do. Create a transaction with the `db.transaction()` method:
 
-```ts
+```ts db.ts icon="/icons/typescript.svg" highlight={2}
 const insertCat = db.prepare("INSERT INTO cats (name) VALUES ($name)");
 const insertCats = db.transaction(cats => {
   for (const cat of cats) insertCat.run(cat);
@@ -511,42 +527,32 @@ At this stage, we haven't inserted any cats! The call to `db.transaction()` retu
 
 To execute the transaction, call this function. All arguments will be passed through to the wrapped function; the return value of the wrapped function will be returned by the transaction function. The wrapped function also has access to the `this` context as defined where the transaction is executed.
 
-```ts
+```ts db.ts icon="/icons/typescript.svg" highlight={3}
 const insert = db.prepare("INSERT INTO cats (name) VALUES ($name)");
 const insertCats = db.transaction(cats => {
   for (const cat of cats) insert.run(cat);
   return cats.length;
 });
 
-const count = insertCats([
-  { $name: "Keanu" },
-  { $name: "Salem" },
-  { $name: "Crookshanks" },
-]);
+const count = insertCats([{ $name: "Keanu" }, { $name: "Salem" }, { $name: "Crookshanks" }]);
 
 console.log(`Inserted ${count} cats`);
 ```
 
 The driver will automatically [`begin`](https://www.sqlite.org/lang_transaction.html) a transaction when `insertCats` is called and `commit` it when the wrapped function returns. If an exception is thrown, the transaction will be rolled back. The exception will propagate as usual; it is not caught.
 
-{% callout %}
+<Note>
 **Nested transactions** — Transaction functions can be called from inside other transaction functions. When doing so, the inner transaction becomes a [savepoint](https://www.sqlite.org/lang_savepoint.html).
 
-{% details summary="View nested transaction example" %}
+<Accordion title="View nested transaction example">
 
-```ts
+```ts db.ts icon="/icons/typescript.svg"
 // setup
 import { Database } from "bun:sqlite";
 const db = Database.open(":memory:");
-db.run(
-  "CREATE TABLE expenses (id INTEGER PRIMARY KEY AUTOINCREMENT, note TEXT, dollars INTEGER);",
-);
-db.run(
-  "CREATE TABLE cats (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT UNIQUE, age INTEGER)",
-);
-const insertExpense = db.prepare(
-  "INSERT INTO expenses (note, dollars) VALUES (?, ?)",
-);
+db.run("CREATE TABLE expenses (id INTEGER PRIMARY KEY AUTOINCREMENT, note TEXT, dollars INTEGER);");
+db.run("CREATE TABLE cats (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT UNIQUE, age INTEGER)");
+const insertExpense = db.prepare("INSERT INTO expenses (note, dollars) VALUES (?, ?)");
 const insert = db.prepare("INSERT INTO cats (name, age) VALUES ($name, $age)");
 const insertCats = db.transaction(cats => {
   for (const cat of cats) insert.run(cat);
@@ -564,8 +570,8 @@ adopt([
 ]);
 ```
 
-{% /details %}
-{% /callout %}
+</Accordion>
+</Note>
 
 Transactions also come with `deferred`, `immediate`, and `exclusive` versions.
 
@@ -580,24 +586,24 @@ insertCats.exclusive(cats); // uses "BEGIN EXCLUSIVE"
 
 To load a [SQLite extension](https://www.sqlite.org/loadext.html), call `.loadExtension(name)` on your `Database` instance
 
-```ts
+```ts db.ts icon="/icons/typescript.svg" highlight={4}
 import { Database } from "bun:sqlite";
 
 const db = new Database();
 db.loadExtension("myext");
 ```
 
-{% details summary="For macOS users" %}
+<Note>
 **MacOS users** By default, macOS ships with Apple's proprietary build of SQLite, which doesn't support extensions. To use extensions, you'll need to install a vanilla build of SQLite.
 
-```bash
-$ brew install sqlite
-$ which sqlite # get path to binary
+```bash terminal icon="terminal"
+brew install sqlite
+which sqlite # get path to binary
 ```
 
 To point `bun:sqlite` to the new build, call `Database.setCustomSQLite(path)` before creating any `Database` instances. (On other operating systems, this is a no-op.) Pass a path to the SQLite `.dylib` file, _not_ the executable. With recent versions of Homebrew this is something like `/opt/homebrew/Cellar/sqlite/<version>/libsqlite3.dylib`.
 
-```ts
+```ts db.ts icon="/icons/typescript.svg" highlight={3}
 import { Database } from "bun:sqlite";
 
 Database.setCustomSQLite("/path/to/libsqlite.dylib");
@@ -606,13 +612,13 @@ const db = new Database();
 db.loadExtension("myext");
 ```
 
-{% /details %}
+</Note>
 
-### .fileControl(cmd: number, value: any)
+### `.fileControl(cmd: number, value: any)`
 
 To use the advanced `sqlite3_file_control` API, call `.fileControl(cmd, value)` on your `Database` instance.
 
-```ts
+```ts db.ts icon="/icons/typescript.svg" highlight={6}
 import { Database, constants } from "bun:sqlite";
 
 const db = new Database();
@@ -627,9 +633,11 @@ db.fileControl(constants.SQLITE_FCNTL_PERSIST_WAL, 0);
 - `TypedArray`
 - `undefined` or `null`
 
+---
+
 ## Reference
 
-```ts
+```ts Type Reference icon="/icons/typescript.svg" expandable
 class Database {
   constructor(
     filename: string,
@@ -643,10 +651,7 @@ class Database {
   );
 
   query<Params, ReturnType>(sql: string): Statement<Params, ReturnType>;
-  run(
-    sql: string,
-    params?: SQLQueryBindings,
-  ): { lastInsertRowid: number; changes: number };
+  run(sql: string, params?: SQLQueryBindings): { lastInsertRowid: number; changes: number };
   exec = this.run;
 }