bunite-core 0.8.1 → 0.9.0

package/src/host/core/Socket.ts

@@ -0,0 +1,98 @@
+import type { Server, WebSocketHandler } from "bun";
+import type { BrowserView } from "./BrowserView";
+import { log } from "../log";
+import { DEFAULT_MAX_BYTES } from "../../rpc/wire";
+
+type ViewRegistry = {
+  getById(id: number): BrowserView | undefined;
+};
+
+type WebSocketData = {
+  webviewId: number;
+  pipe?: { deliver(bytes: Uint8Array): void };
+};
+
+let rpcServer: Server<WebSocketData> | null = null;
+let rpcPort = 0;
+let registry: ViewRegistry | null = null;
+
+export function attachBrowserViewRegistry(nextRegistry: ViewRegistry) {
+  registry = nextRegistry;
+}
+
+function asBytes(message: unknown): Uint8Array | null {
+  if (typeof message === "string") return null;
+  if (message instanceof Uint8Array) return message;
+  if (message instanceof ArrayBuffer) return new Uint8Array(message);
+  if (ArrayBuffer.isView(message)) return new Uint8Array(message.buffer, message.byteOffset, message.byteLength);
+  return null;
+}
+
+const websocket: WebSocketHandler<WebSocketData> = {
+  open(ws) {
+    const view = registry?.getById(ws.data.webviewId);
+    if (!view) { ws.close(); return; }
+    let handler: ((bytes: Uint8Array) => void) | undefined;
+    const pending: Uint8Array[] = [];
+    const pipe = {
+      send: (bytes: Uint8Array) => { ws.send(bytes); },
+      setReceive: (h: (bytes: Uint8Array) => void) => {
+        handler = h;
+        for (const b of pending) h(b);
+        pending.length = 0;
+      },
+      close: () => { try { ws.close(); } catch { /* swallow */ } },
+      deliver: (bytes: Uint8Array) => {
+        if (handler) handler(bytes);
+        else pending.push(bytes);
+      },
+    };
+    ws.data.pipe = pipe;
+    void view.attachNewConnection(pipe);
+  },
+  close(ws) {
+    const view = registry?.getById(ws.data.webviewId);
+    view?.detachNewConnection();
+    ws.data.pipe = undefined;
+  },
+  message(ws, message) {
+    const bytes = asBytes(message);
+    if (bytes) ws.data.pipe?.deliver(bytes);
+  },
+};
+
+export function ensureRpcServer() {
+  if (rpcServer) return { rpcServer, rpcPort };
+
+  let port = 45000;
+  while (port <= 65535) {
+    try {
+      rpcServer = Bun.serve<WebSocketData>({
+        hostname: "127.0.0.1",
+        port,
+        fetch(req, server) {
+          const url = new URL(req.url);
+          if (url.pathname !== "/rpc") return new Response("Not found", { status: 404 });
+          const webviewId = Number(url.searchParams.get("webviewId"));
+          if (!Number.isFinite(webviewId)) return new Response("Missing webviewId", { status: 400 });
+          if (!registry?.getById(webviewId)) return new Response("Unknown webviewId", { status: 403 });
+          const upgraded = server.upgrade(req, { data: { webviewId } });
+          return upgraded ? undefined : new Response("Upgrade failed", { status: 500 });
+        },
+        websocket: { ...websocket, maxPayloadLength: DEFAULT_MAX_BYTES },
+      });
+      rpcPort = port;
+      break;
+    } catch (error: any) {
+      if (error?.code === "EADDRINUSE") { port += 1; continue; }
+      throw error;
+    }
+  }
+  if (!rpcServer) throw new Error("Could not start bunite RPC server.");
+  log.debug(`bunite RPC server listening on 127.0.0.1:${rpcPort}`);
+  return { rpcServer, rpcPort };
+}
+
+export function getRpcPort(): number {
+  return rpcPort;
+}

package/src/host/core/SurfaceBrowserIPC.ts

