@n1h/sweetview 0.0.0-stage → 0.1.0

package/src/native/index.ts

@@ -0,0 +1,38 @@
+// One module per feature. Import what you use.
+export { createTray, type Tray, type TrayIcon, type TrayOptions } from "./tray";
+export { createNotifier, type NotificationOptions, type Notifier, type NotifierOptions } from "./notifications";
+export { nativeWindow, type NativeWindow, type WindowHandle } from "./window";
+export {
+  createOverlayWindow,
+  makeOverlay,
+  type Overlay,
+  type OverlayOptions,
+  type OverlayWindowOptions,
+  type HitRefiner,
+  type Point,
+  type Rect,
+  type ResizeEdge,
+} from "./overlay";
+export { convexHull, createHitRelay, flattenRegions, hitRegions, packRegions, unpackRegions, type HitPolygon, type HitProbe, type HitRelay } from "./hit-regions";
+export { pickFolder } from "./folder-picker";
+export { installAppMenu, type AppMenuOptions } from "./app-menu";
+export { setAppIcon } from "./app-icon";
+export { resolveMenu, type MenuItem, type MenuSource, type MenuTemplate } from "./menu";
+export {
+  decodePng,
+  dotIcns,
+  dotIcon,
+  dotPng,
+  encodeIcns,
+  encodeIco,
+  encodePng,
+  icnsFromPng,
+  icnsFromRgba,
+  icoFromPng,
+  icoFromRgba,
+  renderDot,
+  trimTransparent,
+  type DecodedPng,
+  type DotIconOptions,
+  type Icon,
+} from "./icon";

package/src/native/menu.ts

@@ -0,0 +1,43 @@
+// Menus as data. A template describes items; each platform renders it with
+// its own menu system when the menu opens.
+
+import type { Icon } from "./icon";
+
+export type MenuItem =
+  | {
+      type?: "item";
+      label: string;
+      /** Greyed out and unclickable when false. Default true. */
+      enabled?: boolean;
+      /** Shows a check mark. */
+      checked?: boolean;
+      /** An image before the label: 16px from the .ico on Windows, a 16pt template image on macOS. */
+      icon?: Icon;
+      click?: () => void;
+    }
+  | {
+      type?: "submenu";
+      label: string;
+      enabled?: boolean;
+      icon?: Icon;
+      submenu: MenuTemplate;
+    }
+  | { type: "separator" };
+
+export type MenuTemplate = MenuItem[];
+
+/**
+ * A template, or a function that produces one. The function form is called
+ * every time the menu is about to open, so labels, check marks and enabled
+ * state can reflect current app state without any bookkeeping.
+ */
+export type MenuSource = MenuTemplate | (() => MenuTemplate);
+
+/** A template from a source: calls the function form fresh each time. */
+export const resolveMenu = (source: MenuSource | undefined): MenuTemplate =>
+  source === undefined ? [] : typeof source === "function" ? source() : source;
+
+export const isSeparator = (item: MenuItem): item is { type: "separator" } => item.type === "separator";
+
+export const isSubmenu = (item: MenuItem): item is Extract<MenuItem, { submenu: MenuTemplate }> =>
+  !isSeparator(item) && "submenu" in item;

package/src/native/notifications.ts

@@ -0,0 +1,40 @@
+// System notifications.
+//
+// Windows: the tray icon's balloon, which Windows 10/11 shows as a toast with
+// our icon, so create the tray first. macOS: UNUserNotificationCenter, which
+// asks the user for permission on the first notification and needs a bundle
+// identifier, so run the .app rather than the bare binary.
+
+import { backend } from "./platform";
+
+export type NotificationOptions = {
+  title: string;
+  body?: string;
+  /** No sound. Default false. */
+  silent?: boolean;
+};
+
+export type NotifierOptions = {
+  /** The user clicked a notification. */
+  onClick?: () => void;
+};
+
+export interface Notifier {
+  /**
+   * Shows a notification. Returns false when the platform cannot show one
+   * right now (macOS without a bundle id; Windows after the tray is gone), in
+   * which case nothing is displayed.
+   */
+  notify(notification: NotificationOptions): boolean;
+  dispose(): void;
+}
+
+type Backend = { createNotifier(options?: NotifierOptions): Notifier };
+const impl = backend<Backend>(
+  () => require("./win32/notifier"),
+  () => require("./darwin/notifier"),
+);
+
+export function createNotifier(options: NotifierOptions = {}): Notifier {
+  return impl().createNotifier(options);
+}

