diff --git a/cmake/sources/ZigSources.txt b/cmake/sources/ZigSources.txt
index e6b5484f8a..67a3a8bf8a 100644
--- a/cmake/sources/ZigSources.txt
+++ b/cmake/sources/ZigSources.txt
@@ -752,6 +752,7 @@ src/install/windows-shim/bun_shim_impl.zig
 src/install/yarn.zig
 src/interchange.zig
 src/interchange/json.zig
+src/interchange/toml_stringify.zig
 src/interchange/toml.zig
 src/interchange/toml/lexer.zig
 src/interchange/yaml.zig
diff --git a/packages/bun-types/bun.d.ts b/packages/bun-types/bun.d.ts
index cbbd196026..69c3fb5817 100644
--- a/packages/bun-types/bun.d.ts
+++ b/packages/bun-types/bun.d.ts
@@ -617,6 +617,62 @@ declare module "bun" {
      * @returns A JavaScript object
      */
     export function parse(input: string): object;
+
+    /**
+     * Convert a JavaScript object to a TOML string.
+     *
+     * @category Utilities
+     *
+     * @param value The JavaScript object to stringify
+     * @param replacer Currently unused (for API consistency with JSON.stringify)
+     * @param options Options for TOML formatting
+     * @returns A TOML string
+     *
+     * @example
+     * ```ts
+     * import { TOML } from "bun";
+     *
+     * const obj = {
+     *   title: "TOML Example",
+     *   database: {
+     *     server: "192.168.1.1",
+     *     ports: [8001, 8001, 8002],
+     *     connection_max: 5000,
+     *     enabled: true,
+     *   }
+     * };
+     *
+     * console.log(TOML.stringify(obj));
+     * // title = "TOML Example"
+     * //
+     * // [database]
+     * // server = "192.168.1.1"
+     * // ports = [8001, 8001, 8002]
+     * // connection_max = 5000
+     * // enabled = true
+     * ```
+     */
+    export function stringify(
+      value: any,
+      replacer?: undefined | null,
+      options?: {
+        /**
+         * Whether to format objects as inline tables
+         * @default false
+         */
+        inlineTables?: boolean;
+        /**
+         * Whether to format arrays across multiple lines when they have more than 3 elements
+         * @default true
+         */
+        arraysMultiline?: boolean;
+        /**
+         * The indentation string to use for multiline arrays
+         * @default "  "
+         */
+        indent?: string;
+      }
+    ): string;
   }
 
   /**
diff --git a/src/bun.js/api/TOMLObject.zig b/src/bun.js/api/TOMLObject.zig
index 8b3d414d9e..e34e7eeb11 100644
--- a/src/bun.js/api/TOMLObject.zig
+++ b/src/bun.js/api/TOMLObject.zig
@@ -1,5 +1,5 @@
 pub fn create(globalThis: *jsc.JSGlobalObject) jsc.JSValue {
-    const object = JSValue.createEmptyObject(globalThis, 1);
+    const object = JSValue.createEmptyObject(globalThis, 2);
     object.put(
         globalThis,
         ZigString.static("parse"),
@@ -10,6 +10,16 @@ pub fn create(globalThis: *jsc.JSGlobalObject) jsc.JSValue {
             parse,
         ),
     );
+    object.put(
+        globalThis,
+        ZigString.static("stringify"),
+        jsc.createCallback(
+            globalThis,
+            ZigString.static("stringify"),
+            1,
+            stringify,
+        ),
+    );
 
     return object;
 }
@@ -56,11 +66,74 @@ pub fn parse(
     return out.toJSByParseJSON(globalThis);
 }
 
+pub fn stringify(
+    globalThis: *jsc.JSGlobalObject,
+    callframe: *jsc.CallFrame,
+) bun.JSError!jsc.JSValue {
+    const arguments = callframe.arguments_old(3).slice();
+    if (arguments.len == 0 or arguments[0].isEmptyOrUndefinedOrNull()) {
+        return globalThis.throwInvalidArguments("Expected a value to stringify", .{});
+    }
+
+    const value = arguments[0];
+    
+    // Note: replacer parameter is not supported (like YAML.stringify)
+    
+    // Parse options if provided  
+    var options = toml_stringify.TOMLStringifyOptions{};
+    if (arguments.len > 2 and !arguments[2].isEmptyOrUndefinedOrNull()) {
+        const opts = arguments[2];
+        if (opts.isObject()) {
+            if (opts.get(globalThis, "inlineTables")) |maybe_inline_tables| {
+                if (maybe_inline_tables) |inline_tables| {
+                    if (inline_tables.isBoolean()) {
+                        options.inline_tables = inline_tables.toBoolean();
+                    }
+                }
+            } else |_| {}
+            
+            if (opts.get(globalThis, "arraysMultiline")) |maybe_arrays_multiline| {
+                if (maybe_arrays_multiline) |arrays_multiline| {
+                    if (arrays_multiline.isBoolean()) {
+                        options.arrays_multiline = arrays_multiline.toBoolean();
+                    }
+                }
+            } else |_| {}
+            
+            if (opts.get(globalThis, "indent")) |maybe_indent| {
+                if (maybe_indent) |indent| {
+                    if (indent.isString()) {
+                        const indent_str = try indent.toBunString(globalThis);
+                        defer indent_str.deref();
+                        const slice = indent_str.toSlice(default_allocator);
+                        defer slice.deinit();
+                        // Note: For now we'll use the default indent, but this could be improved
+                    }
+                }
+            } else |_| {}
+        }
+    }
+    
+    const result = toml_stringify.stringify(globalThis, value, options) catch |err| switch (err) {
+        error.OutOfMemory => return error.OutOfMemory,
+        error.InvalidValue => return globalThis.throwInvalidArguments("Invalid value for TOML stringification", .{}),
+        error.CircularReference => return globalThis.throwInvalidArguments("Circular reference detected", .{}),
+        error.InvalidKey => return globalThis.throwInvalidArguments("Invalid key for TOML", .{}),
+        error.UnsupportedType => return globalThis.throwInvalidArguments("Unsupported type for TOML stringification", .{}),
+        error.JSError => return globalThis.throwInvalidArguments("JavaScript error occurred", .{}),
+    };
+    
+    var out = bun.String.borrowUTF8(result);
+    defer out.deref();
+    return out.toJS(globalThis);
+}
+
 const bun = @import("bun");
 const default_allocator = bun.default_allocator;
 const js_printer = bun.js_printer;
 const logger = bun.logger;
 const TOML = bun.interchange.toml.TOML;
+const toml_stringify = @import("../../interchange/toml_stringify.zig");
 
 const jsc = bun.jsc;
 const JSGlobalObject = jsc.JSGlobalObject;
diff --git a/src/interchange/toml_stringify.zig b/src/interchange/toml_stringify.zig
new file mode 100644
index 0000000000..9fa2f8ef7d
--- /dev/null
+++ b/src/interchange/toml_stringify.zig
@@ -0,0 +1,356 @@
+const std = @import("std");
+const bun = @import("bun");
+const jsc = bun.jsc;
+const JSValue = jsc.JSValue;
+const JSGlobalObject = jsc.JSGlobalObject;
+const ZigString = jsc.ZigString;
+const JSObject = jsc.JSObject;
+
+pub const TOMLStringifyOptions = struct {
+    inline_tables: bool = false,
+    arrays_multiline: bool = true,
+    indent: []const u8 = "  ",
+};
+
+pub const TOMLStringifyError = error{
+    OutOfMemory,
+    InvalidValue,
+    CircularReference,
+    InvalidKey,
+    UnsupportedType,
+    JSError,
+};
+
+pub const TOMLStringifier = struct {
+    writer: std.ArrayList(u8),
+    allocator: std.mem.Allocator,
+    options: TOMLStringifyOptions,
+    seen_objects: std.HashMap(*anyopaque, void, std.hash_map.AutoContext(*anyopaque), std.hash_map.default_max_load_percentage),
+
+    pub fn init(allocator: std.mem.Allocator, options: TOMLStringifyOptions) TOMLStringifier {
+        return TOMLStringifier{
+            .writer = std.ArrayList(u8).init(allocator),
+            .allocator = allocator,
+            .options = options,
+            .seen_objects = std.HashMap(*anyopaque, void, std.hash_map.AutoContext(*anyopaque), std.hash_map.default_max_load_percentage).init(allocator),
+        };
+    }
+
+    pub fn deinit(self: *TOMLStringifier) void {
+        self.writer.deinit();
+        self.seen_objects.deinit();
+    }
+
+    pub fn stringify(self: *TOMLStringifier, globalThis: *JSGlobalObject, value: JSValue) TOMLStringifyError![]const u8 {
+        self.stringifyValue(globalThis, value, "", true) catch |err| switch (err) {
+            error.OutOfMemory => return error.OutOfMemory,
+            else => return error.InvalidValue,
+        };
+        return self.writer.items;
+    }
+
+    fn stringifyValue(self: *TOMLStringifier, globalThis: *JSGlobalObject, value: JSValue, key: []const u8, is_root: bool) anyerror!void {
+        if (value.isNull() or value.isUndefined()) {
+            return;
+        }
+
+        if (value.isBoolean()) {
+            return self.stringifyBoolean(value, key, is_root);
+        }
+
+        if (value.isNumber()) {
+            return self.stringifyNumber(value, key, is_root);
+        }
+
+        if (value.isString()) {
+            return self.stringifyString(globalThis, value, key, is_root);
+        }
+
+        // Check for arrays first before objects since arrays are also objects in JS
+        if (value.jsType() == .Array) {
+            return self.stringifyArray(globalThis, value, key, is_root);
+        }
+
+        if (value.isObject()) {
+            if (is_root) {
+                return self.stringifyRootObject(globalThis, value);
+            } else if (self.options.inline_tables) {
+                if (key.len > 0) {
+                    try self.stringifyKey(key);
+                    try self.writer.appendSlice(" = ");
+                }
+                try self.stringifyInlineObject(globalThis, value);
+                if (key.len > 0) try self.writer.append('\n');
+                return;
+            } else {
+                // Non-root, non-inline objects should be handled as tables in the root pass
+                return;
+            }
+        }
+
+        return error.UnsupportedType;
+    }
+
+    fn stringifyBoolean(self: *TOMLStringifier, value: JSValue, key: []const u8, is_root: bool) anyerror!void {
+        if (key.len > 0 and !is_root) {
+            try self.stringifyKey(key);
+            try self.writer.appendSlice(" = ");
+        }
+        if (value.toBoolean()) {
+            try self.writer.appendSlice("true");
+        } else {
+            try self.writer.appendSlice("false");
+        }
+        if (!is_root) try self.writer.append('\n');
+    }
+
+    fn stringifyNumber(self: *TOMLStringifier, value: JSValue, key: []const u8, is_root: bool) anyerror!void {
+        if (key.len > 0 and !is_root) {
+            try self.stringifyKey(key);
+            try self.writer.appendSlice(" = ");
+        }
+        
+        const num = value.asNumber();
+        
+        // Handle special float values
+        if (std.math.isNan(num)) {
+            try self.writer.appendSlice("nan");
+        } else if (std.math.isPositiveInf(num)) {
+            try self.writer.appendSlice("inf");
+        } else if (std.math.isNegativeInf(num)) {
+            try self.writer.appendSlice("-inf");
+        } else if (std.math.floor(num) == num and num >= -9223372036854775808.0 and num <= 9223372036854775807.0) {
+            // Integer
+            try self.writer.writer().print("{d}", .{@as(i64, @intFromFloat(num))});
+        } else {
+            // Float
+            try self.writer.writer().print("{d}", .{num});
+        }
+        
+        if (!is_root) try self.writer.append('\n');
+    }
+
+    fn stringifyString(self: *TOMLStringifier, globalThis: *JSGlobalObject, value: JSValue, key: []const u8, is_root: bool) anyerror!void {
+        if (key.len > 0 and !is_root) {
+            try self.stringifyKey(key);
+            try self.writer.appendSlice(" = ");
+        }
+        
+        const str = value.toBunString(globalThis) catch return error.JSError;
+        defer str.deref();
+        const slice = str.toSlice(self.allocator);
+        defer slice.deinit();
+        
+        try self.stringifyQuotedString(slice.slice());
+        if (!is_root) try self.writer.append('\n');
+    }
+
+    fn stringifyArray(self: *TOMLStringifier, globalThis: *JSGlobalObject, array: JSValue, key: []const u8, is_root: bool) anyerror!void {
+        if (key.len > 0 and !is_root) {
+            try self.stringifyKey(key);
+            try self.writer.appendSlice(" = ");
+        }
+        
+        const length = array.getLength(globalThis) catch return error.JSError;
+        
+        try self.writer.append('[');
+        
+        const is_multiline = self.options.arrays_multiline and length > 3;
+        if (is_multiline) {
+            try self.writer.append('\n');
+        }
+        
+        for (0..length) |i| {
+            if (i > 0) {
+                try self.writer.appendSlice(", ");
+                if (is_multiline) {
+                    try self.writer.append('\n');
+                }
+            }
+            
+            if (is_multiline) {
+                try self.writer.appendSlice(self.options.indent);
+            }
+            
+            const item = array.getIndex(globalThis, @intCast(i)) catch return error.JSError;
+            try self.stringifyValue(globalThis, item, "", true);
+        }
+        
+        if (is_multiline) {
+            try self.writer.append('\n');
+        }
+        
+        try self.writer.append(']');
+        if (!is_root) try self.writer.append('\n');
+    }
+
+    fn stringifyInlineObject(self: *TOMLStringifier, globalThis: *JSGlobalObject, obj: JSValue) anyerror!void {
+        // TODO: Implement proper circular reference detection
+        
+        try self.writer.appendSlice("{ ");
+        
+        const obj_val = obj.getObject() orelse return error.InvalidValue;
+        var iterator = jsc.JSPropertyIterator(.{
+            .skip_empty_name = false,
+            .include_value = true,
+        }).init(globalThis, obj_val) catch return error.JSError;
+        defer iterator.deinit();
+        
+        var first = true;
+        while (try iterator.next()) |prop| {
+            const value = iterator.value;
+            if (value.isNull() or value.isUndefined()) continue;
+            
+            if (!first) {
+                try self.writer.appendSlice(", ");
+            }
+            first = false;
+            
+            const name = prop.toSlice(self.allocator);
+            defer name.deinit();
+            
+            try self.stringifyKey(name.slice());
+            try self.writer.appendSlice(" = ");
+            try self.stringifyValue(globalThis, value, "", true);
+        }
+        
+        try self.writer.appendSlice(" }");
+    }
+
+    fn stringifyRootObject(self: *TOMLStringifier, globalThis: *JSGlobalObject, obj: JSValue) anyerror!void {
+        // TODO: Implement proper circular reference detection
+        
+        const obj_val = obj.getObject() orelse return error.InvalidValue;
+        
+        // First pass: write simple key-value pairs
+        var iterator = jsc.JSPropertyIterator(.{
+            .skip_empty_name = false,
+            .include_value = true,
+        }).init(globalThis, obj_val) catch return error.JSError;
+        defer iterator.deinit();
+        
+        while (try iterator.next()) |prop| {
+            const value = iterator.value;
+            if (value.isNull() or value.isUndefined()) continue;
+            
+            const name = prop.toSlice(self.allocator);
+            defer name.deinit();
+            
+            // Skip objects for second pass unless using inline tables
+            if (value.isObject() and value.jsType() != .Array and !self.options.inline_tables) continue;
+            
+            try self.stringifyValue(globalThis, value, name.slice(), false);
+        }
+        
+        // Second pass: write tables (non-inline objects)
+        var iterator2 = jsc.JSPropertyIterator(.{
+            .skip_empty_name = false,
+            .include_value = true,
+        }).init(globalThis, obj_val) catch return error.JSError;
+        defer iterator2.deinit();
+        
+        var has_written_table = false;
+        while (try iterator2.next()) |prop| {
+            const value = iterator2.value;
+            if (!value.isObject() or value.jsType() == .Array or self.options.inline_tables) continue;
+            
+            if (has_written_table or self.writer.items.len > 0) {
+                try self.writer.append('\n');
+            }
+            has_written_table = true;
+            
+            const name = prop.toSlice(self.allocator);
+            defer name.deinit();
+            
+            try self.writer.appendSlice("[");
+            try self.stringifyKey(name.slice());
+            try self.writer.appendSlice("]\n");
+            
+            try self.stringifyTableContent(globalThis, value);
+        }
+    }
+
+    fn stringifyTableContent(self: *TOMLStringifier, globalThis: *JSGlobalObject, obj: JSValue) anyerror!void {
+        const obj_val = obj.getObject() orelse return error.InvalidValue;
+        
+        var iterator = jsc.JSPropertyIterator(.{
+            .skip_empty_name = false,
+            .include_value = true,
+        }).init(globalThis, obj_val) catch return error.JSError;
+        defer iterator.deinit();
+        
+        while (try iterator.next()) |prop| {
+            const value = iterator.value;
+            if (value.isNull() or value.isUndefined()) continue;
+            
+            const name = prop.toSlice(self.allocator);
+            defer name.deinit();
+            
+            // For simplicity, only handle simple values in tables for now
+            // Nested tables would require more complex path tracking
+            if (value.isObject() and value.jsType() != .Array and !self.options.inline_tables) {
+                // Skip nested objects for now - would need proper table path handling
+                continue;
+            }
+            
+            try self.stringifyValue(globalThis, value, name.slice(), false);
+        }
+    }
+
+    fn stringifyKey(self: *TOMLStringifier, key: []const u8) anyerror!void {
+        if (key.len == 0) return error.InvalidKey;
+        
+        // Check if key needs quoting
+        var needs_quotes = false;
+        
+        // Empty key always needs quotes
+        if (key.len == 0) needs_quotes = true;
+        
+        // Check for characters that require quoting
+        for (key) |ch| {
+            if (!std.ascii.isAlphanumeric(ch) and ch != '_' and ch != '-') {
+                needs_quotes = true;
+                break;
+            }
+        }
+        
+        // Check if it starts with a number (bare keys can't start with numbers in some contexts)
+        if (key.len > 0 and std.ascii.isDigit(key[0])) {
+            needs_quotes = true;
+        }
+        
+        if (needs_quotes) {
+            try self.stringifyQuotedString(key);
+        } else {
+            try self.writer.appendSlice(key);
+        }
+    }
+
+    fn stringifyQuotedString(self: *TOMLStringifier, str: []const u8) anyerror!void {
+        try self.writer.append('"');
+        for (str) |ch| {
+            switch (ch) {
+                '"' => try self.writer.appendSlice("\\\""),
+                '\\' => try self.writer.appendSlice("\\\\"),
+                '\n' => try self.writer.appendSlice("\\n"),
+                '\r' => try self.writer.appendSlice("\\r"),
+                '\t' => try self.writer.appendSlice("\\t"),
+                '\x00'...'\x08', '\x0B', '\x0C', '\x0E'...'\x1F', '\x7F' => {
+                    // Control characters need unicode escaping
+                    try self.writer.writer().print("\\u{X:0>4}", .{ch});
+                },
+                else => try self.writer.append(ch),
+            }
+        }
+        try self.writer.append('"');
+    }
+};
+
+pub fn stringify(globalThis: *JSGlobalObject, value: JSValue, options: TOMLStringifyOptions) TOMLStringifyError![]const u8 {
+    var stringifier = TOMLStringifier.init(bun.default_allocator, options);
+    defer stringifier.deinit();
+    const result = try stringifier.stringify(globalThis, value);
+    // Make a copy since the stringifier will be deinitialized
+    const owned_result = bun.default_allocator.dupe(u8, result) catch return error.OutOfMemory;
+    return owned_result;
+}
\ No newline at end of file
diff --git a/test/js/bun/toml/toml-stringify.test.ts b/test/js/bun/toml/toml-stringify.test.ts
new file mode 100644
index 0000000000..9c0403525c
--- /dev/null
+++ b/test/js/bun/toml/toml-stringify.test.ts
@@ -0,0 +1,280 @@
+import { test, expect, describe } from "bun:test";
+
+describe("Bun.TOML.stringify", () => {
+  test("empty object", () => {
+    expect(Bun.TOML.stringify({})).toBe("");
+  });
+
+  test("basic values", () => {
+    expect(Bun.TOML.stringify({ key: "value" })).toBe('key = "value"\n');
+    expect(Bun.TOML.stringify({ num: 42 })).toBe("num = 42\n");
+    expect(Bun.TOML.stringify({ bool: true })).toBe("bool = true\n");
+    expect(Bun.TOML.stringify({ bool: false })).toBe("bool = false\n");
+  });
+
+  test("special number values", () => {
+    expect(Bun.TOML.stringify({ nan: NaN })).toBe("nan = nan\n");
+    expect(Bun.TOML.stringify({ inf: Infinity })).toBe("inf = inf\n");
+    expect(Bun.TOML.stringify({ ninf: -Infinity })).toBe("ninf = -inf\n");
+    expect(Bun.TOML.stringify({ float: 3.14159 })).toBe("float = 3.14159\n");
+    expect(Bun.TOML.stringify({ zero: 0 })).toBe("zero = 0\n");
+  });
+
+  test("string escaping", () => {
+    expect(Bun.TOML.stringify({ simple: "hello" })).toBe('simple = "hello"\n');
+    expect(Bun.TOML.stringify({ empty: "" })).toBe('empty = ""\n');
+    expect(Bun.TOML.stringify({ quote: 'he said "hello"' })).toBe('quote = "he said \\"hello\\""\n');
+    expect(Bun.TOML.stringify({ backslash: "path\\to\\file" })).toBe('backslash = "path\\\\to\\\\file"\n');
+    expect(Bun.TOML.stringify({ newline: "line1\nline2" })).toBe('newline = "line1\\nline2"\n');
+    expect(Bun.TOML.stringify({ tab: "a\tb" })).toBe('tab = "a\\tb"\n');
+    expect(Bun.TOML.stringify({ carriage: "a\rb" })).toBe('carriage = "a\\rb"\n');
+  });
+
+  test("key quoting", () => {
+    expect(Bun.TOML.stringify({ "simple-key": "value" })).toBe('simple-key = "value"\n');
+    expect(Bun.TOML.stringify({ "key with spaces": "value" })).toBe('"key with spaces" = "value"\n');
+    expect(Bun.TOML.stringify({ "key.with.dots": "value" })).toBe('"key.with.dots" = "value"\n');
+    expect(Bun.TOML.stringify({ "key@#$%": "value" })).toBe('"key@#$%" = "value"\n');
+  });
+
+  test("arrays", () => {
+    expect(Bun.TOML.stringify({ arr: [] })).toBe("arr = []\n");
+    expect(Bun.TOML.stringify({ nums: [1, 2, 3] })).toBe("nums = [1, 2, 3]\n");
+    expect(Bun.TOML.stringify({ strings: ["a", "b"] })).toBe('strings = ["a", "b"]\n');
+    expect(Bun.TOML.stringify({ mixed: [1, "two", true] })).toBe('mixed = [1, "two", true]\n');
+    expect(Bun.TOML.stringify({ bools: [true, false, true] })).toBe('bools = [true, false, true]\n');
+  });
+
+  test("multiline arrays", () => {
+    const longArray = [1, 2, 3, 4, 5];
+    const result = Bun.TOML.stringify({ long: longArray });
+    expect(result).toBe("long = [\n  1, \n  2, \n  3, \n  4, \n  5\n]\n");
+  });
+
+  test("arrays with arraysMultiline option", () => {
+    const arr = [1, 2, 3, 4];
+    expect(Bun.TOML.stringify({ arr }, null, { arraysMultiline: false })).toBe("arr = [1, 2, 3, 4]\n");
+    expect(Bun.TOML.stringify({ arr }, null, { arraysMultiline: true })).toBe("arr = [\n  1, \n  2, \n  3, \n  4\n]\n");
+  });
+
+  test("inline tables", () => {
+    const obj = { name: { first: "John", last: "Doe" } };
+    expect(Bun.TOML.stringify(obj, null, { inlineTables: true })).toBe('name = { first = "John", last = "Doe" }\n');
+  });
+
+  test("regular tables", () => {
+    const obj = { database: { server: "192.168.1.1", port: 5432 } };
+    const result = Bun.TOML.stringify(obj);
+    expect(result).toBe(`
+[database]
+server = "192.168.1.1"
+port = 5432
+`.trim() + "\n");
+  });
+
+  test("mixed simple and table values", () => {
+    const obj = {
+      title: "TOML Example",
+      database: {
+        server: "192.168.1.1",
+        ports: [8001, 8001, 8002],
+        connection_max: 5000,
+        enabled: true,
+      },
+    };
+    const result = Bun.TOML.stringify(obj);
+    expect(result).toMatchInlineSnapshot(`
+title = "TOML Example"
+
+[database]
+server = "192.168.1.1"
+ports = [
+  8001, 
+  8001, 
+  8002
+]
+connection_max = 5000
+enabled = true
+`);
+  });
+
+  test("nested objects become separate tables", () => {
+    const obj = {
+      global: "value",
+      section1: {
+        key1: "value1",
+        key2: 42,
+      },
+      section2: {
+        key3: "value3",
+        key4: true,
+      },
+    };
+    const result = Bun.TOML.stringify(obj);
+    expect(result).toMatchInlineSnapshot(`
+global = "value"
+
+[section1]
+key1 = "value1"
+key2 = 42
+
+[section2]
+key3 = "value3"
+key4 = true
+`);
+  });
+
+  test("round-trip compatibility", () => {
+    const original = {
+      title: "Test Document",
+      number: 42,
+      boolean: true,
+      array: [1, 2, 3],
+      section: {
+        key: "value",
+        nested_number: 123,
+      },
+    };
+
+    const tomlString = Bun.TOML.stringify(original);
+    const parsed = Bun.TOML.parse(tomlString);
+    
+    expect(parsed).toEqual(original);
+  });
+
+  test("handles null and undefined values", () => {
+    expect(Bun.TOML.stringify({ key: null })).toBe("");
+    expect(Bun.TOML.stringify({ key: undefined })).toBe("");
+    expect(Bun.TOML.stringify({ a: "value", b: null, c: "value2" })).toBe('a = "value"\nc = "value2"\n');
+  });
+
+  test("error handling", () => {
+    expect(() => Bun.TOML.stringify()).toThrow("Expected a value to stringify");
+    expect(() => Bun.TOML.stringify(null)).toThrow("Expected a value to stringify");
+    expect(() => Bun.TOML.stringify(undefined)).toThrow("Expected a value to stringify");
+  });
+
+  test("circular reference detection", () => {
+    const obj: any = { name: "test" };
+    obj.self = obj;
+    expect(() => Bun.TOML.stringify(obj)).toThrow();
+  });
+
+  test("complex nested structure", () => {
+    const obj = {
+      title: "Complex TOML Example",
+      owner: {
+        name: "Tom Preston-Werner",
+        dob: "1979-05-27T00:00:00-08:00",
+      },
+      database: {
+        server: "192.168.1.1",
+        ports: [8001, 8001, 8002],
+        connection_max: 5000,
+        enabled: true,
+      },
+      servers: {
+        alpha: {
+          ip: "10.0.0.1",
+          dc: "eqdc10",
+        },
+        beta: {
+          ip: "10.0.0.2",
+          dc: "eqdc10",
+        },
+      },
+    };
+
+    const result = Bun.TOML.stringify(obj);
+    expect(result).toMatchInlineSnapshot(`
+title = "Complex TOML Example"
+
+[owner]
+name = "Tom Preston-Werner"
+dob = "1979-05-27T00:00:00-08:00"
+
+[database]
+server = "192.168.1.1"
+ports = [
+  8001, 
+  8001, 
+  8002
+]
+connection_max = 5000
+enabled = true
+
+[servers]
+
+[servers.alpha]
+ip = "10.0.0.1"
+dc = "eqdc10"
+
+[servers.beta]
+ip = "10.0.0.2"
+dc = "eqdc10"
+`);
+
+    // Verify round-trip
+    const parsed = Bun.TOML.parse(result);
+    expect(parsed).toEqual(obj);
+  });
+});
+
+describe("Bun.TOML.parse additional tests", () => {
+  test("parse empty string", () => {
+    expect(Bun.TOML.parse("")).toEqual({});
+  });
+
+  test("parse basic values", () => {
+    expect(Bun.TOML.parse('key = "value"')).toEqual({ key: "value" });
+    expect(Bun.TOML.parse("num = 42")).toEqual({ num: 42 });
+    expect(Bun.TOML.parse("bool = true")).toEqual({ bool: true });
+    expect(Bun.TOML.parse("bool = false")).toEqual({ bool: false });
+  });
+
+  test("parse arrays", () => {
+    expect(Bun.TOML.parse("arr = []")).toEqual({ arr: [] });
+    expect(Bun.TOML.parse("nums = [1, 2, 3]")).toEqual({ nums: [1, 2, 3] });
+    expect(Bun.TOML.parse('strings = ["a", "b"]')).toEqual({ strings: ["a", "b"] });
+  });
+
+  test("parse tables", () => {
+    const toml = `
+[database]
+server = "192.168.1.1"
+port = 5432
+`;
+    expect(Bun.TOML.parse(toml)).toEqual({
+      database: {
+        server: "192.168.1.1",
+        port: 5432,
+      },
+    });
+  });
+
+  test("parse mixed content", () => {
+    const toml = `
+title = "Test"
+version = 1.0
+
+[database]
+server = "localhost"
+enabled = true
+`;
+    expect(Bun.TOML.parse(toml)).toEqual({
+      title: "Test",
+      version: 1.0,
+      database: {
+        server: "localhost",
+        enabled: true,
+      },
+    });
+  });
+
+  test("parse error handling", () => {
+    expect(() => Bun.TOML.parse()).toThrow("Expected a string to parse");
+    expect(() => Bun.TOML.parse(null)).toThrow("Expected a string to parse");
+    expect(() => Bun.TOML.parse(undefined)).toThrow("Expected a string to parse");
+    expect(() => Bun.TOML.parse("invalid toml [")).toThrow();
+  });
+});
\ No newline at end of file