Improve YAML documentation with Bun.YAML.stringify and TypeScript typing

- Add comprehensive Bun.YAML.stringify() documentation with examples
- Explain spacing parameter (null, 2) for readable format vs (null, 0) for condensed
- Document how YAML can represent shared values more compactly than JSON
- Add practical example for generating YAML configuration files
- Clarify TypeScript typing requirements (unlike JSON, not automatic)
- Add both per-file (.d.ts) and global type declaration approaches
- Include Bun.YAML.stringify(obj, null, 2) in examples like JSON.stringify

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: Claude Bot

docs/guides/runtime/import-yaml.mdx

@@ -77,7 +77,11 @@ console.log(data.hobbies); // => ["reading", "coding"]
 
 ## TypeScript Support
 
-To add TypeScript support for your YAML imports, create a declaration file with `.d.ts` appended to the YAML filename (e.g., `config.yaml` → `config.yaml.d.ts`);
+Unlike JSON files which TypeScript handles automatically, YAML files require manual type definitions. You have two options for adding TypeScript support:
+
+### Option 1: Per-File Declaration (Recommended)
+
+Create a declaration file with `.d.ts` appended to the YAML filename (e.g., `config.yaml` → `config.yaml.d.ts`):
 
 ```ts config.yaml.d.ts icon="/icons/typescript.svg"
 const contents: {
@@ -99,6 +103,26 @@ const contents: {
 export = contents;
 ```
 
+This approach gives you precise types for each YAML file.
+
+### Option 2: Global Declaration
+
+For a global type definition (applies to all `.yaml` and `.yml` files), create a declaration file anywhere in your project:
+
+```ts global.d.ts icon="/icons/typescript.svg"
+declare module "*.yaml" {
+  const content: any;
+  export default content;
+}
+
+declare module "*.yml" {
+  const content: any;
+  export default content;
+}
+```
+
+**Note:** TypeScript doesn't automatically type YAML imports like it does for JSON. You must explicitly add type definitions using one of the methods above.
+
 ---
 
 See [Docs > API > YAML](https://bun.com/docs/api/yaml) for complete documentation on YAML support in Bun.

docs/runtime/yaml.mdx

@@ -23,6 +23,61 @@ Bun's YAML parser currently passes over 90% of the official YAML test suite. Whi
 
 Parse a YAML string into a JavaScript object.
 
+### `Bun.YAML.stringify()`
+
+Convert a JavaScript object into a YAML string.
+
+```ts
+import { YAML } from "bun";
+
+const obj = {
+  name: "John Doe",
+  age: 30,
+  email: "[email protected]",
+  hobbies: ["reading", "coding", "hiking"]
+};
+
+const yaml = Bun.YAML.stringify(obj, null, 2);
+console.log(yaml);
+// name: John Doe
+// age: 30
+// email: [email protected]
+// hobbies:
+//   - reading
+//   - coding
+//   - hiking
+```
+
+The signature is similar to `JSON.stringify()`:
+
+```ts
+Bun.YAML.stringify(value, replacer?, space?)
+```
+
+- `value`: The JavaScript value to convert to YAML
+- `replacer`: Optional function to transform values (same as `JSON.stringify`)
+- `space`: Number of spaces for indentation (default: 2)
+
+#### Spacing Options
+
+The `space` parameter controls indentation. Like `JSON.stringify`, you can pass a number for spaces:
+
+```ts
+// Readable format with 2 spaces (recommended)
+const yaml = Bun.YAML.stringify(obj, null, 2);
+
+// More condensed format with 0 spaces
+// YAML can represent shared values more compactly than JSON
+const compact = Bun.YAML.stringify(obj, null, 0);
+console.log(compact);
+// name: John Doe
+// age: 30
+// email: [email protected]
+// hobbies: [reading, coding, hiking]
+```
+
+With `space: 0`, YAML uses inline notation for arrays and objects where appropriate, making the output more compact than equivalent JSON. This is particularly useful when YAML detects shared/repeated values in your data structure.
+
 ```ts
 import { YAML } from "bun";
 const text = `
@@ -435,6 +490,49 @@ if (parseConfig(migrations).autoRun === "true") {
 }
 ```
 
+### Generating YAML Files
+
+You can use `Bun.YAML.stringify()` to programmatically create YAML configuration files:
+
+```ts generate-config.ts icon="/icons/typescript.svg"
+import { YAML } from "bun";
+
+const config = {
+  server: {
+    port: 3000,
+    host: "localhost",
+  },
+  database: {
+    type: "postgres",
+    host: "localhost",
+    port: 5432,
+    name: "myapp",
+    pool: {
+      min: 2,
+      max: 10,
+    },
+  },
+  features: {
+    auth: true,
+    rateLimit: true,
+    analytics: false,
+  },
+};
+
+// Generate readable YAML with 2-space indentation
+const yaml = Bun.YAML.stringify(config, null, 2);
+await Bun.write("config.yaml", yaml);
+
+console.log("Generated config.yaml:");
+console.log(yaml);
+```
+
+This is particularly useful for:
+- Generating configuration files from templates
+- Exporting settings from your application
+- Creating config files for CI/CD pipelines
+- Building development tools that output YAML
+
 ### Bundler Integration
 
 When you import YAML files in your application and bundle it with Bun, the YAML is parsed at build time and included as a JavaScript module: