@atom-js-org/runtime 0.2.0-alpha.0 → 0.3.0-alpha.0

package/src/runtime/macos-native-host.m

@@ -0,0 +1,519 @@
+#import <Cocoa/Cocoa.h>
+#import <WebKit/WebKit.h>
+#include <string.h>
+
+static NSString *const AtomJSEventPrefix = @"__ATOMJS_EVENT__";
+
+@class AtomJSWindowController;
+static NSMutableDictionary<NSNumber *, AtomJSWindowController *> *atomWindows;
+static NSString *atomAppName = @"AtomJS App";
+
+static void AtomJSEmit(NSDictionary *payload) {
+  if (![NSJSONSerialization isValidJSONObject:payload]) return;
+
+  NSError *error = nil;
+  NSData *json = [NSJSONSerialization dataWithJSONObject:payload options:0 error:&error];
+  if (!json || error) return;
+
+  NSMutableData *output = [NSMutableData data];
+  [output appendData:[AtomJSEventPrefix dataUsingEncoding:NSUTF8StringEncoding]];
+  [output appendData:json];
+  [output appendData:[@"\n" dataUsingEncoding:NSUTF8StringEncoding]];
+
+  @synchronized([NSFileHandle fileHandleWithStandardOutput]) {
+    [[NSFileHandle fileHandleWithStandardOutput] writeData:output];
+  }
+}
+
+static NSString *AtomJSString(id value, NSString *fallback) {
+  return [value isKindOfClass:[NSString class]] ? value : fallback;
+}
+
+static NSNumber *AtomJSNumber(id value, NSNumber *fallback) {
+  return [value isKindOfClass:[NSNumber class]] ? value : fallback;
+}
+
+static BOOL AtomJSBoolean(id value, BOOL fallback) {
+  return [value isKindOfClass:[NSNumber class]] ? [value boolValue] : fallback;
+}
+
+static NSColor *AtomJSColor(NSString *hex) {
+  if (![hex isKindOfClass:[NSString class]]) return [NSColor windowBackgroundColor];
+
+  NSString *value = [hex stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]];
+  if ([value hasPrefix:@"#"]) value = [value substringFromIndex:1];
+  if (value.length != 6 && value.length != 8) return [NSColor windowBackgroundColor];
+
+  unsigned int rgba = 0;
+  if (![[NSScanner scannerWithString:value] scanHexInt:&rgba]) return [NSColor windowBackgroundColor];
+
+  CGFloat red;
+  CGFloat green;
+  CGFloat blue;
+  CGFloat alpha = 1.0;
+
+  if (value.length == 8) {
+    red = ((rgba >> 24) & 0xff) / 255.0;
+    green = ((rgba >> 16) & 0xff) / 255.0;
+    blue = ((rgba >> 8) & 0xff) / 255.0;
+    alpha = (rgba & 0xff) / 255.0;
+  } else {
+    red = ((rgba >> 16) & 0xff) / 255.0;
+    green = ((rgba >> 8) & 0xff) / 255.0;
+    blue = (rgba & 0xff) / 255.0;
+  }
+
+  return [NSColor colorWithSRGBRed:red green:green blue:blue alpha:alpha];
+}
+
+@interface AtomJSWindowController : NSObject <NSWindowDelegate, WKNavigationDelegate>
+@property(nonatomic, strong) NSNumber *windowId;
+@property(nonatomic, strong) NSWindow *window;
+@property(nonatomic, strong) WKWebView *webView;
+- (instancetype)initWithWindowId:(NSNumber *)windowId config:(NSDictionary *)config;
+- (void)navigate:(NSString *)urlString;
+@end
+
+@implementation AtomJSWindowController
+
+- (instancetype)initWithWindowId:(NSNumber *)windowId config:(NSDictionary *)config {
+  self = [super init];
+  if (!self) return nil;
+
+  _windowId = windowId;
+
+  CGFloat width = MAX(320.0, [AtomJSNumber(config[@"width"], @800) doubleValue]);
+  CGFloat height = MAX(240.0, [AtomJSNumber(config[@"height"], @600) doubleValue]);
+  NSRect frame = NSMakeRect(0, 0, width, height);
+
+  NSWindowStyleMask style = NSWindowStyleMaskClosable | NSWindowStyleMaskMiniaturizable;
+  if (AtomJSBoolean(config[@"frame"], YES)) style |= NSWindowStyleMaskTitled;
+  if (AtomJSBoolean(config[@"resizable"], YES)) style |= NSWindowStyleMaskResizable;
+
+  _window = [[NSWindow alloc]
+    initWithContentRect:frame
+    styleMask:style
+    backing:NSBackingStoreBuffered
+    defer:NO];
+  _window.releasedWhenClosed = NO;
+  _window.delegate = self;
+  _window.title = AtomJSString(config[@"title"], atomAppName);
+  _window.backgroundColor = AtomJSColor(config[@"backgroundColor"]);
+  _window.tabbingMode = NSWindowTabbingModeDisallowed;
+
+  if (AtomJSBoolean(config[@"center"], YES)) [_window center];
+
+  WKUserContentController *contentController = [[WKUserContentController alloc] init];
+  NSString *bridgeScript = AtomJSString(config[@"bridgeScript"], @"");
+  if (bridgeScript.length > 0) {
+    WKUserScript *script = [[WKUserScript alloc]
+      initWithSource:bridgeScript
+      injectionTime:WKUserScriptInjectionTimeAtDocumentStart
+      forMainFrameOnly:YES];
+    [contentController addUserScript:script];
+  }
+
+  WKWebViewConfiguration *webConfiguration = [[WKWebViewConfiguration alloc] init];
+  webConfiguration.userContentController = contentController;
+
+  _webView = [[WKWebView alloc] initWithFrame:frame configuration:webConfiguration];
+  _webView.navigationDelegate = self;
+  _webView.autoresizingMask = NSViewWidthSizable | NSViewHeightSizable;
+  _window.contentView = _webView;
+
+  [self navigate:AtomJSString(config[@"url"], @"about:blank")];
+
+  if (AtomJSBoolean(config[@"show"], YES)) {
+    [_window makeKeyAndOrderFront:nil];
+    [NSApp activateIgnoringOtherApps:YES];
+  }
+
+  return self;
+}
+
+- (void)navigate:(NSString *)urlString {
+  NSURL *url = [NSURL URLWithString:urlString ?: @"about:blank"];
+  if (!url) {
+    AtomJSEmit(@{
+      @"type": @"did-fail-load",
+      @"windowId": self.windowId,
+      @"url": urlString ?: @"",
+      @"error": @"Invalid URL"
+    });
+    return;
+  }
+
+  [self.webView loadRequest:[NSURLRequest requestWithURL:url]];
+}
+
+- (NSString *)currentURL {
+  return self.webView.URL.absoluteString ?: @"";
+}
+
+- (void)webView:(WKWebView *)webView didStartProvisionalNavigation:(WKNavigation *)navigation {
+  AtomJSEmit(@{
+    @"type": @"did-start-loading",
+    @"windowId": self.windowId,
+    @"url": [self currentURL]
+  });
+}
+
+- (void)webView:(WKWebView *)webView didFinishNavigation:(WKNavigation *)navigation {
+  AtomJSEmit(@{
+    @"type": @"did-finish-load",
+    @"windowId": self.windowId,
+    @"url": [self currentURL]
+  });
+}
+
+- (void)webView:(WKWebView *)webView didFailNavigation:(WKNavigation *)navigation withError:(NSError *)error {
+  AtomJSEmit(@{
+    @"type": @"did-fail-load",
+    @"windowId": self.windowId,
+    @"url": [self currentURL],
+    @"error": error.localizedDescription ?: @"Navigation failed"
+  });
+}
+
+- (void)webView:(WKWebView *)webView didFailProvisionalNavigation:(WKNavigation *)navigation withError:(NSError *)error {
+  [self webView:webView didFailNavigation:navigation withError:error];
+}
+
+- (void)windowWillClose:(NSNotification *)notification {
+  [atomWindows removeObjectForKey:self.windowId];
+  AtomJSEmit(@{
+    @"type": @"closed",
+    @"windowId": self.windowId
+  });
+}
+
+- (void)windowDidBecomeKey:(NSNotification *)notification {
+  AtomJSEmit(@{
+    @"type": @"focus",
+    @"windowId": self.windowId
+  });
+}
+
+- (void)windowDidResignKey:(NSNotification *)notification {
+  AtomJSEmit(@{
+    @"type": @"blur",
+    @"windowId": self.windowId
+  });
+}
+
+- (void)windowDidMiniaturize:(NSNotification *)notification {
+  AtomJSEmit(@{
+    @"type": @"minimize",
+    @"windowId": self.windowId
+  });
+}
+
+- (void)windowDidDeminiaturize:(NSNotification *)notification {
+  AtomJSEmit(@{
+    @"type": @"restore",
+    @"windowId": self.windowId
+  });
+}
+
+@end
+
+static AtomJSWindowController *AtomJSController(NSDictionary *message) {
+  NSNumber *windowId = AtomJSNumber(message[@"windowId"], nil);
+  return windowId ? atomWindows[windowId] : nil;
+}
+
+static NSArray<NSString *> *AtomJSAllowedExtensions(NSDictionary *options) {
+  NSArray *filters = [options[@"filters"] isKindOfClass:[NSArray class]] ? options[@"filters"] : @[];
+  NSMutableArray<NSString *> *extensions = [NSMutableArray array];
+
+  for (id filter in filters) {
+    if (![filter isKindOfClass:[NSDictionary class]]) continue;
+    NSArray *items = [filter[@"extensions"] isKindOfClass:[NSArray class]] ? filter[@"extensions"] : @[];
+    for (id item in items) {
+      if ([item isKindOfClass:[NSString class]] && ![item isEqualToString:@"*"]) {
+        [extensions addObject:item];
+      }
+    }
+  }
+
+  return extensions;
+}
+
+static void AtomJSRespond(NSString *requestId, BOOL ok, id result, NSString *error) {
+  if (!requestId) return;
+
+  NSMutableDictionary *response = [@{
+    @"type": @"response",
+    @"requestId": requestId,
+    @"ok": @(ok)
+  } mutableCopy];
+
+  if (result) response[@"result"] = result;
+  if (error) response[@"error"] = error;
+  AtomJSEmit(response);
+}
+
+static NSDictionary *AtomJSOpenDialog(NSDictionary *options) {
+  NSOpenPanel *panel = [NSOpenPanel openPanel];
+  panel.title = AtomJSString(options[@"title"], @"");
+  panel.prompt = AtomJSString(options[@"buttonLabel"], panel.prompt);
+
+  NSArray *properties = [options[@"properties"] isKindOfClass:[NSArray class]] ? options[@"properties"] : @[];
+  panel.allowsMultipleSelection = [properties containsObject:@"multiSelections"];
+  panel.canChooseDirectories = [properties containsObject:@"openDirectory"];
+  panel.canChooseFiles = !panel.canChooseDirectories || [properties containsObject:@"openFile"];
+  panel.canCreateDirectories = [properties containsObject:@"createDirectory"];
+
+  NSString *defaultPath = AtomJSString(options[@"defaultPath"], nil);
+  if (defaultPath.length > 0) {
+    BOOL isDirectory = NO;
+    if ([[NSFileManager defaultManager] fileExistsAtPath:defaultPath isDirectory:&isDirectory]) {
+      panel.directoryURL = [NSURL fileURLWithPath:isDirectory ? defaultPath : [defaultPath stringByDeletingLastPathComponent]];
+    }
+  }
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+  NSArray *extensions = AtomJSAllowedExtensions(options);
+  if (extensions.count > 0) panel.allowedFileTypes = extensions;
+#pragma clang diagnostic pop
+
+  NSModalResponse response = [panel runModal];
+  if (response != NSModalResponseOK) {
+    return @{ @"canceled": @YES, @"filePaths": @[] };
+  }
+
+  NSMutableArray<NSString *> *paths = [NSMutableArray array];
+  for (NSURL *url in panel.URLs) {
+    if (url.path) [paths addObject:url.path];
+  }
+  return @{ @"canceled": @(paths.count == 0), @"filePaths": paths };
+}
+
+static NSDictionary *AtomJSSaveDialog(NSDictionary *options) {
+  NSSavePanel *panel = [NSSavePanel savePanel];
+  panel.title = AtomJSString(options[@"title"], @"");
+  panel.prompt = AtomJSString(options[@"buttonLabel"], panel.prompt);
+  panel.canCreateDirectories = YES;
+
+  NSString *defaultPath = AtomJSString(options[@"defaultPath"], nil);
+  if (defaultPath.length > 0) {
+    panel.directoryURL = [NSURL fileURLWithPath:[defaultPath stringByDeletingLastPathComponent]];
+    panel.nameFieldStringValue = [defaultPath lastPathComponent];
+  }
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+  NSArray *extensions = AtomJSAllowedExtensions(options);
+  if (extensions.count > 0) panel.allowedFileTypes = extensions;
+#pragma clang diagnostic pop
+
+  NSModalResponse response = [panel runModal];
+  if (response != NSModalResponseOK || !panel.URL.path) {
+    return @{ @"canceled": @YES };
+  }
+
+  return @{ @"canceled": @NO, @"filePath": panel.URL.path };
+}
+
+static NSDictionary *AtomJSMessageDialog(NSDictionary *options) {
+  NSAlert *alert = [[NSAlert alloc] init];
+  alert.messageText = AtomJSString(options[@"message"], atomAppName);
+  alert.informativeText = AtomJSString(options[@"detail"], @"");
+
+  NSString *type = AtomJSString(options[@"type"], @"none");
+  if ([type isEqualToString:@"error"]) alert.alertStyle = NSAlertStyleCritical;
+  else if ([type isEqualToString:@"warning"]) alert.alertStyle = NSAlertStyleWarning;
+  else alert.alertStyle = NSAlertStyleInformational;
+
+  NSArray *buttons = [options[@"buttons"] isKindOfClass:[NSArray class]] ? options[@"buttons"] : @[];
+  if (buttons.count == 0) buttons = @[ @"OK" ];
+  for (id button in buttons) {
+    [alert addButtonWithTitle:AtomJSString(button, @"OK")];
+  }
+
+  NSString *checkboxLabel = AtomJSString(options[@"checkboxLabel"], nil);
+  NSButton *checkbox = nil;
+  if (checkboxLabel.length > 0) {
+    checkbox = [NSButton checkboxWithTitle:checkboxLabel target:nil action:nil];
+    checkbox.state = AtomJSBoolean(options[@"checkboxChecked"], NO) ? NSControlStateValueOn : NSControlStateValueOff;
+    alert.accessoryView = checkbox;
+  }
+
+  NSModalResponse response = [alert runModal];
+  NSInteger index = MAX(0, response - NSAlertFirstButtonReturn);
+  return @{
+    @"response": @(index),
+    @"checkboxChecked": @(checkbox && checkbox.state == NSControlStateValueOn)
+  };
+}
+
+static void AtomJSHandleMessage(NSDictionary *message) {
+  NSString *command = AtomJSString(message[@"command"], @"");
+  NSString *requestId = AtomJSString(message[@"requestId"], nil);
+
+  if ([command isEqualToString:@"create"]) {
+    NSNumber *windowId = AtomJSNumber(message[@"windowId"], nil);
+    NSDictionary *config = [message[@"config"] isKindOfClass:[NSDictionary class]] ? message[@"config"] : @{};
+    if (!windowId) return;
+
+    AtomJSWindowController *controller = [[AtomJSWindowController alloc] initWithWindowId:windowId config:config];
+    atomWindows[windowId] = controller;
+    return;
+  }
+
+  if ([command isEqualToString:@"dialog-open"]) {
+    AtomJSRespond(requestId, YES, AtomJSOpenDialog([message[@"options"] isKindOfClass:[NSDictionary class]] ? message[@"options"] : @{}), nil);
+    return;
+  }
+
+  if ([command isEqualToString:@"dialog-save"]) {
+    AtomJSRespond(requestId, YES, AtomJSSaveDialog([message[@"options"] isKindOfClass:[NSDictionary class]] ? message[@"options"] : @{}), nil);
+    return;
+  }
+
+  if ([command isEqualToString:@"dialog-message"]) {
+    AtomJSRespond(requestId, YES, AtomJSMessageDialog([message[@"options"] isKindOfClass:[NSDictionary class]] ? message[@"options"] : @{}), nil);
+    return;
+  }
+
+  if ([command isEqualToString:@"quit"]) {
+    [NSApp terminate:nil];
+    return;
+  }
+
+  AtomJSWindowController *controller = AtomJSController(message);
+  if (!controller) {
+    AtomJSRespond(requestId, NO, nil, @"Unknown AtomJS window.");
+    return;
+  }
+
+  if ([command isEqualToString:@"navigate"]) {
+    [controller navigate:AtomJSString(message[@"url"], @"about:blank")];
+  } else if ([command isEqualToString:@"show"]) {
+    [controller.window makeKeyAndOrderFront:nil];
+    [NSApp activateIgnoringOtherApps:YES];
+  } else if ([command isEqualToString:@"hide"]) {
+    [controller.window orderOut:nil];
+  } else if ([command isEqualToString:@"focus"]) {
+    [controller.window makeKeyAndOrderFront:nil];
+    [NSApp activateIgnoringOtherApps:YES];
+  } else if ([command isEqualToString:@"close"] || [command isEqualToString:@"destroy"]) {
+    [controller.window close];
+  } else if ([command isEqualToString:@"set-title"]) {
+    controller.window.title = AtomJSString(message[@"title"], atomAppName);
+  } else if ([command isEqualToString:@"minimize"]) {
+    [controller.window miniaturize:nil];
+  } else if ([command isEqualToString:@"restore"]) {
+    [controller.window deminiaturize:nil];
+    [controller.window makeKeyAndOrderFront:nil];
+  } else if ([command isEqualToString:@"maximize"]) {
+    if (!controller.window.zoomed) [controller.window zoom:nil];
+  } else if ([command isEqualToString:@"unmaximize"]) {
+    if (controller.window.zoomed) [controller.window zoom:nil];
+  } else if ([command isEqualToString:@"fullscreen"]) {
+    BOOL requested = AtomJSBoolean(message[@"value"], YES);
+    BOOL active = (controller.window.styleMask & NSWindowStyleMaskFullScreen) == NSWindowStyleMaskFullScreen;
+    if (requested != active) [controller.window toggleFullScreen:nil];
+  } else if ([command isEqualToString:@"set-bounds"]) {
+    NSDictionary *bounds = [message[@"bounds"] isKindOfClass:[NSDictionary class]] ? message[@"bounds"] : @{};
+    NSRect frame = controller.window.frame;
+    if ([bounds[@"x"] isKindOfClass:[NSNumber class]]) frame.origin.x = [bounds[@"x"] doubleValue];
+    if ([bounds[@"y"] isKindOfClass:[NSNumber class]]) frame.origin.y = [bounds[@"y"] doubleValue];
+    if ([bounds[@"width"] isKindOfClass:[NSNumber class]]) frame.size.width = MAX(1.0, [bounds[@"width"] doubleValue]);
+    if ([bounds[@"height"] isKindOfClass:[NSNumber class]]) frame.size.height = MAX(1.0, [bounds[@"height"] doubleValue]);
+    [controller.window setFrame:frame display:YES animate:NO];
+  } else {
+    AtomJSRespond(requestId, NO, nil, [NSString stringWithFormat:@"Unsupported AtomJS native command: %@", command]);
+    return;
+  }
+
+  AtomJSRespond(requestId, YES, @{}, nil);
+}
+
+static void AtomJSConsumeInput(void) {
+  dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+    NSFileHandle *input = [NSFileHandle fileHandleWithStandardInput];
+    NSMutableData *buffer = [NSMutableData data];
+
+    while (YES) {
+      @autoreleasepool {
+        NSData *chunk = [input readDataOfLength:4096];
+        if (chunk.length == 0) break;
+        [buffer appendData:chunk];
+
+        while (YES) {
+          const unsigned char *bytes = buffer.bytes;
+          NSUInteger newline = NSNotFound;
+          for (NSUInteger index = 0; index < buffer.length; index += 1) {
+            if (bytes[index] == '\n') {
+              newline = index;
+              break;
+            }
+          }
+
+          if (newline == NSNotFound) break;
+
+          NSData *lineData = [buffer subdataWithRange:NSMakeRange(0, newline)];
+          [buffer replaceBytesInRange:NSMakeRange(0, newline + 1) withBytes:NULL length:0];
+          if (lineData.length == 0) continue;
+
+          NSError *error = nil;
+          id value = [NSJSONSerialization JSONObjectWithData:lineData options:0 error:&error];
+          if (![value isKindOfClass:[NSDictionary class]] || error) continue;
+
+          NSDictionary *message = value;
+          dispatch_async(dispatch_get_main_queue(), ^{
+            AtomJSHandleMessage(message);
+          });
+        }
+      }
+    }
+
+    dispatch_async(dispatch_get_main_queue(), ^{
+      [NSApp terminate:nil];
+    });
+  });
+}
+
+static void AtomJSInstallMenu(void) {
+  NSMenu *mainMenu = [[NSMenu alloc] initWithTitle:@""];
+  NSMenuItem *applicationItem = [[NSMenuItem alloc] initWithTitle:@"" action:nil keyEquivalent:@""];
+  [mainMenu addItem:applicationItem];
+
+  NSMenu *applicationMenu = [[NSMenu alloc] initWithTitle:atomAppName];
+  NSString *quitTitle = [NSString stringWithFormat:@"Quit %@", atomAppName];
+  NSMenuItem *quitItem = [[NSMenuItem alloc]
+    initWithTitle:quitTitle
+    action:@selector(terminate:)
+    keyEquivalent:@"q"];
+  [applicationMenu addItem:quitItem];
+  applicationItem.submenu = applicationMenu;
+  NSApp.mainMenu = mainMenu;
+}
+
+int main(int argc, const char *argv[]) {
+  @autoreleasepool {
+    for (int index = 1; index + 1 < argc; index += 1) {
+      if (strcmp(argv[index], "--app-name") == 0) {
+        atomAppName = [NSString stringWithUTF8String:argv[index + 1]] ?: @"AtomJS App";
+        index += 1;
+      }
+    }
+
+    atomWindows = [NSMutableDictionary dictionary];
+    NSApplication *application = [NSApplication sharedApplication];
+    [application setActivationPolicy:NSApplicationActivationPolicyRegular];
+    AtomJSInstallMenu();
+    AtomJSConsumeInput();
+
+    AtomJSEmit(@{
+      @"type": @"ready",
+      @"pid": @([[NSProcessInfo processInfo] processIdentifier])
+    });
+
+    [application run];
+  }
+
+  return 0;
+}

