- Fix error handling to throw for null/undefined at root level (TOML requires object root)
- Fix argument parsing to properly detect when no arguments passed vs undefined argument
- Update array test snapshot to match actual output format (remove extra leading newline)
- All functionality works correctly: deep nesting, arrays, complex objects, round-trips
🤖 Generated with [Claude Code](https://claude.ai/code)
Co-Authored-By: Claude <noreply@anthropic.com>
- Replace deprecated .arguments_old() calls with .argumentsAsArray()
- Remove unnecessary empty argument checking, let system handle naturally
- Update banned words limit since we reduced usage count
🤖 Generated with [Claude Code](https://claude.ai/code)
Co-Authored-By: Claude <noreply@anthropic.com>
Remove confusing multi-parameter signature that didn't actually do anything useful:
- TOML has fixed formatting rules, so space parameter was pointless
- Replacer parameter just threw an error anyway
- Cleaner API: just TOML.stringify(value) like it should be
Updated:
- Function signature to accept only 1 parameter instead of 3
- TypeScript definitions to match the actual API
- Tests to remove multi-parameter test cases
This makes the API much more intuitive and less confusing for users.
🤖 Generated with [Claude Code](https://claude.ai/code)
Co-Authored-By: Claude <noreply@anthropic.com>
- Remove complex options like `inlineTables` to keep API simple and focused
- Follow JSON.stringify(value, replacer, space) signature but ignore replacer/space
- Improve nested object handling with proper dotted table paths
- Add comprehensive tests for deeply nested objects and round-trip compatibility
- Throw error for unsupported replacer parameter (following YAML.stringify pattern)
- Update TypeScript definitions to reflect simplified API
The API is now much cleaner and matches the pattern established by Bun.YAML.stringify:
- Single parameter: `TOML.stringify(obj)`
- JSON.stringify-like: `TOML.stringify(obj, null, space)` (space ignored)
- Proper error for replacer: `TOML.stringify(obj, fn)` throws
🤖 Generated with [Claude Code](https://claude.ai/code)
Co-Authored-By: Claude <noreply@anthropic.com>
### What does this PR do?
fixes https://github.com/oven-sh/bun/issues/21945
### How did you verify your code works?
Run the code bellow and will be way harder the encounter the same
problem (I got it 1 times after 10 tries the same effect as Bun.sleep
mentioned before)
```ts
const sql = new Bun.SQL("postgres://localhost");
using conn1 = await sql.reserve();
using conn2 = await sql.reserve();
await sql`DROP TABLE IF EXISTS test1`;
await sql`CREATE TABLE IF NOT EXISTS test1 (
id INTEGER PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
uuid UUID NOT NULL
)`;
await sql`INSERT INTO test1 (uuid) VALUES (gen_random_uuid())`;
type Row = {
id: number;
uuid: string;
};
for (let i = 0; i < 100_000; i++) {
const [original]: Array<Row> = await conn1`SELECT id, uuid FROM test1 LIMIT 1`;
const [updated]: Array<Row> =
await conn1`UPDATE test1 SET uuid = gen_random_uuid() WHERE id = ${original.id} RETURNING id, uuid`;
const [retrieved]: Array<Row> = await conn2`SELECT id, uuid FROM test1 WHERE id = ${original.id}`;
if (retrieved.uuid !== updated.uuid) {
console.log("Expected retrieved and updated to match", retrieved, updated, i);
break;
}
}
```
### What does this PR do?
add `lastInsertRowid` (matching SQLite)
add `affectedRows`
fix `mysql_native_password` deprecated authentication
fix AuthSwitch
Fixes:
https://github.com/oven-sh/bun/issues/22178#issuecomment-3228716080
### How did you verify your code works?
tests
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
### What does this PR do?
Fix handling BIT(1) and BIT(N) on binary protocol and text protocol, now
behavior is consistent
### How did you verify your code works?
Tests
### What does this PR do?
- Instead of storing `len` in `BoundedArray` as a `usize`, store it as
either a `u8` or ` u16` depending on the `buffer_capacity`
- Copy-paste `BoundedArray` from the standard library into Bun's
codebase as it was removed in
https://github.com/ziglang/zig/pull/24699/files#diff-cbd8cbbc17583cb9ea5cc0f711ce0ad447b446e62ea5ddbe29274696dce89e4f
and we will probably continue using it
### How did you verify your code works?
Ran `bun run zig:check`
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Co-authored-by: taylor.fish <contact@taylor.fish>
in JS, `new TextDecoder("latin1").decode(...)` uses cp1252. In python,
latin1 is half-width utf-16. In our code, latin1 typically refers to
half-width utf-16 because JavaScriptCore uses that for most strings, but
sometimes it refers to cp1252. Rename the cp1252 functions to be called
cp1252
Also fixes an issue where Buffer.from with utf-16le would sometimes
output the wrong value:
```js
$> bun -p "Buffer.from('\x80', 'utf-16le')"
<Buffer ac 20>
$> node -p "Buffer.from('\x80', 'utf-16le')"
<Buffer 80 00>
$> bun-debug -p "Buffer.from('\x80', 'utf-16le')"
<Buffer 80 00>
```
## Summary
- Fixed allocator threading violation when `BUN_INSPECT_CONNECT_TO` is
set
- Created thread-local `env_loader` with proper allocator isolation in
debugger thread
- Added regression test to verify the fix works correctly
## Problem
When `BUN_INSPECT_CONNECT_TO` environment variable is set, Bun creates a
debugger thread that spawns its own `VirtualMachine` instance.
Previously, this VM would fall back to the global `DotEnv.instance`
which was created with the main thread's allocator, causing threading
violations when the debugger thread accessed environment files via
`--env-file` or other env loading operations.
## Solution
Modified `startJSDebuggerThread` in `src/bun.js/Debugger.zig` to:
1. Create a thread-local `DotEnv.Map` and `DotEnv.Loader` using the
debugger thread's allocator
2. Pass this thread-local `env_loader` to `VirtualMachine.init()` to
ensure proper allocator isolation
3. Prevent sharing of allocators across threads
## Test plan
- [x] Added regression test in
`test/regression/issue/test_env_loader_threading.test.ts`
- [x] Verified basic Bun functionality still works
- [x] Test passes with both normal execution and with
`BUN_INSPECT_CONNECT_TO` set
🤖 Generated with [Claude Code](https://claude.ai/code)
---------
Co-authored-by: Claude Bot <claude-bot@bun.sh>
Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
- Replace union type with TypeScript function overloads for cleaner IntelliSense
- Simplify TOML options to only include `inlineTables` (most essential option)
- Remove `arraysMultiline` and `indent` options for consistent formatting
- Update memory management to use ArenaAllocator for better cleanup
- Update test snapshots to match new array formatting (no multiline for <4 elements)
🤖 Generated with [Claude Code](https://claude.ai/code)
Co-Authored-By: Claude <noreply@anthropic.com>
ZLS was tested manually and works with private fields (after restarting)
Zig diff:
d1a4e0b0dd..ebe0cdac31
ZLS diff:
15730e8e5d..3733f39c8d
Increases `zig build check` time by maybe 10ms?
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
## Summary
Fixes an issue where compiled standalone binaries included an extra
executable name argument in `process.argv`, breaking code that uses
`node:util.parseArgs()` with `process.argv.slice(2)`.
## Problem
When running a compiled binary, `process.argv` incorrectly included the
executable name as a third argument:
```bash
./my-app
# process.argv = ["bun", "/$bunfs/root/my-app", "./my-app"] # BUG
```
This caused `parseArgs()` to fail with "Unexpected argument" errors,
breaking previously valid code.
## Solution
Fixed the `offset_for_passthrough` calculation in `cli.zig` to always
skip the executable name for standalone binaries, ensuring
`process.argv` only contains the runtime name and script path:
```bash
./my-app
# process.argv = ["bun", "/$bunfs/root/my-app"] # FIXED
```
## Test plan
- [x] Added regression test in `test/regression/issue/22157.test.ts`
- [x] Verified existing exec-argv functionality still works correctly
- [x] Manual testing confirms the fix resolves the parseArgs issue
Fixes#22157🤖 Generated with [Claude Code](https://claude.ai/code)
---------
Co-authored-by: Claude Bot <claude-bot@bun.sh>
Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: Michael H <git@riskymh.dev>
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Support both JSON.stringify-style and object-style parameters:
JSON.stringify-style:
- Bun.TOML.stringify(obj, null, 2) // number for spaces
- Bun.TOML.stringify(obj, null, '\t') // string for indentation
Object-style (advanced options):
- Bun.TOML.stringify(obj, null, { inlineTables: true })
Updated TypeScript definitions to reflect the enhanced API with
proper union types and comprehensive examples.
🤖 Generated with [Claude Code](https://claude.ai/code)
Co-Authored-By: Claude <noreply@anthropic.com>
Major features implemented:
- Core TOML stringify functionality with comprehensive error handling
- Support for all basic TOML types: strings, numbers, booleans, arrays, tables
- Options support: inlineTables, arraysMultiline, indent
- Proper string escaping with control character handling
- Special float value support (nan, inf, -inf)
- Key validation and quoting when necessary
- Table and inline table formatting
- TypeScript type definitions with comprehensive documentation
- Comprehensive test suite covering basic and advanced functionality
API Features:
- Bun.TOML.stringify(value, replacer?, options?)
- Options: inlineTables, arraysMultiline, indent
- Error messages for different failure modes
- Round-trip compatibility with Bun.TOML.parse()
The implementation provides a solid foundation for TOML stringification
in Bun, following similar patterns to JSON.stringify and YAML.stringify.
Memory management has been carefully handled to prevent use-after-free
issues in the JavaScript runtime.
🤖 Generated with [Claude Code](https://claude.ai/code)
Co-Authored-By: Claude <noreply@anthropic.com>
## Summary
Fixes an issue where compiled standalone binaries included an extra
executable name argument in `process.argv`, breaking code that uses
`node:util.parseArgs()` with `process.argv.slice(2)`.
## Problem
When running a compiled binary, `process.argv` incorrectly included the
executable name as a third argument:
```bash
./my-app
# process.argv = ["bun", "/$bunfs/root/my-app", "./my-app"] # BUG
```
This caused `parseArgs()` to fail with "Unexpected argument" errors,
breaking previously valid code.
## Solution
Fixed the `offset_for_passthrough` calculation in `cli.zig` to always
skip the executable name for standalone binaries, ensuring
`process.argv` only contains the runtime name and script path:
```bash
./my-app
# process.argv = ["bun", "/$bunfs/root/my-app"] # FIXED
```
## Test plan
- [x] Added regression test in `test/regression/issue/22157.test.ts`
- [x] Verified existing exec-argv functionality still works correctly
- [x] Manual testing confirms the fix resolves the parseArgs issue
Fixes#22157🤖 Generated with [Claude Code](https://claude.ai/code)
---------
Co-authored-by: Claude Bot <claude-bot@bun.sh>
Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: Michael H <git@riskymh.dev>
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
### What does this PR do?
### How did you verify your code works?
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
### What does this PR do?
Change tinyint/bool type from mysql to number instead of bool to match
mariadb and mysql2 behavior since tinyint/bool can be bigger than 1 in
mysql
Fixes https://github.com/oven-sh/bun/issues/22158
### How did you verify your code works?
Test
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Replace `catch bun.outOfMemory()`, which can accidentally catch
non-OOM-related errors, with either `bun.handleOom` or a manual `catch
|err| switch (err)`.
(For internal tracking: fixes STAB-1070)
---------
Co-authored-by: Dylan Conway <dylan.conway567@gmail.com>
### What does this PR do?
- Implements .onEnd
Fixes#22061
Once #22144 is merged, this also fixes:
Fixes#9862Fixes#20806
### How did you verify your code works?
Tests
---
TODO in a followup (#22144)
> ~~Make all entrypoints be called in onResolve~~
> ~~Fixes # 9862~~
> ~~Fixes # 20806~~
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
### What does this PR do?
optimize advance method
after this optimizations
100k req the query bellow in 1 connection takes 792ms instead of 6s
```sql
SELECT CAST(1 AS UNSIGNED) AS x
```
1mi req of the query bellow with 10 connections takes 57.41s - 62.5s
instead of 162.50s, mysql2 takes 1516.94s for comparison
```sql
SELECT * FROM users_bun_bench LIMIT 100
```
### How did you verify your code works?
Tested and benchmarked + CI
For jest compatibility. Fixes#5228
---------
Co-authored-by: Claude Bot <claude-bot@bun.sh>
Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
### What does this PR do?
fixes parsing strings like `"1e18495d9d7f6b41135e5ee828ef538dc94f9be4"`
### How did you verify your code works?
added a test.
## Summary
Fixes a bug in the internal `bun.spawnSync` implementation where
stderr's poll file descriptor was incorrectly set to stdout's fd when
polling both streams.
## The Bug
In `/src/bun.js/api/bun/process.zig` line 2204, when setting up the poll
file descriptor array for stderr, the code incorrectly used
`out_fds_to_wait_for[0]` (stdout) instead of `out_fds_to_wait_for[1]`
(stderr).
This meant:
- stderr's fd was never actually polled
- stdout's fd was polled twice
- Could cause stderr data to be lost or incomplete
- Could potentially cause hangs when reading from stderr
## Impact
This bug only affects Bun's internal CLI commands that use
`bun.spawnSync` with both stdout and stderr piped (like `bun create`,
`bun upgrade`, etc.). The JavaScript `spawnSync` API uses a different
code path and is not affected.
## The Fix
Changed line 2204 from:
```zig
poll_fds[poll_fds.len - 1].fd = @intCast(out_fds_to_wait_for[0].cast());
```
to:
```zig
poll_fds[poll_fds.len - 1].fd = @intCast(out_fds_to_wait_for[1].cast());
```
🤖 Generated with [Claude Code](https://claude.ai/code)
Co-authored-by: Claude <noreply@anthropic.com>
## Summary
Fixes an issue where `--compile-exec-argv` options were incorrectly
appearing in `process.argv` when no user arguments were provided to a
compiled standalone binary.
## Problem
When building a standalone binary with `--compile-exec-argv`, the exec
argv options would leak into `process.argv` when running the binary
without any user arguments:
```bash
# Build with exec argv
bun build --compile-exec-argv="--user-agent=hello" --compile ./a.js
# Run without arguments - BEFORE fix
./a
# Output showed --user-agent=hello in both execArgv AND argv (incorrect)
{
execArgv: [ "--user-agent=hello" ],
argv: [ "bun", "/$bunfs/root/a", "--user-agent=hello" ], # <- BUG: exec argv leaked here
}
# Expected behavior (matches runtime):
bun --user-agent=hello a.js
{
execArgv: [ "--user-agent=hello" ],
argv: [ "/path/to/bun", "/path/to/a.js" ], # <- No exec argv in process.argv
}
```
## Solution
The issue was in the offset calculation for determining which arguments
to pass through to the JavaScript runtime. The offset was being
calculated before modifying the argv array with exec argv options,
causing it to be incorrect when the original argv only contained the
executable name.
The fix ensures that:
- `process.execArgv` correctly contains the compile-exec-argv options
- `process.argv` only contains the executable, script path, and user
arguments
- exec argv options never leak into `process.argv`
## Test plan
Added comprehensive tests to verify:
1. Exec argv options don't leak into process.argv when no user arguments
are provided
2. User arguments are properly passed through when exec argv is present
3. Existing behavior continues to work correctly
All tests pass:
```
bun test compile-argv.test.ts
✓ 3 tests pass
```
🤖 Generated with [Claude Code](https://claude.ai/code)
---------
Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
This PR adds `Bun.secrets`, a new API for securely storing and
retrieving credentials using the operating system's native credential
storage locally. This helps developers avoid storing sensitive data in
plaintext config files.
```javascript
// Store a GitHub token securely
await Bun.secrets.set({
service: "my-cli-tool",
name: "github-token",
value: "ghp_xxxxxxxxxxxxxxxxxxxx"
});
// Retrieve it when needed
const token = await Bun.secrets.get({
service: "my-cli-tool",
name: "github-token"
});
// Use with fallback to environment variable
const apiKey = await Bun.secrets.get({
service: "my-app",
name: "api-key"
}) || process.env.API_KEY;
```
Marking this as a draft because Linux and Windows have not been manually
tested yet. This API is only really meant for local development usecases
right now, but it would be nice if in the future to support adapters for
production or CI usecases.
### Core API
- `Bun.secrets.get({ service, name })` - Retrieve a stored credential
- `Bun.secrets.set({ service, name, value })` - Store or update a
credential
- `Bun.secrets.delete({ service, name })` - Delete a stored credential
### Platform Support
- **macOS**: Uses Keychain Services via Security.framework
- **Linux**: Uses libsecret (works with GNOME Keyring, KWallet, etc.)
- **Windows**: Uses Windows Credential Manager via advapi32.dll
### Implementation Highlights
- Non-blocking - all operations run on the threadpool
- Dynamic loading - no hard dependencies on system libraries
- Sensitive data is zeroed after use
- Consistent API across all platforms
## Use Cases
This API is particularly useful for:
- CLI tools that need to store authentication tokens
- Development tools that manage API keys
- Any tool that currently stores credentials in `~/.npmrc`,
`~/.aws/credentials` or in environment variables that're globally loaded
## Testing
Comprehensive test suite included with coverage for:
- Basic CRUD operations
- Empty strings and special characters
- Unicode support
- Concurrent operations
- Error handling
All tests pass on macOS. Linux and Windows implementations are complete
but would benefit from additional platform testing.
## Documentation
- Complete API documentation in `docs/api/secrets.md`
- TypeScript definitions with detailed JSDoc comments and examples
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Co-authored-by: Claude Bot <claude-bot@bun.sh>
Co-authored-by: Claude <noreply@anthropic.com>
### What does this PR do?
This PR adds builtin YAML parsing with `Bun.YAML.parse`
```js
import { YAML } from "bun";
const items = YAML.parse("- item1");
console.log(items); // [ "item1" ]
```
Also YAML imports work just like JSON and TOML imports
```js
import pkg from "./package.yaml"
console.log({ pkg }); // { pkg: { name: "pkg", version: "1.1.1" } }
```
### How did you verify your code works?
Added some tests for YAML imports and parsed values.
---------
Co-authored-by: Claude Bot <claude-bot@bun.sh>
Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Co-authored-by: Jarred Sumner <jarred@jarredsumner.com>
* `IncrementalGraph(.client).File` packs its fields in a specific way to
save space, but it makes the struct hard to use and error-prone (e.g.,
untagged unions with tags stored in a separate `flags` struct). This PR
changes `File` to have a human-readable layout, but adds methods to
convert it to and from `File.Packed`, a packed version with the same
space efficiency as before.
* Reduce the need to pass the dev allocator to functions (e.g.,
`deinit`) by storing it as a struct field via the new `DevAllocator`
type. This type has no overhead in release builds, or when
`AllocationScope` is disabled.
* Use owned pointers in `PackedMap`.
* Use `bun.ptr.Shared` for `PackedMap` instead of the old
`bun.ptr.RefPtr`.
* Add `bun.ptr.ScopedOwned`, which is like `bun.ptr.Owned`, but can
store an `AllocationScope`. No overhead in release builds or when
`AllocationScope` is disabled.
* Reduce redundant allocators in `BundleV2`.
* Add owned pointer conversions to `MutableString`.
* Make `AllocationScope` behave like a pointer, so it can be moved
without invalidating allocations. This eliminates the need for
self-references.
* Change memory cost algorithm so it doesn't rely on “dedupe bits”.
These bits used to take advantage of padding but there is now no padding
in `PackedMap`.
* Replace `VoidFieldTypes` with `useAllFields`; this eliminates the need
for `voidFieldTypesDiscardHelper`.
(For internal tracking: fixes STAB-1035, STAB-1036, STAB-1037,
STAB-1038, STAB-1039, STAB-1040, STAB-1041, STAB-1042, STAB-1043,
STAB-1044, STAB-1045)
---------
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Co-authored-by: Jarred Sumner <jarred@jarredsumner.com>
Co-authored-by: Claude Bot <claude-bot@bun.sh>
Co-authored-by: Claude <noreply@anthropic.com>
## Summary
Fixes an assertion failure that occurred when `server.stop()` was called
while HTTP requests were still in flight.
## Root Cause
The issue was in `jsValueAssertAlive()` at
`src/bun.js/api/server.zig:627`, which had an assertion requiring
`server.listener != null`. However, `server.stop()` immediately sets
`listener` to null, causing assertion failures when pending requests
triggered callbacks that accessed the server's JavaScript value.
## Solution
Converted the server's `js_value` from `jsc.Strong.Optional` to
`jsc.JSRef` for safer lifecycle management:
- **On `stop()`**: Downgrade from strong to weak reference instead of
calling `deinit()`
- **In `finalize()`**: Properly call `deinit()` on the JSRef
- **Remove problematic assertion**: JSRef allows safe access to JS value
via weak reference even after stop
## Benefits
- ✅ No more assertion failures when stopping servers with pending
requests
- ✅ In-flight requests can still access the server JS object safely
- ✅ JS object can be garbage collected when appropriate
- ✅ Maintains backward compatibility - no external API changes
## Test plan
- [x] Reproduces the original assertion failure
- [x] Verifies the fix resolves the issue
- [x] Adds regression test to prevent future occurrences
- [x] Confirms normal server functionality still works
The fix includes a comprehensive regression test at
`test/regression/issue/server-stop-with-pending-requests.test.ts`.
🤖 Generated with [Claude Code](https://claude.ai/code)
---------
Co-authored-by: Claude Bot <claude-bot@bun.sh>
Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Co-authored-by: Jarred Sumner <jarred@jarredsumner.com>
## Summary
- Implement `Symbol.asyncDispose` for the `Worker` class in
`worker_threads` module
- Enables automatic resource cleanup with `await using` syntax
- Calls `await this.terminate()` to properly shut down workers when they
go out of scope
## Implementation Details
The implementation adds a simple async method to the Worker class:
```typescript
async [Symbol.asyncDispose]() {
await this.terminate();
}
```
This allows workers to be used with the new `await using` syntax for
automatic cleanup:
```javascript
{
await using worker = new Worker('./worker.js');
// worker automatically terminates when leaving this scope
}
```
## Test Plan
- [x] Added comprehensive tests for `Symbol.asyncDispose` functionality
- [x] Tests verify the method exists and returns undefined
- [x] Tests verify `await using` syntax works correctly for automatic
worker cleanup
- [x] All new tests pass
- [x] Existing worker_threads functionality remains intact
🤖 Generated with [Claude Code](https://claude.ai/code)
---------
Co-authored-by: Claude Bot <claude-bot@bun.sh>
Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
