@atom-js-org/runtime 0.4.5-alpha.0 → 0.5.1-alpha.0

package/README.md

@@ -1,17 +1,25 @@
 # @atom-js-org/runtime
 
-The lightweight AtomJS runtime. It uses Node.js for the main process and the operating system WebView for rendering.
+The AtomJS runtime provides an Electron-style main-process API powered by operating-system WebViews.
 
-AtomJS does not install or execute the Electron runtime and does not bundle a private Chromium copy. On Windows, the system WebView is Microsoft Edge WebView2; on macOS it is WKWebView; on Linux it is WebKitGTK through the current native binding.
+```js
+const { app, BrowserWindow } = require('electron');
+
+app.whenReady().then(() => {
+  const main = new BrowserWindow({ width: 1000, height: 700 });
+  const auth = new BrowserWindow({ parent: main, modal: true, width: 520, height: 720 });
+  auth.loadURL('https://example.com/login');
+});
+```
+
+Supported window options include parent/modal relationships, frame and resize controls, always-on-top, opacity, transparency, min/max sizes, taskbar behavior, macOS title-bar styles and traffic-light positioning.
 
-Most applications should import the Electron-compatible alias instead:
+AtomJS does not install or execute Electron and does not bundle a private Chromium copy. Windows uses WebView2, macOS uses WKWebView, and Linux uses WebKitGTK.
+
+Most applications should install the Electron-compatible alias:
 
 ```bash
 npm install electron@npm:@atom-js-org/electron@alpha
 ```
 
-```js
-const { app, BrowserWindow, ipcMain } = require('electron');
-```
-
 Project: https://github.com/Atom-js-org/atom

package/index.d.ts