@@ -0,0 +1,7 @@
+import { onSurfaceInit, emitDidNavigate } from "./SurfaceManager";
+
+onSurfaceInit((surfaceId, hostViewId, view) => {
+  view.on("did-navigate", (event: any) => {
+    emitDidNavigate(hostViewId, surfaceId, event.data.detail);
+  });
+});

package/src/host/core/SurfaceManager.ts

@@ -0,0 +1,154 @@
+import { BrowserView } from "./BrowserView";
+import {
+  trackSurface, untrackSurface, getOwnedSurface,
+  getHostSurfaceIds, getSurfaceRecord,
+  MAX_SURFACES_PER_HOST
+} from "./SurfaceRegistry";
+import { SurfaceCap, type ImplOf, IpcError } from "../../rpc/index";
+import { Stream } from "../../rpc/stream";
+
+function applyHostOffset(hostView: BrowserView, x: number, y: number) {
+  return { x: x + hostView.frame.x, y: y + hostView.frame.y };
+}
+
+type SurfaceInitCallback = (surfaceId: number, hostViewId: number, view: BrowserView) => void;
+const initCallbacks: SurfaceInitCallback[] = [];
+
+export function onSurfaceInit(cb: SurfaceInitCallback) {
+  initCallbacks.push(cb);
+}
+
+type DidNavigateEmit = (event: { surfaceId: number; url: string }) => void;
+const didNavigateSubs = new Map<number, Set<DidNavigateEmit>>();
+
+export function emitDidNavigate(hostViewId: number, surfaceId: number, url: string) {
+  const subs = didNavigateSubs.get(hostViewId);
+  if (!subs) return;
+  for (const emit of subs) emit({ surfaceId, url });
+}
+
+export function createSurfaceCapImpl(hostViewId: number): ImplOf<typeof SurfaceCap> {
+  function ownedSurface(surfaceId: number) {
+    const record = getOwnedSurface(surfaceId, { viewId: hostViewId });
+    return record;
+  }
+
+  return {
+    init: async ({ src, x, y, width, height, hidden = false }) => {
+      const hostView = BrowserView.getById(hostViewId);
+      if (!hostView) throw new IpcError({ code: "not_found", message: `Host view not found: ${hostViewId}` });
+      if (!hostView.windowId) throw new IpcError({ code: "failed_precondition", message: `Host window not found` });
+
+      const hostIds = getHostSurfaceIds(hostViewId);
+      if (hostIds && hostIds.size >= MAX_SURFACES_PER_HOST) {
+        throw new IpcError({ code: "resource_exhausted", message: `Surface limit reached (${MAX_SURFACES_PER_HOST})` });
+      }
+
+      const offset = applyHostOffset(hostView, x, y);
+      const view = new BrowserView({
+        url: src,
+        windowId: hostView.windowId,
+        appresRoot: hostView.appresRoot,
+        frame: { x: offset.x, y: offset.y, width, height },
+        autoResize: false,
+      });
+      trackSurface(view.id, { view, hostViewId, hidden });
+      try {
+        await view.whenReady();
+      } catch {
+        untrackSurface(view.id);
+        view.remove();
+        throw new IpcError({ code: "unavailable", message: "Surface browser creation failed or timed out" });
+      }
+      for (const cb of initCallbacks) cb(view.id, hostViewId, view);
+      if (hidden) view.setVisible(false); else view.bringToFront();
+      return { surfaceId: view.id };
+    },
+
+    resize: ({ surfaceId, x, y, w, h }) => {
+      const record = ownedSurface(surfaceId);
+      if (!record) return;
+      const hostView = BrowserView.getById(hostViewId);
+      if (!hostView) return;
+      const offset = applyHostOffset(hostView, x, y);
+      record.view.setBoundsAsync(offset.x, offset.y, w, h);
+    },
+
+    remove: ({ surfaceId }) => {
+      const record = ownedSurface(surfaceId);
+      if (!record) return;
+      untrackSurface(surfaceId);
+      record.view.remove();
+    },
+
+    setHidden: ({ surfaceId, hidden }) => {
+      const record = ownedSurface(surfaceId);
+      if (!record) return;
+      record.hidden = hidden;
+      record.view.setVisible(!hidden);
+      if (!hidden) record.view.bringToFront();
+    },
+
+    setMasks: ({ surfaceId, masks }) => {
+      const record = ownedSurface(surfaceId);
+      if (!record) return;
+      const hostView = BrowserView.getById(hostViewId);
+      if (!hostView) return;
+      const offset = applyHostOffset(hostView, 0, 0);
+      record.view.setMaskRegion(masks.map((m) => ({
+        x: m.x + offset.x,
+        y: m.y + offset.y,
+        w: m.w,
+        h: m.h,
+      })));
+    },
+
+    setAllPassthrough: ({ passthrough }) => {
+      const ids = getHostSurfaceIds(hostViewId);
+      if (!ids) return;
+      for (const surfaceId of ids) {
+        const record = getSurfaceRecord(surfaceId);
+        record?.view.setInputPassthrough(passthrough);
+      }
+    },
+
+    bringAllVisiblesToFront: () => {
+      const ids = getHostSurfaceIds(hostViewId);
+      if (!ids) return;
+      for (const surfaceId of ids) {
+        const record = getSurfaceRecord(surfaceId);
+        if (record && !record.hidden) record.view.bringToFront();
+      }
+    },
+
+    navigate: ({ surfaceId, url }) => {
+      const record = ownedSurface(surfaceId);
+      record?.view.loadURL(url);
+    },
+
+    goBack: ({ surfaceId }) => {
+      const record = ownedSurface(surfaceId);
+      record?.view.goBack();
+    },
+
+    reload: ({ surfaceId }) => {
+      const record = ownedSurface(surfaceId);
+      record?.view.reload();
+    },
+
+    didNavigate: () => Stream.from<{ surfaceId: number; url: string }>((emit, signal) => {
+      let subs = didNavigateSubs.get(hostViewId);
+      if (!subs) {
+        subs = new Set();
+        didNavigateSubs.set(hostViewId, subs);
+      }
+      subs.add(emit);
+      signal.addEventListener("abort", () => {
+        const set = didNavigateSubs.get(hostViewId);
+        if (!set) return;
+        set.delete(emit);
+        if (set.size === 0) didNavigateSubs.delete(hostViewId);
+      });
+    }),
+  };
+}

