electrobun 1.18.1 → 1.18.4-beta.10

package/dist/api/{bun → sdks/bun}/webGPU.ts

@@ -291,7 +291,7 @@ const WGPU_LIB_NAMES: Record<string, string[]> = {
 };
 
 function findWgpuLibraryPath(): string | null {
-	const envPath = process.env['ELECTROBUN_WGPU_PATH'];
+	const envPath = process.env["ELECTROBUN_WGPU_PATH"];
 	if (envPath && existsSync(envPath)) return envPath;
 
 	const names = WGPU_LIB_NAMES[process.platform] ?? ["libwebgpu_dawn." + suffix];

package/dist/api/{bun → sdks/bun}/webgpuAdapter.ts

@@ -3,7 +3,7 @@ import { WGPUView } from "./core/WGPUView";
 import { GpuWindow } from "./core/GpuWindow";
 import WGPU from "./webGPU";
 import { WGPUBridge } from "./proc/native";
-import { ptr, CString, toArrayBuffer, type Pointer, JSCallback } from "bun:ffi";
+import { ptr, toArrayBuffer, type Pointer, JSCallback } from "bun:ffi";
 import { inflateSync } from "zlib";
 
 const WGPUNative = WGPU.native;
@@ -223,9 +223,13 @@ function makeStringView(str?: string | null) {
 	if (!str) {
 		return { ptr: 0, len: 0n, cstr: null };
 	}
-	const cstr = new CString(str);
-	WGPU_KEEPALIVE.push(cstr);
-	return { ptr: cstr.ptr, len: WGPU_STRLEN, cstr };
+	const bytes = new TextEncoder().encode(str);
+	WGPU_KEEPALIVE.push(bytes);
+	return { ptr: ptr(bytes), len: BigInt(bytes.byteLength), cstr: bytes };
+}
+
+function ptrOrNull(value: ArrayBuffer | ArrayBufferView) {
+	return value.byteLength === 0 ? 0 : ptr(value);
 }
 
 function makeSurfaceConfiguration(
@@ -935,7 +939,7 @@ class GPUQueue {
 		WGPUNative.symbols.wgpuQueueSubmit(
 			this.ptr,
 			BigInt(commandBuffers.length) as any,
-			ptr(buffer),
+			ptrOrNull(buffer),
 		);
 		if (LAST_SURFACE_PTR && LAST_SURFACE_HAS_TEXTURE) {
 			LAST_SURFACE_HAS_TEXTURE = false;
@@ -947,7 +951,7 @@ class GPUQueue {
 			this.ptr,
 			buffer.ptr,
 			BigInt(offset),
-			ptr(data),
+			ptrOrNull(data),
 			data.byteLength,
 		);
 	}
@@ -1271,7 +1275,7 @@ class GPUDevice {
 				new Uint8Array(entry.buffer),
 			);
 		});
-		const entryPtr = ptr(entryBuf);
+		const entryPtr = ptrOrNull(entryBuf);
 		WGPU_KEEPALIVE.push(entryBuf);
 		const desc = makeBindGroupLayoutDescriptor(
 			entryPtr as any,
@@ -1286,39 +1290,39 @@ class GPUDevice {
 	}
 	createBindGroup(descriptor: { layout: GPUBindGroupLayout; entries: any[] }) {
 		const entries = descriptor.entries.map((entry) => {
-			if (entry.resource?.buffer || entry.resource instanceof GPUBuffer) {
-				const buffer = entry.resource.buffer ?? entry.resource;
+			const bufferResource =
+				entry.resource?.buffer || entry.resource instanceof GPUBuffer
+					? entry.resource
+					: entry.buffer;
+			if (bufferResource) {
+				const buffer = bufferResource.buffer ?? bufferResource;
 				return makeBindGroupEntry({
 					binding: entry.binding ?? 0,
 					buffer: {
 						buffer,
-						offset: entry.resource.offset ?? 0,
-						size: entry.resource.size ?? 0xffffffffffffffffn,
+						offset: bufferResource.offset ?? 0,
+						size: bufferResource.size ?? 0xffffffffffffffffn,
 					},
 				});
 			}
-			if (entry.resource instanceof GPUSampler) {
-				return makeBindGroupEntry({
-					binding: entry.binding ?? 0,
-					sampler: entry.resource,
-				});
-			}
-			if (entry.resource instanceof GPUTextureView) {
+			const sampler =
+				entry.resource instanceof GPUSampler
+					? entry.resource
+					: entry.resource?.sampler ?? entry.sampler;
+			if (sampler) {
 				return makeBindGroupEntry({
 					binding: entry.binding ?? 0,
-					textureView: entry.resource,
+					sampler,
 				});
 			}
-			if (entry.resource?.sampler) {
+			const textureView =
+				entry.resource instanceof GPUTextureView
+					? entry.resource
+					: entry.resource?.textureView ?? entry.textureView;
+			if (textureView) {
 				return makeBindGroupEntry({
 					binding: entry.binding ?? 0,
-					sampler: entry.resource.sampler,
-				});
-			}
-			if (entry.resource?.textureView) {
-				return makeBindGroupEntry({
-					binding: entry.binding ?? 0,
-					textureView: entry.resource.textureView,
+					textureView,
 				});
 			}
 			return makeBindGroupEntry({ binding: entry.binding ?? 0 });
@@ -1329,7 +1333,7 @@ class GPUDevice {
 				new Uint8Array(entry.buffer),
 			);
 		});
-		const entryPtr = ptr(entryBuf);
+		const entryPtr = ptrOrNull(entryBuf);
 		WGPU_KEEPALIVE.push(entryBuf);
 		const desc = makeBindGroupDescriptor(
 			descriptor.layout.ptr,
@@ -1349,7 +1353,10 @@ class GPUDevice {
 			layouts[i] = BigInt(descriptor.bindGroupLayouts[i]!.ptr);
 		}
 		WGPU_KEEPALIVE.push(layouts);
-		const desc = makePipelineLayoutDescriptor(ptr(layouts) as any, layouts.length);
+		const desc = makePipelineLayoutDescriptor(
+			ptrOrNull(layouts) as any,
+			layouts.length,
+		);
 		WGPU_KEEPALIVE.push(desc.buffer);
 		const layoutPtr = WGPUNative.symbols.wgpuDeviceCreatePipelineLayout(
 			this.ptr,
@@ -1391,7 +1398,7 @@ class GPUDevice {
 					new Uint8Array(attrStruct.buffer),
 				);
 			});
-			const attrPtr = ptr(attrBuf);
+			const attrPtr = ptrOrNull(attrBuf);
 			WGPU_KEEPALIVE.push(attrBuf);
 			const layout = makeVertexBufferLayout(
 				attrPtr as any,
@@ -1410,7 +1417,7 @@ class GPUDevice {
 				new Uint8Array(layoutBuf),
 			);
 		});
-		const vertexLayoutsPtr = ptr(vertexLayoutsBuf);
+		const vertexLayoutsPtr = ptrOrNull(vertexLayoutsBuf);
 		WGPU_KEEPALIVE.push(vertexLayoutsBuf);
 
 		const vertexState = makeVertexState(
@@ -1453,7 +1460,7 @@ class GPUDevice {
 					new Uint8Array(target.buffer),
 				);
 			});
-			const targetPtr = ptr(targetBuf);
+			const targetPtr = ptrOrNull(targetBuf);
 			WGPU_KEEPALIVE.push(targetBuf);
 			const fragState = makeFragmentState(
 				fragModule.ptr,
@@ -1831,7 +1838,7 @@ class GPUCommandEncoder {
 		colorAttachments.forEach((c, i) => {
 			new Uint8Array(colorBuf, i * 72, 72).set(new Uint8Array(c.buffer));
 		});
-		const colorPtr = ptr(colorBuf);
+		const colorPtr = ptrOrNull(colorBuf);
 		WGPU_KEEPALIVE.push(colorBuf);
 
 		let depthPtr: number | null = null;

package/dist/api/shared/build-dependencies.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, test } from "bun:test";
+import {
+	BUILD_DEPENDENCIES_PUBLIC_BASE_URL,
+	OWNED_BUILD_DEPENDENCY_VERSIONS,
+	ownedBuildDependencyArtifact,
+} from "./build-dependencies";
+
+describe("owned build dependency artifacts", () => {
+	test.each([
+		["zig-bsdiff", "macos", "arm64", "zig-bsdiff-darwin-arm64.tar.gz"],
+		["zig-zstd", "linux", "x64", "zig-zstd-linux-x64.tar.gz"],
+		["zig-asar", "win", "x64", "zig-asar-win32-x64.tar.gz"],
+		[
+			"electrobun-dawn",
+			"linux",
+			"arm64",
+			"electrobun-dawn-linux-arm64.tar.gz",
+		],
+	] as const)(
+		"maps %s on %s-%s to its immutable release key",
+		(product, platform, arch, filename) => {
+			const artifact = ownedBuildDependencyArtifact(product, platform, arch);
+			const version = OWNED_BUILD_DEPENDENCY_VERSIONS[product];
+
+			expect(artifact.filename).toBe(filename);
+			expect(artifact.key).toBe(
+				`${product}/releases/${version}/${filename}`,
+			);
+			expect(artifact.url).toBe(
+				`${BUILD_DEPENDENCIES_PUBLIC_BASE_URL}/${artifact.key}`,
+			);
+			expect(artifact.checksumUrl).toBe(`${artifact.url}.sha256`);
+		},
+	);
+
+	test("normalizes an overridden public base URL", () => {
+		const artifact = ownedBuildDependencyArtifact(
+			"zig-bsdiff",
+			"linux",
+			"x64",
+			"https://artifacts.example.test///",
+		);
+
+		expect(artifact.url).toBe(
+			"https://artifacts.example.test/zig-bsdiff/releases/0.1.21/zig-bsdiff-linux-x64.tar.gz",
+		);
+	});
+});

package/dist/api/shared/build-dependencies.ts

@@ -0,0 +1,46 @@
+export const BUILD_DEPENDENCIES_PUBLIC_BASE_URL =
+	"https://electrobun-artifacts.blackboard.sh";
+
+export const ZIG_VERSION = "0.13.0";
+
+export const OWNED_BUILD_DEPENDENCY_VERSIONS = {
+	"zig-bsdiff": "0.1.21",
+	"zig-zstd": "0.1.4",
+	"zig-asar": "0.2.3",
+	"electrobun-dawn": "0.2.5",
+} as const;
+
+export type OwnedBuildDependency =
+	keyof typeof OWNED_BUILD_DEPENDENCY_VERSIONS;
+
+export type BuildDependencyPlatform = "macos" | "linux" | "win";
+export type BuildDependencyArch = "arm64" | "x64";
+
+const artifactPlatform = (
+	platform: BuildDependencyPlatform,
+): "darwin" | "linux" | "win32" => {
+	if (platform === "macos") return "darwin";
+	if (platform === "win") return "win32";
+	return "linux";
+};
+
+export const ownedBuildDependencyArtifact = (
+	product: OwnedBuildDependency,
+	platform: BuildDependencyPlatform,
+	arch: BuildDependencyArch,
+	publicBaseUrl = BUILD_DEPENDENCIES_PUBLIC_BASE_URL,
+) => {
+	const version = OWNED_BUILD_DEPENDENCY_VERSIONS[product];
+	const filename = `${product}-${artifactPlatform(platform)}-${arch}.tar.gz`;
+	const key = `${product}/releases/${version}/${filename}`;
+	const baseUrl = publicBaseUrl.replace(/\/+$/, "");
+
+	return {
+		product,
+		version,
+		filename,
+		key,
+		url: `${baseUrl}/${key}`,
+		checksumUrl: `${baseUrl}/${key}.sha256`,
+	};
+};

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

@@ -0,0 +1,3 @@
+// Default Go toolchain version used to compile Go main processes.
+// This is vendored by package/build.ts; Electrobun must not use a system Go.
+export const GO_VERSION = "1.26.4";

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

@@ -0,0 +1,6 @@
+// Default Odin toolchain release used to compile Odin main processes.
+// This is vendored by package/build.ts; Electrobun must not use a system Odin.
+// Odin is pre-1.0 and ships monthly "dev-YYYY-MM" releases that can contain
+// breaking changes, so this must stay pinned to a release the SDK is known
+// to compile with.
+export const ODIN_VERSION = "dev-2026-07a";

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

@@ -0,0 +1,3 @@
+// Default Rust toolchain version used to compile Rust main processes.
+// This is vendored by package/build.ts; Electrobun must not use a system Rust.
+export const RUST_VERSION = "1.88.0";

package/dist/go-sdk/callbacks.go

@@ -0,0 +1,260 @@
+package electrobun
+
+/*
+#include <stdint.h>
+*/
+import "C"
+
+import "sync"
+
+var callbackMu sync.RWMutex
+
+var windowCallbackRegistry = map[uint32]WindowCallbacks{}
+var webviewCallbackRegistry = map[uint32]WebviewCallbacks{}
+
+var statusItemHandler StatusItemHandler
+var globalShortcutHandler func(string)
+var urlOpenHandler func(string)
+var appReopenHandler func()
+var quitRequestedHandler func()
+
+func registerWindowCallbacks(windowID uint32, callbacks WindowCallbacks) {
+	if callbacks.Close == nil &&
+		callbacks.Move == nil &&
+		callbacks.Resize == nil &&
+		callbacks.Focus == nil &&
+		callbacks.Blur == nil &&
+		callbacks.Key == nil {
+		return
+	}
+	callbackMu.Lock()
+	windowCallbackRegistry[windowID] = callbacks
+	callbackMu.Unlock()
+}
+
+func forgetWindowCallbacks(windowID uint32) {
+	callbackMu.Lock()
+	delete(windowCallbackRegistry, windowID)
+	callbackMu.Unlock()
+}
+
+func registerWebviewCallbacks(webviewID uint32, callbacks WebviewCallbacks) {
+	if callbacks.DecideNavigation == nil &&
+		callbacks.Event == nil &&
+		callbacks.EventBridge == nil &&
+		callbacks.HostBridge == nil &&
+		callbacks.InternalBridge == nil {
+		return
+	}
+	callbackMu.Lock()
+	webviewCallbackRegistry[webviewID] = callbacks
+	callbackMu.Unlock()
+}
+
+func forgetWebviewCallbacks(webviewID uint32) {
+	callbackMu.Lock()
+	delete(webviewCallbackRegistry, webviewID)
+	callbackMu.Unlock()
+}
+
+func setStatusItemHandler(handler StatusItemHandler) {
+	callbackMu.Lock()
+	statusItemHandler = handler
+	callbackMu.Unlock()
+}
+
+func setGlobalShortcutHandler(handler func(string)) {
+	callbackMu.Lock()
+	globalShortcutHandler = handler
+	callbackMu.Unlock()
+}
+
+func setURLOpenHandler(handler func(string)) {
+	callbackMu.Lock()
+	urlOpenHandler = handler
+	callbackMu.Unlock()
+}
+
+func setAppReopenHandler(handler func()) {
+	callbackMu.Lock()
+	appReopenHandler = handler
+	callbackMu.Unlock()
+}
+
+func setQuitRequestedHandler(handler func()) {
+	callbackMu.Lock()
+	quitRequestedHandler = handler
+	callbackMu.Unlock()
+}
+
+//export electrobunWindowCloseHandler
+func electrobunWindowCloseHandler(windowID C.uint32_t) {
+	id := uint32(windowID)
+	callbackMu.RLock()
+	handler := windowCallbackRegistry[id].Close
+	callbackMu.RUnlock()
+	if handler != nil {
+		handler(id)
+	}
+}
+
+//export electrobunWindowMoveHandler
+func electrobunWindowMoveHandler(windowID C.uint32_t, x C.double, y C.double) {
+	id := uint32(windowID)
+	callbackMu.RLock()
+	handler := windowCallbackRegistry[id].Move
+	callbackMu.RUnlock()
+	if handler != nil {
+		handler(id, float64(x), float64(y))
+	}
+}
+
+//export electrobunWindowResizeHandler
+func electrobunWindowResizeHandler(windowID C.uint32_t, x C.double, y C.double, width C.double, height C.double) {
+	id := uint32(windowID)
+	callbackMu.RLock()
+	handler := windowCallbackRegistry[id].Resize
+	callbackMu.RUnlock()
+	if handler != nil {
+		handler(id, float64(x), float64(y), float64(width), float64(height))
+	}
+}
+
+//export electrobunWindowFocusHandler
+func electrobunWindowFocusHandler(windowID C.uint32_t) {
+	id := uint32(windowID)
+	callbackMu.RLock()
+	handler := windowCallbackRegistry[id].Focus
+	callbackMu.RUnlock()
+	if handler != nil {
+		handler(id)
+	}
+}
+
+//export electrobunWindowBlurHandler
+func electrobunWindowBlurHandler(windowID C.uint32_t) {
+	id := uint32(windowID)
+	callbackMu.RLock()
+	handler := windowCallbackRegistry[id].Blur
+	callbackMu.RUnlock()
+	if handler != nil {
+		handler(id)
+	}
+}
+
+//export electrobunWindowKeyHandler
+func electrobunWindowKeyHandler(windowID C.uint32_t, key C.uint32_t, modifiers C.uint32_t, eventType C.uint32_t, characters C.uint32_t) {
+	id := uint32(windowID)
+	callbackMu.RLock()
+	handler := windowCallbackRegistry[id].Key
+	callbackMu.RUnlock()
+	if handler != nil {
+		handler(id, uint32(key), uint32(modifiers), uint32(eventType), uint32(characters))
+	}
+}
+
+//export electrobunDecideNavigationHandler
+func electrobunDecideNavigationHandler(webviewID C.uint32_t, url *C.char) C.uint32_t {
+	id := uint32(webviewID)
+	callbackMu.RLock()
+	handler := webviewCallbackRegistry[id].DecideNavigation
+	callbackMu.RUnlock()
+	if handler == nil {
+		return 1
+	}
+	return C.uint32_t(handler(id, C.GoString(url)))
+}
+
+//export electrobunWebviewEventHandler
+func electrobunWebviewEventHandler(webviewID C.uint32_t, eventName *C.char, detail *C.char) {
+	id := uint32(webviewID)
+	callbackMu.RLock()
+	handler := webviewCallbackRegistry[id].Event
+	callbackMu.RUnlock()
+	if handler != nil {
+		handler(id, C.GoString(eventName), C.GoString(detail))
+	}
+}
+
+//export electrobunWebviewEventBridgeHandler
+func electrobunWebviewEventBridgeHandler(webviewID C.uint32_t, message *C.char) {
+	id := uint32(webviewID)
+	callbackMu.RLock()
+	handler := webviewCallbackRegistry[id].EventBridge
+	callbackMu.RUnlock()
+	if handler != nil {
+		handler(id, C.GoString(message))
+	}
+}
+
+//export electrobunWebviewHostBridgeHandler
+func electrobunWebviewHostBridgeHandler(webviewID C.uint32_t, message *C.char) {
+	id := uint32(webviewID)
+	callbackMu.RLock()
+	handler := webviewCallbackRegistry[id].HostBridge
+	callbackMu.RUnlock()
+	if handler != nil {
+		handler(id, C.GoString(message))
+	}
+}
+
+//export electrobunWebviewInternalBridgeHandler
+func electrobunWebviewInternalBridgeHandler(webviewID C.uint32_t, message *C.char) {
+	id := uint32(webviewID)
+	callbackMu.RLock()
+	handler := webviewCallbackRegistry[id].InternalBridge
+	callbackMu.RUnlock()
+	if handler != nil {
+		handler(id, C.GoString(message))
+	}
+}
+
+//export electrobunStatusItemHandler
+func electrobunStatusItemHandler(itemID C.uint32_t, message *C.char) {
+	callbackMu.RLock()
+	handler := statusItemHandler
+	callbackMu.RUnlock()
+	if handler != nil {
+		handler(uint32(itemID), C.GoString(message))
+	}
+}
+
+//export electrobunGlobalShortcutHandler
+func electrobunGlobalShortcutHandler(accelerator *C.char) {
+	callbackMu.RLock()
+	handler := globalShortcutHandler
+	callbackMu.RUnlock()
+	if handler != nil {
+		handler(C.GoString(accelerator))
+	}
+}
+
+//export electrobunURLOpenHandler
+func electrobunURLOpenHandler(url *C.char) {
+	callbackMu.RLock()
+	handler := urlOpenHandler
+	callbackMu.RUnlock()
+	if handler != nil {
+		handler(C.GoString(url))
+	}
+}
+
+//export electrobunAppReopenHandler
+func electrobunAppReopenHandler() {
+	callbackMu.RLock()
+	handler := appReopenHandler
+	callbackMu.RUnlock()
+	if handler != nil {
+		handler()
+	}
+}
+
+//export electrobunQuitRequestedHandler
+func electrobunQuitRequestedHandler() {
+	callbackMu.RLock()
+	handler := quitRequestedHandler
+	callbackMu.RUnlock()
+	if handler != nil {
+		handler()
+	}
+}