package/src/native/overlay.ts

@@ -0,0 +1,182 @@
+// Turn a window someone else created (the webview's) into an overlay: no
+// frame, above everything, off the taskbar, never takes focus, and see-through
+// where the page paints the colour key. Then move it around.
+//
+// Units: physical pixels on Windows (the process is per-monitor DPI aware),
+// points on macOS; `scale()` says how many of them one CSS pixel of the page
+// is. Origin top-left of the primary screen on both.
+//
+// The colour key (Windows only) is 1-bit transparency; `transparent` is real
+// alpha on both platforms.
+
+import type { HitPolygon } from "./hit-regions";
+import type { Icon } from "./icon";
+import type { WindowHandle } from "./window";
+import { backend } from "./platform";
+
+export type Rect = { x: number; y: number; width: number; height: number };
+export type Point = { x: number; y: number };
+
+/**
+ * Asked while the cursor is inside a hit polygon, with the cursor in
+ * window-local units; whoever knows the exact shape (the page, with a
+ * triangle pick) calls `answer` with whether that point is really solid.
+ * Until the answer arrives the polygon's own answer stands; an answer that
+ * arrives after the cursor has moved on is dropped.
+ */
+export type HitRefiner = (local: Point, answer: (solid: boolean) => void) => void;
+
+/** An edge or corner of the window, for startResize. */
+export type ResizeEdge = "left" | "right" | "top" | "bottom" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
+
+export type OverlayOptions = {
+  /**
+   * Honour the page's alpha: wherever the page is transparent, the desktop
+   * shows through, anti-aliased edges and all. Needs the browser to paint a
+   * transparent background too (sweetview's `transparent: true`). Clicks on
+   * transparent pixels still land on the window; use setClickThrough for
+   * whole-window pass-through.
+   */
+  transparent?: boolean;
+  /** `#rrggbb`; pixels of exactly this colour are transparent and click-through. 1-bit; not needed with `transparent`. */
+  colorKey?: string;
+  /** Whole-window opacity, 0..1. Combines with the colour key. */
+  opacity?: number;
+  /** Above every normal window. Default true. */
+  topmost?: boolean;
+  /** No taskbar button, no Alt+Tab entry. Default true. */
+  hideFromTaskbar?: boolean;
+  /**
+   * Clicking it never takes focus from the app the user is in. Default true.
+   * `false` makes a frameless window that takes focus and keyboard input (a
+   * settings window drawing its own chrome); on macOS that needs the window
+   * created by `createOverlayWindow`, which gives it a class that can become key.
+   */
+  noActivate?: boolean;
+};
+
+export interface Overlay {
+  /** The HWND / NSWindow*, for handing to sweetview as the host window. */
+  readonly handle: WindowHandle;
+  /** Shows without taking focus. */
+  show(): void;
+  hide(): void;
+  /**
+   * Windows: the title bar, taskbar and Alt+Tab icon from `icon.windows.ico`;
+   * undefined restores the stock one. Only a framed window shows it. macOS:
+   * no-op, a window has no icon of its own there; `setAppIcon` sets the Dock's.
+   */
+  setIcon(icon: Icon | undefined): void;
+  /** Position and size in window units (see `scale()`). */
+  bounds(): Rect;
+  moveTo(x: number, y: number): void;
+  resize(width: number, height: number): void;
+  setBounds(rect: Rect): void;
+  /** Whole-window: when on, every click falls through to what is underneath. */
+  setClickThrough(on: boolean): void;
+  /**
+   * Which parts of the window take clicks: polygons in window-local units
+   * (see `scale()`); a click anywhere else falls through to whatever is
+   * underneath. `null` means the whole window takes clicks again. Meant to
+   * be resent as things move, tens of times a second if need be: nothing is
+   * repainted for it. The page computes the polygons from what it draws
+   * (the convex hull of each mesh's projected bounding-box corners is its
+   * exact silhouette for box-shaped meshes; `convexHull` in
+   * `@n1h/sweetview/native/hit-regions` is page-safe) and this side answers the
+   * cursor itself, so the page is never in the click path.
+   *
+   * How: a 10 ms timer, and every update, test the cursor against the
+   * polygons and flip the window's pass-through state (Windows:
+   * WS_EX_TRANSPARENT with WS_EX_LAYERED, the only thing the window manager
+   * honours across processes short of a window region, which forces a
+   * repaint of the browser each time it changes; macOS: ignoresMouseEvents).
+   * Nothing changes while a mouse button is down, so a drag survives leaving
+   * the polygons. While the cursor is outside the window the window passes
+   * clicks through, so entering onto empty space is right from the first
+   * pixel; entering onto a polygon takes one tick.
+   *
+   * The polygons are the coarse answer: a mesh's bounding-box hull includes
+   * the gap between a cat's ears. With `refine`, every time the cursor is
+   * inside a polygon (and whenever the polygons change under a still cursor)
+   * the refiner is asked for the exact answer and the pass-through state
+   * follows its reply, typically a few milliseconds later; outside every
+   * polygon nobody is asked. A refiner that never answers leaves polygon
+   * precision, so a stalled page degrades, never breaks.
+   */
+  setHitRegions(polygons: HitPolygon[] | null, refine?: HitRefiner): void;
+  setTopmost(on: boolean): void;
+  /**
+   * Hand the mouse gesture in progress to the OS as a window move, as a
+   * title bar would: called from a UI-thread method on the page's
+   * pointer-down in its own title bar, the OS then moves the window with the
+   * cursor, with snapping and all, until the button is released. A page
+   * draws its own chrome this way in a frameless window.
+   */
+  startDrag(): void;
+  /** The same for a resize from an edge or corner (the page's own resize handles). macOS: no-op; a frameless macOS overlay has no resizable mask, so it is not resized by the user at all. */
+  startResize(edge: ResizeEdge): void;
+  minimize(): void;
+  /** Between the work area and the previous bounds (Windows); zoom (macOS). */
+  toggleMaximize(): void;
+  maximized(): boolean;
+  /** Cursor position on the screen, window units. */
+  cursor(): Point;
+  /** The whole primary monitor, window units. The overlay draws over the taskbar or Dock there. */
+  screen(): Rect;
+  /** The whole monitor under a point, window units; the nearest one when the point is on none. A window dropped on another monitor finds its new bounds with this. */
+  screenAt(point: Point): Rect;
+  /** The primary monitor minus the taskbar or Dock, window units. */
+  workArea(): Rect;
+  /** Every monitor together, window units. */
+  virtualScreen(): Rect;
+  /** Window units per CSS pixel of the page: the DPI scale on Windows, 1 on macOS. */
+  scale(): number;
+}
+
+export type OverlayWindowOptions = OverlayOptions & {
+  title?: string;
+  /** Initial bounds, window units. Default: 320x240 at the work area's centre. */
+  bounds?: Rect;
+  /**
+   * A normal window instead of an overlay: title bar and close button, a
+   * taskbar or Dock presence, activates when clicked, not above other
+   * windows, opaque. Still created hidden, so `show()` is the first time it
+   * appears, and its close button hides it rather than ending the app. For
+   * a settings window next to an overlay, hosted by the same process and OS
+   * loop. On macOS the overlay options are ignored; on Windows `frame` only
+   * changes their defaults (not topmost, in the taskbar, activating, opaque),
+   * and an option given explicitly still applies.
+   */
+  frame?: boolean;
+  /** Framed windows: dark title bar and frame (Windows 11's immersive dark mode; the dark appearance on macOS), for a dark page. */
+  dark?: boolean;
+  /** Windows: the title bar, taskbar and Alt+Tab icon (see `Overlay.setIcon`). macOS: ignored. */
+  icon?: Icon;
+};
+
+type Backend = {
+  makeOverlay(handle: WindowHandle, options: OverlayOptions): Overlay;
+  createOverlayWindow(options: OverlayWindowOptions): Overlay;
+};
+const impl = backend<Backend>(
+  () => require("./win32/overlay"),
+  () => require("./darwin/overlay"),
+);
+
+/** Restyle an existing window (the webview's) into an overlay. */
+export function makeOverlay(handle: WindowHandle, options: OverlayOptions = {}): Overlay {
+  return impl().makeOverlay(handle, options);
+}
+
+/**
+ * Create a hidden overlay window of our own, to hand to sweetview as the host
+ * (`createWebviewApp({ window: overlay.handle })`). Transparency set up before
+ * the browser is created is what WebView2 needs for a see-through page; it
+ * ignores a host that turned transparent later. Call `show()` once the page
+ * is set. On Windows the window's procedure ends the run loop when the
+ * window is destroyed and keeps the browser sized to the client area; on
+ * macOS neither happens here.
+ */
+export function createOverlayWindow(options: OverlayWindowOptions = {}): Overlay {
+  return impl().createOverlayWindow(options);
+}

