electrobun 1.17.3-beta.10 → 1.17.3-beta.12

package/README.md

@@ -14,16 +14,27 @@
 ## What is Electrobun?
 
 Electrobun aims to be a complete **solution-in-a-box** for building, updating, and shipping ultra fast, tiny, and cross-platform desktop applications written in Typescript.
-Under the hood it uses <a href="https://bun.sh">bun</a> to execute the main process and to bundle webview typescript, and has native bindings written in <a href="https://ziglang.org/">zig</a>.
+Under the hood it uses <a href="https://bun.sh">bun</a> to execute the main process and to bundle webview typescript, and has native bindings written in Objc, C++, and several core parts written in <a href="https://ziglang.org/">zig</a>.
 
-Visit <a href="https://blackboard.sh/electrobun/">https://blackboard.sh/electrobun/</a> to see api documentation, guides, and more.
+Visit <a href="https://docs.electrobunny.ai/electrobun/">https://docs.electrobunny.ai/electrobun/</a> to see api documentation, guides, and more.
+
+You use it via npm.
+
+Don't miss our:
+- self-extracting bundles that use ZSTD compression for more compact distributables as small as 16MB
+- zig optimized BSDIFF implementation that lets you ship tiny app updates as small as 4KB
+- `bundleCEF` flag to bundle and pin Chromium for those that want that tradeoff of consistency over file size
+- `bundleWGPU` that lets you use Bun Typescript -> WGPU to control a native GPU surface without a webview
+- Our Three.js and Babylon.js adapters that work right in Bun
+- Our `<electrobun-webview>` and `<electrobun-wpgu>` html elements that let you composit proper OOPIFs and native GPU surfaces into your UIs
+- so much more.
 
 **Project Goals**
 
 - Write typescript for the main process and webviews without having to think about it.
 - Isolation between main and webview processes with fast, typed, easy to implement RPC between them.
-- Small self-extracting app bundles ~12MB (when using system webview, most of this is the bun runtime)
-- Even smaller app updates as small as 14KB (using bsdiff it only downloads tiny patches between versions)
+- Small self-extracting app bundles ~14MB (when using system webview, most of this is the bun runtime)
+- Even smaller app updates as small as 4KB (using bsdiff it only downloads tiny patches between versions)
 - Provide everything you need in one tightly integrated workflow to start writing code in 5 minutes and distribute in 10.
 
 ## Apps Built with Electrobun
