Bun v1.2.6

import crypto from "node:crypto";

const derivedKey = crypto.hkdfSync(
  "sha256",
  "secret-key",
  "salt",
  "info", // optional info
  32, // length of output key
);

crypto.hkdf("sha256", "secret-key", "salt", "info", 32, (err, derivedKey) => {
  // console.log(derivedKey);
});

import crypto from "node:crypto";

// Generate a 512-bit prime number synchronously
const prime = crypto.generatePrimeSync(512);
const isPrime = crypto.checkPrimeSync(prime); // true

crypto.generatePrime(2048, (err, prime) => {
  // `prime` is a 2048-bit prime number
});

crypto.checkPrime(prime, (err, result) => {
  // `result` is true
});

// Creating an ED25519 key pair and exporting the public key now works correctly
import { generateKeyPair } from "crypto";

const { publicKey, privateKey } = await generateKeyPair("ed25519");
const publicKeyObject = privateKey.export({ type: "spki", format: "pem" });
// This operation is now safer and more reliable

// Use the Node.js test API in your Bun projects
import test from "node:test";

test("basic functionality", (t) => {
  // Your test code here
});

const result = Bun.spawnSync({
  cmd: ["sleep", "1000"],
  timeout: 1000, // Will terminate after 1 second
});

console.log(result.exitedDueToTimeout); // true

import { SQL } from "bun";

await using sql = new SQL({
  // Connect via unix socket
  path: "/tmp/.s.PGSQL.5432", // Full path to socket
  // or just specify the directory
  // path: "/tmp", // Bun will append /.s.PGSQL.{port}

  user: "postgres",
  password: "postgres",
  database: "mydb"
});

const result = await sql`SELECT * FROM users`;

// The children will be tracked automatically
const childModule = require("./child-module");
console.log(module.children); // [Module { ... }]

// Use via connection string query parameters
await using db = new SQL(
  "postgres://user:pass@localhost:5432/mydb?search_path=information_schema",
  { max: 1 }
);

// Or use via connection options object
await using db = new SQL("postgres://user:pass@localhost:5432/mydb", {
  connection: {
    search_path: "information_schema"
  },
  max: 1
});

// Query tables from the specified schema
const count = await db`SELECT COUNT(*)::INT FROM columns LIMIT 1`.value();

// Before: Limited configuration
const db = Database.deserialize(serializedData);

// Now: Configure database settings during deserialization
const db = Database.deserialize(serializedData, {
  readonly: true,
  strict: true,
  safeIntegers: true,
});

// Now you can use translatePeerCertificate from the _tls_common module
const { translatePeerCertificate } = require("_tls_common");

// Convert raw certificate data to a more developer-friendly format
const formattedCert = translatePeerCertificate(rawCertificate);

// Compile a function in a specific context
const vm = require("node:vm");
const context = vm.createContext({ x: 42 });
const fn = vm.compileFunction("return x + y", ["y"], {
  contextExtension: context,
});

// Call the compiled function
console.log(fn(8)); // 50

❯ ls -lSh ~/Build/bun-v1.2.5/bun-darwin-aarch64/bun
... 56M ...

❯ ls -lSh ~/Build/bun-v1.2.6/bun-darwin-aarch64/bun
... 55M ...

// Before
import { createSocket } from "node:dgram";
const socket = createSocket("udp4");
await new Promise((resolve) => {
  socket.bind(resolve);
});

socket.connect(60865, "127.0.0.1", () => {
  console.log(socket.address().address);
  // Before:     0.0.0.0
  // Bun 1.2.6:  127.0.0.1
});

// Now works with packages that use the "svelte" export condition
import { Canvas } from "@threlte/core";

// Does not emit a warning
setTimeout(() => {});

// This still emits a warning (as expected)
setTimeout(() => {}, NaN);

// Before this fix, global selectors wouldn't work correctly
// index.module.css
:global(.button) {
  color: blue;
}

// Now properly outputs as
.button {
  color: blue;
}

// Now works properly
serve({
  routes: {
    "/*": () => new Response("Global catch-all"),
  },
});

// Previously
import fs from "node:fs";
// Would be resolved as just "fs"

// Now
import fs from "node:fs";
// Correctly maintains "node:" prefix

// When an unknown built-in module is requested
import nonexistent from "node:nonexistent";
// Throws ERR_UNKNOWN_BUILTIN_MODULE: "No such built-in module: node:nonexistent"

// When this file is executed as the main script
console.log(module.id); // "."

// When imported as a module from elsewhere
console.log(module.id); // "/path/to/file.js"

// This should now handle edge cases more reliably
const addon = require("./build/Release/my_addon.node");
const result = addon.convertString("Hello, 世界");

// Now you can properly import .svelte.ts modules
import { myHelper } from "./helper.svelte.ts";

// And use them in your Svelte components
<script>
  import {myHelper} from './helper.svelte.ts'; const result = myHelper();
</script>;

// Before: Memory would leak when spawning many processes
for (let i = 0; i < 1000; i++) {
  const proc = Bun.spawn({
    cmd: ["echo", "hello world"],
    stdout: "pipe",
  });
  await proc.exited;
}

// Now: Memory is properly released when processes complete

// Before - caused rendering issues in Safari
// .rounded-full { border-radius: 1e999px; }

// After - properly renders in all browsers
// .rounded-full { border-radius: 3.40282e38px; }

// This would previously crash after spawning many processes
import { $, which } from "bun";

const cat = which("cat");

// Spawn hundreds of processes in quick succession
const promises = [];
for (let i = 0; i < 100; i++) {
  promises.push($`${cat} some_file.txt`.text());
}

await Promise.all(promises);