package/src/native/platform.ts

@@ -0,0 +1,25 @@
+// Internal. Picks the implementation folder for the running OS, once, lazily.
+//
+// `require` rather than `import()` so every public function stays synchronous:
+// the UI thread cannot await while the webview's run loop owns it, and the
+// bundler still embeds both folders (the strings are static), evaluating only
+// the one the process is on.
+
+export function backend<T>(win32: () => T, darwin: () => T): () => T {
+  let loaded: T | undefined;
+  return () => {
+    if (loaded === undefined) {
+      switch (process.platform) {
+        case "win32":
+          loaded = win32();
+          break;
+        case "darwin":
+          loaded = darwin();
+          break;
+        default:
+          throw new Error(`sweetnative: ${process.platform} is not supported (win32 and darwin are)`);
+      }
+    }
+    return loaded;
+  };
+}

package/src/native/tray.ts

@@ -0,0 +1,41 @@
+// Tray icon (Windows notification area) / menu bar status item (macOS).
+//
+// Runs on the UI thread. Callbacks fire on that thread from inside the OS
+// loop: return quickly, and do not await anything that needs Bun's event loop
+// (it is blocked while webview.run() is on the stack).
+
+import type { Icon } from "./icon";
+import type { MenuSource } from "./menu";
+import { backend } from "./platform";
+
+/** The tray's icon: an `Icon`. Windows picks the 16px image for the tray and 32px for toasts; macOS shows the PNG at 18x18 points (36px for Retina). */
+export type TrayIcon = Icon;
+
+export type TrayOptions = {
+  tooltip?: string;
+  icon?: TrayIcon;
+  /** Windows: opened by right click. macOS: by any click, as menu bar items do. */
+  menu?: MenuSource;
+  /** Left single click. Fires only when the click did not turn into a double click. macOS: only when no menu is set. */
+  onClick?: () => void;
+  /** Left double click. macOS: only when no menu is set. */
+  onDoubleClick?: () => void;
+};
+
+export interface Tray {
+  setTooltip(text: string): void;
+  setIcon(icon: TrayIcon): void;
+  setMenu(menu: MenuSource | undefined): void;
+  /** Removes the icon. Safe to call twice. */
+  dispose(): void;
+}
+
+type Backend = { createTray(options: TrayOptions): Tray };
+const impl = backend<Backend>(
+  () => require("./win32/tray"),
+  () => require("./darwin/tray"),
+);
+
+export function createTray(options: TrayOptions): Tray {
+  return impl().createTray(options);
+}

