sparkbun 0.1.9 → 0.2.1

package/package.json

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

package/src/cli/index.ts

@@ -76,7 +76,7 @@ const commandArg = process.argv[indexOfCli + 1] || "build";
 // Walk up from projectRoot to find electrobun in node_modules (supports hoisted monorepo layouts)
 function resolveSparkBunDir(): string {
 	// When running from SparkBun source (src/cli/index.ts), the package root is two levels up
-	const cliDir = dirname(new URL(import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, "$1"));
+	const cliDir = dirname(decodeURIComponent(new URL(import.meta.url).pathname).replace(/^\/([A-Za-z]:)/, "$1"));
 	const sourcePackageDir = join(cliDir, "..", "..");
 	if (existsSync(join(sourcePackageDir, "package.json")) && existsSync(join(sourcePackageDir, "src", "cli"))) {
 		return sourcePackageDir;
@@ -2078,7 +2078,7 @@ usageDescriptions : ""}${urlTypes ? "\n" + urlTypes : ""}${documentTypes ?
 		}
 
 		// Compile launcher from source using Bun.build() API
-		const cliDir = dirname(new URL(import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, "$1"));
+		const cliDir = dirname(decodeURIComponent(new URL(import.meta.url).pathname).replace(/^\/([A-Za-z]:)/, "$1"));
 		const sparkbunRoot = join(cliDir, "..", "..");
 		const launcherSourcePath = join(sparkbunRoot, "src", "launcher", "main.ts");
 		const bunTarget = `bun-${targetOS === "macos" ? "darwin" : targetOS === "win" ? "windows" : "linux"}-${currentTarget.arch}` as const;
@@ -3198,6 +3198,23 @@ usageDescriptions : ""}${urlTypes ? "\n" + urlTypes : ""}${documentTypes ?
 		// stapler validate -v <app path>
 	}
 
+	/**
+	 * Build a graphical installer as a single-file executable.
+	 *
+	 * The output is a SparkBun app compiled into one binary. It uses a two-phase
+	 * execution model: on first launch it extracts a small runtime bundle (~1MB
+	 * of DLLs, views, app code) to temp, copies itself there, and re-launches
+	 * with admin elevation. On second launch (from temp, with DLLs present) it
+	 * loads SparkBunCore and runs the webview-based installer UI.
+	 *
+	 * Payload archives are compressed with LZMA via NSIS and embedded directly
+	 * in the binary. They stay embedded until the user triggers installation,
+	 * at which point the app code writes them to disk and runs them as silent
+	 * self-extractors.
+	 *
+	 * This is a separate pipeline from `runBuild` — it does not produce update
+	 * artifacts, delta patches, DMGs, or .deb packages.
+	 */
 	async function runInstallerBuild(
 		config: Awaited<ReturnType<typeof getConfig>>,
 		buildEnvironment: "dev" | "stable",
@@ -3282,76 +3299,74 @@ usageDescriptions : ""}${urlTypes ? "\n" + urlTypes : ""}${documentTypes ?
 		}
 		mkdirSync(buildFolder, { recursive: true });
 
-		// --- Create app bundle ---
+		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";
 
-		const appFileName = getAppFileName(config.app.name, buildEnvironment);
-		const bundle = createAppBundle(appFileName, buildFolder, targetOS);
-		const appBundleFolderPath = bundle.appBundleFolderPath;
-		const appBundleMacOSPath = bundle.appBundleMacOSPath;
-		const appBundleFolderResourcesPath = bundle.appBundleFolderResourcesPath;
-		const appBundleAppCodePath = join(appBundleFolderResourcesPath, "app");
-		mkdirSync(appBundleAppCodePath, { recursive: true });
+		// --- Create archives first (they go into the compiled binary, not the runtime bundle) ---
 
-		// --- Compile launcher ---
+		const stagingDir = join(buildFolder, ".installer-staging");
+		if (existsSync(stagingDir)) rmSync(stagingDir, { recursive: true, force: true });
+		mkdirSync(stagingDir, { recursive: true });
 