package/src/host/encryptedPipe.ts

@@ -0,0 +1,62 @@
+import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
+import type { BytesPipe } from "../rpc/transport";
+
+const VERSION = 1;
+const IV_LENGTH = 12;
+const TAG_LENGTH = 16;
+const HEADER_LENGTH = 1 + IV_LENGTH;
+
+// node:crypto AES-256-GCM. wire layout matches WebCrypto's: version | iv(12) | ciphertext | authTag(16).
+export async function createEncryptedPipe(base: BytesPipe, rawKey: Uint8Array): Promise<BytesPipe> {
+  let downstream: ((bytes: Uint8Array) => void) | undefined;
+  let closed = false;
+  const closeOnce = () => { if (!closed) { closed = true; base.close(); } };
+
+  base.setReceive((frame) => {
+    if (closed) return;
+    if (frame.length < HEADER_LENGTH + TAG_LENGTH || frame[0] !== VERSION) {
+      closeOnce();
+      return;
+    }
+    try {
+      const iv = frame.subarray(1, HEADER_LENGTH);
+      const body = frame.subarray(HEADER_LENGTH);
+      const ciphertext = body.subarray(0, body.length - TAG_LENGTH);
+      const authTag = body.subarray(body.length - TAG_LENGTH);
+      const decipher = createDecipheriv("aes-256-gcm", rawKey, iv);
+      decipher.setAuthTag(authTag);
+      const head = decipher.update(ciphertext);
+      const tail = decipher.final();
+      const plaintext = tail.length === 0 ? head : Buffer.concat([head, tail]);
+      // Normalize Buffer → plain Uint8Array so downstream prototype checks (msgpackr fast paths,
+      // structured clone, etc.) see the same type as the WebCrypto path.
+      downstream?.(new Uint8Array(plaintext.buffer, plaintext.byteOffset, plaintext.byteLength));
+    } catch {
+      closeOnce();
+    }
+  });
+
+  return {
+    send(bytes) {
+      if (closed) return;
+      try {
+        const iv = randomBytes(IV_LENGTH);
+        const cipher = createCipheriv("aes-256-gcm", rawKey, iv);
+        const head = cipher.update(bytes);
+        const tail = cipher.final();
+        const authTag = cipher.getAuthTag();
+        const out = new Uint8Array(HEADER_LENGTH + head.length + tail.length + authTag.length);
+        out[0] = VERSION;
+        out.set(iv, 1);
+        out.set(head, HEADER_LENGTH);
+        if (tail.length > 0) out.set(tail, HEADER_LENGTH + head.length);
+        out.set(authTag, HEADER_LENGTH + head.length + tail.length);
+        base.send(out);
+      } catch {
+        closeOnce();
+      }
+    },
+    setReceive(handler) { downstream = handler; },
+    close() { closeOnce(); },
+  };
+}