package/src/runtime/window-host.mjs

@@ -1,7 +1,4 @@
 import fs from 'node:fs';
-import path from 'node:path';
-import { spawn } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
 
 const configPath = process.argv[2];
 if (!configPath) {
@@ -15,80 +12,39 @@ try {
 } catch (error) {
   console.error('Unable to read AtomJS window configuration:', error);
   process.exit(1);
+} finally {
+  fs.rmSync(configPath, { force: true });
 }
 
 if (process.platform === 'darwin') {
-  await runMacOSHost(configPath);
-} else {
-  fs.rmSync(configPath, { force: true });
-  await runNativeBindingHost(config);
+  console.error('AtomJS macOS windows must use the shared native Cocoa host, not the legacy Node window host.');
+  process.exit(1);
 }
 
-async function runMacOSHost(configurationPath) {
-  const runtimeDirectory = path.dirname(fileURLToPath(import.meta.url));
-  const helperPath = path.join(runtimeDirectory, 'macos-window-host.jxa.js');
-  const osascript = '/usr/bin/osascript';
-
-  if (!fs.existsSync(osascript)) {
-    console.error('AtomJS could not find /usr/bin/osascript, required for the pure-JavaScript macOS WKWebView host.');
-    fs.rmSync(configurationPath, { force: true });
-    process.exit(1);
-  }
-
-  const child = spawn(osascript, ['-l', 'JavaScript', helperPath, configurationPath], {
-    cwd: process.cwd(),
-    env: process.env,
-    stdio: ['ignore', 'inherit', 'inherit']
-  });
-
-  const forwardSignal = (signal) => {
-    if (!child.killed) child.kill(signal);
-  };
-  process.once('SIGINT', () => forwardSignal('SIGINT'));
-  process.once('SIGTERM', () => forwardSignal('SIGTERM'));
-  process.once('SIGHUP', () => forwardSignal('SIGHUP'));
-
-  await new Promise((resolve) => {
-    child.once('error', (error) => {
-      console.error('AtomJS macOS WKWebView host failed to start:', error && error.stack ? error.stack : error);
-      process.exitCode = 1;
-      resolve();
-    });
-    child.once('exit', (code, signal) => {
-      if (code !== 0 && signal == null) process.exitCode = code || 1;
-      resolve();
-    });
-  });
-
-  fs.rmSync(configurationPath, { force: true });
+let Webview;
+let SizeHint;
+try {
+  ({ Webview, SizeHint } = await import('webview-nodejs'));
+} catch (error) {
+  console.error('\nAtomJS could not load the system WebView binding.');
+  console.error('Windows and Linux currently require the webview-nodejs package.');
+  console.error('Run `atom doctor`, install the platform prerequisites, then install dependencies again.');
+  console.error(error && error.stack ? error.stack : error);
+  process.exit(1);
 }
 
-async function runNativeBindingHost(runtimeConfig) {
-  let Webview;
-  let SizeHint;
-  try {
-    ({ Webview, SizeHint } = await import('webview-nodejs'));
-  } catch (error) {
-    console.error('\nAtomJS could not load the system WebView binding.');
-    console.error('Windows and Linux currently require the webview-nodejs package.');
-    console.error('Run `atom doctor`, install the platform prerequisites, then install dependencies again.');
-    console.error(error && error.stack ? error.stack : error);
-    process.exit(1);
-  }
-
-  try {
-    const view = new Webview(Boolean(runtimeConfig.debug));
-    view.title(String(runtimeConfig.title || 'AtomJS App'));
-    view.size(
-      Number(runtimeConfig.width || 800),
-      Number(runtimeConfig.height || 600),
-      runtimeConfig.resizable === false ? SizeHint.Fixed : SizeHint.None
-    );
-    view.init(String(runtimeConfig.bridgeScript || ''));
-    view.navigate(String(runtimeConfig.url));
-    view.show();
-  } catch (error) {
-    console.error('AtomJS native window failed:', error && error.stack ? error.stack : error);
-    process.exit(1);
-  }
+try {
+  const view = new Webview(Boolean(config.debug));
+  view.title(String(config.title || 'AtomJS App'));
+  view.size(
+    Number(config.width || 800),
+    Number(config.height || 600),
+    config.resizable === false ? SizeHint.Fixed : SizeHint.None
+  );
+  view.init(String(config.bridgeScript || ''));
+  view.navigate(String(config.url));
+  view.show();
+} catch (error) {
+  console.error('AtomJS native window failed:', error && error.stack ? error.stack : error);
+  process.exit(1);
 }

package/src/web-contents.cjs

@@ -25,12 +25,18 @@ class WebContents extends EventEmitter {
 
   reload() {
     ensureAlive(this.owner);
-    state.bridgeServer.send(this.owner.id, { type: 'system', command: 'reload' });
+    if (!this.owner._sendHostCommand({ command: 'reload' })) {
+      state.bridgeServer.send(this.owner.id, { type: 'system', command: 'reload' });
+    }
   }
 
   loadURL(url) {
     ensureAlive(this.owner);
-    state.bridgeServer.send(this.owner.id, { type: 'system', command: 'navigate', url: String(url) });
+    const value = String(url);
+    this.owner._currentUrl = value;
+    if (!this.owner._sendHostCommand({ command: 'navigate', url: value })) {
+      state.bridgeServer.send(this.owner.id, { type: 'system', command: 'navigate', url: value });
+    }
   }
 
   openDevTools() {