sparkbun 0.2.4 → 0.2.6

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "sparkbun",
-	"version": "0.2.4",
+	"version": "0.2.6",
 	"description": "Build fast, lightweight, cross-platform desktop apps with TypeScript and Bun.",
 	"license": "MIT",
 	"author": "SparkBun Contributors",

package/src/browser/index.ts

@@ -4,6 +4,7 @@ import {
 	type SparkBunRPCSchema,
 	type SparkBunRPCConfig,
 	type RPCWithTransport,
+	type AnyRPC,
 	createRPC,
 	defineSparkBunRPC,
 } from "../shared/rpc.js";
@@ -18,11 +19,11 @@ const WEBVIEW_ID = window.__sparkbunWebviewId;
 const HOST_SOCKET_PORT =
 	window.__sparkbunHostSocketPort ?? window.__sparkbunRpcSocketPort;
 
-class Electroview<T extends RPCWithTransport> {
+class Electroview<T extends RPCWithTransport = AnyRPC> {
 	hostSocket?: WebSocket;
 	hostSocketCanSend = false;
-	// user's custom rpc browser <-> bun
-	rpc?: T;
+	// user's custom rpc browser <-> bun — always provided via the constructor
+	rpc: T;
 	rpcHandler?: (msg: unknown) => void;
 	carrots = {
 		invoke: <R = unknown>(

package/src/bun/core/BrowserView.ts

@@ -4,6 +4,7 @@ import {
 	type SparkBunRPCSchema,
 	type SparkBunRPCConfig,
 	type RPCWithTransport,
+	type AnyRPC,
 	defineSparkBunRPC,
 } from "../../shared/rpc.js";
 import { BuildConfig } from "./BuildConfig";
@@ -62,7 +63,7 @@ const defaultOptions: Partial<BrowserViewOptions> = {
 		height: 600,
 	},
 };
-export class BrowserView<T extends RPCWithTransport = RPCWithTransport> {
+export class BrowserView<T extends RPCWithTransport = AnyRPC> {
 	id = 0;
 	hostWebviewId?: number;
 	windowId!: number;
@@ -351,7 +352,7 @@ export class BrowserView<T extends RPCWithTransport = RPCWithTransport> {
 
 	// Core can create webviews before Bun has constructed a JS wrapper for them.
 	// Use this in native/runtime paths that need to ensure a wrapper exists.
-	static ensureWrapped<T extends RPCWithTransport = RPCWithTransport>(
+	static ensureWrapped<T extends RPCWithTransport = AnyRPC>(
 		id: number,
 		options: Partial<BrowserViewOptions<T>> = {},
 	) {
@@ -361,7 +362,7 @@ export class BrowserView<T extends RPCWithTransport = RPCWithTransport> {
 		);
 	}
 
-	static adoptExisting<T extends RPCWithTransport = RPCWithTransport>(
+	static adoptExisting<T extends RPCWithTransport = AnyRPC>(
 		id: number,
 		options: Partial<BrowserViewOptions<T>> = {},
 	) {

package/src/bun/core/BrowserWindow.ts

@@ -3,7 +3,7 @@ import sparkBunEventEmitter from "../events/eventEmitter";
 import { BrowserView } from "./BrowserView";
 import { type Pointer } from "bun:ffi";
 import { BuildConfig } from "./BuildConfig";
-import { type RPCWithTransport } from "../../shared/rpc.js";
+import { type RPCWithTransport, type AnyRPC } from "../../shared/rpc.js";
 import { WGPUView } from "./WGPUView";
 
 const buildConfig = BuildConfig.getSync();
@@ -29,6 +29,12 @@ export type WindowOptionsType<T = undefined> = {
 	preload: string | null;
 	viewsRoot: string | null;
 	renderer: "native" | "cef";
+	// Storage partition for the webview's cookies/localStorage/cache/IndexedDB.
+	// A value starting with "persist:" is written to disk; any other non-empty
+	// value is ephemeral — in-memory only, gone when the process exits — which
+	// is what incognito-style/diskless sessions want. Omitted/null falls back to
+	// "persist:default" (on-disk).
+	partition?: string;
 	rpc?: T;
 	styleMask?: {};
 	// titleBarStyle options:
@@ -97,7 +103,7 @@ sparkBunEventEmitter.on("close", (event: { data: { id: number } }) => {
 
 });
 
-export class BrowserWindow<T extends RPCWithTransport = RPCWithTransport> {
+export class BrowserWindow<T extends RPCWithTransport = AnyRPC> {
 	id = 0;
 	title: string = "SparkBun";
 	state: "creating" | "created" = "creating";
@@ -105,6 +111,7 @@ export class BrowserWindow<T extends RPCWithTransport = RPCWithTransport> {
 	html: string | null = null;
 	preload: string | null = null;
 	viewsRoot: string | null = null;
+	partition: string | null = null;
 	renderer: "native" | "cef" = "native";
 	transparent: boolean = false;
 	passthrough: boolean = false;
@@ -139,6 +146,7 @@ export class BrowserWindow<T extends RPCWithTransport = RPCWithTransport> {
 		this.html = options.html || null;
 		this.preload = options.preload || null;
 		this.viewsRoot = options.viewsRoot || null;
+		this.partition = options.partition ?? null;
 		this.renderer = options.renderer || defaultOptions.renderer;
 		this.transparent = options.transparent ?? false;
 		this.passthrough = options.passthrough ?? false;
@@ -223,6 +231,7 @@ export class BrowserWindow<T extends RPCWithTransport = RPCWithTransport> {
 			html: this.html,
 			preload: this.preload,
 			viewsRoot: this.viewsRoot,
+			partition: this.partition,
 			// frame: this.frame,
 			renderer: this.renderer,
 			frame: {

package/src/bun/core/Updater.ts

@@ -632,7 +632,9 @@ const Updater = {
 				emitStatus("decompressing", "Decompressing update bundle...");
 				try {
 					const compressed = readFileSync(prevVersionCompressedTarballPath);
-					const decompressed = Bun.gunzipSync(compressed);
+					const decompressed = Bun.gunzipSync(
+						compressed as unknown as Uint8Array<ArrayBuffer>,
+					);
 					writeFileSync(latestTarPath, decompressed);
 					emitStatus("decompressing", "Decompression complete");
 				} catch (err) {

package/src/bun/preload/.generated/compiled.d.ts

@@ -0,0 +1,5 @@
+// Type declarations for the build-generated ./compiled.ts (produced by build.ts;
+// gitignored). This stub lets the runtime typecheck from a clean tree before the
+// file is generated; the generated .ts supersedes it at build time.
+export const preloadScript: string;
+export const preloadScriptSandboxed: string;

package/src/bun/proc/native.ts

@@ -2384,7 +2384,7 @@ export const Screen = {
 	 * @returns Display object for the primary monitor
 	 */
 	getPrimaryDisplay: (): Display => {
-		const jsonStr = hasFFI ? core_.symbols.getPrimaryDisplay() : null;
+		const jsonStr = core_.symbols.getPrimaryDisplay();
 		if (!jsonStr) {
 			return {
 				id: 0,
@@ -2412,7 +2412,7 @@ export const Screen = {
 	 * @returns Array of Display objects
 	 */
 	getAllDisplays: (): Display[] => {
-		const jsonStr = hasFFI ? core_.symbols.getAllDisplays() : null;
+		const jsonStr = core_.symbols.getAllDisplays();
 		if (!jsonStr) {
 			return [];
 		}
@@ -2428,7 +2428,7 @@ export const Screen = {
 	 * @returns Point with x and y coordinates
 	 */
 	getCursorScreenPoint: (): Point => {
-		const jsonStr = hasFFI ? core_.symbols.getCursorScreenPoint() : null;
+		const jsonStr = core_.symbols.getCursorScreenPoint();
 		if (!jsonStr) {
 			return { x: 0, y: 0 };
 		}
@@ -2444,7 +2444,7 @@ export const Screen = {
 	 */
 	getMouseButtons: (): bigint => {
 		try {
-			return hasFFI ? core_.symbols.getMouseButtons() : BigInt(0);
+			return core_.symbols.getMouseButtons();
 		} catch {
 			return 0n;
 		}

package/src/cli/index.ts

@@ -39,6 +39,14 @@ const _MAX_CHUNK_SIZE = 1024 * 2;
 
 // const binExt = OS === 'win' ? '.exe' : '';
 
+// @types/node's Buffer is backed by ArrayBufferLike, which doesn't structurally
+// match the Uint8Array<ArrayBuffer> that Bun APIs, fs writes, and
+// Buffer.prototype.copy expect under this lib config (ArrayBufferLike admits
+// SharedArrayBuffer). These buffers are always ArrayBuffer-backed at runtime;
+// asU8 narrows the type without touching the value.
+const asU8 = (b: Buffer | Uint8Array): Uint8Array<ArrayBuffer> =>
+	b as unknown as Uint8Array<ArrayBuffer>;
+
 // Create a tar file using system tar command (preserves file permissions unlike Bun.Archive)
 function createTar(tarPath: string, cwd: string, entries: string[]) {
 	// Use a relative path for the tar output on Windows to avoid bsdtar
@@ -331,8 +339,6 @@ async function ensureCoreDependencies(
 		// Verify extraction completed successfully - check platform-specific binaries only
 		const requiredBinaries = [
 			platformPaths.BUN_BINARY,
-			platformPaths.BSDIFF,
-			platformPaths.BSPATCH,
 		];
 		if (platformOS === "macos") {
 			requiredBinaries.push(
@@ -426,6 +432,7 @@ function getEffectiveWGPUDir(
  * Trims an ICU .dat file to only include the specified locales.
  * Uses icupkg (from ICU tools) to list and remove unwanted locale data.
  */
+// @ts-expect-error - reserved for future use (wiring for the build.locales option)
 async function trimICUData(
 	source: string,
 	dest: string,
@@ -1194,6 +1201,8 @@ const defaultConfig = {
 		identifier: "com.example.myapp",
 		version: "0.1.0",
 		description: "" as string | undefined,
+		publisher: undefined as string | undefined,
+		copyright: undefined as string | undefined,
 		urlSchemes: undefined as string[] | undefined,
 		fileAssociations: undefined as FileAssociation[] | undefined,
 	},
@@ -1221,6 +1230,7 @@ const defaultConfig = {
 			icons: "icon.iconset",
 			defaultRenderer: undefined as "native" | "cef" | undefined,
 			chromiumFlags: undefined as Record<string, string | boolean> | undefined,
+			requireAdmin: undefined as boolean | undefined,
 		},
 		win: {
 			bundleCEF: false,
@@ -1228,6 +1238,7 @@ const defaultConfig = {
 			icon: undefined as string | undefined,
 			defaultRenderer: undefined as "native" | "cef" | undefined,
 			chromiumFlags: undefined as Record<string, string | boolean> | undefined,
+			requireAdmin: undefined as boolean | undefined,
 		},
 		linux: {
 			bundleCEF: false,
@@ -1235,6 +1246,8 @@ const defaultConfig = {
 			icon: undefined as string | undefined,
 			defaultRenderer: undefined as "native" | "cef" | undefined,
 			chromiumFlags: undefined as Record<string, string | boolean> | undefined,
+			requireAdmin: undefined as boolean | undefined,
+			createDeb: undefined as boolean | undefined,
 		},
 		bun: {
 			entrypoint: "src/bun/index.ts",
@@ -1301,13 +1314,13 @@ function escapeXml(str: string): string {
 }
 
 function patchPeSubsystem(exePath: string): void {
-	const buf = Buffer.from(readFileSync(exePath));
+	const buf = readFileSync(exePath);
 	const peOffset = buf.readUInt32LE(0x3c);
 	const subsystemOffset = peOffset + 0x5c;
 	const current = buf.readUInt16LE(subsystemOffset);
 	if (current !== 2) {
 		buf.writeUInt16LE(2, subsystemOffset);
-		writeFileSync(exePath, buf);
+		writeFileSync(exePath, asU8(buf));
 		console.log(`Patched PE subsystem: ${current} -> 2 (WINDOWS)`);
 	}
 }
@@ -2961,7 +2974,7 @@ usageDescriptions : ""}${urlTypes ? "\n" + urlTypes : ""}${documentTypes ?
 
 						try {
 							const compressed = readFileSync(prevVersionCompressedTarballPath);
-							const decompressed = Bun.gunzipSync(compressed);
+							const decompressed = Bun.gunzipSync(asU8(compressed));
 							writeFileSync(prevTarballPath, decompressed);
 						} catch (err) {
 							console.log(
@@ -3018,7 +3031,7 @@ usageDescriptions : ""}${urlTypes ? "\n" + urlTypes : ""}${documentTypes ?
 			{
 				console.log("compressing tarball with gzip...");
 				const tarBytes = readFileSync(tarPath);
-				const gzipped = Bun.gzipSync(tarBytes);
+				const gzipped = Bun.gzipSync(asU8(tarBytes));
 				writeFileSync(compressedTarPath, gzipped);
 				artifactsToUpload.push(compressedTarPath);
 			}
@@ -3385,8 +3398,6 @@ usageDescriptions : ""}${urlTypes ? "\n" + urlTypes : ""}${documentTypes ?
 		mkdirSync(buildFolder, { recursive: true });
 
 		const cliDir = dirname(decodeURIComponent(new URL(import.meta.url).pathname).replace(/^\/([A-Za-z]:)/, "$1"));
-		const sparkbunRoot = join(cliDir, "..", "..");
-		const bunTarget = `bun-${targetOS === "macos" ? "darwin" : targetOS === "win" ? "windows" : "linux"}-${targetARCH}` as const;
 		const targetOSName = targetOS === "macos" ? "darwin" : targetOS === "win" ? "windows" : "linux";
 		const isWindows = targetOS === "win";
 
@@ -4255,10 +4266,6 @@ ${archiveExports.join("\n")}
 					...defaultConfig.build.bun,
 					...(loadedConfig?.build?.bun || {}),
 				},
-				zig: {
-					...defaultConfig.build.zig,
-					...(loadedConfig?.build?.zig || {}),
-				},
 			},
 			runtime: {
 				...defaultConfig.runtime,
@@ -4409,12 +4416,12 @@ ${archiveExports.join("\n")}
 	function createArHeader(name: string, size: number, mode: number = 0o100644): Buffer {
 		const header = Buffer.alloc(60, 0x20); // fill with spaces
 		const now = Math.floor(Date.now() / 1000).toString();
-		Buffer.from(name.padEnd(16, " ")).copy(header, 0);       // filename
-		Buffer.from(now.padEnd(12, " ")).copy(header, 16);        // timestamp
-		Buffer.from("0".padEnd(6, " ")).copy(header, 28);         // owner
-		Buffer.from("0".padEnd(6, " ")).copy(header, 34);         // group
-		Buffer.from(mode.toString(8).padEnd(8, " ")).copy(header, 40); // mode
-		Buffer.from(size.toString().padEnd(10, " ")).copy(header, 48); // size
+		Buffer.from(name.padEnd(16, " ")).copy(asU8(header),0);       // filename
+		Buffer.from(now.padEnd(12, " ")).copy(asU8(header),16);        // timestamp
+		Buffer.from("0".padEnd(6, " ")).copy(asU8(header),28);         // owner
+		Buffer.from("0".padEnd(6, " ")).copy(asU8(header),34);         // group
+		Buffer.from(mode.toString(8).padEnd(8, " ")).copy(asU8(header),40); // mode
+		Buffer.from(size.toString().padEnd(10, " ")).copy(asU8(header),48); // size
 		header[58] = 0x60; // magic
 		header[59] = 0x0A;
 		return header;
@@ -4430,7 +4437,7 @@ ${archiveExports.join("\n")}
 				parts.push(Buffer.from("\n"));
 			}
 		}
-		return Buffer.concat(parts);
+		return Buffer.concat(parts.map(asU8));
 	}
 
 	function collectFiles(dir: string, prefix: string = ""): { path: string; fullPath: string; isDir: boolean }[] {
@@ -4451,38 +4458,38 @@ ${archiveExports.join("\n")}
 
 	function writeTarHeader(header: Buffer, file: { path: string; fullPath: string; isDir: boolean }, content?: Buffer): void {
 		const tarPath = file.path;
-		Buffer.from(tarPath).copy(header, 0, 0, Math.min(tarPath.length, 100));
+		Buffer.from(tarPath).copy(asU8(header),0, 0, Math.min(tarPath.length, 100));
 
 		// mtime from actual file
 		const mtime = Math.floor(statSync(file.fullPath).mtimeMs / 1000);
-		Buffer.from(mtime.toString(8).padStart(11, "0") + "\0").copy(header, 136);
+		Buffer.from(mtime.toString(8).padStart(11, "0") + "\0").copy(asU8(header),136);
 
 		// uid/gid = 0 (root)
-		Buffer.from("0000000\0").copy(header, 108);
-		Buffer.from("0000000\0").copy(header, 116);
+		Buffer.from("0000000\0").copy(asU8(header),108);
+		Buffer.from("0000000\0").copy(asU8(header),116);
 
 		// ustar magic
-		Buffer.from("ustar\0").copy(header, 257);
-		Buffer.from("00").copy(header, 263);
-		Buffer.from("root\0").copy(header, 265);
-		Buffer.from("root\0").copy(header, 297);
+		Buffer.from("ustar\0").copy(asU8(header),257);
+		Buffer.from("00").copy(asU8(header),263);
+		Buffer.from("root\0").copy(asU8(header),265);
+		Buffer.from("root\0").copy(asU8(header),297);
 
 		if (file.isDir) {
-			Buffer.from("0040755\0").copy(header, 100);
-			Buffer.from("00000000000\0").copy(header, 124);
+			Buffer.from("0040755\0").copy(asU8(header),100);
+			Buffer.from("00000000000\0").copy(asU8(header),124);
 			header[156] = 0x35; // '5'
 		} else {
 			const isExecutable = file.path.match(/\/bin\/|\/postinst$|\/preinst$|\/postrm$|\/prerm$/);
-			Buffer.from(isExecutable ? "0100755\0" : "0100644\0").copy(header, 100);
-			Buffer.from((content!.length).toString(8).padStart(11, "0") + "\0").copy(header, 124);
+			Buffer.from(isExecutable ? "0100755\0" : "0100644\0").copy(asU8(header),100);
+			Buffer.from((content!.length).toString(8).padStart(11, "0") + "\0").copy(asU8(header),124);
 			header[156] = 0x30; // '0'
 		}
 
 		// checksum (must be computed last)
-		Buffer.from("        ").copy(header, 148);
+		Buffer.from("        ").copy(asU8(header),148);
 		let checksum = 0;
-		for (let i = 0; i < 512; i++) checksum += header[i];
-		Buffer.from(checksum.toString(8).padStart(6, "0") + "\0 ").copy(header, 148);
+		for (let i = 0; i < 512; i++) checksum += header[i]!;
+		Buffer.from(checksum.toString(8).padStart(6, "0") + "\0 ").copy(asU8(header),148);
 	}
 
 	function buildTarGz(baseDir: string, prefix: string = "./"): Buffer {
@@ -4507,8 +4514,8 @@ ${archiveExports.join("\n")}
 		}
 
 		blocks.push(Buffer.alloc(1024, 0));
-		const tarData = Buffer.concat(blocks);
-		return Buffer.from(Bun.gzipSync(tarData));
+		const tarData = Buffer.concat(blocks.map(asU8));
+		return Buffer.from(Bun.gzipSync(asU8(tarData)));
 	}
 
 	async function createDebPackage(
@@ -4516,7 +4523,7 @@ ${archiveExports.join("\n")}
 		appBundleFolderPath: string,
 		config: any,
 		targetArch: string,
-		projectRoot: string,
+		_projectRoot: string,
 	): Promise<string> {
 		const debArch = targetArch === "arm64" ? "arm64" : "amd64";
 		const appNameNoSpaces = config.app.name.replace(/ /g, "");
@@ -4567,19 +4574,19 @@ ${archiveExports.join("\n")}
 		const wmClass = config.app.name.slice(0, oldWmName.length);
 		if (existsSync(nativeLib)) {
 			const newName = Buffer.alloc(oldWmName.length, 0);
-			Buffer.from(wmClass).copy(newName);
+			Buffer.from(wmClass).copy(asU8(newName));
 			const data = readFileSync(nativeLib);
 			let patched = 0;
 			let offset = 0;
 			while (true) {
-				const idx = data.indexOf(oldWmName, offset);
+				const idx = data.indexOf(asU8(oldWmName), offset);
 				if (idx === -1) break;
-				newName.copy(data, idx);
+				newName.copy(asU8(data), idx);
 				offset = idx + oldWmName.length;
 				patched++;
 			}
 			if (patched > 0) {
-				writeFileSync(nativeLib, data);
+				writeFileSync(nativeLib, asU8(data));
 				console.log(`  Patched WM class in libNativeWrapper.so (${patched} occurrences)`);
 			}
 		}
@@ -4590,7 +4597,7 @@ ${archiveExports.join("\n")}
 		if (existsSync(resourcesDir)) {
 			const pngs = readdirSync(resourcesDir).filter((f: string) => f.endsWith(".png"));
 			if (pngs.length > 0) {
-				const iconSrc = join(resourcesDir, pngs[0]);
+				const iconSrc = join(resourcesDir, pngs[0]!);
 				for (const size of ["256x256", "128x128"]) {
 					const iconDir = join(dataDir, "usr", "share", "icons", "hicolor", size, "apps");
 					mkdirSync(iconDir, { recursive: true });
@@ -4680,7 +4687,7 @@ update-desktop-database /usr/share/applications 2>/dev/null || true
 
 		const debFileName = `${pkgName}_${version}_${debArch}.deb`;
 		const debOutputPath = join(buildFolder, debFileName);
-		writeFileSync(debOutputPath, debData);
+		writeFileSync(debOutputPath, asU8(debData));
 
 		// Clean up
 		rmSync(stagingDir, { recursive: true, force: true });
@@ -4775,7 +4782,6 @@ update-desktop-database /usr/share/applications 2>/dev/null || true
 		}
 
 		// Sign CEF helper apps (they're in the main Frameworks directory, not inside CEF framework)
-		const mainProcess = config.build.mainProcess ?? "bun";
 		const cefHelperApps = getCEFHelperNames().map(
 			(helperName) => `${helperName}.app`,
 		);

package/src/cli/templates/embedded.d.ts

@@ -0,0 +1,12 @@
+// Type declarations for the build-generated ./embedded.ts (produced by build.ts
+// from the templates/ directory; gitignored). This stub lets the CLI typecheck
+// from a clean tree before the file is generated; the generated .ts supersedes
+// it at build time.
+export interface Template {
+	name: string;
+	files: Record<string, string>;
+}
+
+export const templates: Record<string, Template>;
+export function getTemplateNames(): string[];
+export function getTemplate(name: string): Template | undefined;

package/src/launcher/main.ts

@@ -36,7 +36,7 @@ function elevateAndExit(): void {
 				returns: "ptr",
 			},
 		});
-		const encode = (s: string) => ptr(new Uint8Array(Buffer.from(s + "\0", "utf-16le")));
+		const encode = (s: string) => ptr(new Uint8Array(Buffer.from(s + "\0", "utf16le")));
 		shell32.symbols.ShellExecuteW(
 			null,
 			encode("runas"),

package/src/native/linux/nativeWrapper.cpp

@@ -11208,55 +11208,66 @@ static std::map<std::string, WebKitWebsiteDataManager*> g_partitionDataManagers;
 static WebKitWebsiteDataManager* getDataManagerForPartition(const char* partitionIdentifier) {
     std::string partition = partitionIdentifier ? partitionIdentifier : "";
 
+    // Prefer the data manager owned by the live webview context for this
+    // partition. getContextForPartition() builds each webview's context around
+    // its own WebKitWebsiteDataManager; creating a separate manager here — even
+    // one pointing at the same on-disk directory — clears a different instance
+    // and leaves the running webview's storage untouched, which made
+    // clearStorageData()/cookies.clear() appear to do nothing. Resolving through
+    // the context keeps clears on the exact store the page reads and writes.
+    if (partition.empty()) {
+        WebKitWebContext* context = webkit_web_context_get_default();
+        return webkit_web_context_get_website_data_manager(context);
+    }
+
+    auto ctxIt = g_partitionContexts.find(partition);
+    if (ctxIt != g_partitionContexts.end() && ctxIt->second) {
+        return webkit_web_context_get_website_data_manager(ctxIt->second);
+    }
+
+    // No live context for this partition yet — fall back to a standalone manager
+    // (cached) so cookie/storage APIs still work before a webview is created.
     auto it = g_partitionDataManagers.find(partition);
     if (it != g_partitionDataManagers.end()) {
         return it->second;
     }
 
     WebKitWebsiteDataManager* dataManager = nullptr;
+    bool isPersistent = partition.substr(0, 8) == "persist:";
 
-    if (partition.empty()) {
-        // Default: use default context's data manager
-        WebKitWebContext* context = webkit_web_context_get_default();
-        dataManager = webkit_web_context_get_website_data_manager(context);
-    } else {
-        bool isPersistent = partition.substr(0, 8) == "persist:";
+    if (isPersistent) {
+        std::string partitionName = partition.substr(8);
 
-        if (isPersistent) {
-            std::string partitionName = partition.substr(8);
+        // Build paths with identifier/channel structure (consistent with CLI and updater)
+        char* home = getenv("HOME");
+        std::string homeStr = home ? std::string(home) : "/tmp";
+        std::string dataPath = buildPartitionPath(homeStr + "/.local/share", g_sparkbunIdentifier, g_sparkbunChannel, "WebKit", partitionName);
+        std::string cachePath = buildPartitionPath(homeStr + "/.cache", g_sparkbunIdentifier, g_sparkbunChannel, "WebKit", partitionName);
 
-            // Build paths with identifier/channel structure (consistent with CLI and updater)
-            char* home = getenv("HOME");
-            std::string homeStr = home ? std::string(home) : "/tmp";
-            std::string dataPath = buildPartitionPath(homeStr + "/.local/share", g_sparkbunIdentifier, g_sparkbunChannel, "WebKit", partitionName);
-            std::string cachePath = buildPartitionPath(homeStr + "/.cache", g_sparkbunIdentifier, g_sparkbunChannel, "WebKit", partitionName);
+        g_mkdir_with_parents(dataPath.c_str(), 0755);
+        g_mkdir_with_parents(cachePath.c_str(), 0755);
 
-            g_mkdir_with_parents(dataPath.c_str(), 0755);
-            g_mkdir_with_parents(cachePath.c_str(), 0755);
+        dataManager = webkit_website_data_manager_new(
+            "base-data-directory", dataPath.c_str(),
+            "base-cache-directory", cachePath.c_str(),
+            NULL
+        );
 
-            dataManager = webkit_website_data_manager_new(
-                "base-data-directory", dataPath.c_str(),
-                "base-cache-directory", cachePath.c_str(),
-                NULL
+        // Enable persistent cookie storage (SQLite-backed)
+        WebKitCookieManager* cookieManager = webkit_website_data_manager_get_cookie_manager(dataManager);
+        if (cookieManager) {
+            std::string cookiePath = dataPath + "/cookies.sqlite";
+            webkit_cookie_manager_set_persistent_storage(
+                cookieManager,
+                cookiePath.c_str(),
+                WEBKIT_COOKIE_PERSISTENT_STORAGE_SQLITE
             );
-
-            // Enable persistent cookie storage (SQLite-backed)
-            WebKitCookieManager* cookieManager = webkit_website_data_manager_get_cookie_manager(dataManager);
-            if (cookieManager) {
-                std::string cookiePath = dataPath + "/cookies.sqlite";
-                webkit_cookie_manager_set_persistent_storage(
-                    cookieManager,
-                    cookiePath.c_str(),
-                    WEBKIT_COOKIE_PERSISTENT_STORAGE_SQLITE
-                );
-            }
-        } else {
-            dataManager = webkit_website_data_manager_new_ephemeral();
         }
-
-        g_partitionDataManagers[partition] = dataManager;
+    } else {
+        dataManager = webkit_website_data_manager_new_ephemeral();
     }
 
+    g_partitionDataManagers[partition] = dataManager;
     return dataManager;
 }
 
@@ -11651,11 +11662,44 @@ SPARKBUN_EXPORT bool sessionRemoveCookie(const char* partitionIdentifier, const
 // Clear all cookies (WebKit2GTK)
 // Clear all cookies (WebKit2GTK) - STUB implementation to prevent crashes
 SPARKBUN_EXPORT void sessionClearCookies(const char* partitionIdentifier) {
-    // Stub implementation: do nothing and return immediately
-    // This prevents crashes from complex WebKit async patterns during tests
-    // while maintaining API compatibility
-    (void)partitionIdentifier; // Suppress unused parameter warning
-    return;
+    // Copy argument before dispatching to main thread
+    std::string partitionStr = partitionIdentifier ? partitionIdentifier : "";
+
+    // Clear cookies via the website data manager rather than per-cookie
+    // get/delete. This reuses the same dispatch + GMainLoop pattern as
+    // sessionClearStorageData (which is stable) instead of the async cookie
+    // enumeration that previously crashed and led to this being stubbed out.
+    dispatch_sync_main_void([partitionStr]() {
+        WebKitWebsiteDataManager* dataManager = getDataManagerForPartition(partitionStr.c_str());
+        if (!dataManager) {
+            return;
+        }
+
+        GMainLoop* loop = g_main_loop_new(NULL, FALSE);
+
+        webkit_website_data_manager_clear(dataManager, WEBKIT_WEBSITE_DATA_COOKIES, 0, nullptr,
+            [](GObject* source, GAsyncResult* result, gpointer user_data) {
+                GMainLoop* loop = static_cast<GMainLoop*>(user_data);
+                GError* error = nullptr;
+                webkit_website_data_manager_clear_finish(WEBKIT_WEBSITE_DATA_MANAGER(source), result, &error);
+                if (error) {
+                    g_error_free(error);
+                }
+                g_main_loop_quit(loop);
+            }, loop);
+
+        GSource* timeout = g_timeout_source_new(10000);
+        g_source_set_callback(timeout, [](gpointer data) -> gboolean {
+            g_main_loop_quit(static_cast<GMainLoop*>(data));
+            return G_SOURCE_REMOVE;
+        }, loop, nullptr);
+        g_source_attach(timeout, g_main_loop_get_context(loop));
+
+        g_main_loop_run(loop);
+        g_source_destroy(timeout);
+        g_source_unref(timeout);
+        g_main_loop_unref(loop);
+    });
 }
 
 // Clear storage data (WebKit2GTK)

package/src/shared/bsdiff.ts

@@ -4,18 +4,6 @@
 
 const MAGIC = "SBDIFF10";
 
-function offtin(buf: Uint8Array, offset: number): bigint {
-	let y = 0n;
-	for (let i = 0; i < 7; i++) {
-		y |= BigInt(buf[offset + i]) << BigInt(i * 8);
-	}
-	y |= BigInt(buf[offset + 7] & 0x7f) << 56n;
-	if (buf[offset + 7] & 0x80) {
-		y = -y;
-	}
-	return y;
-}
-
 function offtout(x: bigint, buf: Uint8Array, offset: number): void {
 	let y: bigint;
 	if (x < 0n) {
@@ -47,24 +35,24 @@ function search(
 	bestPos: { value: number },
 ): number {
 	if (hi - lo < 2) {
-		const loMatch = matchlen(oldData, suffixArray[lo], newData, newStart);
-		const hiMatch = matchlen(oldData, suffixArray[hi], newData, newStart);
+		const loMatch = matchlen(oldData, suffixArray[lo]!, newData, newStart);
+		const hiMatch = matchlen(oldData, suffixArray[hi]!, newData, newStart);
 		if (loMatch > hiMatch) {
-			bestPos.value = suffixArray[lo];
+			bestPos.value = suffixArray[lo]!;
 			return loMatch;
 		}
-		bestPos.value = suffixArray[hi];
+		bestPos.value = suffixArray[hi]!;
 		return hiMatch;
 	}
 
 	const mid = lo + ((hi - lo) >>> 1);
-	const midPos = suffixArray[mid];
+	const midPos = suffixArray[mid]!;
 	const compareLen = Math.min(oldData.length - midPos, newData.length - newStart);
 
 	let cmp = 0;
 	for (let i = 0; i < compareLen; i++) {
-		if (oldData[midPos + i] < newData[newStart + i]) { cmp = -1; break; }
-		if (oldData[midPos + i] > newData[newStart + i]) { cmp = 1; break; }
+		if (oldData[midPos + i]! < newData[newStart + i]!) { cmp = -1; break; }
+		if (oldData[midPos + i]! > newData[newStart + i]!) { cmp = 1; break; }
 	}
 
 	if (cmp < 0) {
@@ -82,7 +70,7 @@ function qsufsort(data: Uint8Array): Int32Array {
 		const lb = n - b;
 		const len = la < lb ? la : lb;
 		for (let i = 0; i < len; i++) {
-			if (data[a + i] !== data[b + i]) return data[a + i] - data[b + i];
+			if (data[a + i] !== data[b + i]) return data[a + i]! - data[b + i]!;
 		}
 		return la - lb;
 	});
@@ -175,12 +163,12 @@ export function createPatch(oldData: Uint8Array, newData: Uint8Array): Uint8Arra
 			}
 
 			for (let i = 0; i < lenf; i++) {
-				diffBytes.push((newData[lastScan + i] - oldData[lastPos + i] + 256) & 0xff);
+				diffBytes.push((newData[lastScan + i]! - oldData[lastPos + i]! + 256) & 0xff);
 			}
 
 			const extraLen = (scan - lenb) - (lastScan + lenf);
 			for (let i = 0; i < extraLen; i++) {
-				extraBytes.push(newData[lastScan + lenf + i]);
+				extraBytes.push(newData[lastScan + lenf + i]!);
 			}
 
 			controlEntries.push(BigInt(lenf), BigInt(extraLen), BigInt((pos - lenb) - (lastPos + lenf)));
@@ -193,7 +181,7 @@ export function createPatch(oldData: Uint8Array, newData: Uint8Array): Uint8Arra
 
 	const controlBuf = new Uint8Array(controlEntries.length * 8);
 	for (let i = 0; i < controlEntries.length; i++) {
-		offtout(controlEntries[i], controlBuf, i * 8);
+		offtout(controlEntries[i]!, controlBuf, i * 8);
 	}
 
 	const controlCompressed = Bun.gzipSync(controlBuf);
@@ -225,7 +213,7 @@ if (import.meta.main) {
 		console.error("Usage: bsdiff <oldfile> <newfile> <patchfile>");
 		process.exit(1);
 	}
-	const [oldPath, newPath, patchPath] = args;
+	const [oldPath, newPath, patchPath] = args as [string, string, string];
 	const oldData = new Uint8Array(await Bun.file(oldPath).arrayBuffer());
 	const newData = new Uint8Array(await Bun.file(newPath).arrayBuffer());
 	const patch = createPatch(oldData, newData);

package/src/shared/bspatch.ts

@@ -7,10 +7,10 @@ const MAGIC = "SBDIFF10";
 function offtin(buf: Uint8Array, offset: number): bigint {
 	let y = 0n;
 	for (let i = 0; i < 7; i++) {
-		y |= BigInt(buf[offset + i]) << BigInt(i * 8);
+		y |= BigInt(buf[offset + i]!) << BigInt(i * 8);
 	}
-	y |= BigInt(buf[offset + 7] & 0x7f) << 56n;
-	if (buf[offset + 7] & 0x80) {
+	y |= BigInt(buf[offset + 7]! & 0x7f) << 56n;
+	if (buf[offset + 7]! & 0x80) {
 		y = -y;
 	}
 	return y;
@@ -64,7 +64,7 @@ export function applyPatch(oldData: Uint8Array, patchData: Uint8Array): Uint8Arr
 		}
 
 		for (let i = 0; i < readDiffBy; i++) {
-			newData[newPos + i] = (oldData[oldPos + i] + diffBlock[diffPos + i]) & 0xff;
+			newData[newPos + i] = (oldData[oldPos + i]! + diffBlock[diffPos + i]!) & 0xff;
 		}
 		diffPos += readDiffBy;
 		newPos += readDiffBy;
@@ -88,7 +88,7 @@ if (import.meta.main) {
 		console.error("Usage: bspatch <oldfile> <newfile> <patchfile>");
 		process.exit(1);
 	}
-	const [oldPath, newPath, patchPath] = args;
+	const [oldPath, newPath, patchPath] = args as [string, string, string];
 	const oldData = new Uint8Array(await Bun.file(oldPath).arrayBuffer());
 	const patchData = new Uint8Array(await Bun.file(patchPath).arrayBuffer());
 	const newData = applyPatch(oldData, patchData);

package/src/shared/rpc.ts

@@ -461,6 +461,32 @@ export interface RPCWithTransport {
 	setTransport: (transport: RPCTransport) => void;
 }
 
+/**
+ * Permissive RPC surface used as the *default* type argument for BrowserView,
+ * BrowserWindow and Electroview when the caller does not parameterize them with
+ * a concrete schema (e.g. `let win: BrowserWindow`). It exposes the send/request
+ * proxies with loose typing so member access type-checks without casts, while a
+ * concrete `BrowserWindow<typeof myRpc>` still gets fully-typed methods. It
+ * extends RPCWithTransport, so real RPC objects (the return of defineRPC) remain
+ * assignable to the `T extends RPCWithTransport` constraint.
+ */
+export interface AnyRPC extends RPCWithTransport {
+	// Members are intentionally `any`: this is the permissive *default* type
+	// argument, so member access (rpc.send.foo(), rpc.request.bar()) type-checks
+	// without casts. Crucially, the concrete RPC object returned by defineRPC
+	// (with fully-typed send/request) stays assignable to AnyRPC — so a typed
+	// `new BrowserWindow({ rpc })` is assignable to a bare `BrowserWindow`
+	// annotation. Parameterize explicitly (BrowserWindow<typeof rpc>) for full
+	// per-method typing.
+	send: any;
+	request: any;
+	sendProxy: any;
+	requestProxy: any;
+	addMessageListener: any;
+	removeMessageListener: any;
+	proxy: any;
+}
+
 export type SparkBunRPCConfig<
 	Schema extends SparkBunRPCSchema,
 	Side extends "bun" | "webview",

package/tsconfig.json

@@ -27,5 +27,8 @@
       "noUncheckedIndexedAccess": true
     },
     "include": ["src/**/*"],
-    "exclude": ["node_modules", "dist", "vendors", "build", "src/tests"]
+    // src/installer/* are standalone templates compiled by the CLI in a staging
+    // dir alongside generated siblings (app-archive.tar.gz, embedded-archives,
+    // metadata.json); they cannot resolve in the library's own compilation.
+    "exclude": ["node_modules", "dist", "vendors", "build", "src/tests", "src/installer"]
   }