package/src/{bun → host}/events/appEvents.ts

@@ -1,7 +1,6 @@
 import { BuniteEvent } from "./event";
 
 export default {
-  ready: (data: Record<string, unknown>) => new BuniteEvent("ready", data),
   beforeQuit: (data: Record<string, unknown>) =>
     new BuniteEvent<Record<string, unknown>, { allow?: boolean }>("before-quit", data),
   allWindowsClosed: () => new BuniteEvent("all-windows-closed", {})

package/src/host/index.ts

@@ -0,0 +1,29 @@
+import { AppRuntime } from "./core/App";
+import { BrowserWindow, type WindowOptionsType } from "./core/BrowserWindow";
+import { BrowserView, type BrowserViewOptions } from "./core/BrowserView";
+import { buniteEventEmitter } from "./events/eventEmitter";
+import { BuniteEvent } from "./events/event";
+import { completePermissionRequest } from "./native";
+import { acquireSingleInstanceLock, type SingleInstanceLock } from "./core/singleInstanceLock";
+import { log, type LogLevel } from "./log";
+
+export { serveWeb } from "./serveWeb";
+export type { WebRpcMount } from "./serveWeb";
+
+export {
+  acquireSingleInstanceLock,
+  AppRuntime,
+  BrowserWindow,
+  BrowserView,
+  buniteEventEmitter,
+  completePermissionRequest,
+  log
+};
+
+export type {
+  LogLevel,
+  BuniteEvent,
+  BrowserViewOptions,
+  SingleInstanceLock,
+  WindowOptionsType
+};

package/src/{bun/proc → host}/native.ts

@@ -1,12 +1,11 @@
 import { CString, dlopen, FFIType, JSCallback, ptr, type Pointer } from "bun:ffi";
 import { existsSync } from "node:fs";
 import { delimiter, join } from "node:path";
-import { buniteEventEmitter } from "../events/eventEmitter";
-import { resolveNativeArtifacts, type ResolvedNativeArtifacts } from "../../shared/paths";
-import { log } from "../../shared/log";
+import { buniteEventEmitter } from "./events/eventEmitter";
+import { resolveNativeArtifacts, type ResolvedNativeArtifacts } from "./paths";
+import { log } from "./log";
 
 export type NativeBootstrapOptions = {
-  allowStub?: boolean;
   hideConsole?: boolean;
   popupBlocking?: boolean;
   /**
@@ -19,8 +18,6 @@ export type NativeBootstrapOptions = {
 
 export type NativeRuntimeState = {
   initialized: boolean;
-  usingStub: boolean;
-  nativeLoaded: boolean;
   artifacts: ResolvedNativeArtifacts;
 };
 
@@ -32,7 +29,7 @@ type NativeSymbols = {
   bunite_engine_version: () => CString;
   bunite_set_log_level: (level: number) => void;
   bunite_init: (
-    engineDir: CStringPointer,
+    cefDir: CStringPointer,
     hideConsole: boolean,
     popupBlocking: boolean,
     engineConfigJson: CStringPointer
@@ -97,7 +94,6 @@ type NativeSymbols = {
   bunite_view_bring_to_front: (viewId: number) => void;
   bunite_view_set_bounds: (viewId: number, x: number, y: number, width: number, height: number) => void;
   bunite_view_set_bounds_async: (viewId: number, x: number, y: number, width: number, height: number) => void;
-  bunite_view_set_anchor: (viewId: number, mode: number, inset: number) => void;
   bunite_view_go_back: (viewId: number) => void;
   bunite_view_reload: (viewId: number) => void;
   bunite_view_execute_javascript: (viewId: number, script: CStringPointer) => void;
@@ -272,10 +268,6 @@ const nativeSymbolDefinitions = {
     args: [FFIType.u32, FFIType.f64, FFIType.f64, FFIType.f64, FFIType.f64],
     returns: FFIType.void
   },
-  bunite_view_set_anchor: {
-    args: [FFIType.u32, FFIType.i32, FFIType.f64],
-    returns: FFIType.void
-  },
   bunite_view_go_back: {
     args: [FFIType.u32],
     returns: FFIType.void
@@ -365,12 +357,12 @@ export function toCString(value: string): CStringPointer {
 
 function applyEnvironment(artifacts: ResolvedNativeArtifacts) {
   // CEF needs engine dir on PATH (libcef.dll) and ICU_DATA pointing at resources. Null for mac/linux.
-  const engineBinaryDir = artifacts.engineDir && existsSync(join(artifacts.engineDir, "Release", "libcef.dll"))
-    ? join(artifacts.engineDir, "Release")
-    : artifacts.engineDir;
-  const engineResourceDir = artifacts.engineDir && existsSync(join(artifacts.engineDir, "Resources", "resources.pak"))
-    ? join(artifacts.engineDir, "Resources")
-    : artifacts.engineDir;
+  const engineBinaryDir = artifacts.cefDir && existsSync(join(artifacts.cefDir, "Release", "libcef.dll"))
+    ? join(artifacts.cefDir, "Release")
+    : artifacts.cefDir;
+  const engineResourceDir = artifacts.cefDir && existsSync(join(artifacts.cefDir, "Resources", "resources.pak"))
+    ? join(artifacts.cefDir, "Resources")
+    : artifacts.cefDir;
 
   if (engineResourceDir && !process.env.ICU_DATA) {
     process.env.ICU_DATA = engineResourceDir;
@@ -583,7 +575,6 @@ export async function initNativeRuntime(
     return state;
   }
 
-  const allowStub = options.allowStub ?? true;
   const artifacts = resolveNativeArtifacts();
   const hasNativeArtifacts = Boolean(
     artifacts.nativeLibPath && existsSync(artifacts.nativeLibPath)
@@ -591,50 +582,45 @@ export async function initNativeRuntime(
 
   applyEnvironment(artifacts);
 
-  if (!hasNativeArtifacts && !allowStub) {
+  if (!hasNativeArtifacts) {
     throw new Error(
-      "bunite native runtime packages are missing. Install platform packages or allow stub mode."
+      "bunite: native runtime not found. Install the platform package " +
+      `(bunite-native-${process.platform === "win32" ? "win" : process.platform === "darwin" ? "mac" : "linux"}-<arch>) ` +
+      "or set BUNITE_CEF_DIR to a CEF runtime directory."
     );
   }
 
-  nativeLibrary = hasNativeArtifacts ? tryLoadNativeLibrary(artifacts) : null;
+  nativeLibrary = tryLoadNativeLibrary(artifacts);
+  if (!nativeLibrary) {
+    throw new Error(`bunite: failed to load native library at ${artifacts.nativeLibPath}.`);
+  }
 
-  if (nativeLibrary) {
-    const EXPECTED_ABI = 4;
-    const nativeAbi = nativeLibrary.symbols.bunite_abi_version();
-    if (nativeAbi !== EXPECTED_ABI) {
-      throw new Error(
-        `bunite native ABI mismatch: JS expects ${EXPECTED_ABI}, native reports ${nativeAbi}. ` +
-        `Rebuild native binaries with 'bun run build:native:win'.`
-      );
-    }
-    registerNativeCallbacks(nativeLibrary);
-    const engineConfigJson = options.engineFlags
-      ? JSON.stringify(options.engineFlags)
-      : "";
-    const initOk = nativeLibrary.symbols.bunite_init(
-      toCString(artifacts.engineDir ?? ""),
-      options.hideConsole ?? false,
-      options.popupBlocking ?? false,
-      toCString(engineConfigJson)
+  const EXPECTED_ABI = 4;
+  const nativeAbi = nativeLibrary.symbols.bunite_abi_version();
+  if (nativeAbi !== EXPECTED_ABI) {
+    throw new Error(
+      `bunite native ABI mismatch: JS expects ${EXPECTED_ABI}, native reports ${nativeAbi}. ` +
+      `Rebuild native binaries with 'bun run build:native:win'.`
     );
-
-    if (!initOk) {
-      nativeLibrary = null;
-      if (!allowStub) {
-        throw new Error("bunite native runtime failed to initialize.");
-      }
-    }
   }
-
-  if (!nativeLibrary) {
-    log.warn("Native runtime packages were not found or could not be loaded. Initializing in stub mode.");
+  registerNativeCallbacks(nativeLibrary);
+  const engineConfigJson = options.engineFlags ? JSON.stringify(options.engineFlags) : "";
+  const initOk = nativeLibrary.symbols.bunite_init(
+    toCString(artifacts.cefDir ?? ""),
+    options.hideConsole ?? false,
+    options.popupBlocking ?? false,
+    toCString(engineConfigJson)
+  );
+  if (!initOk) {
+    throw new Error(
+      "bunite: native runtime failed to initialize " +
+      `(engine dir: ${artifacts.cefDir || "<unset>"}). ` +
+      "Verify CEF binaries are available, or set BUNITE_CEF_DIR."
+    );
   }
 
   state = {
     initialized: true,
-    usingStub: !nativeLibrary,
-    nativeLoaded: Boolean(nativeLibrary),
     artifacts
   };
   return state;

package/src/{shared → host}/paths.ts

@@ -12,12 +12,8 @@ export type ResolvedNativeArtifacts = {
   nativePackageName: string | null;
   enginePackageName: string | null;
   nativeLibPath: string | null;
-  /**
-   * Engine runtime directory. Engine-specific meaning:
-   * - CEF (Windows): CEF framework dir containing libcef.dll. Resolved via env, package, or vendors/cef.
-   * - WKWebView (macOS), WebKitGTK (Linux): null. Engine is the system framework.
-   */
-  engineDir: string | null;
+  /** CEF framework dir containing libcef.dll. Null on macOS/Linux (system framework). */
+  cefDir: string | null;
 };
 
 export function resolvePackageRoot(packageName: string): string | null {
@@ -47,12 +43,12 @@ function parseCefVersion(name: string): number[] | null {
   return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : null;
 }
 
-function resolveEngineDir(searchDirs: string[]): string | null {
+function resolveCefDir(searchDirs: string[]): string | null {
   // CEF-only (Win). mac/linux use system frameworks.
   if (PLATFORM_TAG !== "win") return null;
 
-  // 0. Explicit override (BUNITE_ENGINE_DIR; BUNITE_CEF_DIR as legacy fallback).
-  const forceDir = process.env.BUNITE_ENGINE_DIR ?? process.env.BUNITE_CEF_DIR;
+  // 0. Explicit override.
+  const forceDir = process.env.BUNITE_CEF_DIR;
   if (forceDir && hasCefRuntime(forceDir)) {
     return forceDir;
   }
@@ -65,6 +61,12 @@ function resolveEngineDir(searchDirs: string[]): string | null {
     }
   }
 
+  // 1b. App's own dist/cef (dev mode reuses `bunite-build`-produced binaries).
+  const cwdDist = join(process.cwd(), "dist", "cef");
+  if (hasCefRuntime(cwdDist)) {
+    return cwdDist;
+  }
+
   // 2. Shared CEF root: BUNITE_CEF_ROOTDIR/cef-<version>/
   const rootDir = process.env.BUNITE_CEF_ROOTDIR;
   if (rootDir && existsSync(rootDir)) {
@@ -89,15 +91,6 @@ function resolveEngineDir(searchDirs: string[]): string | null {
     } catch {}
   }
 
-  // 3. vendors/cef inside bunite-core package (monorepo dev)
-  const packageRoot = resolveBunitePackageRoot();
-  if (packageRoot) {
-    const vendorPath = join(packageRoot, "vendors", "cef");
-    if (hasCefRuntime(vendorPath)) {
-      return vendorPath;
-    }
-  }
-
   return null;
 }
 
@@ -114,9 +107,10 @@ export function resolveDefaultAppResRoot(): string | null {
 }
 
 export function resolveNativeArtifacts(): ResolvedNativeArtifacts {
-  const exeDir = dirname(process.execPath);
+  const exeDir = getBaseDir();
 
-  // 1. Executable-relative (compiled standalone binary)
+  // 1. Entry-script-dir / executable-relative — covers both `bun dist/main.js`
+  //    and a compiled standalone binary, where artifacts ship alongside the entry.
   const exeNativeLib = join(exeDir, `libBuniteNative${NATIVE_LIB_EXT}`);
   if (existsSync(exeNativeLib)) {
     return {
@@ -125,7 +119,7 @@ export function resolveNativeArtifacts(): ResolvedNativeArtifacts {
       nativePackageName: null,
       enginePackageName: null,
       nativeLibPath: exeNativeLib,
-      engineDir: resolveEngineDir([exeDir])
+      cefDir: resolveCefDir([exeDir])
     };
   }
 
@@ -149,9 +143,9 @@ export function resolveNativeArtifacts(): ResolvedNativeArtifacts {
       nativePackageName,
       enginePackageName: packagedEngineDir && existsSync(packagedEngineDir) ? enginePackageName : null,
       nativeLibPath: packagedNativeLibPath,
-      engineDir: (packagedEngineDir && existsSync(packagedEngineDir))
+      cefDir: (packagedEngineDir && existsSync(packagedEngineDir))
         ? packagedEngineDir
-        : resolveEngineDir([nativePackageRoot, packageRoot].filter(Boolean) as string[])
+        : resolveCefDir([nativePackageRoot, packageRoot].filter(Boolean) as string[])
     };
   }
 
@@ -167,7 +161,7 @@ export function resolveNativeArtifacts(): ResolvedNativeArtifacts {
         nativePackageName: null,
         enginePackageName: null,
         nativeLibPath: directLib,
-        engineDir: resolveEngineDir([localBuildRoot])
+        cefDir: resolveCefDir([localBuildRoot])
       };
     }
 
@@ -180,7 +174,7 @@ export function resolveNativeArtifacts(): ResolvedNativeArtifacts {
         nativePackageName: null,
         enginePackageName: null,
         nativeLibPath: releaseLib,
-        engineDir: resolveEngineDir([localBuildRoot])
+        cefDir: resolveCefDir([localBuildRoot])
       };
     }
   }
@@ -191,6 +185,6 @@ export function resolveNativeArtifacts(): ResolvedNativeArtifacts {
     nativePackageName: nativePackageRoot ? nativePackageName : null,
     enginePackageName: enginePackageRoot ? enginePackageName : null,
     nativeLibPath: null,
-    engineDir: null
+    cefDir: null
   };
 }

package/src/{bun/preload/inline.ts → host/preloadBundle.ts}

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync } from "node:fs";
 import { isAbsolute, resolve, sep } from "node:path";
-import { log } from "../../shared/log";
+import { log } from "./log";
 
 function escapeRootForComparison(path: string) {
   return process.platform === "win32" ? path.toLowerCase() : path;
@@ -55,7 +55,7 @@ function readCustomPreload(preload: string | null, appresRoot: string | null) {
 
 // Bundled at build time so bun --compile works without filesystem access.
 // @ts-ignore — text import attribute
-import embeddedPreloadRuntime from "../../preload/runtime.built.js" with { type: "text" };
+import embeddedPreloadRuntime from "../preload/runtime.built.js" with { type: "text" };
 
 function getPreloadRuntime(): string {
   return embeddedPreloadRuntime;