@@ -42,8 +53,10 @@ Visit <a href="https://blackboard.sh/electrobun/">https://blackboard.sh/electrob
 - [Codex Agents Composer](https://github.com/MrLesk/codex-agents-composer) - desktop app for managing your Codex agents and their skills
 - [codex-devtools](https://github.com/gulivan/codex-devtools) - desktop inspector for Codex session data; browse conversations, search messages, and analyze agent activity
 - [Deskdown](https://github.com/guarana-studio/deskdown) - transform any web address into a desktop app in under 20 seconds
+- [Dictate](https://github.com/siddhantparadox/dictate) - Windows dictation app with local and BYOK cloud transcription
 - [dev-3.0](https://github.com/h0x91b/dev-3.0) - helps you not get lost while managing multiple AI agents across projects
 - [DOOM](https://github.com/blackboardsh/electrobun-doom) - DOOM implemented in 2 ways: bun -> (c doom -> bundled wgpu) and (full ts port bun -> bundled wgpu)
+- [dotlock](https://github.com/tsconfigdotjson/dotlock) - macOS desktop app for managing `.env` files across your projects
 - [electrobun-pdf](https://github.com/GijungKim/electrobun-pdf) - local-first PDF & DOCX editor for opening, annotating, and exporting documents without leaving your machine
 - [electrobun-rms](https://github.com/khanhthanhdev/electrobun-rms) - fast Electrobun desktop app template with React, Tailwind CSS, and Vite
 - [golb](https://github.com/chrisdadev13/golb) - desktop AI coding workspace built with React, Vite, and Tailwind
@@ -55,6 +68,7 @@ Visit <a href="https://blackboard.sh/electrobun/">https://blackboard.sh/electrob
 - [md-browse](https://github.com/needle-tools/md-browse) - a markdown-first browser that converts web pages to clean markdown
 - [Patchline](https://github.com/adwaithks/Patchline) - lightweight desktop Git client for reading patches and line diffs, then staging and committing changes
 - [peekachu](https://github.com/needle-tools/peekachu) - password manager for AIs; store secrets in your OS keychain and scrub output so AI assistants never see actual values
+- [PiBun](https://github.com/khairold/pibun) - desktop GUI for the Pi coding agent with chat, terminal, git integration, and plugin system
 - [PLEXI](https://github.com/ianjamesburke/PLEXI) - a multi-dimensional terminal multiplexer for the agentic era
 - [Prometheus](https://github.com/opensourcectl/prometheus) - desktop utility toolbox for file cleanup, document manipulation, and image processing
 - [Quiver](https://ataraxy-labs.github.io/quiver/) - desktop app for GitHub PR reviews, merge conflict resolution, and AI commit messages
@@ -67,6 +81,7 @@ Visit <a href="https://blackboard.sh/electrobun/">https://blackboard.sh/electrob
 - [VibesOS](https://github.com/popmechanic/VibesOS) - A GUI for Claude Code that makes it easy to vibe code simple, un-hackable apps
 - [VoiceVault](https://github.com/PJH720/VoiceVault) - AI-powered voice recorder with transcription, summarization, and RAG search
 - [warren](https://github.com/Loa212/warren) - open-source, peer-to-peer terminal mesh for accessing your machines from any device without SSH keys or config files
+- [whatsapp-reminder](https://github.com/FatahChan/whatsapp-reminder) - managed scheduled WhatsApp messages
 
 ### Video Demos
 
@@ -81,8 +96,11 @@ Visit <a href="https://blackboard.sh/electrobun/">https://blackboard.sh/electrob
 [![Star History Chart](https://api.star-history.com/svg?repos=blackboardsh/electrobun&type=date&legend=top-left&cache=3)](https://www.star-history.com/#blackboardsh/electrobun&type=date&legend=top-left)
 
 ## Contributing
+Electrobun is one piece of a vision I'm building. I'm optimizing for focus and execution. Issues and PRs can be used to share ideas, but there should be no expectation that I will review, respond to, or merge them.
+
 Ways to get involved:
 
+- Read the [Contribution guidelines](./CONTRIBUTING.md)
 - Follow us on X for updates <a href="https://twitter.com/BlackboardTech">@BlackboardTech</a> and <a href="https://twitter.com/YoavCodes">@YoavCodes</a> or on bluesky <a href="https://bsky.app/profile/yoav.codes">@yoav.codes</a>
 - Join the conversation on <a href="https://discord.gg/ueKE4tjaCE">Discord</a>
 - Create and participate in Github issues and discussions

package/bin/electrobun.cjs

@@ -32,6 +32,16 @@ const platform = getPlatform();
 const arch = platform === 'win' ? 'x64' : getArch();
 const binExt = platform === 'win' ? '.exe' : '';
 
+function getTarCommand() {
+  if (platform !== 'win') {
+    return 'tar';
+  }
+
+  // Git Bash tar can treat C:\... as a remote path. Force the built-in Windows tar.
+  const systemTar = join(process.env.SystemRoot || 'C:\\Windows', 'System32', 'tar.exe');
+  return existsSync(systemTar) ? `"${systemTar}"` : 'tar';
+}
+
 // Paths
 const electrobunDir = join(__dirname, '..');
 const cacheDir = join(electrobunDir, '.cache');
@@ -98,7 +108,7 @@ async function ensureCliBinary() {
     await downloadFile(tarballUrl, tarballPath);
 
     // Extract using system tar (available on macOS, Linux, and Windows 10+)
-    execSync(`tar -xzf "${tarballPath}"`, { cwd: cacheDir, stdio: 'pipe' });
+    execSync(`${getTarCommand()} -xzf "${tarballPath}"`, { cwd: cacheDir, stdio: 'pipe' });
 
     // Clean up tarball
     unlinkSync(tarballPath);

package/dist/api/bun/ElectrobunConfig.ts

@@ -56,6 +56,39 @@ export interface ElectrobunConfig {
 		 * ```
 		 */
 		urlSchemes?: string[];
+
+		/**
+		 * File type associations for the application.
+		 * Registers document types so the OS can open files with your app
+		 * (e.g., double-click in Finder, "Open With" menu, drag-to-dock).
+		 *
+		 * Platform support:
+		 * - macOS: Fully supported. Generates CFBundleDocumentTypes in Info.plist.
+		 * - Windows/Linux: Not yet supported.
+		 *
+		 * Files arrive as file:// URLs via the existing "open-url" event:
+		 * ```typescript
+		 * Electrobun.events.on("open-url", (e) => {
+		 *   if (e.data.url.startsWith("file://")) {
+		 *     console.log("Opened file:", e.data.url);
+		 *   }
+		 * });
+		 * ```
+		 */
+		fileAssociations?: Array<{
+			/** File extensions without the leading dot (e.g., ["dotlock", "json"]) */
+			ext: string[];
+			/** Human-readable name for this file type (e.g., "DotLock Document") */
+			name: string;
+			/** The app's role for this file type. @default "Viewer" */
+			role?: "Editor" | "Viewer" | "Shell" | "None";
+			/**
+			 * Path to an .icns file for this document type (macOS only).
+			 * The file is automatically copied into the app bundle's Resources folder
+			 * during the build. Only the filename (without path) is written to Info.plist.
+			 */
+			icon?: string;
+		}>;
 	};
 
 	/**
@@ -278,7 +311,15 @@ export interface ElectrobunConfig {
 			entitlements?: Record<string, boolean | string | string[]>;
 
 			/**
-			 * Path to .iconset folder containing app icons
+			 * Path to .iconset folder or .icon file (from Icon Composer)
+			 * containing app icons.
+			 *
+			 * - `.iconset` folders are converted to .icns via iconutil
+			 *   (requires Command Line Tools)
+			 * - `.icon` files are compiled via actool, producing Assets.car
+			 *   for Liquid Glass on macOS 26+ and a .icns fallback for older
+			 *   macOS versions (requires Xcode)
+			 *
 			 * @default "icon.iconset"
 			 */
 			icons?: string;

package/dist/api/bun/__tests__/ffi-contract.test.ts

@@ -0,0 +1,105 @@
+// Contract tests for the bun:ffi APIs that electrobun depends on.
+//
+// Bun bumps don't usually break electrobun, but when they do, the breakage
+// almost always lives in this surface — JSCallback marshaling, FFIType
+// encoding, dlopen behavior. These tests are a tripwire: if a new Bun release
+// breaks any of them, we want to know before cutting an electrobun release,
+// not after a user reports a crash.
+//
+// Skipped on Windows for now since the bun-check workflow runs on Linux and
+// the system library paths differ. If we add a Windows runner later, switch
+// the libc path resolution to include msvcrt/ucrtbase.
+
+import { describe, expect, it } from "bun:test";
+import {
+	CString,
+	FFIType,
+	JSCallback,
+	dlopen,
+	ptr,
+	toArrayBuffer,
+	type Pointer,
+} from "bun:ffi";
+
+const isUnix =
+	process.platform === "darwin" || process.platform === "linux";
+
+const libcPath =
+	process.platform === "darwin" ? "libSystem.B.dylib" : "libc.so.6";
+
+(isUnix ? describe : describe.skip)(
+	"bun:ffi contract used by electrobun",
+	() => {
+		it("dlopen + FFIType.cstring + FFIType.u64 (strlen)", () => {
+			const lib = dlopen(libcPath, {
+				strlen: {
+					args: [FFIType.cstring],
+					returns: FFIType.u64,
+				},
+			});
+
+			const len = lib.symbols.strlen(
+				new TextEncoder().encode("hello\0"),
+			);
+			expect(Number(len)).toBe(5);
+
+			lib.close();
+		});
+
+		it("ptr + toArrayBuffer round-trip", () => {
+			const src = new Uint8Array([1, 2, 3, 4, 5]);
+			const back = new Uint8Array(
+				toArrayBuffer(ptr(src), 0, src.byteLength),
+			);
+			expect(Array.from(back)).toEqual([1, 2, 3, 4, 5]);
+		});
+
+		it("CString reads null-terminated bytes", () => {
+			const buf = new Uint8Array([72, 105, 33, 0]); // "Hi!\0"
+			const s = new CString(ptr(buf));
+			expect(s.toString()).toBe("Hi!");
+		});
+
+		it("JSCallback: native invokes JS via function pointer (qsort)", () => {
+			const lib = dlopen(libcPath, {
+				qsort: {
+					args: [
+						FFIType.ptr,
+						FFIType.u64,
+						FFIType.u64,
+						FFIType.function,
+					],
+					returns: FFIType.void,
+				},
+			});
+
+			let comparisonCount = 0;
+			const compare = new JSCallback(
+				(aPtr: Pointer, bPtr: Pointer) => {
+					comparisonCount++;
+					const a = new Int32Array(toArrayBuffer(aPtr, 0, 4))[0]!;
+					const b = new Int32Array(toArrayBuffer(bPtr, 0, 4))[0]!;
+					return a - b;
+				},
+				{
+					args: [FFIType.ptr, FFIType.ptr],
+					returns: FFIType.i32,
+				},
+			);
+
+			const arr = new Int32Array([5, 2, 8, 1, 3]);
+			lib.symbols.qsort(
+				ptr(arr),
+				BigInt(arr.length),
+				4n,
+				compare.ptr,
+			);
+
+			expect(Array.from(arr)).toEqual([1, 2, 3, 5, 8]);
+			expect(comparisonCount).toBeGreaterThan(0);
+
+			compare.close();
+			lib.close();
+		});
+	},
+);

package/dist/api/bun/core/BrowserView.ts

@@ -74,7 +74,7 @@ const randomId = Math.random().toString(36).substring(7);
 
 export class BrowserView<T extends RPCWithTransport = RPCWithTransport> {
 	id: number = nextWebviewId++;
-	ptr!: Pointer;
+	ptr: Pointer | null = null;
 	hostWebviewId?: number;
 	windowId!: number;
 	renderer!: "cef" | "native";
@@ -361,8 +361,10 @@ export class BrowserView<T extends RPCWithTransport = RPCWithTransport> {
 			unregisterHandler() {},
 		});
 		this.rpcHandler = undefined;
-		this.ptr = null as any;
-		native!.symbols.webviewRemove(ptr);
+    
+    this.rpcHandler = undefined;
+    this.ptr = null;
+    native!.symbols.webviewRemove(ptr);
 	}
 
 	static getById(id: number) {

package/dist/api/bun/core/BrowserWindow.ts

@@ -12,6 +12,11 @@ import { WGPUView } from "./WGPUView";
 const buildConfig = await BuildConfig.get();
 
 export type WindowOptionsType<T = undefined> = {
+	trafficLightOffset?: {
+		x: number;
+		y: number;
+	};
+	activate?: boolean;
 	title: string;
 	frame: {
 		x: number;
@@ -123,6 +128,7 @@ export class BrowserWindow<T extends RPCWithTransport = RPCWithTransport> {
 	transparent: boolean = false;
 	passthrough: boolean = false;
 	hidden: boolean = false;
+	trafficLightOffset: { x: number; y: number } = { x: 0, y: 0 };
 	navigationRules: string | null = null;
 	// Sandbox mode disables RPC and only allows event emission (for untrusted content)
 	sandbox: boolean = false;
@@ -153,6 +159,10 @@ export class BrowserWindow<T extends RPCWithTransport = RPCWithTransport> {
 		this.transparent = options.transparent ?? false;
 		this.passthrough = options.passthrough ?? false;
 		this.hidden = options.hidden ?? false;
+		this.trafficLightOffset = {
+			x: options.trafficLightOffset?.x ?? 0,
+			y: options.trafficLightOffset?.y ?? 0,
+		};
 		this.navigationRules = options.navigationRules || null;
 		this.sandbox = options.sandbox ?? false;
 
@@ -165,6 +175,7 @@ export class BrowserWindow<T extends RPCWithTransport = RPCWithTransport> {
 		titleBarStyle,
 		transparent,
 		hidden,
+		activate,
 	}: Partial<WindowOptionsType<T>>) {
 		this.ptr = ffi.request.createWindow({
 			id: this.id,
@@ -208,6 +219,8 @@ export class BrowserWindow<T extends RPCWithTransport = RPCWithTransport> {
 			titleBarStyle: titleBarStyle || "default",
 			transparent: transparent ?? false,
 			hidden: hidden ?? false,
+			activate: activate ?? true,
+			trafficLightOffset: this.trafficLightOffset,
 		}) as Pointer;
 
 		BrowserWindowMap[this.id] = this;
@@ -263,12 +276,27 @@ export class BrowserWindow<T extends RPCWithTransport = RPCWithTransport> {
 		return ffi.request.closeWindow({ winId: this.id });
 	}
 
+	activate() {
+		return ffi.request.activateWindow({ winId: this.id });
+	}
+
 	focus() {
-		return ffi.request.focusWindow({ winId: this.id });
+		console.log(
+			"[electrobun] BrowserWindow.focus() is deprecated. Use window.activate() instead.",
+		);
+		return this.activate();
 	}
 
 	show() {
-		return ffi.request.focusWindow({ winId: this.id });
+		return ffi.request.showWindow({ winId: this.id, activate: true });
+	}
+
+	showInactive() {
+		return ffi.request.showWindow({ winId: this.id, activate: false });
+	}
+
+	hide() {
+		return ffi.request.hideWindow({ winId: this.id });
 	}
 
 	minimize() {
@@ -325,6 +353,10 @@ export class BrowserWindow<T extends RPCWithTransport = RPCWithTransport> {
 		return ffi.request.setWindowPosition({ winId: this.id, x, y });
 	}
 
+	setWindowButtonPosition(x: number, y: number) {
+		return ffi.request.setWindowButtonPosition({ winId: this.id, x, y });
+	}
+
 	setSize(width: number, height: number) {
 		this.frame.width = width;
 		this.frame.height = height;

package/dist/api/bun/core/GpuWindow.ts

@@ -6,6 +6,11 @@ import { getNextWindowId } from "./windowIds";
 
 
 export type GpuWindowOptionsType = {
+	trafficLightOffset?: {
+		x: number;
+		y: number;
+	};
+	activate?: boolean;
 	title: string;
 	frame: {
 		x: number;
@@ -54,6 +59,7 @@ export class GpuWindow {
 	title: string = "Electrobun";
 	state: "creating" | "created" = "creating";
 	transparent: boolean = false;
+	trafficLightOffset: { x: number; y: number } = { x: 0, y: 0 };
 	frame: {
 		x: number;
 		y: number;
@@ -73,6 +79,10 @@ export class GpuWindow {
 			? { ...defaultOptions.frame, ...options.frame }
 			: { ...defaultOptions.frame };
 		this.transparent = options.transparent ?? false;
+		this.trafficLightOffset = {
+			x: options.trafficLightOffset?.x ?? 0,
+			y: options.trafficLightOffset?.y ?? 0,
+		};
 
 		this.init(options);
 	}
@@ -81,6 +91,7 @@ export class GpuWindow {
 		styleMask,
 		titleBarStyle,
 		transparent,
+		activate,
 	}: Partial<GpuWindowOptionsType>) {
 		this.ptr = ffi.request.createWindow({
 			id: this.id,
@@ -123,6 +134,8 @@ export class GpuWindow {
 			},
 			titleBarStyle: titleBarStyle || "default",
 			transparent: transparent ?? false,
+			activate: activate ?? true,
+			trafficLightOffset: this.trafficLightOffset,
 		}) as Pointer;
 
 		GpuWindowMap[this.id] = this;
@@ -160,12 +173,23 @@ export class GpuWindow {
 		return ffi.request.closeWindow({ winId: this.id });
 	}
 
+	activate() {
+		return ffi.request.activateWindow({ winId: this.id });
+	}
+
 	focus() {
-		return ffi.request.focusWindow({ winId: this.id });
+		console.log(
+			"[electrobun] GpuWindow.focus() is deprecated. Use window.activate() instead.",
+		);
+		return this.activate();
 	}
 
 	show() {
-		return ffi.request.focusWindow({ winId: this.id });
+		return ffi.request.showWindow({ winId: this.id, activate: true });
+	}
+
+	showInactive() {
+		return ffi.request.showWindow({ winId: this.id, activate: false });
 	}
 
 	minimize() {
@@ -214,6 +238,10 @@ export class GpuWindow {
 		return ffi.request.setWindowPosition({ winId: this.id, x, y });
 	}
 
+	setWindowButtonPosition(x: number, y: number) {
+		return ffi.request.setWindowButtonPosition({ winId: this.id, x, y });
+	}
+
 	setSize(width: number, height: number) {
 		this.frame.width = width;
 		this.frame.height = height;

package/dist/api/bun/core/Paths.ts

@@ -1,5 +1,5 @@
 import { resolve } from "path";
 
-const RESOURCES_FOLDER = resolve("../Resources/");
+export const RESOURCES_FOLDER = resolve("../Resources/");
 
 export const VIEWS_FOLDER = resolve(RESOURCES_FOLDER, "app/views");

package/dist/api/bun/core/Updater.ts

@@ -179,7 +179,7 @@ const Updater = {
 	// todo: allow switching channels, by default will check the current channel
 	checkForUpdate: async () => {
 		emitStatus("checking", "Checking for updates...");
-		const localInfo = await Updater.getLocallocalInfo();
+		const localInfo = await Updater.getLocalInfo();
 
 		if (localInfo.channel === "dev") {
 			emitStatus("no-update", "Dev channel - updates disabled", {
@@ -283,7 +283,7 @@ const Updater = {
 		await Updater.channelBucketUrl(); // Ensure localInfo is loaded
 		const appFileName = localInfo.name;
 
-		let currentHash = (await Updater.getLocallocalInfo()).hash;
+		let currentHash = (await Updater.getLocalInfo()).hash;
 		let latestHash = (await Updater.checkForUpdate()).hash;
 
 		const extractionFolder = join(appDataFolder, "self-extraction");
@@ -1074,14 +1074,14 @@ del "%~f0"
 	},
 
 	channelBucketUrl: async () => {
-		await Updater.getLocallocalInfo();
+		await Updater.getLocalInfo();
 		// With flat prefix-based naming, channelBucketUrl is just the baseUrl
 		// Users can also use Updater.localInfo.baseUrl() directly
 		return localInfo.baseUrl;
 	},
 
 	appDataFolder: async () => {
-		await Updater.getLocallocalInfo();
+		await Updater.getLocalInfo();
 		// Use identifier + channel for the app data folder
 		// e.g., ~/Library/Application Support/sh.blackboard.myapp/canary/
 		const appDataFolder = join(
@@ -1096,20 +1096,20 @@ del "%~f0"
 	// TODO: consider moving this from "Updater.localInfo" to "BuildVars"
 	localInfo: {
 		version: async () => {
-			return (await Updater.getLocallocalInfo()).version;
+			return (await Updater.getLocalInfo()).version;
 		},
 		hash: async () => {
-			return (await Updater.getLocallocalInfo()).hash;
+			return (await Updater.getLocalInfo()).hash;
 		},
 		channel: async () => {
-			return (await Updater.getLocallocalInfo()).channel;
+			return (await Updater.getLocalInfo()).channel;
 		},
 		baseUrl: async () => {
-			return (await Updater.getLocallocalInfo()).baseUrl;
+			return (await Updater.getLocalInfo()).baseUrl;
 		},
 	},
 
-	getLocallocalInfo: async () => {
+	getLocalInfo: async () => {
 		if (localInfo) {
 			return localInfo;
 		}
@@ -1122,8 +1122,15 @@ del "%~f0"
 			console.error("Failed to read version.json", error);
 			localInfo = { identifier: "", channel: "", version: "", hash: "", baseUrl: "", name: "" };
 			return localInfo;
-		}
-	},
-};
+			}
+		},
+		getLocallocalInfo: async () => {
+			console.error(
+				"[Electrobun] Updater.getLocallocalInfo() is deprecated. Use Updater.getLocalInfo() instead.",
+			);
+
+			return Updater.getLocalInfo();
+		},
+	};
 
 export { Updater };

package/dist/api/bun/index.ts

@@ -229,6 +229,7 @@ export {
 	Screen,
 	Session,
 	WGPUBridge,
+
 	BuildConfig,
 };
 
@@ -247,6 +248,7 @@ const Electrobun = {
 	Screen,
 	Session,
 	WGPUBridge,
+
 	BuildConfig,
 	events: electobunEventEmmitter,
 	PATHS,

package/dist/api/bun/proc/native.ts

@@ -97,6 +97,8 @@ export const native = (() => {
 					FFIType.u32, // styleMask
 					FFIType.cstring, // titleBarStyle
 					FFIType.bool, // transparent
+					FFIType.f64, // trafficLightOffsetX
+					FFIType.f64, // trafficLightOffsetY
 					FFIType.function, // closeHandler
 					FFIType.function, // moveHandler
 					FFIType.function, // resizeHandler
@@ -116,9 +118,20 @@ export const native = (() => {
 			showWindow: {
 				args: [
 					FFIType.ptr, // window ptr
+					FFIType.bool, // activate
 				],
 				returns: FFIType.void,
 			},
+			activateWindow: {
+				args: [
+					FFIType.ptr, // window ptr
+				],
+				returns: FFIType.void,
+			},
+			hideWindow: {
+				args: [FFIType.ptr],
+				returns: FFIType.void,
+			},
 			closeWindow: {
 				args: [
 					FFIType.ptr, // window ptr
@@ -173,14 +186,18 @@ export const native = (() => {
 				args: [FFIType.ptr],
 				returns: FFIType.bool,
 			},
-			setWindowPosition: {
-				args: [FFIType.ptr, FFIType.f64, FFIType.f64],
-				returns: FFIType.void,
-			},
-			setWindowSize: {
-				args: [FFIType.ptr, FFIType.f64, FFIType.f64],
-				returns: FFIType.void,
-			},
+				setWindowPosition: {
+					args: [FFIType.ptr, FFIType.f64, FFIType.f64],
+					returns: FFIType.void,
+				},
+				setWindowButtonPosition: {
+					args: [FFIType.ptr, FFIType.f64, FFIType.f64],
+					returns: FFIType.void,
+				},
+				setWindowSize: {
+					args: [FFIType.ptr, FFIType.f64, FFIType.f64],
+					returns: FFIType.void,
+				},
 			setWindowFrame: {
 				args: [FFIType.ptr, FFIType.f64, FFIType.f64, FFIType.f64, FFIType.f64],
 				returns: FFIType.void,
@@ -835,6 +852,11 @@ const _ffiImpl = {
 			titleBarStyle: string;
 			transparent: boolean;
 			hidden?: boolean;
+			activate?: boolean;
+			trafficLightOffset?: {
+				x: number;
+				y: number;
+			};
 		}): FFIType.ptr => {
 			const {
 				id,
@@ -858,6 +880,8 @@ const _ffiImpl = {
 				titleBarStyle,
 				transparent,
 				hidden = false,
+				activate = true,
+				trafficLightOffset = { x: 0, y: 0 },
 			} = params;
 
 			const styleMask = native_.symbols.getWindowStyle(
@@ -886,6 +910,8 @@ const _ffiImpl = {
 				// style
 				toCString(titleBarStyle),
 				transparent,
+				trafficLightOffset.x,
+				trafficLightOffset.y,
 				// callbacks
 				windowCloseCallback,
 				windowMoveCallback,
@@ -901,7 +927,7 @@ const _ffiImpl = {
 
 			native_.symbols.setWindowTitle(windowPtr, toCString(title));
 			if (!hidden) {
-				native_.symbols.showWindow(windowPtr);
+				native_.symbols.showWindow(windowPtr, activate);
 			}
 
 			return windowPtr;
@@ -930,15 +956,37 @@ const _ffiImpl = {
 			// Note: Cleanup of BrowserWindowMap happens in the windowCloseCallback
 		},
 
-		focusWindow: (params: { winId: number }) => {
+		showWindow: (params: { winId: number; activate?: boolean }) => {
+			const { winId } = params;
+			const windowPtr = getWindowPtr(winId);
+
+			if (!windowPtr) {
+				throw `Can't show window. Window no longer exists`;
+			}
+
+			native_.symbols.showWindow(windowPtr, params.activate ?? true);
+		},
+
+		activateWindow: (params: { winId: number }) => {
 			const { winId } = params;
 			const windowPtr = getWindowPtr(winId);
 
 			if (!windowPtr) {
-				throw `Can't focus window. Window no longer exists`;
+				throw `Can't activate window. Window no longer exists`;
 			}
 
-			native_.symbols.showWindow(windowPtr);
+			native_.symbols.activateWindow(windowPtr);
+		},
+
+		hideWindow: (params: { winId: number }) => {
+			const { winId } = params;
+			const windowPtr = getWindowPtr(winId);
+
+			if (!windowPtr) {
+				throw `Can't hide window. Window no longer exists`;
+			}
+
+			native_.symbols.hideWindow(windowPtr);
 		},
 
 		minimizeWindow: (params: { winId: number }) => {
@@ -1079,21 +1127,32 @@ const _ffiImpl = {
 			return native_.symbols.isWindowVisibleOnAllWorkspaces(windowPtr);
 		},
 
-		setWindowPosition: (params: { winId: number; x: number; y: number }) => {
-			const { winId, x, y } = params;
-			const windowPtr = getWindowPtr(winId);
+			setWindowPosition: (params: { winId: number; x: number; y: number }) => {
+				const { winId, x, y } = params;
+				const windowPtr = getWindowPtr(winId);
 
-			if (!windowPtr) {
-				throw `Can't set window position. Window no longer exists`;
-			}
+				if (!windowPtr) {
+					throw `Can't set window position. Window no longer exists`;
+				}
 
-			native_.symbols.setWindowPosition(windowPtr, x, y);
-		},
+				native_.symbols.setWindowPosition(windowPtr, x, y);
+			},
 
-		setWindowSize: (params: {
-			winId: number;
-			width: number;
-			height: number;
+			setWindowButtonPosition: (params: { winId: number; x: number; y: number }) => {
+				const { winId, x, y } = params;
+				const windowPtr = getWindowPtr(winId);
+
+				if (!windowPtr) {
+					throw `Can't set window button position. Window no longer exists`;
+				}
+
+				native_.symbols.setWindowButtonPosition(windowPtr, x, y);
+			},
+
+			setWindowSize: (params: {
+				winId: number;
+				width: number;
+				height: number;
 		}) => {
 			const { winId, width, height } = params;
 			const windowPtr = getWindowPtr(winId);
@@ -1814,6 +1873,7 @@ export const WGPUBridge = {
 	},
 };
 
+
 // Worker management. Move to a different file
 process.on("uncaughtException", (err) => {
 	console.error("Uncaught exception in worker:", err);

package/dist/api/bun/webGPU.ts

@@ -291,43 +291,20 @@ const WGPU_LIB_NAMES: Record<string, string[]> = {
 };
 
 function findWgpuLibraryPath(): string | null {
-	const debug = process.env["ELECTROBUN_WGPU_DEBUG"] === "1";
-	const envPath = process.env["ELECTROBUN_WGPU_PATH"];
-	if (envPath && existsSync(envPath)) {
-		if (debug) console.log("[WGPU] using ELECTROBUN_WGPU_PATH:", envPath);
-		return envPath;
-	} else if (envPath && debug) {
-		console.warn("[WGPU] ELECTROBUN_WGPU_PATH not found:", envPath);
-	}
+	const envPath = process.env['ELECTROBUN_WGPU_PATH'];
+	if (envPath && existsSync(envPath)) return envPath;
 
 	const names = WGPU_LIB_NAMES[process.platform] ?? ["libwebgpu_dawn." + suffix];
 	for (const name of names) {
 		const cwdCandidate = join(process.cwd(), name);
-		if (existsSync(cwdCandidate)) {
-			if (debug) console.log("[WGPU] found in cwd:", cwdCandidate);
-			return cwdCandidate;
-		}
+		if (existsSync(cwdCandidate)) return cwdCandidate;
 		const execDir = dirname(process.execPath);
 		const macCandidate = join(execDir, "..", "MacOS", name);
-		if (existsSync(macCandidate)) {
-			if (debug) console.log("[WGPU] found in bundle MacOS:", macCandidate);
-			return macCandidate;
-		}
+		if (existsSync(macCandidate)) return macCandidate;
 		const resCandidate = join(execDir, "..", "Resources", name);
-		if (existsSync(resCandidate)) {
-			if (debug) console.log("[WGPU] found in bundle Resources:", resCandidate);
-			return resCandidate;
-		}
+		if (existsSync(resCandidate)) return resCandidate;
 		const execCandidate = join(execDir, name);
-		if (existsSync(execCandidate)) {
-			if (debug) console.log("[WGPU] found next to exec:", execCandidate);
-			return execCandidate;
-		}
-	}
-
-	if (debug) {
-		console.warn("[WGPU] not found. platform:", process.platform, "execPath:", process.execPath, "cwd:", process.cwd());
-		console.warn("[WGPU] names:", names);
+		if (existsSync(execCandidate)) return execCandidate;
 	}
 
 	return null;
@@ -352,9 +329,7 @@ export const native = (() => {
 			symbols: lib.symbols,
 			close: lib.close,
 		};
-	} catch (err) {
-		const message = err instanceof Error ? err.message : String(err);
-		console.warn("[WGPU] dlopen failed:", libPath, message);
+	} catch {
 		return {
 			available: false,
 			path: libPath,

package/dist/api/bun/webgpuAdapter.ts

@@ -811,11 +811,6 @@ function makeCommandBufferArray(cmdPtr: number) {
 	return { buffer, ptr: ptr(buffer) };
 }
 
-function makeSurfaceTexture() {
-	const buffer = new ArrayBuffer(24);
-	return { buffer, view: new DataView(buffer), ptr: ptr(buffer) };
-}
-
 function makeSurfaceCapabilities() {
 	const buffer = new ArrayBuffer(64);
 	const view = new DataView(buffer);

package/dist/api/shared/bun-version.ts

@@ -1,3 +1,3 @@
 // Default Bun version shipped with this Electrobun release.
 // All platforms use the same version. Update this when bumping Bun.
-export const BUN_VERSION = "1.3.11";
+export const BUN_VERSION = "1.3.13";

package/dist/api/shared/cef-version.ts

@@ -1,5 +1,5 @@
 // Default CEF version shipped with this Electrobun release.
 // All platforms use the same version. Update this single pair when bumping CEF.
-export const CEF_VERSION = `145.0.23+g3e7fe1c`;
-export const CHROMIUM_VERSION = `145.0.7632.68`;
+export const CEF_VERSION = `147.0.10+gd58e84d`;
+export const CHROMIUM_VERSION = `147.0.7727.118`;
 export const DEFAULT_CEF_VERSION_STRING = `${CEF_VERSION}+chromium-${CHROMIUM_VERSION}`;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "electrobun",
-	"version": "1.17.3-beta.10",
+	"version": "1.17.3-beta.12",
 	"description": "Build ultra fast, tiny, and cross-platform desktop apps with Typescript.",
 	"license": "MIT",
 	"author": "Blackboard Technologies Inc.",
@@ -46,7 +46,7 @@
 		"push:stable": "bun run typecheck && bun scripts/push-version.js stable",
 		"build:push:artifacts": "bun scripts/build-and-upload-artifacts.js",
 		"test": "bun install && bun build:dev && bun build:cli && cd ../tests && bun install && bun build:dev && bun start",
-		"test:unit": "bun test src/shared",
+		"test:unit": "bun test src/shared src/bun",
 		"bump-cef": "bun scripts/update-cef-version.ts"
 	},
 	"devDependencies": {

package/src/cli/index.ts

@@ -1462,6 +1462,13 @@ const _commandDefaults = {
 	},
 };
 
+type FileAssociation = {
+	ext: string[];
+	name: string;
+	role?: "Editor" | "Viewer" | "Shell" | "None";
+	icon?: string;
+};
+
 // Default values merged with user's electrobun.config.ts
 // For the user-facing type, see ElectrobunConfig in src/bun/ElectrobunConfig.ts
 const defaultConfig = {
@@ -1471,6 +1478,7 @@ const defaultConfig = {
 		version: "0.1.0",
 		description: "" as string | undefined,
 		urlSchemes: undefined as string[] | undefined,
+		fileAssociations: undefined as FileAssociation[] | undefined,
 	},
 	build: {
 		buildFolder: "build",
@@ -1779,6 +1787,151 @@ ${schemesXml}
     </array>`;
 }
 
+// Generates CFBundleDocumentTypes and UTExportedTypeDeclarations for file associations.
+// Each association gets a UTI derived from the app identifier (e.g., com.example.app.myext).
+// LSItemContentTypes in CFBundleDocumentTypes references these UTIs so Launch Services
+// properly associates files with the app on modern macOS.
+function generateDocumentTypes(
+	fileAssociations: FileAssociation[] | undefined,
+	projectRoot: string,
+	appIdentifier: string,
+): string {
+	if (!fileAssociations || fileAssociations.length === 0) {
+		return "";
+	}
+
+	const validAssociations = fileAssociations.filter((assoc) => {
+		if (!assoc.ext || assoc.ext.length === 0) {
+			console.log(
+				`WARNING: fileAssociations entry "${assoc.name || "(unnamed)"}" has no extensions — skipping`,
+			);
+			return false;
+		}
+		if (!assoc.name) {
+			console.log(
+				`WARNING: fileAssociations entry with extensions [${assoc.ext.join(", ")}] has no name — skipping`,
+			);
+			return false;
+		}
+		return true;
+	});
+
+	if (validAssociations.length === 0) {
+		return "";
+	}
+
+	// Clean extensions and warn about leading dots
+	const cleaned = validAssociations.map((assoc) => ({
+		...assoc,
+		ext: assoc.ext.map((ext) => {
+			const clean = ext.replace(/^\./, "");
+			if (clean !== ext) {
+				console.log(
+					`WARNING: fileAssociations ext "${ext}" has a leading dot — stripping to "${clean}"`,
+				);
+			}
+			return clean;
+		}),
+	}));
+
+	// Generate CFBundleDocumentTypes with LSItemContentTypes
+	const docTypes = cleaned
+		.map((assoc) => {
+			const role = assoc.role || "Viewer";
+			// Resolve icon: only reference if file exists to avoid dangling plist entries
+			let iconName = "";
+			if (assoc.icon) {
+				const iconSourcePath = join(projectRoot, assoc.icon);
+				if (existsSync(iconSourcePath)) {
+					iconName = basename(assoc.icon).replace(/\.icns$/i, "");
+				} else {
+					console.log(
+						`WARNING: Document type icon not found: ${iconSourcePath} — skipping icon reference`,
+					);
+				}
+			}
+			const iconLine = iconName
+				? `            <key>CFBundleTypeIconFile</key>\n            <string>${escapeXml(iconName)}</string>\n`
+				: "";
+			// One UTI per extension, all listed under LSItemContentTypes
+			const utiXml = assoc.ext
+				.map(
+					(ext) =>
+						`                <string>${escapeXml(appIdentifier)}.${escapeXml(ext)}</string>`,
+				)
+				.join("\n");
+			const extsXml = assoc.ext
+				.map(
+					(ext) =>
+						`                <string>${escapeXml(ext)}</string>`,
+				)
+				.join("\n");
+
+			return `        <dict>
+            <key>CFBundleTypeName</key>
+            <string>${escapeXml(assoc.name)}</string>
+            <key>CFBundleTypeRole</key>
+            <string>${escapeXml(role)}</string>
+${iconLine}            <key>LSItemContentTypes</key>
+            <array>
+${utiXml}
+            </array>
+            <key>CFBundleTypeExtensions</key>
+            <array>
+${extsXml}
+            </array>
+        </dict>`;
+		})
+		.join("\n");
+
+	// Generate UTExportedTypeDeclarations — one per extension
+	const utiDecls = cleaned
+		.flatMap((assoc) => {
+			let iconName = "";
+			if (assoc.icon) {
+				const iconSourcePath = join(projectRoot, assoc.icon);
+				if (existsSync(iconSourcePath)) {
+					iconName = basename(assoc.icon).replace(/\.icns$/i, "");
+				}
+			}
+			const iconLine = iconName
+				? `            <key>UTTypeIconFiles</key>
+            <array>
+                <string>${escapeXml(iconName)}</string>
+            </array>\n`
+				: "";
+			return assoc.ext.map(
+				(ext) => `        <dict>
+            <key>UTTypeIdentifier</key>
+            <string>${escapeXml(appIdentifier)}.${escapeXml(ext)}</string>
+            <key>UTTypeDescription</key>
+            <string>${escapeXml(assoc.name)}</string>
+            <key>UTTypeConformsTo</key>
+            <array>
+                <string>public.data</string>
+            </array>
+${iconLine}            <key>UTTypeTagSpecification</key>
+            <dict>
+                <key>public.filename-extension</key>
+                <array>
+                    <string>${escapeXml(ext)}</string>
+                </array>
+            </dict>
+        </dict>`,
+			);
+		})
+		.join("\n");
+
+	return `    <key>CFBundleDocumentTypes</key>
+    <array>
+${docTypes}
+    </array>
+    <key>UTExportedTypeDeclarations</key>
+    <array>
+${utiDecls}
+    </array>`;
+}
+
 // Execute command handling
 (async () => {
 	if (commandArg === "init") {
@@ -1913,7 +2066,7 @@ ${schemesXml}
 			console.log(
 				"Different architecture, different APIs. Do not use Electron patterns.",
 			);
-			console.log("Docs: https://blackboard.sh/electrobun/llms.txt");
+			console.log("Docs: https://docs.electrobunny.ai/electrobun/llms.txt");
 			console.log(
 				"━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━",
 			);
@@ -1932,9 +2085,7 @@ ${schemesXml}
 		try {
 			await runBuild(config, buildEnvironment);
 		} catch (error) {
-			if (error instanceof Error) {
-				console.error(error.message);
-			}
+			console.error("Build failed:", error);
 			process.exit(1);
 		}
 	} else if (commandArg === "run") {
@@ -1950,9 +2101,7 @@ ${schemesXml}
 			try {
 				await runBuild(config, "dev");
 			} catch (error) {
-				if (error instanceof Error) {
-					console.error(error.message);
-				}
+				console.error("Build failed:", error);
 				process.exit(1);
 			}
 			await runAppWithSignalHandling(config);
@@ -2059,18 +2208,97 @@ ${schemesXml}
 				const iconDestPath = join(appBundleFolderResourcesPath, "AppIcon.icns");
 				if (existsSync(iconSourceFolder)) {
 					if (OS === "macos") {
-						// Use iconutil to convert .iconset folder to .icns
-						Bun.spawnSync(
-							["iconutil", "-c", "icns", "-o", iconDestPath, iconSourceFolder],
-							{
-								cwd: appBundleFolderResourcesPath,
-								stdio: ["ignore", "inherit", "inherit"],
-								env: {
-									...process.env,
-									ELECTROBUN_BUILD_ENV: buildEnvironment,
+						if (config.build.mac.icons.endsWith(".icon")) {
+							// .icon format (Icon Composer) — compile with actool
+							// Produces Assets.car (Liquid Glass on macOS 26+) and .icns fallback
+							const actoolCheck = Bun.spawnSync(
+								["xcrun", "--find", "actool"],
+								{ stdio: ["ignore", "pipe", "pipe"] },
+							);
+							if (actoolCheck.exitCode !== 0) {
+								throw new Error(
+									"Building .icon files requires Xcode (actool is not available from Command Line Tools alone). " +
+										"Install Xcode from the App Store, or set mac.icons to an .iconset folder instead.",
+								);
+							}
+
+							const iconStem = basename(config.build.mac.icons, ".icon");
+							const partialPlistPath = join(
+								buildFolder,
+								".actool-partial-info.plist",
+							);
+
+							console.log(
+								"Compiling .icon file with actool (requires Xcode)...",
+							);
+							const result = Bun.spawnSync(
+								[
+									"xcrun",
+									"actool",
+									"--compile",
+									appBundleFolderResourcesPath,
+									"--app-icon",
+									iconStem,
+									"--platform",
+									"macosx",
+									"--minimum-deployment-target",
+									"11.0",
+									"--output-partial-info-plist",
+									partialPlistPath,
+									iconSourceFolder,
+								],
+								{
+									cwd: projectRoot,
+									stdio: ["ignore", "inherit", "inherit"],
+									env: {
+										...process.env,
+										ELECTROBUN_BUILD_ENV: buildEnvironment,
+									},
 								},
-							},
-						);
+							);
+
+							if (result.exitCode !== 0) {
+								throw new Error(
+									`actool failed to compile ${config.build.mac.icons} (exit code ${result.exitCode})`,
+								);
+							}
+
+							// actool produces <stem>.icns — rename to AppIcon.icns so
+							// CFBundleIconFile ("AppIcon") resolves correctly
+							const actoolIcns = join(
+								appBundleFolderResourcesPath,
+								`${iconStem}.icns`,
+							);
+							if (existsSync(actoolIcns) && actoolIcns !== iconDestPath) {
+								renameSync(actoolIcns, iconDestPath);
+							}
+						} else {
+							// Use iconutil to convert .iconset folder to .icns
+							const result = Bun.spawnSync(
+								[
+									"iconutil",
+									"-c",
+									"icns",
+									"-o",
+									iconDestPath,
+									iconSourceFolder,
+								],
+								{
+									cwd: appBundleFolderResourcesPath,
+									stdio: ["ignore", "inherit", "inherit"],
+									env: {
+										...process.env,
+										ELECTROBUN_BUILD_ENV: buildEnvironment,
+									},
+								},
+							);
+
+							if (result.exitCode !== 0) {
+								throw new Error(
+									`iconutil failed to convert ${config.build.mac.icons} (exit code ${result.exitCode})`,
+								);
+							}
+						}
 					} else {
 						console.log(
 							`WARNING: Cannot build macOS icons on ${OS} - iconutil is only available on macOS`,
@@ -2137,6 +2365,26 @@ Categories=Utility;Application;
 					cpSync(iconPath, targetIconPath, { dereference: true });
 				}
 			}
+
+			// Copy document type icon files to the app bundle Resources folder
+			if (targetOS === "macos" && config.app.fileAssociations) {
+				for (const assoc of config.app.fileAssociations) {
+					if (assoc.icon) {
+						const iconSourcePath = join(projectRoot, assoc.icon);
+						if (existsSync(iconSourcePath)) {
+							const iconFileName = basename(iconSourcePath);
+							const iconDestPath = join(
+								appBundleFolderResourcesPath,
+								iconFileName,
+							);
+							cpSync(iconSourcePath, iconDestPath, {
+								dereference: true,
+							});
+						}
+						// Missing icon warning is handled by generateDocumentTypes
+					}
+				}
+			}
 		};
 
 		// Run preBuild hook before anything starts
@@ -2212,8 +2460,20 @@ Categories=Utility;Application;
 			config.app.urlSchemes,
 			config.app.identifier,
 		);
+		// Generate document type associations
+		const documentTypes = generateDocumentTypes(
+			config.app.fileAssociations,
+			projectRoot,
+			config.app.identifier,
+		);
+
+		// When using .icon format, CFBundleIconName is needed for Assets.car lookup
+		const iconName = config.build.mac?.icons?.endsWith(".icon")
+			? basename(config.build.mac.icons, ".icon")
+			: null;
 
 		InfoPlistContents = `<?xml version="1.0" encoding="UTF-8"?>
+
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
@@ -2228,7 +2488,9 @@ Categories=Utility;Application;
     <key>CFBundlePackageType</key>
     <string>APPL</string>
     <key>CFBundleIconFile</key>
-    <string>AppIcon</string>${usageDescriptions ? "\n" + usageDescriptions : ""}${urlTypes ? "\n" + urlTypes : ""}
+    <string>AppIcon</string>${iconName ? `\n    <key>CFBundleIconName</key>\n <string>${iconName}</string>` : ""}${usageDescriptions ? "\n" +
+usageDescriptions : ""}${urlTypes ? "\n" + urlTypes : ""}${documentTypes ?
+"\n" + documentTypes : ""}
 </dict>
 </plist>`;
 
@@ -2328,10 +2590,12 @@ Categories=Utility;Application;
 					}
 
 					// Use rcedit to embed the icon into launcher.exe
-					const rcedit = (await import("rcedit")).default;
-					await rcedit(bunCliLauncherDestination, {
-						icon: iconPath,
-					});
+										const { execFileSync } = await import("child_process");
+					const rceditPkgPath = require.resolve("rcedit/package.json");
+					const rceditDir = dirname(rceditPkgPath);
+					const rceditX64 = join(rceditDir, "bin", "rcedit-x64.exe");
+					const rceditExe = existsSync(rceditX64) ? rceditX64 : join(rceditDir, "bin", "rcedit.exe");
+					execFileSync(rceditExe, [bunCliLauncherDestination, "--set-icon", iconPath]);
 					console.log(`Successfully embedded icon into launcher.exe`);
 
 					// Clean up temp ICO file
@@ -2425,10 +2689,12 @@ Categories=Utility;Application;
 					}
 
 					// Use rcedit to embed the icon into bun.exe
-					const rcedit = (await import("rcedit")).default;
-					await rcedit(bunBinaryDestInBundlePath, {
-						icon: iconPath,
-					});
+										const { execFileSync } = await import("child_process");
+					const rceditPkgPath = require.resolve("rcedit/package.json");
+					const rceditDir = dirname(rceditPkgPath);
+					const rceditX64 = join(rceditDir, "bin", "rcedit-x64.exe");
+					const rceditExe = existsSync(rceditX64) ? rceditX64 : join(rceditDir, "bin", "rcedit.exe");
+					execFileSync(rceditExe, [bunBinaryDestInBundlePath, "--set-icon", iconPath]);
 					console.log(`Successfully embedded icon into bun.exe`);
 
 					// Clean up temp ICO file
@@ -4610,10 +4876,12 @@ Categories=Utility;Application;
 					}
 
 					// Use rcedit to embed the icon
-					const rcedit = (await import("rcedit")).default;
-					await rcedit(outputExePath, {
-						icon: iconPath,
-					});
+										const { execFileSync } = await import("child_process");
+					const rceditPkgPath = require.resolve("rcedit/package.json");
+					const rceditDir = dirname(rceditPkgPath);
+					const rceditX64 = join(rceditDir, "bin", "rcedit-x64.exe");
+					const rceditExe = existsSync(rceditX64) ? rceditX64 : join(rceditDir, "bin", "rcedit.exe");
+					execFileSync(rceditExe, [outputExePath, "--set-icon", iconPath]);
 					console.log(`Successfully embedded icon into ${setupFileName}`);
 
 					// Clean up temp ICO file