package/src/native/win32/api.ts

@@ -0,0 +1,234 @@
+// The Win32 symbols this library needs, dlopened once. Handles travel as
+// bigint (FFIType.u64) so a NULL handle is 0n, never a JS null.
+
+import { FFIType, dlopen, type Pointer } from "bun:ffi";
+
+export const user32 = dlopen("user32.dll", {
+  // (const WNDCLASSEXW*) -> ATOM
+  RegisterClassExW: { args: [FFIType.ptr], returns: FFIType.u16 },
+  // (DWORD exStyle, LPCWSTR class, LPCWSTR title, DWORD style, int x, int y, int w, int h,
+  //  HWND parent, HMENU menu, HINSTANCE, LPVOID param) -> HWND
+  CreateWindowExW: {
+    args: [
+      FFIType.u32,
+      FFIType.ptr,
+      FFIType.ptr,
+      FFIType.u32,
+      FFIType.i32,
+      FFIType.i32,
+      FFIType.i32,
+      FFIType.i32,
+      FFIType.u64,
+      FFIType.u64,
+      FFIType.u64,
+      FFIType.ptr,
+    ],
+    returns: FFIType.u64,
+  },
+  DestroyWindow: { args: [FFIType.u64], returns: FFIType.i32 },
+  // (HWND, UINT, WPARAM, LPARAM) -> LRESULT
+  DefWindowProcW: { args: [FFIType.u64, FFIType.u32, FFIType.u64, FFIType.i64], returns: FFIType.i64 },
+  PostMessageW: { args: [FFIType.u64, FFIType.u32, FFIType.u64, FFIType.i64], returns: FFIType.i32 },
+  RegisterWindowMessageW: { args: [FFIType.ptr], returns: FFIType.u32 },
+
+  ShowWindow: { args: [FFIType.u64, FFIType.i32], returns: FFIType.i32 },
+  IsWindowVisible: { args: [FFIType.u64], returns: FFIType.i32 },
+  IsIconic: { args: [FFIType.u64], returns: FFIType.i32 },
+  IsZoomed: { args: [FFIType.u64], returns: FFIType.i32 },
+  ReleaseCapture: { args: [], returns: FFIType.i32 },
+  SendMessageW: { args: [FFIType.u64, FFIType.u32, FFIType.u64, FFIType.i64], returns: FFIType.i64 },
+  SetForegroundWindow: { args: [FFIType.u64], returns: FFIType.i32 },
+  GetCursorPos: { args: [FFIType.ptr], returns: FFIType.i32 },
+  GetAsyncKeyState: { args: [FFIType.i32], returns: FFIType.i16 },
+  GetSystemMetrics: { args: [FFIType.i32], returns: FFIType.i32 },
+  // (const RECT*, DWORD flags) -> HMONITOR; the monitor with the largest overlap, or the nearest one with MONITOR_DEFAULTTONEAREST
+  MonitorFromRect: { args: [FFIType.ptr, FFIType.u32], returns: FFIType.u64 },
+  // (HMONITOR, MONITORINFO*) -> BOOL; cbSize set by the caller
+  GetMonitorInfoW: { args: [FFIType.u64, FFIType.ptr], returns: FFIType.i32 },
+  GetDoubleClickTime: { args: [], returns: FFIType.u32 },
+  // (HWND, UINT_PTR id, UINT ms, TIMERPROC) -> UINT_PTR
+  SetTimer: { args: [FFIType.u64, FFIType.u64, FFIType.u32, FFIType.ptr], returns: FFIType.u64 },
+  KillTimer: { args: [FFIType.u64, FFIType.u64], returns: FFIType.i32 },
+
+  CreatePopupMenu: { args: [], returns: FFIType.u64 },
+  // (HMENU, UINT flags, UINT_PTR idOrSubmenu, LPCWSTR text) -> BOOL
+  AppendMenuW: { args: [FFIType.u64, FFIType.u32, FFIType.u64, FFIType.ptr], returns: FFIType.i32 },
+  DestroyMenu: { args: [FFIType.u64], returns: FFIType.i32 },
+  // (HMENU, UINT item, BOOL byPosition, const MENUITEMINFOW*) -> BOOL
+  SetMenuItemInfoW: { args: [FFIType.u64, FFIType.u32, FFIType.i32, FFIType.ptr], returns: FFIType.i32 },
+  // (HMENU, UINT flags, int x, int y, int reserved, HWND owner, const RECT*) -> int
+  TrackPopupMenu: {
+    args: [FFIType.u64, FFIType.u32, FFIType.i32, FFIType.i32, FFIType.i32, FFIType.u64, FFIType.ptr],
+    returns: FFIType.i32,
+  },
+
+  // (PBYTE bits, DWORD size, BOOL icon, DWORD version, int cx, int cy, UINT flags) -> HICON
+  CreateIconFromResourceEx: {
+    args: [FFIType.ptr, FFIType.u32, FFIType.i32, FFIType.u32, FFIType.i32, FFIType.i32, FFIType.u32],
+    returns: FFIType.u64,
+  },
+  LoadIconW: { args: [FFIType.u64, FFIType.u64], returns: FFIType.u64 },
+  DestroyIcon: { args: [FFIType.u64], returns: FFIType.i32 },
+  // Overlay windows: styles, placement, layered transparency, screen geometry
+  GetWindowLongPtrW: { args: [FFIType.u64, FFIType.i32], returns: FFIType.i64 },
+  SetWindowLongPtrW: { args: [FFIType.u64, FFIType.i32, FFIType.i64], returns: FFIType.i64 },
+  // (HWND, HWND insertAfter, x, y, cx, cy, flags) -> BOOL
+  SetWindowPos: { args: [FFIType.u64, FFIType.i64, FFIType.i32, FFIType.i32, FFIType.i32, FFIType.i32, FFIType.u32], returns: FFIType.i32 },
+  GetWindowRect: { args: [FFIType.u64, FFIType.ptr], returns: FFIType.i32 },
+  // (HWND, COLORREF key, BYTE alpha, DWORD flags) -> BOOL
+  SetLayeredWindowAttributes: { args: [FFIType.u64, FFIType.u32, FFIType.u8, FFIType.u32], returns: FFIType.i32 },
+  SystemParametersInfoW: { args: [FFIType.u32, FFIType.u32, FFIType.ptr, FFIType.u32], returns: FFIType.i32 },
+  PostQuitMessage: { args: [FFIType.i32], returns: FFIType.void },
+  // (DPI_AWARENESS_CONTEXT) -> BOOL; the webview library does this only for windows it creates itself
+  SetProcessDpiAwarenessContext: { args: [FFIType.i64], returns: FFIType.i32 },
+  GetDpiForWindow: { args: [FFIType.u64], returns: FFIType.u32 },
+  // (HWND, UINT cmd) -> HWND
+  GetWindow: { args: [FFIType.u64, FFIType.u32], returns: FFIType.u64 },
+  GetClientRect: { args: [FFIType.u64, FFIType.ptr], returns: FFIType.i32 },
+  MoveWindow: { args: [FFIType.u64, FFIType.i32, FFIType.i32, FFIType.i32, FFIType.i32, FFIType.i32], returns: FFIType.i32 },
+  // (HWND, HRGN, BOOL redraw) -> int; the system owns the region afterwards
+  SetWindowRgn: { args: [FFIType.u64, FFIType.u64, FFIType.i32], returns: FFIType.i32 },
+}).symbols;
+
+export const kernel32 = dlopen("kernel32.dll", {
+  GetModuleHandleW: { args: [FFIType.ptr], returns: FFIType.u64 },
+  GetLastError: { args: [], returns: FFIType.u32 },
+}).symbols;
+
+export const comctl32 = dlopen("comctl32.dll", {
+  // (HWND, SUBCLASSPROC, UINT_PTR id, DWORD_PTR refData) -> BOOL
+  SetWindowSubclass: { args: [FFIType.u64, FFIType.ptr, FFIType.u64, FFIType.u64], returns: FFIType.i32 },
+  RemoveWindowSubclass: { args: [FFIType.u64, FFIType.ptr, FFIType.u64], returns: FFIType.i32 },
+  // (HWND, UINT, WPARAM, LPARAM) -> LRESULT : the next procedure in the subclass chain
+  DefSubclassProc: { args: [FFIType.u64, FFIType.u32, FFIType.u64, FFIType.i64], returns: FFIType.i64 },
+}).symbols;
+
+export const ole32 = dlopen("ole32.dll", {
+  // (LPVOID reserved, DWORD coinit) -> HRESULT (S_OK, S_FALSE if already initialised, RPC_E_CHANGED_MODE if the other model)
+  CoInitializeEx: { args: [FFIType.ptr, FFIType.u32], returns: FFIType.i32 },
+}).symbols;
+
+export const dwmapi = dlopen("dwmapi.dll", {
+  // (HWND, const DWM_BLURBEHIND*) -> HRESULT
+  DwmEnableBlurBehindWindow: { args: [FFIType.u64, FFIType.ptr], returns: FFIType.i32 },
+  DwmSetWindowAttribute: { args: [FFIType.u64, FFIType.u32, FFIType.ptr, FFIType.u32], returns: FFIType.i32 },
+}).symbols;
+
+export const gdi32 = dlopen("gdi32.dll", {
+  CreateRectRgn: { args: [FFIType.i32, FFIType.i32, FFIType.i32, FFIType.i32], returns: FFIType.u64 },
+  // (const XFORM*, DWORD bytes, const RGNDATA*) -> HRGN
+  ExtCreateRegion: { args: [FFIType.ptr, FFIType.u32, FFIType.ptr], returns: FFIType.u64 },
+  DeleteObject: { args: [FFIType.u64], returns: FFIType.i32 },
+  // (HDC, const BITMAPINFO*, UINT usage, void** bits, HANDLE section, DWORD offset) -> HBITMAP
+  CreateDIBSection: { args: [FFIType.u64, FFIType.ptr, FFIType.u32, FFIType.ptr, FFIType.u64, FFIType.u32], returns: FFIType.u64 },
+}).symbols;
+
+export const shell32 = dlopen("shell32.dll", {
+  // (DWORD message, PNOTIFYICONDATAW) -> BOOL
+  Shell_NotifyIconW: { args: [FFIType.u32, FFIType.ptr], returns: FFIType.i32 },
+}).symbols;
+
+/**
+ * NUL-terminated UTF-16LE for LPCWSTR arguments. Pass the array itself to an
+ * FFIType.ptr parameter (never `ptr(wstr(..))`): Bun keeps a TypedArray
+ * argument alive for the duration of the call, while a bare pointer can be
+ * collected by a GC triggered while the remaining arguments are evaluated.
+ */
+export const wstr = (s: string): Uint8Array => new Uint8Array(Buffer.from(s + "\0", "utf16le"));
+
+/** A non-null pointer from a bigint/number out-parameter; throws on NULL. */
+export const asPointer = (v: bigint | number | null): Pointer => {
+  if (v === null || v === 0 || v === 0n) throw new Error("sweetnative: unexpected NULL pointer");
+  return Number(v) as Pointer;
+};
+
+/** A nullable pointer for a Win32 handle argument (HWND etc.) given as bigint, number or null. */
+export const toPointer = (v: bigint | number | null): Pointer | null => (v === null || v === 0 || v === 0n ? null : (Number(v) as Pointer));
+
+export const hInstance = (): bigint => kernel32.GetModuleHandleW(null);
+
+export const lastError = () => kernel32.GetLastError();
+
+// Window messages
+export const WM_CLOSE = 0x0010;
+export const WM_NCDESTROY = 0x0082;
+export const WM_TIMER = 0x0113;
+export const WM_LBUTTONUP = 0x0202;
+export const WM_LBUTTONDBLCLK = 0x0203;
+export const WM_RBUTTONUP = 0x0205;
+export const WM_NULL = 0x0000;
+export const WM_APP = 0x8000;
+export const WM_SETICON = 0x0080;
+export const ICON_SMALL = 0n;
+export const ICON_BIG = 1n;
+
+// ShowWindow
+export const SW_HIDE = 0;
+export const SW_SHOWNOACTIVATE = 4;
+export const SW_SHOW = 5;
+export const SW_RESTORE = 9;
+export const SW_MINIMIZE = 6;
+/** Non-client mouse down: with a hit-test code it starts the OS's own move (HTCAPTION) or size loop. */
+export const WM_NCLBUTTONDOWN = 0x00a1;
+export const HTCAPTION = 2;
+
+// More window messages
+export const WM_DESTROY = 0x0002;
+export const WM_SIZE = 0x0005;
+
+// GetWindow
+export const GW_CHILD = 5;
+
+// GetSystemMetrics
+export const SM_CXICON = 11;
+export const SM_CXSMICON = 49;
+export const SM_CXSCREEN = 0;
+export const SM_CYSCREEN = 1;
+export const SM_XVIRTUALSCREEN = 76;
+export const SM_YVIRTUALSCREEN = 77;
+export const SM_CXVIRTUALSCREEN = 78;
+export const SM_CYVIRTUALSCREEN = 79;
+
+// MonitorFromRect
+export const MONITOR_DEFAULTTONEAREST = 2;
+/** MONITORINFO: cbSize, rcMonitor, rcWork, dwFlags; 40 bytes. */
+export const MONITORINFO_SIZE = 40;
+
+// Get/SetWindowLongPtr
+export const GWL_STYLE = -16;
+export const GWL_EXSTYLE = -20;
+export const WS_POPUP = 0x80000000;
+export const WS_CLIPCHILDREN = 0x02000000;
+export const WS_OVERLAPPEDWINDOW = 0x00cf0000; // caption, sysmenu, thickframe, min/max boxes
+export const WS_EX_TRANSPARENT = 0x00000020;
+export const WS_EX_TOOLWINDOW = 0x00000080;
+export const WS_EX_APPWINDOW = 0x00040000;
+export const WS_EX_LAYERED = 0x00080000;
+export const WS_EX_NOACTIVATE = 0x08000000;
+
+// SetWindowPos
+export const HWND_TOPMOST = -1n;
+export const HWND_NOTOPMOST = -2n;
+export const SWP_NOSIZE = 0x0001;
+export const SWP_NOMOVE = 0x0002;
+export const SWP_NOZORDER = 0x0004;
+export const SWP_NOACTIVATE = 0x0010;
+export const SWP_FRAMECHANGED = 0x0020;
+
+// SetLayeredWindowAttributes
+export const LWA_COLORKEY = 0x1;
+export const LWA_ALPHA = 0x2;
+
+// SystemParametersInfo
+export const SPI_GETWORKAREA = 0x0030;
+
+// CoInitializeEx
+export const COINIT_APARTMENTTHREADED = 0x2;
+export const RPC_E_CHANGED_MODE = -2147417850; // 0x80010106
+
+// SetProcessDpiAwarenessContext
+export const DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2 = -4n;
+
+// DWM_BLURBEHIND.dwFlags
+export const DWM_BB_ENABLE = 0x1;
+export const DWM_BB_BLURREGION = 0x2;

package/src/native/win32/app-icon.ts

@@ -0,0 +1,5 @@
+// Windows has no run-time app icon: see ../app-icon.ts.
+
+import type { Icon } from "../icon";
+
+export function setAppIcon(_icon: Icon): void {}

package/src/native/win32/app-menu.ts

@@ -0,0 +1,4 @@
+import type { AppMenuOptions } from "../app-menu";
+
+/** Windows has no application menu bar here; the tray menu is the app's menu. */
+export function installAppMenu(_options: AppMenuOptions): void {}