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

package/index.d.ts

@@ -61,6 +61,7 @@ export class BrowserWindow extends EventEmitter {
   hide(): void;
   isVisible(): boolean;
   focus(): void;
+  startDrag(): void;
   blur(): void;
   close(): void;
   destroy(): void;

package/package.json

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

package/src/bridge-script.cjs

@@ -39,6 +39,252 @@ function generateBridgeScript({ websocketUrl, preloadCode = '' }) {
     }
   }
 
+  function normalizeAppRegion(value) {
+    const normalized = String(value || '').trim().toLowerCase();
+    return normalized === 'drag' || normalized === 'no-drag' ? normalized : '';
+  }
+
+  function appRegionForElement(element) {
+    if (!(element instanceof Element)) return '';
+    if (element.hasAttribute('data-atom-no-drag')) return 'no-drag';
+    if (element.hasAttribute('data-atom-drag-region')) return 'drag';
+
+    const attribute = normalizeAppRegion(
+      element.getAttribute('data-atom-app-region') || element.getAttribute('data-app-region')
+    );
+    if (attribute) return attribute;
+
+    const inline = normalizeAppRegion(
+      element.style && (
+        element.style.getPropertyValue('-webkit-app-region') ||
+        element.style.getPropertyValue('app-region') ||
+        element.style.getPropertyValue('--atom-app-region')
+      )
+    );
+    if (inline) return inline;
+
+    try {
+      const computed = getComputedStyle(element);
+      return normalizeAppRegion(
+        computed.getPropertyValue('-webkit-app-region') ||
+        computed.getPropertyValue('app-region') ||
+        computed.getPropertyValue('--atom-app-region')
+      );
+    } catch {
+      return '';
+    }
+  }
+
+  function collectStylesheetAppRegions() {
+    const regions = new Map();
+
+    function visitRules(rules) {
+      for (const rule of rules || []) {
+        if (rule && rule.cssRules) {
+          visitRules(rule.cssRules);
+          continue;
+        }
+        if (!rule || !rule.selectorText || !rule.style) continue;
+
+        const match = String(rule.cssText || '').match(
+          /(?:-webkit-app-region|app-region)\s*:\s*(drag|no-drag)/i
+        );
+        const region = normalizeAppRegion(
+          rule.style.getPropertyValue('-webkit-app-region') ||
+          rule.style.getPropertyValue('app-region') ||
+          rule.style.getPropertyValue('--atom-app-region') ||
+          (match && match[1])
+        );
+        if (!region) continue;
+
+        try {
+          for (const element of document.querySelectorAll(rule.selectorText)) {
+            regions.set(element, region);
+          }
+        } catch {}
+      }
+    }
+
+    for (const sheet of document.styleSheets || []) {
+      try {
+        visitRules(sheet.cssRules);
+      } catch {}
+    }
+
+    return regions;
+  }
+
+  function composedParent(element) {
+    if (!(element instanceof Element)) return null;
+    if (element.assignedSlot) return element.assignedSlot;
+    if (element.parentElement) return element.parentElement;
+    const root = element.getRootNode && element.getRootNode();
+    return root && root.host instanceof Element ? root.host : null;
+  }
+
+  function isInteractiveElement(element) {
+    return element instanceof Element && element.matches(
+      'button, input, textarea, select, option, a[href], [contenteditable=""], [contenteditable="true"], [role="button"]'
+    );
+  }
+
+  function hasDraggableAncestor(element) {
+    let current = composedParent(element);
+    while (current) {
+      const region = appRegionForElement(current);
+      if (region === 'no-drag') return false;
+      if (region === 'drag') return true;
+      current = composedParent(current);
+    }
+    return false;
+  }
+
+  const observedDragRoots = new WeakSet();
+  let dragRegionObserver = null;
+  let dragRegionFrame = 0;
+  let lastDragRegionPayload = '';
+
+  function observeDragRoot(root) {
+    if (!dragRegionObserver || !root || observedDragRoots.has(root)) return;
+    observedDragRoots.add(root);
+    dragRegionObserver.observe(root, {
+      attributes: true,
+      childList: true,
+      subtree: true,
+      attributeFilter: [
+        'class',
+        'style',
+        'hidden',
+        'data-atom-drag-region',
+        'data-atom-no-drag',
+        'data-atom-app-region',
+        'data-app-region'
+      ]
+    });
+  }
+
+  function walkRegionElements(root, visitor) {
+    const stack = [];
+    if (root && root.documentElement instanceof Element) {
+      stack.push(root.documentElement);
+    } else if (root && root.children) {
+      for (let index = root.children.length - 1; index >= 0; index -= 1) {
+        stack.push(root.children[index]);
+      }
+    }
+
+    while (stack.length > 0) {
+      const element = stack.pop();
+      if (!(element instanceof Element)) continue;
+      visitor(element);
+
+      if (element.shadowRoot) {
+        observeDragRoot(element.shadowRoot);
+        for (let index = element.shadowRoot.children.length - 1; index >= 0; index -= 1) {
+          stack.push(element.shadowRoot.children[index]);
+        }
+      }
+
+      for (let index = element.children.length - 1; index >= 0; index -= 1) {
+        stack.push(element.children[index]);
+      }
+    }
+  }
+
+  function roundedRegionNumber(value) {
+    return Math.round(Number(value) * 4) / 4;
+  }
+
+  function collectWindowDragRegions() {
+    const regions = [];
+    const stylesheetRegions = collectStylesheetAppRegions();
+    const viewportWidth = Math.max(0, Number(window.innerWidth) || 0);
+    const viewportHeight = Math.max(0, Number(window.innerHeight) || 0);
+
+    walkRegionElements(document, (element) => {
+      let region = appRegionForElement(element) || stylesheetRegions.get(element) || '';
+      if (!region && isInteractiveElement(element) && hasDraggableAncestor(element)) {
+        region = 'no-drag';
+      }
+      if (!region) return;
+
+      let style;
+      try {
+        style = getComputedStyle(element);
+      } catch {
+        return;
+      }
+      if (style.display === 'none' || style.visibility === 'hidden') return;
+
+      const rect = element.getBoundingClientRect();
+      const left = Math.max(0, Math.min(viewportWidth, rect.left));
+      const top = Math.max(0, Math.min(viewportHeight, rect.top));
+      const right = Math.max(0, Math.min(viewportWidth, rect.right));
+      const bottom = Math.max(0, Math.min(viewportHeight, rect.bottom));
+      const width = right - left;
+      const height = bottom - top;
+      if (width <= 0 || height <= 0) return;
+
+      regions.push({
+        x: roundedRegionNumber(left),
+        y: roundedRegionNumber(top),
+        width: roundedRegionNumber(width),
+        height: roundedRegionNumber(height),
+        draggable: region === 'drag'
+      });
+    });
+
+    return {
+      type: 'system',
+      command: 'set-window-drag-regions',
+      viewport: {
+        width: roundedRegionNumber(viewportWidth),
+        height: roundedRegionNumber(viewportHeight)
+      },
+      deviceScaleFactor: Number(window.devicePixelRatio) || 1,
+      regions
+    };
+  }
+
+  function publishWindowDragRegions() {
+    dragRegionFrame = 0;
+    const payload = collectWindowDragRegions();
+    const serialized = JSON.stringify(payload);
+    if (serialized === lastDragRegionPayload) return;
+    lastDragRegionPayload = serialized;
+    sendNow(payload);
+  }
+
+  function scheduleWindowDragRegionUpdate() {
+    if (dragRegionFrame) return;
+    dragRegionFrame = requestAnimationFrame(publishWindowDragRegions);
+  }
+
+  function activateWindowDragRegions() {
+    observeDragRoot(document.documentElement);
+    scheduleWindowDragRegionUpdate();
+
+    if (typeof ResizeObserver === 'function') {
+      const resizeObserver = new ResizeObserver(scheduleWindowDragRegionUpdate);
+      resizeObserver.observe(document.documentElement);
+      if (document.body) resizeObserver.observe(document.body);
+    }
+  }
+
+  dragRegionObserver = new MutationObserver(scheduleWindowDragRegionUpdate);
+  window.addEventListener('resize', scheduleWindowDragRegionUpdate, { passive: true });
+  window.addEventListener('scroll', scheduleWindowDragRegionUpdate, { capture: true, passive: true });
+  window.addEventListener('transitionend', scheduleWindowDragRegionUpdate, true);
+  window.addEventListener('animationend', scheduleWindowDragRegionUpdate, true);
+  window.addEventListener('load', scheduleWindowDragRegionUpdate, { once: true });
+  document.addEventListener('load', scheduleWindowDragRegionUpdate, true);
+
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', activateWindowDragRegions, { once: true });
+  } else {
+    activateWindowDragRegions();
+  }
+
   function makeEvent(channel) {
     return Object.freeze({
       channel,

package/src/bridge-server.cjs

@@ -163,6 +163,15 @@ class BridgeServer {
       return;
     }
 
+    if (message.type === 'system') {
+      if (message.command === 'start-window-drag') {
+        win._startNativeDrag();
+      } else if (message.command === 'set-window-drag-regions') {
+        win._setNativeDragRegions(message.regions, message.viewport);
+      }
+      return;
+    }
+
     if (message.type === 'send') {
       const event = createIpcEvent(win);
       ipcMain.emit(message.channel, event, ...(Array.isArray(message.args) ? message.args : []));

package/src/browser-window.cjs

@@ -219,6 +219,44 @@ class BrowserWindow extends EventEmitter {
     return false;
   }
 
+  _startNativeDrag() {
+    if (this._destroyed) return false;
+    return this._sendHostCommand({ command: 'start-drag' });
+  }
+
+  _setNativeDragRegions(regions, viewport) {
+    if (this._destroyed) return false;
+
+    const normalizedRegions = [];
+    for (const region of Array.isArray(regions) ? regions.slice(0, 4096) : []) {
+      const x = Number(region && region.x);
+      const y = Number(region && region.y);
+      const width = Number(region && region.width);
+      const height = Number(region && region.height);
+      if (![x, y, width, height].every(Number.isFinite) || width <= 0 || height <= 0) continue;
+      normalizedRegions.push({
+        x,
+        y,
+        width,
+        height,
+        draggable: region.draggable === true
+      });
+    }
+
+    const viewportWidth = Number(viewport && viewport.width);
+    const viewportHeight = Number(viewport && viewport.height);
+    const normalizedViewport = {
+      width: Number.isFinite(viewportWidth) && viewportWidth > 0 ? viewportWidth : this._bounds.width,
+      height: Number.isFinite(viewportHeight) && viewportHeight > 0 ? viewportHeight : this._bounds.height
+    };
+
+    return this._sendHostCommand({
+      command: 'set-drag-regions',
+      regions: normalizedRegions,
+      viewport: normalizedViewport
+    });
+  }
+
   _markRendererReady(details) {
     this._notifyDidFinishLoad(details && details.href ? details.href : this._currentUrl, 'bridge');
   }
@@ -240,6 +278,16 @@ class BrowserWindow extends EventEmitter {
       this.emit('blur');
       return;
     }
+    if (event.type === 'bounds-changed') {
+      const bounds = event.bounds && typeof event.bounds === 'object' ? event.bounds : {};
+      for (const key of ['x', 'y', 'width', 'height']) {
+        const value = Number(bounds[key]);
+        if (Number.isFinite(value)) this._bounds[key] = value;
+      }
+      if (event.reason === 'move') this.emit('move');
+      if (event.reason === 'resize') this.emit('resize');
+      return;
+    }
     if (event.type === 'minimize') {
       this._minimized = true;
       this.emit('minimize');
@@ -334,6 +382,12 @@ class BrowserWindow extends EventEmitter {
     }
   }
 
+  startDrag() {
+    if (!this._startNativeDrag()) {
+      console.warn('[AtomJS] Native window dragging is not supported by the current platform host.');
+    }
+  }
+
   blur() {}
 
   close() {

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

@@ -70,6 +70,51 @@ static NSColor *AtomJSColor(NSString *hex) {
   return [NSColor colorWithSRGBRed:red green:green blue:blue alpha:alpha];
 }
 
+static NSRect AtomJSVirtualDesktopFrame(void) {
+  NSArray<NSScreen *> *screens = [NSScreen screens];
+  if (screens.count == 0) {
+    NSScreen *mainScreen = [NSScreen mainScreen];
+    return mainScreen ? mainScreen.frame : NSZeroRect;
+  }
+
+  NSRect frame = screens.firstObject.frame;
+  for (NSUInteger index = 1; index < screens.count; index += 1) {
+    NSScreen *screen = screens[index];
+    frame = NSUnionRect(frame, screen.frame);
+  }
+  return frame;
+}
+
+static NSRect AtomJSCocoaFrameFromAtomBounds(NSDictionary *bounds, NSRect fallback) {
+  NSRect virtualDesktop = AtomJSVirtualDesktopFrame();
+  CGFloat width = MAX(1.0, [AtomJSNumber(bounds[@"width"], @(fallback.size.width)) doubleValue]);
+  CGFloat height = MAX(1.0, [AtomJSNumber(bounds[@"height"], @(fallback.size.height)) doubleValue]);
+  CGFloat defaultX = fallback.origin.x - NSMinX(virtualDesktop);
+  CGFloat defaultY = NSMaxY(virtualDesktop) - NSMaxY(fallback);
+  CGFloat atomX = [AtomJSNumber(bounds[@"x"], @(defaultX)) doubleValue];
+  CGFloat atomY = [AtomJSNumber(bounds[@"y"], @(defaultY)) doubleValue];
+
+  return NSMakeRect(
+    NSMinX(virtualDesktop) + atomX,
+    NSMaxY(virtualDesktop) - atomY - height,
+    width,
+    height
+  );
+}
+
+static NSDictionary *AtomJSAtomBoundsFromWindow(NSWindow *window) {
+  if (!window) return @{ @"x": @0, @"y": @0, @"width": @0, @"height": @0 };
+
+  NSRect virtualDesktop = AtomJSVirtualDesktopFrame();
+  NSRect frame = window.frame;
+  return @{
+    @"x": @(frame.origin.x - NSMinX(virtualDesktop)),
+    @"y": @(NSMaxY(virtualDesktop) - NSMaxY(frame)),
+    @"width": @(frame.size.width),
+    @"height": @(frame.size.height)
+  };
+}
+
 static void AtomJSConfigureTransparentWebView(WKWebView *webView) {
   if (!webView) return;
 
@@ -132,14 +177,129 @@ static void AtomJSConfigureApplicationIdentity(NSApplication *application) {
   application.applicationIconImage = icon ?: AtomJSDefaultApplicationIcon();
 }
 
+@interface AtomJSDraggableContentView : NSView
+@property(nonatomic, strong) WKWebView *webView;
+@property(nonatomic, copy) NSArray<NSDictionary *> *dragRegions;
+@property(nonatomic, assign) NSSize viewportSize;
+- (instancetype)initWithFrame:(NSRect)frame webView:(WKWebView *)webView;
+- (void)updateDragRegions:(NSArray *)regions viewport:(NSDictionary *)viewport;
+@end
+
+@implementation AtomJSDraggableContentView
+
+- (instancetype)initWithFrame:(NSRect)frame webView:(WKWebView *)webView {
+  self = [super initWithFrame:frame];
+  if (!self) return nil;
+
+  _webView = webView;
+  _dragRegions = @[];
+  _viewportSize = frame.size;
+  self.autoresizesSubviews = YES;
+  webView.frame = self.bounds;
+  webView.autoresizingMask = NSViewWidthSizable | NSViewHeightSizable;
+  [self addSubview:webView];
+  return self;
+}
+
+- (BOOL)isFlipped {
+  return YES;
+}
+
+- (void)layout {
+  [super layout];
+  self.webView.frame = self.bounds;
+}
+
+- (void)updateDragRegions:(NSArray *)regions viewport:(NSDictionary *)viewport {
+  NSMutableArray<NSDictionary *> *normalized = [NSMutableArray array];
+  for (id value in [regions isKindOfClass:[NSArray class]] ? regions : @[]) {
+    if (![value isKindOfClass:[NSDictionary class]]) continue;
+    NSDictionary *region = value;
+    NSNumber *x = AtomJSNumber(region[@"x"], nil);
+    NSNumber *y = AtomJSNumber(region[@"y"], nil);
+    NSNumber *width = AtomJSNumber(region[@"width"], nil);
+    NSNumber *height = AtomJSNumber(region[@"height"], nil);
+    if (!x || !y || !width || !height || width.doubleValue <= 0 || height.doubleValue <= 0) continue;
+
+    [normalized addObject:@{
+      @"x": x,
+      @"y": y,
+      @"width": width,
+      @"height": height,
+      @"draggable": @(AtomJSBoolean(region[@"draggable"], NO))
+    }];
+    if (normalized.count >= 4096) break;
+  }
+
+  CGFloat viewportWidth = [AtomJSNumber(viewport[@"width"], @(self.bounds.size.width)) doubleValue];
+  CGFloat viewportHeight = [AtomJSNumber(viewport[@"height"], @(self.bounds.size.height)) doubleValue];
+  self.viewportSize = NSMakeSize(
+    viewportWidth > 0 ? viewportWidth : self.bounds.size.width,
+    viewportHeight > 0 ? viewportHeight : self.bounds.size.height
+  );
+  self.dragRegions = normalized;
+}
+
+- (BOOL)isDraggablePoint:(NSPoint)point {
+  CGFloat scaleX = self.viewportSize.width > 0 ? self.bounds.size.width / self.viewportSize.width : 1.0;
+  CGFloat scaleY = self.viewportSize.height > 0 ? self.bounds.size.height / self.viewportSize.height : 1.0;
+  BOOL draggable = NO;
+
+  for (NSDictionary *region in self.dragRegions) {
+    NSRect rect = NSMakeRect(
+      [AtomJSNumber(region[@"x"], @0) doubleValue] * scaleX,
+      [AtomJSNumber(region[@"y"], @0) doubleValue] * scaleY,
+      [AtomJSNumber(region[@"width"], @0) doubleValue] * scaleX,
+      [AtomJSNumber(region[@"height"], @0) doubleValue] * scaleY
+    );
+    if (!NSPointInRect(point, rect)) continue;
+    if (!AtomJSBoolean(region[@"draggable"], NO)) return NO;
+    draggable = YES;
+  }
+
+  return draggable;
+}
+
+- (NSView *)hitTest:(NSPoint)point {
+  if ([self isDraggablePoint:point]) return self;
+  return [super hitTest:point];
+}
+
+- (BOOL)acceptsFirstMouse:(NSEvent *)event {
+  return YES;
+}
+
+- (void)mouseDown:(NSEvent *)event {
+  if (!self.window || event.buttonNumber != 0) {
+    [super mouseDown:event];
+    return;
+  }
+
+  if (event.clickCount == 2) {
+    NSButton *zoomButton = [self.window standardWindowButton:NSWindowZoomButton];
+    if (zoomButton.enabled) {
+      [self.window zoom:nil];
+      return;
+    }
+  }
+
+  [self.window performWindowDragWithEvent:event];
+}
+
+@end
+
 @interface AtomJSWindowController : NSObject <NSWindowDelegate, WKNavigationDelegate>
 @property(nonatomic, strong) NSNumber *windowId;
 @property(nonatomic, strong) NSWindow *window;
 @property(nonatomic, strong) WKWebView *webView;
+@property(nonatomic, strong) AtomJSDraggableContentView *contentView;
 @property(nonatomic, weak) AtomJSWindowController *parentController;
 @property(nonatomic, assign) BOOL modal;
 - (instancetype)initWithWindowId:(NSNumber *)windowId config:(NSDictionary *)config;
 - (void)navigate:(NSString *)urlString;
+- (void)beginWindowDrag;
+- (void)updateDragRegions:(NSArray *)regions viewport:(NSDictionary *)viewport;
+- (void)emitBoundsChangedWithReason:(NSString *)reason;
 @end
 
 @implementation AtomJSWindowController
@@ -175,6 +335,8 @@ static void AtomJSConfigureApplicationIdentity(NSApplication *application) {
     defer:NO];
   _window.releasedWhenClosed = NO;
   _window.delegate = self;
+  _window.movable = YES;
+  _window.movableByWindowBackground = NO;
   _window.title = AtomJSString(config[@"title"], atomAppName);
   _window.backgroundColor = AtomJSColor(config[@"backgroundColor"]);
   _window.tabbingMode = NSWindowTabbingModeDisallowed;
@@ -209,7 +371,13 @@ static void AtomJSConfigureApplicationIdentity(NSApplication *application) {
   }
 
   if ([config[@"x"] isKindOfClass:[NSNumber class]] && [config[@"y"] isKindOfClass:[NSNumber class]]) {
-    [_window setFrameOrigin:NSMakePoint([config[@"x"] doubleValue], [config[@"y"] doubleValue])];
+    NSDictionary *initialBounds = @{
+      @"x": config[@"x"],
+      @"y": config[@"y"],
+      @"width": @(_window.frame.size.width),
+      @"height": @(_window.frame.size.height)
+    };
+    [_window setFrame:AtomJSCocoaFrameFromAtomBounds(initialBounds, _window.frame) display:NO animate:NO];
   } else if (AtomJSBoolean(config[@"center"], YES)) {
     [_window center];
   }
@@ -231,7 +399,11 @@ static void AtomJSConfigureApplicationIdentity(NSApplication *application) {
   _webView.navigationDelegate = self;
   _webView.autoresizingMask = NSViewWidthSizable | NSViewHeightSizable;
   if (AtomJSBoolean(config[@"transparent"], NO)) AtomJSConfigureTransparentWebView(_webView);
-  _window.contentView = _webView;
+
+  _contentView = [[AtomJSDraggableContentView alloc]
+    initWithFrame:NSMakeRect(0, 0, width, height)
+    webView:_webView];
+  _window.contentView = _contentView;
 
   NSNumber *parentWindowId = AtomJSNumber(config[@"parentWindowId"], nil);
   _parentController = parentWindowId ? atomWindows[parentWindowId] : nil;
@@ -270,6 +442,33 @@ static void AtomJSConfigureApplicationIdentity(NSApplication *application) {
   return self;
 }
 
+- (void)beginWindowDrag {
+  NSEvent *event = [NSApp currentEvent];
+  if (
+    !self.window ||
+    !event ||
+    event.type != NSEventTypeLeftMouseDown ||
+    event.window != self.window
+  ) {
+    return;
+  }
+
+  [self.window performWindowDragWithEvent:event];
+}
+
+- (void)updateDragRegions:(NSArray *)regions viewport:(NSDictionary *)viewport {
+  [self.contentView updateDragRegions:regions viewport:viewport];
+}
+
+- (void)emitBoundsChangedWithReason:(NSString *)reason {
+  AtomJSEmit(@{
+    @"type": @"bounds-changed",
+    @"windowId": self.windowId,
+    @"reason": reason ?: @"unknown",
+    @"bounds": AtomJSAtomBoundsFromWindow(self.window)
+  });
+}
+
 - (void)navigate:(NSString *)urlString {
   NSURL *url = [NSURL URLWithString:urlString ?: @"about:blank"];
   if (!url) {
@@ -361,6 +560,14 @@ static void AtomJSConfigureApplicationIdentity(NSApplication *application) {
   });
 }
 
+- (void)windowDidMove:(NSNotification *)notification {
+  [self emitBoundsChangedWithReason:@"move"];
+}
+
+- (void)windowDidResize:(NSNotification *)notification {
+  [self emitBoundsChangedWithReason:@"resize"];
+}
+
 @end
 
 static AtomJSWindowController *AtomJSController(NSDictionary *message) {
@@ -518,6 +725,7 @@ static void AtomJSHandleMessage(NSDictionary *message) {
       @"type": @"created",
       @"windowId": windowId
     });
+    [controller emitBoundsChangedWithReason:@"create"];
     return;
   }
 
@@ -561,6 +769,12 @@ static void AtomJSHandleMessage(NSDictionary *message) {
     [controller.window makeKeyAndOrderFront:nil];
     [controller.window orderFrontRegardless];
     [NSApp activateIgnoringOtherApps:YES];
+  } else if ([command isEqualToString:@"start-drag"]) {
+    [controller beginWindowDrag];
+  } else if ([command isEqualToString:@"set-drag-regions"]) {
+    NSArray *regions = [message[@"regions"] isKindOfClass:[NSArray class]] ? message[@"regions"] : @[];
+    NSDictionary *viewport = [message[@"viewport"] isKindOfClass:[NSDictionary class]] ? message[@"viewport"] : @{};
+    [controller updateDragRegions:regions viewport:viewport];
   } else if ([command isEqualToString:@"close"] || [command isEqualToString:@"destroy"]) {
     [controller.window close];
   } else if ([command isEqualToString:@"set-title"]) {
@@ -579,13 +793,12 @@ static void AtomJSHandleMessage(NSDictionary *message) {
     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];
+    NSDictionary *requested = [message[@"bounds"] isKindOfClass:[NSDictionary class]] ? message[@"bounds"] : @{};
+    NSMutableDictionary *bounds = [AtomJSAtomBoundsFromWindow(controller.window) mutableCopy];
+    for (NSString *key in @[ @"x", @"y", @"width", @"height" ]) {
+      if ([requested[key] isKindOfClass:[NSNumber class]]) bounds[key] = requested[key];
+    }
+    [controller.window setFrame:AtomJSCocoaFrameFromAtomBounds(bounds, controller.window.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"]) {