-		const launcherBinaryName = config.app.name.replace(/ /g, "");
-		const launcherDestination = join(appBundleMacOSPath, launcherBinaryName) + targetBinExt;
-		mkdirSync(dirname(launcherDestination), { recursive: true });
+		const archiveManifest: Record<string, string> = {};
 
-		const cliDir = dirname(new URL(import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, "$1"));
-		const sparkbunRoot = join(cliDir, "..", "..");
-		const launcherSourcePath = join(sparkbunRoot, "src", "launcher", "main.ts");
-		const bunTarget = `bun-${targetOS === "macos" ? "darwin" : targetOS === "win" ? "windows" : "linux"}-${targetARCH}` as const;
+		if (archives.length > 0) {
+			console.log("Creating archives (LZMA solid via NSIS)...");
 
-		const compileOptions: any = {
-			target: bunTarget,
-			outfile: launcherDestination,
-		};
+			const nsisDir = join(SPARKBUN_DEP_PATH, `dist-${targetOS}-${targetARCH}`, "nsis");
+			const makensisPath = join(nsisDir, "Bin", "makensis.exe");
+			if (!existsSync(makensisPath)) {
+				throw new Error(`makensis not found at ${makensisPath}. LZMA compression requires NSIS binaries in dist-${targetOS}-${targetARCH}/nsis/`);
+			}
 
-		if (targetOS === "win" && OS === "win") {
-			let icoPath: string | undefined;
-			if (config.build.win?.icon) {
-				const iconSrc = config.build.win.icon.startsWith("/") || config.build.win.icon.match(/^[a-zA-Z]:/)
-					? config.build.win.icon
-					: join(projectRoot, config.build.win.icon);
-				if (existsSync(iconSrc)) {
-					icoPath = iconSrc;
-					if (iconSrc.toLowerCase().endsWith(".png")) {
-						const pngToIco = (await import("png-to-ico")).default;
-						const tempIcoPath = join(buildFolder, "temp-launcher-icon.ico");
-						const icoBuffer = await pngToIco(iconSrc);
-						writeFileSync(tempIcoPath, new Uint8Array(icoBuffer));
-						icoPath = tempIcoPath;
-					}
+			for (const { name, path: archiveSrcPath } of archives) {
+				const archiveFileName = `archive-${name}.exe`;
+				const archiveDestPath = join(stagingDir, archiveFileName);
+				const nsiPath = join(stagingDir, `archive-${name}.nsi`);
+
+				console.log(`  Archiving ${name}: ${archiveSrcPath}`);
+
+				const nsiContent = `SetCompressor /SOLID lzma\nSilentInstall silent\nName "${name}"\nOutFile "${archiveDestPath.replace(/\\/g, "\\\\")}"\nInstallDir "$TEMP\\sparkbun-extract-${name}"\nSection\n  SetOutPath "$INSTDIR"\n  File /r "${archiveSrcPath.replace(/\\/g, "\\\\")}\\*.*"\nSectionEnd\n`;
+				writeFileSync(nsiPath, nsiContent);
+
+				const result = Bun.spawnSync([makensisPath, nsiPath], {
+					cwd: nsisDir,
+					env: { ...process.env, NSISDIR: nsisDir },
+					stdout: "pipe",
+					stderr: "pipe",
+				});
+
+				if (result.exitCode !== 0) {
+					const stderr = result.stderr.toString();
+					const stdout = result.stdout.toString();
+					console.error(`makensis failed for ${name}:`, stderr || stdout);
+					throw new Error(`Failed to compress archive: ${name}`);
 				}
-			}
-			compileOptions.windows = {
-				hideConsole: true,
-				...(icoPath && { icon: icoPath }),
-				title: config.app.name,
-				version: installerVersion,
-				description: config.app.name,
-				publisher: installerPublisher || " ",
-				copyright: (config.app as any).copyright || " ",
-			};
-		}
 
-		console.log("Compiling installer launcher...");
-		const launcherBuild = await Bun.build({
-			entrypoints: [launcherSourcePath],
-			compile: compileOptions,
-		});
-		if (!launcherBuild.success) {
-			console.error("Launcher compilation failed:", launcherBuild.logs);
-			throw new Error("Launcher compilation failed");
-		}
+				unlinkSync(nsiPath);
 
-		if (targetOS === "win") {
-			patchPeSubsystem(launcherDestination);
+				const archiveSize = statSync(archiveDestPath).size;
+				console.log(`  ${name}: ${(archiveSize / 1024 / 1024).toFixed(2)} MB`);
+				archiveManifest[name] = archiveFileName;
+			}
 		}
 
-		// --- Copy native wrappers ---
+		// --- Build the runtime bundle (DLLs, views, app code — NO launcher binary, NO archives) ---
 
+		console.log("Building runtime bundle...");
+		const appFileName = getAppFileName(config.app.name, buildEnvironment);
+		const bundle = createAppBundle(appFileName, buildFolder, targetOS);
+		const appBundleFolderPath = bundle.appBundleFolderPath;
+		const appBundleMacOSPath = bundle.appBundleMacOSPath;
+		const appBundleFolderResourcesPath = bundle.appBundleFolderResourcesPath;
+		const appBundleAppCodePath = join(appBundleFolderResourcesPath, "app");
+		mkdirSync(appBundleAppCodePath, { recursive: true });
+		mkdirSync(appBundleMacOSPath, { recursive: true });
+
+		// Copy native wrappers
 		if (targetOS === "win") {
 			cpSync(targetPaths.CORE_WIN, join(appBundleMacOSPath, "SparkBunCore.dll"), { dereference: true });
 			cpSync(targetPaths.NATIVE_WRAPPER_WIN, join(appBundleMacOSPath, "libNativeWrapper.dll"), { dereference: true });
@@ -3372,8 +3387,7 @@ usageDescriptions : ""}${urlTypes ? "\n" + urlTypes : ""}${documentTypes ?
 			cpSync(asarLibSource, join(appBundleMacOSPath, "libasar" + libExt), { dereference: true });
 		}
 
-		// --- Bundle bun code ---
-
+		// Bundle bun code
 		const bunConfig = config.build.bun;
 		const bunSource = join(projectRoot, bunConfig.entrypoint);
 		if (!existsSync(bunSource)) {
@@ -3394,8 +3408,7 @@ usageDescriptions : ""}${urlTypes ? "\n" + urlTypes : ""}${documentTypes ?
 			throw new Error("Build failed: bun build failed");
 		}
 
-		// --- Bundle views ---
-
+		// Bundle views
 		for (const viewName in config.build.views) {
 			const viewConfig = config.build.views[viewName]!;
 			const viewSource = join(projectRoot, viewConfig.entrypoint);
@@ -3420,8 +3433,7 @@ usageDescriptions : ""}${urlTypes ? "\n" + urlTypes : ""}${documentTypes ?
 			}
 		}
 
-		// --- Copy assets ---
-
+		// Copy assets
 		for (const relSource in config.build.copy) {
 			const source = join(projectRoot, relSource);
 			if (!existsSync(source)) {
@@ -3438,8 +3450,7 @@ usageDescriptions : ""}${urlTypes ? "\n" + urlTypes : ""}${documentTypes ?
 			cpSync(source, destination, { recursive: true, dereference: true });
 		}
 
-		// --- Write build.json ---
-
+		// Write build.json
 		const buildJson = {
 			name: config.app.name,
 			identifier: config.app.identifier,
@@ -3449,69 +3460,42 @@ usageDescriptions : ""}${urlTypes ? "\n" + urlTypes : ""}${documentTypes ?
 		};
 		await Bun.write(join(appBundleAppCodePath, "build.json"), JSON.stringify(buildJson, null, 2));
 
-		// --- Create and embed archives ---
-
-		if (archives.length > 0) {
-			console.log("Creating archives...");
-			const archiveManifest: Record<string, string> = {};
-
-			for (const { name, path: archiveSrcPath } of archives) {
-				const archiveFileName = `archive-${name}.tar.gz`;
-				const archiveDestPath = join(appBundleFolderResourcesPath, archiveFileName);
-
-				console.log(`  Archiving ${name}: ${archiveSrcPath}`);
-				const tarPath = join(buildFolder, `archive-${name}.tar`);
-				createTar(tarPath, dirname(archiveSrcPath), [basename(archiveSrcPath)]);
-
-				const tarBytes = readFileSync(tarPath);
-				const gzipped = Bun.gzipSync(tarBytes);
-				writeFileSync(archiveDestPath, gzipped);
-
-				// Clean up intermediate tar
-				unlinkSync(tarPath);
+		// Write archives.json manifest into runtime bundle so app code knows archive names
+		await Bun.write(
+			join(appBundleFolderResourcesPath, "archives.json"),
+			JSON.stringify(archiveManifest, null, 2),
+		);
 
-				const gzSize = statSync(archiveDestPath).size;
-				console.log(`  ${name}: ${(gzSize / 1024 / 1024).toFixed(2)} MB`);
-				archiveManifest[name] = archiveFileName;
+		// --- Create runtime bundle tar.gz (small — no launcher binary, no archives) ---
+
+		console.log("Packaging runtime bundle (gzip level 12)...");
+		const runtimeFiles: Record<string, ArrayBuffer> = {};
+		const bundleBase = basename(appBundleFolderPath);
+		async function walkBundle(dir: string, prefix: string) {
+			for (const entry of readdirSync(dir, { withFileTypes: true })) {
+				const fullPath = join(dir, entry.name);
+				const archivePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+				if (entry.isDirectory()) {
+					await walkBundle(fullPath, archivePath);
+				} else {
+					runtimeFiles[archivePath] = await Bun.file(fullPath).arrayBuffer();
+				}
 			}
-
-			// Write archives.json manifest
-			await Bun.write(
-				join(appBundleFolderResourcesPath, "archives.json"),
-				JSON.stringify(archiveManifest, null, 2),
-			);
-			console.log(`Archives manifest written (${archives.length} archives)`);
 		}
+		await walkBundle(appBundleFolderPath, bundleBase);
 
-		// --- Tar + gzip the app bundle ---
-
-		console.log("Packaging app bundle...");
-		const tarPath = join(buildFolder, `${appFileName}.tar`);
-		createTar(tarPath, buildFolder, [basename(appBundleFolderPath)]);
-
-		const compressedTarPath = `${tarPath}.gz`;
-		const tarBytes = readFileSync(tarPath);
-		const gzipped = Bun.gzipSync(tarBytes);
-		writeFileSync(compressedTarPath, gzipped);
-		unlinkSync(tarPath);
-
-		// Clean up the uncompressed app bundle
+		const runtimeArchive = new Bun.Archive(runtimeFiles, { compress: "gzip", level: 12 });
+		const runtimeCompressedPath = join(buildFolder, `${appFileName}-runtime.tar.gz`);
+		await Bun.write(runtimeCompressedPath, await runtimeArchive.bytes());
 		rmSync(appBundleFolderPath, { recursive: true });
 
-		// --- Compile outer installer exe ---
+		const runtimeSize = statSync(runtimeCompressedPath).size;
+		console.log(`  Runtime bundle: ${(runtimeSize / 1024 / 1024).toFixed(2)} MB`);
 
-		const defaultOutName = `${installerName.replace(/ /g, "-")}-Setup${targetBinExt}`;
-		const outputPath = outPath
-			? path.resolve(projectRoot, outPath)
-			: join(buildFolder, defaultOutName);
+		// --- Generate entrypoint and compile single installer exe ---
 
-		console.log("Compiling installer executable...");
-		const stagingDir = join(buildFolder, ".installer-wrapper-staging");
-		if (existsSync(stagingDir)) rmSync(stagingDir, { recursive: true, force: true });
-		mkdirSync(stagingDir, { recursive: true });
-
-		// Copy app bundle archive
-		copyFileSync(compressedTarPath, join(stagingDir, "app-archive.tar.gz"));
+		// Copy runtime bundle into staging
+		copyFileSync(runtimeCompressedPath, join(stagingDir, "runtime-bundle.tar.gz"));
 
 		// Write metadata
 		const metadata: Record<string, unknown> = {
@@ -3519,6 +3503,7 @@ usageDescriptions : ""}${urlTypes ? "\n" + urlTypes : ""}${documentTypes ?
 			version: installerVersion,
 			identifier: config.app.identifier,
 			channel: buildEnvironment,
+			requireAdmin: (config.build?.win as any)?.requireAdmin || (config.build?.linux as any)?.requireAdmin || false,
 		};
 		if (metadataPath) {
 			const userMetadata = JSON.parse(readFileSync(path.resolve(projectRoot, metadataPath), "utf-8"));
@@ -3526,16 +3511,42 @@ usageDescriptions : ""}${urlTypes ? "\n" + urlTypes : ""}${documentTypes ?
 		}
 		writeFileSync(join(stagingDir, "metadata.json"), JSON.stringify(metadata, null, 2));
 
-		// Copy wrapper template
+		// Generate the entrypoint that imports the wrapper template + all archive files
+		// The wrapper template imports runtime-bundle.tar.gz and metadata.json.
+		// We generate an archives module that the app code can import at runtime.
 		const wrapperTemplatePath = join(cliDir, "..", "installer", "installer-wrapper-template.ts");
 		copyFileSync(wrapperTemplatePath, join(stagingDir, "installer.ts"));
 
-		const targetOSName = targetOS === "macos" ? "darwin" : targetOS === "win" ? "windows" : "linux";
-		const isWindows = targetOS === "win";
+		// Generate archives.ts that embeds each archive via static imports
+		const archiveImports: string[] = [];
+		const archiveExports: string[] = [];
+		for (const { name } of archives) {
+			const fileName = archiveManifest[name];
+			archiveImports.push(`import archive_${name} from "./${fileName}" with { type: "file" };`);
+			archiveExports.push(`  "${name}": archive_${name},`);
+		}
+
+		const archivesModuleContent = `${archiveImports.join("\n")}
+
+export const embeddedArchives: Record<string, string> = {
+${archiveExports.join("\n")}
+};
+`;
+		writeFileSync(join(stagingDir, "embedded-archives.ts"), archivesModuleContent);
+
+		// --- Compile single installer exe ---
+
+		const defaultOutName = `${installerName.replace(/ /g, "-")}-Setup${targetBinExt}`;
+		const outputPath = outPath
+			? path.resolve(projectRoot, outPath)
+			: join(buildFolder, defaultOutName);
+
+		console.log("Compiling installer executable...");
 
 		const installerCompileOptions: any = {
 			target: `bun-${targetOSName}-${targetARCH}`,
 			outfile: outputPath,
+			minify: true,
 		};
 
 		if (isWindows && OS === "win") {
@@ -3554,7 +3565,9 @@ usageDescriptions : ""}${urlTypes ? "\n" + urlTypes : ""}${documentTypes ?
 				}
 			}
 			installerCompileOptions.windows = {
-				hideConsole: true,
+				// Don't set hideConsole — it conflicts with the ShellExecuteW("runas")
+				// elevation flow in the wrapper template. The PE subsystem patch
+				// (CONSOLE -> WINDOWS) applied after compilation hides the console.
 				...(icoPath && { icon: icoPath }),
 				title: `${installerName} Setup`,
 				version: installerVersion,
@@ -4226,7 +4239,7 @@ usageDescriptions : ""}${urlTypes ? "\n" + urlTypes : ""}${documentTypes ?
 		writeFileSync(join(stagingDir, "metadata.json"), JSON.stringify(metadata, null, 2));
 
 		// Copy installer template
-		const cliDir = dirname(new URL(import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, "$1"));
+		const cliDir = dirname(decodeURIComponent(new URL(import.meta.url).pathname).replace(/^\/([A-Za-z]:)/, "$1"));
 		const templatePath = join(cliDir, "..", "installer", "installer-template.ts");
 		copyFileSync(templatePath, join(stagingDir, "installer.ts"));
 

package/src/installer/installer-wrapper-template.ts

@@ -1,69 +1,145 @@
-import archiveData from "./app-archive.tar.gz" with { type: "file" };
+/**
+ * SparkBun Installer Wrapper Template
+ *
+ * This file is the entrypoint for installers built with `bun sparkbun installer`.
+ * It gets compiled into a single executable that contains:
+ *   - A small runtime bundle (DLLs, views, app code — ~1MB compressed)
+ *   - The installer's payload archives (LZMA compressed via NSIS)
+ *
+ * The binary uses a two-phase execution model with a single Bun runtime:
+ *
+ *   Phase 1 (first launch — user double-clicks the exe):
+ *     No native DLLs next to the exe, so we can't load SparkBunCore yet.
+ *     Extract the runtime bundle to a temp directory, copy ourselves there
+ *     (so the same binary now has DLLs next to it), and re-launch the copy
+ *     with admin elevation via ShellExecuteW("runas"). The UAC prompt shows
+ *     the exe's PE metadata (app name, publisher) since Windows reads it
+ *     from the binary being elevated.
+ *
+ *   Phase 2 (second launch — from temp, elevated):
+ *     DLLs are next to us. Load SparkBunCore via FFI, start the app code
+ *     as a Worker thread, and run the native event loop. The app code opens
+ *     a webview window (the installer wizard UI) and can access the embedded
+ *     payload archives via globalThis.__installerArchives when the user
+ *     triggers installation.
+ *
+ * The payload archives stay embedded in the binary at all times — they are
+ * never extracted to temp. Only when the user clicks "Install" does the app
+ * code write them to disk and run them (NSIS silent self-extractors).
+ */
+
+import runtimeArchive from "./runtime-bundle.tar.gz" with { type: "file" };
 import metadataJson from "./metadata.json" with { type: "file" };
-import { join } from "path";
-import { existsSync, mkdirSync, rmSync } from "fs";
+import { embeddedArchives } from "./embedded-archives";
+import { join, dirname, basename } from "path";
+import { existsSync, mkdirSync, readdirSync, copyFileSync } from "fs";
+import { dlopen, suffix, ptr } from "bun:ffi";
 
-interface Metadata {
-	name: string;
-	version?: string;
-}
+const metadata = await Bun.file(metadataJson).json();
+const binDir = dirname(process.execPath);
+const coreLibName = process.platform === "win32"
+	? "SparkBunCore.dll"
+	: `libSparkBunCore.${suffix}`;
+const hasRuntime = existsSync(join(binDir, coreLibName));
 
-const metadata: Metadata = await Bun.file(metadataJson).json();
-const tempDir = join(
-	process.env.TEMP || process.env.TMP || process.env.LOCALAPPDATA || ".",
-	`.sparkbun-installer-${Date.now()}`,
-);
+if (hasRuntime) {
+	// ── Phase 2: DLLs are next to us — run the SparkBun app ──
 
-try {
-	console.log(`Starting ${metadata.name} installer...`);
+	process.chdir(binDir);
+
+	// Expose embedded archives to the app code via globalThis.
+	// The app's install logic reads these paths to extract payloads.
+	(globalThis as any).__installerArchives = embeddedArchives;
+
+	const coreLibPath = join(binDir, coreLibName);
+	const lib = dlopen(coreLibPath, {
+		sparkbun_core_run_main_thread: {
+			args: ["cstring", "cstring", "cstring", "i32"],
+			returns: "i32",
+		},
+	});
+
+	const resourcesDir = join(binDir, "..", "Resources");
+	const appEntrypointPath = join(resourcesDir, "app", "bun", "index.js");
+
+	// Read app identity from build.json for SparkBunCore initialization
+	let identifier = metadata.name || "";
+	let name = metadata.name || "";
+	let channel = "";
+	try {
+		const buildJsonPath = join(resourcesDir, "app", "build.json");
+		if (existsSync(buildJsonPath)) {
+			const buildConfig = JSON.parse(require("fs").readFileSync(buildJsonPath, "utf-8"));
+			identifier = buildConfig.identifier || identifier;
+			name = buildConfig.name || name;
+			channel = buildConfig.channel || "";
+		}
+	} catch {}
+
+	// Suppress default signal handling so the native event loop controls shutdown
+	process.on("SIGINT", () => {});
+	process.on("SIGTERM", () => {});
+
+	// Start the app code in a Worker thread (same pattern as SparkBun's launcher).
+	// The Worker runs the developer's Bun entrypoint which creates BrowserWindows,
+	// sets up RPC handlers, etc.
+	new Worker(appEntrypointPath);
+
+	// Run the native event loop on the main thread (blocks until app exits)
+	lib.symbols.sparkbun_core_run_main_thread(
+		ptr(new Uint8Array(Buffer.from(identifier + "\0", "utf8"))),
+		ptr(new Uint8Array(Buffer.from(name + "\0", "utf8"))),
+		ptr(new Uint8Array(Buffer.from(channel + "\0", "utf8"))),
+		0,
+	);
+} else {
+	// ── Phase 1: No DLLs — extract runtime, copy self, launch elevated ──
+
+	const tempDir = join(
+		process.env.TEMP || process.env.LOCALAPPDATA || ".",
+		`.sparkbun-installer-${metadata.name.replace(/[^a-zA-Z0-9]/g, "_")}`,
+	);
 
-	const archiveBytes = await Bun.file(archiveData).bytes();
-	const archive = new Bun.Archive(archiveBytes);
 	mkdirSync(tempDir, { recursive: true });
+	const archiveBytes = await Bun.file(runtimeArchive).bytes();
+	const archive = new Bun.Archive(archiveBytes);
 	await archive.extract(tempDir);
 
-	// Find the launcher exe inside the extracted bundle
-	const { readdirSync } = await import("fs");
-	let appDir = tempDir;
-	const entries = readdirSync(tempDir);
-	for (const entry of entries) {
+	// The runtime bundle extracts as AppName/bin/ with DLLs inside
+	let extractedBinDir = tempDir;
+	for (const entry of readdirSync(tempDir)) {
 		const entryPath = join(tempDir, entry);
 		if (existsSync(join(entryPath, "bin"))) {
-			appDir = entryPath;
+			extractedBinDir = join(entryPath, "bin");
 			break;
 		}
 	}
 
-	const exeName = metadata.name.replace(/ /g, "");
-	const binExt = process.platform === "win32" ? ".exe" : "";
-	const launcherPath = join(appDir, "bin", `${exeName}${binExt}`);
-
-	if (!existsSync(launcherPath)) {
-		throw new Error(`Launcher not found: ${launcherPath}`);
-	}
-
-	const proc = Bun.spawn([launcherPath], {
-		cwd: join(appDir, "bin"),
-		stdio: ["inherit", "inherit", "inherit"],
-	});
+	// Copy ourselves next to the DLLs so the second launch detects hasRuntime
+	const destExe = join(extractedBinDir, basename(process.execPath));
+	copyFileSync(process.execPath, destExe);
 
-	const exitCode = await proc.exited;
-
-	// Clean up temp directory
-	try {
-		rmSync(tempDir, { recursive: true, force: true });
-	} catch {}
-
-	process.exit(exitCode);
-} catch (e: any) {
-	console.error(`Installer failed: ${e.message}`);
-	// Clean up on failure
-	try {
-		rmSync(tempDir, { recursive: true, force: true });
-	} catch {}
-	if (process.platform === "win32") {
-		console.log("Press Enter to exit...");
-		for await (const _ of console) { break; }
+	// Launch the copy with elevation using the same pattern as installer-template.ts.
+	// ShellExecuteW("runas") triggers the UAC prompt showing the exe's PE metadata.
+	if (process.platform === "win32" && metadata.requireAdmin) {
+		const shell32 = dlopen("shell32.dll", {
+			ShellExecuteW: {
+				args: ["ptr", "ptr", "ptr", "ptr", "ptr", "i32"],
+				returns: "ptr",
+			},
+		});
+		const encode = (s: string) => ptr(new Uint8Array(Buffer.from(s + "\0", "utf-16le")));
+		shell32.symbols.ShellExecuteW(
+			null,
+			encode("runas"),
+			encode(destExe),
+			null,
+			encode(extractedBinDir),
+			1,
+		);
+		shell32.close();
+	} else {
+		Bun.spawn([destExe], { cwd: extractedBinDir });
 	}
-	process.exit(1);
+	await Bun.sleep(1000);
 }