@@ -5,11 +5,30 @@ import { EventEmitter } from 'node:events';
 export interface BrowserWindowConstructorOptions {
   width?: number;
   height?: number;
+  x?: number;
+  y?: number;
   title?: string;
   show?: boolean;
   resizable?: boolean;
   center?: boolean;
   frame?: boolean;
+  parent?: BrowserWindow;
+  modal?: boolean;
+  alwaysOnTop?: boolean;
+  focusable?: boolean;
+  closable?: boolean;
+  minimizable?: boolean;
+  maximizable?: boolean;
+  fullscreenable?: boolean;
+  skipTaskbar?: boolean;
+  transparent?: boolean;
+  opacity?: number;
+  titleBarStyle?: 'default' | 'hidden' | 'hiddenInset' | 'customButtonsOnHover';
+  trafficLightPosition?: { x: number; y: number };
+  minWidth?: number;
+  minHeight?: number;
+  maxWidth?: number;
+  maxHeight?: number;
   backgroundColor?: string;
   webPreferences?: {
     preload?: string;
@@ -48,6 +67,8 @@ export class BrowserWindow extends EventEmitter {
   isDestroyed(): boolean;
   setTitle(title: string): void;
   getTitle(): string;
+  getParentWindow(): BrowserWindow | null;
+  getChildWindows(): BrowserWindow[];
   setMenu(menu: Menu | null): this;
   getMenu(): Menu | null;
   removeMenu(): void;
@@ -55,6 +76,13 @@ export class BrowserWindow extends EventEmitter {
   isMenuBarVisible(): boolean;
   setAutoHideMenuBar(hide: boolean): void;
   isFullScreen(): boolean;
+  setAlwaysOnTop(flag?: boolean): void;
+  isAlwaysOnTop(): boolean;
+  setOpacity(opacity: number): void;
+  getOpacity(): number;
+  setResizable(flag: boolean): void;
+  isResizable(): boolean;
+  isModal(): boolean;
   setFullScreen(flag: boolean): void;
   maximize(): void;
   unmaximize(): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atom-js-org/runtime",
-  "version": "0.4.5-alpha.0",
+  "version": "0.5.1-alpha.0",
   "description": "Electron-like desktop runtime powered by the operating system WebView.",
   "main": "src/index.cjs",
   "types": "index.d.ts",

package/src/browser-window.cjs

@@ -15,6 +15,14 @@ class BrowserWindow extends EventEmitter {
   constructor(options = {}) {
     super();
     this.id = state.nextWindowId++;
+    const explicitParent = options.parent instanceof BrowserWindow && !options.parent.isDestroyed()
+      ? options.parent
+      : null;
+    const modalParent = !explicitParent && options.modal === true
+      ? BrowserWindow.getFocusedWindow()
+      : null;
+    this._parent = explicitParent || modalParent || null;
+    this._children = new Set();
     this.options = normalizeOptions(options);
     this.webContents = new WebContents(this);
     this._child = null;
@@ -32,12 +40,15 @@ class BrowserWindow extends EventEmitter {
     this._fullScreen = false;
     this._maximized = false;
     this._minimized = false;
+    this._alwaysOnTop = this.options.alwaysOnTop;
+    this._opacity = this.options.opacity;
     this._bounds = {
-      x: 0,
-      y: 0,
+      x: this.options.x == null ? 0 : this.options.x,
+      y: this.options.y == null ? 0 : this.options.y,
       width: this.options.width,
       height: this.options.height
     };
+    if (this._parent) this._parent._children.add(this);
     state.windows.set(this.id, this);
   }
 
@@ -82,12 +93,33 @@ class BrowserWindow extends EventEmitter {
     if (preloadPath) preloadCode = await fs.promises.readFile(path.resolve(preloadPath), 'utf8');
 
     const config = {
+      windowId: this.id,
       title: this.options.title || app.getName(),
       width: this.options.width,
       height: this.options.height,
+      x: this.options.x,
+      y: this.options.y,
       resizable: this.options.resizable,
       center: this.options.center,
       frame: this.options.frame,
+      parentWindowId: this._parent ? this._parent.id : null,
+      parentProcessId: this._parent && this._parent._child ? this._parent._child.pid : null,
+      modal: this.options.modal,
+      alwaysOnTop: this.options.alwaysOnTop,
+      focusable: this.options.focusable,
+      closable: this.options.closable,
+      minimizable: this.options.minimizable,
+      maximizable: this.options.maximizable,
+      fullscreenable: this.options.fullscreenable,
+      skipTaskbar: this.options.skipTaskbar,
+      transparent: this.options.transparent,
+      opacity: this.options.opacity,
+      titleBarStyle: this.options.titleBarStyle,
+      trafficLightPosition: this.options.trafficLightPosition,
+      minWidth: this.options.minWidth,
+      minHeight: this.options.minHeight,
+      maxWidth: this.options.maxWidth,
+      maxHeight: this.options.maxHeight,
       show: this.options.show,
       backgroundColor: this.options.backgroundColor,
       debug: Boolean(this.options.webPreferences.devTools || process.env.ATOM_DEV === '1'),
@@ -124,7 +156,8 @@ class BrowserWindow extends EventEmitter {
     this._child = spawn(nodeExecutable, hostArgs, {
       cwd: state.projectRoot,
       env: process.env,
-      stdio: ['ignore', 'pipe', 'inherit']
+      stdio: ['ignore', 'pipe', 'inherit'],
+      windowsHide: true
     });
     this._hostAttached = true;
     attachHostOutput(this, this._child);
@@ -198,10 +231,12 @@ class BrowserWindow extends EventEmitter {
       return;
     }
     if (event.type === 'focus') {
+      state.focusedWindowId = this.id;
       this.emit('focus');
       return;
     }
     if (event.type === 'blur') {
+      if (state.focusedWindowId === this.id) state.focusedWindowId = null;
       this.emit('blur');
       return;
     }
@@ -266,6 +301,10 @@ class BrowserWindow extends EventEmitter {
     if (this._destroyed) return;
     this._destroyed = true;
     this._hostAttached = false;
+    if (state.focusedWindowId === this.id) state.focusedWindowId = null;
+    if (this._parent) this._parent._children.delete(this);
+    for (const child of this._children) child._parent = null;
+    this._children.clear();
     state.windows.delete(this.id);
     this.emit('closed', details);
     if (state.windows.size === 0 && !state.isQuitting) app.emit('window-all-closed');
@@ -337,6 +376,14 @@ class BrowserWindow extends EventEmitter {
     return this.options.title || app.getName();
   }
 
+  getParentWindow() {
+    return this._parent && !this._parent.isDestroyed() ? this._parent : null;
+  }
+
+  getChildWindows() {
+    return [...this._children].filter((child) => !child.isDestroyed());
+  }
+
   setMenu(menu) {
     this._menu = menu || null;
     return this;
@@ -368,6 +415,49 @@ class BrowserWindow extends EventEmitter {
     return this._fullScreen;
   }
 
+  setAlwaysOnTop(value = true) {
+    this._alwaysOnTop = Boolean(value);
+    this.options.alwaysOnTop = this._alwaysOnTop;
+    if (!this._sendHostCommand({ command: 'set-always-on-top', value: this._alwaysOnTop })) {
+      console.warn('[AtomJS] Changing always-on-top after creation is not supported by the current platform host. Set alwaysOnTop in BrowserWindow options.');
+    }
+  }
+
+  isAlwaysOnTop() {
+    return this._alwaysOnTop;
+  }
+
+  setOpacity(value) {
+    const number = Number(value);
+    if (!Number.isFinite(number) || number < 0 || number > 1) {
+      throw new TypeError('BrowserWindow.setOpacity expects a number between 0 and 1.');
+    }
+    this._opacity = number;
+    this.options.opacity = number;
+    if (!this._sendHostCommand({ command: 'set-opacity', value: number })) {
+      console.warn('[AtomJS] Changing opacity after creation is not supported by the current platform host. Set opacity in BrowserWindow options.');
+    }
+  }
+
+  getOpacity() {
+    return this._opacity;
+  }
+
+  setResizable(value) {
+    this.options.resizable = Boolean(value);
+    if (!this._sendHostCommand({ command: 'set-resizable', value: this.options.resizable })) {
+      console.warn('[AtomJS] Changing resizable after creation is not supported by the current platform host.');
+    }
+  }
+
+  isResizable() {
+    return this.options.resizable;
+  }
+
+  isModal() {
+    return this.options.modal;
+  }
+
   setFullScreen(value = true) {
     this._fullScreen = Boolean(value);
     if (!this._sendHostCommand({ command: 'fullscreen', value: this._fullScreen })) {
@@ -443,6 +533,10 @@ class BrowserWindow extends EventEmitter {
   }
 
   static getFocusedWindow() {
+    if (state.focusedWindowId != null) {
+      const focused = BrowserWindow.fromId(state.focusedWindowId);
+      if (focused && !focused.isDestroyed()) return focused;
+    }
     const windows = BrowserWindow.getAllWindows();
     return windows.length ? windows[windows.length - 1] : null;
   }
@@ -483,9 +577,27 @@ function normalizeOptions(options) {
   return {
     width: finiteOr(options.width, 800),
     height: finiteOr(options.height, 600),
+    x: finiteOrNull(options.x),
+    y: finiteOrNull(options.y),
     title: options.title ? String(options.title) : '',
     show: options.show !== false,
     resizable: options.resizable !== false,
+    modal: options.modal === true,
+    alwaysOnTop: options.alwaysOnTop === true,
+    focusable: options.focusable !== false,
+    closable: options.closable !== false,
+    minimizable: options.minimizable !== false,
+    maximizable: options.maximizable !== false,
+    fullscreenable: options.fullscreenable !== false,
+    skipTaskbar: options.skipTaskbar === true,
+    transparent: options.transparent === true,
+    opacity: clampOpacity(options.opacity),
+    titleBarStyle: normalizeTitleBarStyle(options.titleBarStyle),
+    trafficLightPosition: normalizePoint(options.trafficLightPosition),
+    minWidth: finiteOrZero(options.minWidth),
+    minHeight: finiteOrZero(options.minHeight),
+    maxWidth: finiteOrZero(options.maxWidth),
+    maxHeight: finiteOrZero(options.maxHeight),
     center: options.center !== false,
     frame: options.frame !== false,
     backgroundColor: options.backgroundColor || '#ffffff',
@@ -500,6 +612,38 @@ function normalizeOptions(options) {
   };
 }
 
+function clampOpacity(value) {
+  if (value == null) return 1;
+  const number = Number(value);
+  if (!Number.isFinite(number)) return 1;
+  return Math.min(1, Math.max(0, number));
+}
+
+function finiteOrZero(value) {
+  const number = Number(value);
+  return Number.isFinite(number) && number > 0 ? Math.round(number) : 0;
+}
+
+function finiteOrNull(value) {
+  if (value == null) return null;
+  const number = Number(value);
+  return Number.isFinite(number) ? Math.round(number) : null;
+}
+
+function normalizePoint(value) {
+  if (!value || typeof value !== 'object') return null;
+  const x = Number(value.x);
+  const y = Number(value.y);
+  return Number.isFinite(x) && Number.isFinite(y) ? { x, y } : null;
+}
+
+function normalizeTitleBarStyle(value) {
+  const normalized = String(value || 'default');
+  return ['default', 'hidden', 'hiddenInset', 'customButtonsOnHover'].includes(normalized)
+    ? normalized
+    : 'default';
+}
+
 function finiteOr(value, fallback) {
   const number = Number(value);
   return Number.isFinite(number) && number > 0 ? Math.round(number) : fallback;

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

@@ -70,6 +70,28 @@ static NSColor *AtomJSColor(NSString *hex) {
   return [NSColor colorWithSRGBRed:red green:green blue:blue alpha:alpha];
 }
 
+static void AtomJSConfigureTransparentWebView(WKWebView *webView) {
+  if (!webView) return;
+
+  // `drawsBackground` is not exposed as a public Objective-C property by every
+  // macOS SDK. Use guarded KVC so older SDKs still compile, while retaining the
+  // WebKit behavior needed for genuinely transparent pages.
+  @try {
+    [webView setValue:@NO forKey:@"drawsBackground"];
+  } @catch (__unused NSException *exception) {}
+
+  // Newer WebKit versions expose a public under-page color. Set it through the
+  // Objective-C runtime so the host also compiles against SDKs that predate it.
+  if ([webView respondsToSelector:NSSelectorFromString(@"setUnderPageBackgroundColor:")]) {
+    @try {
+      [webView setValue:[NSColor clearColor] forKey:@"underPageBackgroundColor"];
+    } @catch (__unused NSException *exception) {}
+  }
+
+  webView.wantsLayer = YES;
+  webView.layer.backgroundColor = [NSColor clearColor].CGColor;
+}
+
 static NSImage *AtomJSDefaultApplicationIcon(void) {
   NSSize size = NSMakeSize(512.0, 512.0);
   NSImage *image = [[NSImage alloc] initWithSize:size];
@@ -114,6 +136,8 @@ static void AtomJSConfigureApplicationIdentity(NSApplication *application) {
 @property(nonatomic, strong) NSNumber *windowId;
 @property(nonatomic, strong) NSWindow *window;
 @property(nonatomic, strong) WKWebView *webView;
+@property(nonatomic, weak) AtomJSWindowController *parentController;
+@property(nonatomic, assign) BOOL modal;
 - (instancetype)initWithWindowId:(NSNumber *)windowId config:(NSDictionary *)config;
 - (void)navigate:(NSString *)urlString;
 @end
@@ -130,10 +154,20 @@ static void AtomJSConfigureApplicationIdentity(NSApplication *application) {
   CGFloat height = MAX(240.0, [AtomJSNumber(config[@"height"], @600) doubleValue]);
   NSRect frame = NSMakeRect(0, 0, width, height);
 
-  NSWindowStyleMask style = NSWindowStyleMaskClosable | NSWindowStyleMaskMiniaturizable;
+  NSWindowStyleMask style = 0;
+  if (AtomJSBoolean(config[@"closable"], YES)) style |= NSWindowStyleMaskClosable;
+  if (AtomJSBoolean(config[@"minimizable"], YES)) style |= NSWindowStyleMaskMiniaturizable;
   if (AtomJSBoolean(config[@"frame"], YES)) style |= NSWindowStyleMaskTitled;
   if (AtomJSBoolean(config[@"resizable"], YES)) style |= NSWindowStyleMaskResizable;
 
+  NSString *titleBarStyle = AtomJSString(config[@"titleBarStyle"], @"default");
+  BOOL usesHiddenTitleBar = [titleBarStyle isEqualToString:@"hidden"]
+    || [titleBarStyle isEqualToString:@"hiddenInset"]
+    || [titleBarStyle isEqualToString:@"customButtonsOnHover"];
+  if (usesHiddenTitleBar) {
+    style |= NSWindowStyleMaskFullSizeContentView;
+  }
+
   _window = [[NSWindow alloc]
     initWithContentRect:frame
     styleMask:style
@@ -144,8 +178,41 @@ static void AtomJSConfigureApplicationIdentity(NSApplication *application) {
   _window.title = AtomJSString(config[@"title"], atomAppName);
   _window.backgroundColor = AtomJSColor(config[@"backgroundColor"]);
   _window.tabbingMode = NSWindowTabbingModeDisallowed;
+  _window.alphaValue = MIN(1.0, MAX(0.0, [AtomJSNumber(config[@"opacity"], @1) doubleValue]));
+  _window.opaque = !AtomJSBoolean(config[@"transparent"], NO);
+  if (!_window.opaque) {
+    _window.backgroundColor = [NSColor clearColor];
+  }
+
+  if (usesHiddenTitleBar) {
+    _window.titleVisibility = NSWindowTitleHidden;
+    _window.titlebarAppearsTransparent = YES;
+  }
 
-  if (AtomJSBoolean(config[@"center"], YES)) [_window center];
+  if (!AtomJSBoolean(config[@"fullscreenable"], YES)) {
+    _window.collectionBehavior |= NSWindowCollectionBehaviorFullScreenNone;
+  }
+  [_window standardWindowButton:NSWindowZoomButton].enabled = AtomJSBoolean(config[@"maximizable"], YES);
+  if (AtomJSBoolean(config[@"alwaysOnTop"], NO)) {
+    _window.level = NSFloatingWindowLevel;
+  }
+
+  CGFloat minWidth = [AtomJSNumber(config[@"minWidth"], @0) doubleValue];
+  CGFloat minHeight = [AtomJSNumber(config[@"minHeight"], @0) doubleValue];
+  CGFloat maxWidth = [AtomJSNumber(config[@"maxWidth"], @0) doubleValue];
+  CGFloat maxHeight = [AtomJSNumber(config[@"maxHeight"], @0) doubleValue];
+  if (minWidth > 0 || minHeight > 0) {
+    _window.contentMinSize = NSMakeSize(MAX(1.0, minWidth), MAX(1.0, minHeight));
+  }
+  if (maxWidth > 0 || maxHeight > 0) {
+    _window.contentMaxSize = NSMakeSize(maxWidth > 0 ? maxWidth : CGFLOAT_MAX, maxHeight > 0 ? maxHeight : CGFLOAT_MAX);
+  }
+
+  if ([config[@"x"] isKindOfClass:[NSNumber class]] && [config[@"y"] isKindOfClass:[NSNumber class]]) {
+    [_window setFrameOrigin:NSMakePoint([config[@"x"] doubleValue], [config[@"y"] doubleValue])];
+  } else if (AtomJSBoolean(config[@"center"], YES)) {
+    [_window center];
+  }
 
   WKUserContentController *contentController = [[WKUserContentController alloc] init];
   NSString *bridgeScript = AtomJSString(config[@"bridgeScript"], @"");
@@ -163,14 +230,40 @@ static void AtomJSConfigureApplicationIdentity(NSApplication *application) {
   _webView = [[WKWebView alloc] initWithFrame:frame configuration:webConfiguration];
   _webView.navigationDelegate = self;
   _webView.autoresizingMask = NSViewWidthSizable | NSViewHeightSizable;
+  if (AtomJSBoolean(config[@"transparent"], NO)) AtomJSConfigureTransparentWebView(_webView);
   _window.contentView = _webView;
 
+  NSNumber *parentWindowId = AtomJSNumber(config[@"parentWindowId"], nil);
+  _parentController = parentWindowId ? atomWindows[parentWindowId] : nil;
+  _modal = AtomJSBoolean(config[@"modal"], NO) && _parentController != nil;
+
+  NSDictionary *trafficLightPosition = [config[@"trafficLightPosition"] isKindOfClass:[NSDictionary class]]
+    ? config[@"trafficLightPosition"]
+    : nil;
+  if (trafficLightPosition) {
+    CGFloat x = [AtomJSNumber(trafficLightPosition[@"x"], @0) doubleValue];
+    CGFloat y = [AtomJSNumber(trafficLightPosition[@"y"], @0) doubleValue];
+    NSButton *closeButton = [_window standardWindowButton:NSWindowCloseButton];
+    NSView *container = closeButton.superview;
+    if (container) {
+      NSPoint origin = container.frame.origin;
+      origin.x = x;
+      origin.y = MAX(0.0, _window.frame.size.height - container.frame.size.height - y);
+      [container setFrameOrigin:origin];
+    }
+  }
+
   [self navigate:AtomJSString(config[@"url"], @"about:blank")];
 
   if (AtomJSBoolean(config[@"show"], YES)) {
     [NSApp unhide:nil];
-    [_window makeKeyAndOrderFront:nil];
-    [_window orderFrontRegardless];
+    if (_modal) {
+      [_parentController.window beginSheet:_window completionHandler:nil];
+    } else {
+      if (_parentController) [_parentController.window addChildWindow:_window ordered:NSWindowAbove];
+      [_window makeKeyAndOrderFront:nil];
+      [_window orderFrontRegardless];
+    }
     [NSApp activateIgnoringOtherApps:YES];
   }
 
@@ -226,6 +319,13 @@ static void AtomJSConfigureApplicationIdentity(NSApplication *application) {
 }
 
 - (void)windowWillClose:(NSNotification *)notification {
+  if (self.parentController) {
+    if (self.modal && self.window.sheetParent) {
+      [self.window.sheetParent endSheet:self.window];
+    } else {
+      [self.parentController.window removeChildWindow:self.window];
+    }
+  }
   [atomWindows removeObjectForKey:self.windowId];
   AtomJSEmit(@{
     @"type": @"closed",
@@ -486,6 +586,14 @@ static void AtomJSHandleMessage(NSDictionary *message) {
     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 if ([command isEqualToString:@"set-always-on-top"]) {
+    controller.window.level = AtomJSBoolean(message[@"value"], NO) ? NSFloatingWindowLevel : NSNormalWindowLevel;
+  } else if ([command isEqualToString:@"set-opacity"]) {
+    controller.window.alphaValue = MIN(1.0, MAX(0.0, [AtomJSNumber(message[@"value"], @1) doubleValue]));
+  } else if ([command isEqualToString:@"set-resizable"]) {
+    BOOL requested = AtomJSBoolean(message[@"value"], YES);
+    if (requested) controller.window.styleMask |= NSWindowStyleMaskResizable;
+    else controller.window.styleMask &= ~NSWindowStyleMaskResizable;
   } else {
     AtomJSRespond(requestId, NO, nil, [NSString stringWithFormat:@"Unsupported AtomJS native command: %@", command]);
     return;

package/src/runtime/window-host.mjs

@@ -1,5 +1,7 @@
 import fs from 'node:fs';
+import { spawnSync } from 'node:child_process';
 
+const EVENT_PREFIX = '__ATOMJS_EVENT__';
 const configPath = process.argv[2];
 if (!configPath) {
   console.error('AtomJS window host expected a configuration file');
@@ -33,18 +35,387 @@ try {
   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);
+function emit(event) {
+  process.stdout.write(`${EVENT_PREFIX}${JSON.stringify(event)}\n`);
+}
+
+function configureWindowsWindow(options) {
+  const parentProcessId = Number(options.parentProcessId || 0);
+  const modal = Boolean(options.modal && parentProcessId > 0);
+  const env = {
+    ...process.env,
+    ATOMJS_CHILD_PID: String(process.pid),
+    ATOMJS_PARENT_PID: String(parentProcessId || 0),
+    ATOMJS_MODAL: modal ? '1' : '0',
+    ATOMJS_FRAME: options.frame === false ? '0' : '1',
+    ATOMJS_RESIZABLE: options.resizable === false ? '0' : '1',
+    ATOMJS_MINIMIZABLE: options.minimizable === false ? '0' : '1',
+    ATOMJS_MAXIMIZABLE: options.maximizable === false ? '0' : '1',
+    ATOMJS_CLOSABLE: options.closable === false ? '0' : '1',
+    ATOMJS_ALWAYS_ON_TOP: options.alwaysOnTop ? '1' : '0',
+    ATOMJS_FOCUSABLE: options.focusable === false ? '0' : '1',
+    ATOMJS_SKIP_TASKBAR: options.skipTaskbar ? '1' : '0',
+    ATOMJS_TRANSPARENT: options.transparent ? '1' : '0',
+    ATOMJS_OPACITY: String(normalizeOpacity(options.opacity)),
+    ATOMJS_CENTER: options.center === false ? '0' : '1',
+    ATOMJS_SHOW: options.show === false ? '0' : '1',
+    ATOMJS_X: Number.isFinite(Number(options.x)) ? String(Math.round(Number(options.x))) : '',
+    ATOMJS_Y: Number.isFinite(Number(options.y)) ? String(Math.round(Number(options.y))) : ''
+  };
+
+  const result = spawnSync('powershell.exe', [
+    '-NoLogo',
+    '-NoProfile',
+    '-NonInteractive',
+    '-ExecutionPolicy', 'Bypass',
+    '-Command', WINDOWS_WINDOW_SETUP
+  ], {
+    env,
+    encoding: 'utf8',
+    windowsHide: true,
+    stdio: ['ignore', 'pipe', 'pipe']
+  });
+
+  if (result.error) {
+    console.warn(`[AtomJS] Could not configure the native Windows window: ${result.error.message}`);
+  } else if (result.status !== 0) {
+    const detail = String(result.stderr || result.stdout || '').trim();
+    if (detail) console.warn(`[AtomJS] Could not configure every native Windows option: ${detail}`);
+  }
+
+  return modal ? { parentProcessId } : null;
+}
+
+function releaseWindowsModal(ownership) {
+  if (!ownership || !ownership.parentProcessId) return;
+  const result = spawnSync('powershell.exe', [
+    '-NoLogo',
+    '-NoProfile',
+    '-NonInteractive',
+    '-ExecutionPolicy', 'Bypass',
+    '-Command', WINDOWS_MODAL_RELEASE
+  ], {
+    env: {
+      ...process.env,
+      ATOMJS_PARENT_PID: String(ownership.parentProcessId)
+    },
+    encoding: 'utf8',
+    windowsHide: true,
+    stdio: ['ignore', 'pipe', 'pipe']
+  });
+  if (result.error) {
+    console.warn(`[AtomJS] Could not restore the parent Windows window: ${result.error.message}`);
+  }
 }
+
+function normalizeOpacity(value) {
+  const number = Number(value);
+  if (!Number.isFinite(number)) return 1;
+  return Math.min(1, Math.max(0, number));
+}
+
+const WINDOWS_INTEROP = String.raw`
+Add-Type -TypeDefinition @'
+using System;
+using System.Runtime.InteropServices;
+
+public static class AtomJSNativeWindow {
+  public delegate bool EnumWindowsProc(IntPtr hWnd, IntPtr lParam);
+
+  [DllImport("user32.dll")]
+  public static extern bool EnumWindows(EnumWindowsProc callback, IntPtr lParam);
+
+  [DllImport("user32.dll")]
+  public static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint processId);
+
+  [DllImport("user32.dll")]
+  public static extern IntPtr GetParent(IntPtr hWnd);
+
+  [DllImport("user32.dll", EntryPoint = "GetWindowLongPtr")]
+  private static extern IntPtr GetWindowLongPtr64(IntPtr hWnd, int index);
+
+  [DllImport("user32.dll", EntryPoint = "GetWindowLong")]
+  private static extern IntPtr GetWindowLongPtr32(IntPtr hWnd, int index);
+
+  [DllImport("user32.dll", EntryPoint = "SetWindowLongPtr")]
+  private static extern IntPtr SetWindowLongPtr64(IntPtr hWnd, int index, IntPtr value);
+
+  [DllImport("user32.dll", EntryPoint = "SetWindowLong")]
+  private static extern IntPtr SetWindowLongPtr32(IntPtr hWnd, int index, IntPtr value);
+
+  [DllImport("user32.dll")]
+  public static extern bool SetWindowPos(IntPtr hWnd, IntPtr insertAfter, int x, int y, int cx, int cy, uint flags);
+
+  [DllImport("user32.dll")]
+  public static extern bool SetForegroundWindow(IntPtr hWnd);
+
+  [DllImport("user32.dll")]
+  public static extern IntPtr GetForegroundWindow();
+
+  [DllImport("user32.dll")]
+  public static extern bool AttachThreadInput(uint attachThreadId, uint attachToThreadId, bool attach);
+
+  [DllImport("kernel32.dll")]
+  public static extern uint GetCurrentThreadId();
+
+  [DllImport("user32.dll")]
+  public static extern IntPtr SetActiveWindow(IntPtr hWnd);
+
+  [DllImport("user32.dll")]
+  public static extern IntPtr SetFocus(IntPtr hWnd);
+
+  [DllImport("user32.dll")]
+  public static extern bool BringWindowToTop(IntPtr hWnd);
+
+  [DllImport("user32.dll")]
+  public static extern bool ShowWindow(IntPtr hWnd, int command);
+
+  [DllImport("user32.dll")]
+  public static extern bool EnableWindow(IntPtr hWnd, bool enabled);
+
+  [DllImport("user32.dll")]
+  public static extern bool GetWindowRect(IntPtr hWnd, out RECT rect);
+
+  [DllImport("user32.dll")]
+  public static extern int GetSystemMetrics(int index);
+
+  [DllImport("user32.dll")]
+  public static extern IntPtr GetSystemMenu(IntPtr hWnd, bool revert);
+
+  [DllImport("user32.dll")]
+  public static extern bool DeleteMenu(IntPtr menu, uint position, uint flags);
+
+  [DllImport("user32.dll")]
+  public static extern bool DrawMenuBar(IntPtr hWnd);
+
+  [DllImport("user32.dll")]
+  public static extern bool SetLayeredWindowAttributes(IntPtr hWnd, uint colorKey, byte alpha, uint flags);
+
+  [StructLayout(LayoutKind.Sequential)]
+  public struct RECT { public int Left; public int Top; public int Right; public int Bottom; }
+
+  public static IntPtr GetWindowLongPtr(IntPtr hWnd, int index) {
+    return IntPtr.Size == 8 ? GetWindowLongPtr64(hWnd, index) : GetWindowLongPtr32(hWnd, index);
+  }
+
+  public static IntPtr SetWindowLongPtr(IntPtr hWnd, int index, IntPtr value) {
+    return IntPtr.Size == 8 ? SetWindowLongPtr64(hWnd, index, value) : SetWindowLongPtr32(hWnd, index, value);
+  }
+
+  public static IntPtr FindWindowForProcess(uint expectedProcessId) {
+    IntPtr result = IntPtr.Zero;
+    EnumWindows((window, state) => {
+      uint processId;
+      GetWindowThreadProcessId(window, out processId);
+      if (processId == expectedProcessId && GetParent(window) == IntPtr.Zero) {
+        result = window;
+        return false;
+      }
+      return true;
+    }, IntPtr.Zero);
+    return result;
+  }
+}
+'@
+
+function Find-AtomWindow([uint32] $ProcessId) {
+  for ($attempt = 0; $attempt -lt 50; $attempt += 1) {
+    $window = [AtomJSNativeWindow]::FindWindowForProcess($ProcessId)
+    if ($window -ne [IntPtr]::Zero) { return $window }
+    Start-Sleep -Milliseconds 40
+  }
+  return [IntPtr]::Zero
+}
+`;
+
+const WINDOWS_WINDOW_SETUP = WINDOWS_INTEROP + String.raw`
+$child = Find-AtomWindow ([uint32]$env:ATOMJS_CHILD_PID)
+if ($child -eq [IntPtr]::Zero) { throw 'The AtomJS WebView window handle was not found.' }
+
+$GWL_STYLE = -16
+$GWL_EXSTYLE = -20
+$GWLP_HWNDPARENT = -8
+$WS_CAPTION = 0x00C00000L
+$WS_THICKFRAME = 0x00040000L
+$WS_MINIMIZEBOX = 0x00020000L
+$WS_MAXIMIZEBOX = 0x00010000L
+$WS_EX_TOOLWINDOW = 0x00000080L
+$WS_EX_APPWINDOW = 0x00040000L
+$WS_EX_LAYERED = 0x00080000L
+$WS_EX_NOACTIVATE = 0x08000000L
+$SWP_NOSIZE = 0x0001
+$SWP_NOMOVE = 0x0002
+$SWP_NOACTIVATE = 0x0010
+$SWP_FRAMECHANGED = 0x0020
+$SWP_SHOWWINDOW = 0x0040
+$SC_CLOSE = 0xF060
+$MF_BYCOMMAND = 0x0000
+$LWA_ALPHA = 0x00000002
+
+$style = [AtomJSNativeWindow]::GetWindowLongPtr($child, $GWL_STYLE).ToInt64()
+if ($env:ATOMJS_FRAME -eq '0') { $style = $style -band (-bnot ($WS_CAPTION -bor $WS_THICKFRAME)) }
+if ($env:ATOMJS_RESIZABLE -eq '0') { $style = $style -band (-bnot $WS_THICKFRAME) }
+if ($env:ATOMJS_MINIMIZABLE -eq '0') { $style = $style -band (-bnot $WS_MINIMIZEBOX) }
+if ($env:ATOMJS_MAXIMIZABLE -eq '0') { $style = $style -band (-bnot $WS_MAXIMIZEBOX) }
+[void][AtomJSNativeWindow]::SetWindowLongPtr($child, $GWL_STYLE, [IntPtr]$style)
+
+$extendedStyle = [AtomJSNativeWindow]::GetWindowLongPtr($child, $GWL_EXSTYLE).ToInt64()
+if ($env:ATOMJS_SKIP_TASKBAR -eq '1') {
+  $extendedStyle = ($extendedStyle -bor $WS_EX_TOOLWINDOW) -band (-bnot $WS_EX_APPWINDOW)
+}
+if ($env:ATOMJS_FOCUSABLE -eq '0') {
+  $extendedStyle = $extendedStyle -bor $WS_EX_NOACTIVATE
+} else {
+  $extendedStyle = $extendedStyle -band (-bnot $WS_EX_NOACTIVATE)
+}
+$opacity = [Math]::Max(0.0, [Math]::Min(1.0, [double]$env:ATOMJS_OPACITY))
+if ($env:ATOMJS_TRANSPARENT -eq '1' -or $opacity -lt 1.0) {
+  $extendedStyle = $extendedStyle -bor $WS_EX_LAYERED
+}
+[void][AtomJSNativeWindow]::SetWindowLongPtr($child, $GWL_EXSTYLE, [IntPtr]$extendedStyle)
+
+if ($env:ATOMJS_CLOSABLE -eq '0') {
+  $menu = [AtomJSNativeWindow]::GetSystemMenu($child, $false)
+  if ($menu -ne [IntPtr]::Zero) {
+    [void][AtomJSNativeWindow]::DeleteMenu($menu, $SC_CLOSE, $MF_BYCOMMAND)
+    [void][AtomJSNativeWindow]::DrawMenuBar($child)
+  }
+}
+
+$alpha = [byte][Math]::Round($opacity * 255.0)
+if ($env:ATOMJS_TRANSPARENT -eq '1' -or $opacity -lt 1.0) {
+  [void][AtomJSNativeWindow]::SetLayeredWindowAttributes($child, 0, $alpha, $LWA_ALPHA)
+}
+
+$parent = [IntPtr]::Zero
+if ([uint32]$env:ATOMJS_PARENT_PID -gt 0) {
+  $parent = Find-AtomWindow ([uint32]$env:ATOMJS_PARENT_PID)
+  if ($parent -ne [IntPtr]::Zero) {
+    [void][AtomJSNativeWindow]::SetWindowLongPtr($child, $GWLP_HWNDPARENT, $parent)
+    if ($env:ATOMJS_MODAL -eq '1') { [void][AtomJSNativeWindow]::EnableWindow($parent, $false) }
+  }
+}
+
+$rect = New-Object AtomJSNativeWindow+RECT
+[void][AtomJSNativeWindow]::GetWindowRect($child, [ref]$rect)
+$width = $rect.Right - $rect.Left
+$height = $rect.Bottom - $rect.Top
+$x = $rect.Left
+$y = $rect.Top
+if ($env:ATOMJS_CENTER -eq '1' -and $parent -ne [IntPtr]::Zero) {
+  $parentRect = New-Object AtomJSNativeWindow+RECT
+  [void][AtomJSNativeWindow]::GetWindowRect($parent, [ref]$parentRect)
+  $x = $parentRect.Left + [Math]::Max(0, (($parentRect.Right - $parentRect.Left) - $width) / 2)
+  $y = $parentRect.Top + [Math]::Max(0, (($parentRect.Bottom - $parentRect.Top) - $height) / 2)
+} elseif ($env:ATOMJS_CENTER -eq '1') {
+  $x = [Math]::Max(0, ([AtomJSNativeWindow]::GetSystemMetrics(0) - $width) / 2)
+  $y = [Math]::Max(0, ([AtomJSNativeWindow]::GetSystemMetrics(1) - $height) / 2)
+}
+if ($env:ATOMJS_X -ne '') { $x = [int]$env:ATOMJS_X }
+if ($env:ATOMJS_Y -ne '') { $y = [int]$env:ATOMJS_Y }
+
+$insertAfter = if ($env:ATOMJS_ALWAYS_ON_TOP -eq '1') { [IntPtr](-1) } else { [IntPtr]::Zero }
+$positionFlags = $SWP_FRAMECHANGED
+if ($env:ATOMJS_SHOW -ne '0') { $positionFlags = $positionFlags -bor $SWP_SHOWWINDOW }
+[void][AtomJSNativeWindow]::SetWindowPos($child, $insertAfter, [int]$x, [int]$y, $width, $height, $positionFlags)
+if ($env:ATOMJS_SHOW -eq '0') {
+  [void][AtomJSNativeWindow]::ShowWindow($child, 0)
+} else {
+  [void][AtomJSNativeWindow]::ShowWindow($child, 5)
+  [void][AtomJSNativeWindow]::BringWindowToTop($child)
+}
+if ($env:ATOMJS_SHOW -ne '0' -and $env:ATOMJS_FOCUSABLE -ne '0') {
+  # WebView windows live in helper processes. Temporarily attach the setup
+  # thread to the foreground and WebView UI threads so Windows accepts the
+  # activation request instead of leaving OAuth/login windows behind the app.
+  $foreground = [AtomJSNativeWindow]::GetForegroundWindow()
+  [uint32]$foregroundProcess = 0
+  [uint32]$childProcess = 0
+  $foregroundThread = if ($foreground -ne [IntPtr]::Zero) {
+    [AtomJSNativeWindow]::GetWindowThreadProcessId($foreground, [ref]$foregroundProcess)
+  } else { 0 }
+  $childThread = [AtomJSNativeWindow]::GetWindowThreadProcessId($child, [ref]$childProcess)
+  $currentThread = [AtomJSNativeWindow]::GetCurrentThreadId()
+  $attachedForeground = $false
+  $attachedChild = $false
+
+  try {
+    if ($foregroundThread -ne 0 -and $foregroundThread -ne $currentThread) {
+      $attachedForeground = [AtomJSNativeWindow]::AttachThreadInput($currentThread, $foregroundThread, $true)
+    }
+    if ($childThread -ne 0 -and $childThread -ne $currentThread) {
+      $attachedChild = [AtomJSNativeWindow]::AttachThreadInput($currentThread, $childThread, $true)
+    }
+    [void][AtomJSNativeWindow]::BringWindowToTop($child)
+    [void][AtomJSNativeWindow]::SetActiveWindow($child)
+    [void][AtomJSNativeWindow]::SetForegroundWindow($child)
+    [void][AtomJSNativeWindow]::SetFocus($child)
+  } finally {
+    if ($attachedChild) {
+      [void][AtomJSNativeWindow]::AttachThreadInput($currentThread, $childThread, $false)
+    }
+    if ($attachedForeground) {
+      [void][AtomJSNativeWindow]::AttachThreadInput($currentThread, $foregroundThread, $false)
+    }
+  }
+}
+`;
+
+const WINDOWS_MODAL_RELEASE = WINDOWS_INTEROP + String.raw`
+$parent = Find-AtomWindow ([uint32]$env:ATOMJS_PARENT_PID)
+if ($parent -ne [IntPtr]::Zero) {
+  [void][AtomJSNativeWindow]::EnableWindow($parent, $true)
+  [void][AtomJSNativeWindow]::ShowWindow($parent, 5)
+  [void][AtomJSNativeWindow]::BringWindowToTop($parent)
+  [void][AtomJSNativeWindow]::SetForegroundWindow($parent)
+}
+`;
+
+async function main() {
+  let view = null;
+  let windowsOwnership = null;
+  try {
+    view = new Webview(Boolean(config.debug));
+    view.title(String(config.title || 'AtomJS App'));
+
+    const width = Number(config.width || 800);
+    const height = Number(config.height || 600);
+    view.size(
+      width,
+      height,
+      config.resizable === false ? SizeHint.Fixed : SizeHint.None
+    );
+
+    if (Number(config.minWidth) > 0 || Number(config.minHeight) > 0) {
+      view.size(
+        Number(config.minWidth) > 0 ? Number(config.minWidth) : width,
+        Number(config.minHeight) > 0 ? Number(config.minHeight) : height,
+        SizeHint.Min
+      );
+    }
+    if (Number(config.maxWidth) > 0 || Number(config.maxHeight) > 0) {
+      view.size(
+        Number(config.maxWidth) > 0 ? Number(config.maxWidth) : width,
+        Number(config.maxHeight) > 0 ? Number(config.maxHeight) : height,
+        SizeHint.Max
+      );
+    }
+
+    view.init(String(config.bridgeScript || ''));
+    view.navigate(String(config.url));
+
+    if (process.platform === 'win32') {
+      windowsOwnership = configureWindowsWindow(config);
+    }
+
+    emit({ type: 'created', windowId: Number(config.windowId || 0), pid: process.pid });
+    view.show();
+  } catch (error) {
+    console.error('AtomJS native window failed:', error && error.stack ? error.stack : error);
+    process.exitCode = 1;
+  } finally {
+    if (process.platform === 'win32') releaseWindowsModal(windowsOwnership);
+  }
+}
+
+await main();

package/src/state.cjs

@@ -6,6 +6,7 @@ module.exports = {
   windows,
   bridgeServer: null,
   nextWindowId: 1,
+  focusedWindowId: null,
   projectRoot: process.env.ATOM_PROJECT_ROOT || process.cwd(),
   isQuitting: false
 };