@n1h/sweetview 0.0.0-stage → 0.1.0

package/src/native/darwin/image.ts

@@ -0,0 +1,47 @@
+// NSImage from the macOS half of an Icon: an SF Symbol by name, else PNG
+// bytes. The one place the tray, menus, windows and the Dock icon get their
+// images, so sizing and the template flag are decided the same way everywhere.
+
+import type { Icon } from "../icon";
+import { NIL, type Id, allocRaw, asId, cls, nsString, release, sel, sendBool, sendBytesLen, sendPtr, sendPtrPtr, sendSize } from "./objc";
+
+export type MadeImage = {
+  img: Id;
+  /** We hold a +1 to release once the receiver has retained it. */
+  owned: boolean;
+};
+
+/**
+ * `points`: the size the image should report (18 for the menu bar, 16 for
+ * menu items); omitted leaves the PNG's own size, which is what the Dock
+ * wants. A PNG with 2x pixels renders crisp on Retina once its size is set
+ * in points. `templateDefault`: what `template` means when unset.
+ */
+export function makeImage(icon: Icon["macos"] | undefined, points?: number, templateDefault = true): MadeImage {
+  const template = icon?.template ?? templateDefault;
+  if (icon?.symbol) {
+    const img = asId(sendPtrPtr(cls("NSImage"), sel("imageWithSystemSymbolName:accessibilityDescription:"), nsString(icon.symbol), NIL));
+    if (img !== NIL) {
+      sendBool(img, sel("setTemplate:"), template);
+      return { img, owned: false }; // +0 (autoreleased)
+    }
+    console.error(`sweetnative: no SF Symbol named "${icon.symbol}"${icon.png ? "; using the PNG" : ""}`);
+  }
+  if (icon?.png) {
+    const data = asId(sendBytesLen(cls("NSData"), sel("dataWithBytes:length:"), icon.png, BigInt(icon.png.length)));
+    const img = asId(sendPtr(allocRaw("NSImage"), sel("initWithData:"), data));
+    if (img !== NIL) {
+      sendBool(img, sel("setTemplate:"), template);
+      if (points !== undefined) sendSize(img, sel("setSize:"), points, points);
+      return { img, owned: true }; // +1 from alloc/init
+    }
+    console.error("sweetnative: NSImage could not decode the PNG bytes");
+  }
+  return { img: NIL, owned: false };
+}
+
+/** Sends `setter` (setImage:, setApplicationIconImage:, ...) with the made image, then drops our reference. */
+export function applyImage(receiver: Id, setter: string, made: MadeImage): void {
+  sendPtr(receiver, sel(setter), made.img); // the receiver retains it
+  if (made.owned) release(made.img);
+}

package/src/native/darwin/menu.ts

@@ -0,0 +1,89 @@
+// NSMenu from a MenuTemplate. Every item targets one shared NSObject whose
+// `menuAction:` looks the sender up in a map, so item handlers never need
+// their own Objective-C class.
+
+import { isSeparator, isSubmenu, type MenuTemplate } from "../menu";
+import { applyImage, makeImage } from "./image";
+import {
+  NIL,
+  type Id,
+  alloc,
+  allocRaw,
+  asId,
+  cls,
+  makeTarget,
+  nsString,
+  release,
+  sel,
+  send,
+  sendBool,
+  sendIntArg,
+  sendIntRetBool,
+  sendPtr,
+  sendPtrSelPtr,
+} from "./objc";
+
+const NSControlStateValueOn = 1n;
+/** Menu item images are 16x16 points. */
+const MENU_ITEM_POINTS = 16;
+// macOS 27 hides menu item images by default (NSMenuItemImageVisibilityAutomatic = 0):
+// symbol images for apps linked on the 26 SDK, every image on the 27 SDK. An
+// item keeps its image only by asking for it. The selector is new in 27, so
+// it is sent only where it exists.
+const NSMenuItemImageVisibilityVisible = 1n;
+
+/** NSMenuItem pointer -> click handler, for the menus currently alive. */
+const handlers = new Map<Id, () => void>();
+
+let target: Id | undefined;
+const menuTarget = () => (target ??= makeTarget("NativeShellMenuTarget", { "menuAction:": (sender) => handlers.get(sender)?.() }));
+
+export type BuiltMenu = { readonly menu: Id; readonly dispose: () => void };
+
+/** Builds an NSMenu (+1, retained for the caller) from `template`. */
+export function buildMenu(template: MenuTemplate): BuiltMenu {
+  const owned: Id[] = [];
+  const build = (items: MenuTemplate): Id => {
+    const menu = alloc("NSMenu");
+    sendBool(menu, sel("setAutoenablesItems:"), false);
+    for (const item of items) {
+      if (isSeparator(item)) {
+        sendPtr(menu, sel("addItem:"), asId(send(cls("NSMenuItem"), sel("separatorItem"))));
+        continue;
+      }
+      const it = allocRaw("NSMenuItem");
+      const inited = asId(sendPtrSelPtr(it, sel("initWithTitle:action:keyEquivalent:"), nsString(item.label), NIL, nsString("")));
+      sendBool(inited, sel("setEnabled:"), item.enabled !== false);
+      if (item.icon?.macos) {
+        const made = makeImage(item.icon.macos, MENU_ITEM_POINTS);
+        if (made.img === NIL) console.error(`sweetnative: menu item "${item.label}" has no usable macOS image`);
+        applyImage(inited, "setImage:", made);
+        if (sendIntRetBool(inited, sel("respondsToSelector:"), sel("setPreferredImageVisibility:"))) {
+          sendIntArg(inited, sel("setPreferredImageVisibility:"), NSMenuItemImageVisibilityVisible);
+        }
+      }
+      if (isSubmenu(item)) {
+        const sub = build(item.submenu);
+        sendPtr(inited, sel("setSubmenu:"), sub);
+        release(sub); // the item retains it
+      } else {
+        sendPtr(inited, sel("setTarget:"), menuTarget());
+        sendPtr(inited, sel("setAction:"), sel("menuAction:"));
+        sendIntArg(inited, sel("setState:"), item.checked ? NSControlStateValueOn : 0n);
+        handlers.set(inited, item.click ?? (() => {}));
+        owned.push(inited);
+      }
+      sendPtr(menu, sel("addItem:"), inited);
+      release(inited); // the menu retains it
+    }
+    return menu;
+  };
+  const menu = build(template);
+  return {
+    menu,
+    dispose() {
+      for (const id of owned) handlers.delete(id);
+      release(menu);
+    },
+  };
+}

package/src/native/darwin/notifier.ts

@@ -0,0 +1,95 @@
+// macOS notifications through UNUserNotificationCenter. It needs a bundle
+// identifier, so this works from the .app and silently does nothing from the
+// bare binary (`bun run dev`): currentNotificationCenter would raise there.
+//
+// The first notify() asks for permission (system prompt, once per bundle id).
+// A delegate makes banners show while the app is frontmost and routes clicks.
+
+import { FFIType } from "bun:ffi";
+import type { Notifier, NotifierOptions } from "../notifications";
+import {
+  NIL,
+  type Id,
+  allocRaw,
+  asId,
+  cls,
+  invokeBlock,
+  makeBlock,
+  makeTarget,
+  nsString,
+  release,
+  sel,
+  send,
+  sendPtr,
+  sendPtrPtr,
+  sendPtrPtrPtr,
+  sendUIntPtrVoid,
+} from "./objc";
+
+const UNAuthorizationOptionBadge = 1n;
+const UNAuthorizationOptionSound = 2n;
+const UNAuthorizationOptionAlert = 4n;
+// UNNotificationPresentationOptions (macOS 11+): list | banner | sound
+const PRESENT_BANNER_LIST_SOUND = 8n | 16n | 2n;
+
+let nextId = 1;
+
+const bundled = (): boolean => asId(send(asId(send(cls("NSBundle"), sel("mainBundle"))), sel("bundleIdentifier"))) !== NIL;
+
+export function createNotifier(options: NotifierOptions = {}): Notifier {
+  let disposed = false;
+  let authorized = false; // asked, not necessarily granted; the answer arrives off-thread and is not awaited
+  let center: Id = NIL;
+
+  const delegate = makeTarget("NativeShellNotificationDelegate", {
+    // Called on the main thread while the app is frontmost: show it anyway.
+    "userNotificationCenter:willPresentNotification:withCompletionHandler:": {
+      args: 3,
+      impl: (_center, _notification, handler) => invokeBlock(handler, [FFIType.u64], PRESENT_BANNER_LIST_SOUND),
+    },
+    // Main thread: the user clicked (or dismissed) a notification.
+    "userNotificationCenter:didReceiveNotificationResponse:withCompletionHandler:": {
+      args: 3,
+      impl: (_center, _response, handler) => {
+        if (!disposed) options.onClick?.();
+        invokeBlock(handler, []);
+      },
+    },
+  });
+
+  const ensureCenter = (): boolean => {
+    if (center !== NIL) return true;
+    if (!bundled()) return false;
+    center = asId(send(cls("UNUserNotificationCenter"), sel("currentNotificationCenter")));
+    if (center === NIL) return false;
+    sendPtr(center, sel("setDelegate:"), delegate);
+    return true;
+  };
+
+  const ensureAuthorized = () => {
+    if (authorized) return;
+    authorized = true;
+    const done = makeBlock(() => {}, [FFIType.bool, FFIType.u64], true); // (BOOL granted, NSError*) on a background queue
+    sendUIntPtrVoid(center, sel("requestAuthorizationWithOptions:completionHandler:"), UNAuthorizationOptionAlert | UNAuthorizationOptionSound | UNAuthorizationOptionBadge, done);
+  };
+
+  return {
+    notify(n) {
+      if (disposed || !ensureCenter()) return false;
+      ensureAuthorized();
+      const content = asId(send(allocRaw("UNMutableNotificationContent"), sel("init")));
+      sendPtr(content, sel("setTitle:"), nsString(n.title));
+      if (n.body) sendPtr(content, sel("setBody:"), nsString(n.body));
+      if (!n.silent) sendPtr(content, sel("setSound:"), asId(send(cls("UNNotificationSound"), sel("defaultSound"))));
+      const request = asId(sendPtrPtrPtr(cls("UNNotificationRequest"), sel("requestWithIdentifier:content:trigger:"), nsString(`sweetnative-${nextId++}`), content, NIL));
+      sendPtrPtr(center, sel("addNotificationRequest:withCompletionHandler:"), request, NIL);
+      release(content); // the request retains it
+      return true;
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      if (center !== NIL && asId(send(center, sel("delegate"))) === delegate) sendPtr(center, sel("setDelegate:"), NIL); // a newer notifier's delegate stays
+    },
+  };
+}

package/src/native/darwin/objc.ts

@@ -0,0 +1,246 @@
+// Minimal Objective-C runtime bridge over bun:ffi, shared by the macOS
+// native pieces (folder picker, main menu).
+//
+// Every `id` and `SEL` is carried as a bigint (FFIType.u64), never as a JS
+// number. Short NSStrings are tagged pointers with the top bit set
+// (0x8000_0000_0000_0000 | ...), which a double cannot hold exactly; passing
+// one through `Number()` or `FFIType.ptr` rounds the low bits and the next
+// objc_msgSend dereferences garbage.
+
+import { CFunction, CString, FFIType, JSCallback, dlopen, ptr, read, type Pointer } from "bun:ffi";
+
+// Make sure AppKit classes exist even if nothing else has loaded the framework.
+dlopen("/System/Library/Frameworks/AppKit.framework/AppKit", {
+  NSApplicationLoad: { args: [], returns: FFIType.bool },
+});
+
+const objc = dlopen("/usr/lib/libobjc.A.dylib", {
+  objc_getClass: { args: [FFIType.ptr], returns: FFIType.u64 },
+  sel_registerName: { args: [FFIType.ptr], returns: FFIType.u64 },
+  objc_msgSend: { args: [FFIType.u64, FFIType.u64], returns: FFIType.u64 },
+  objc_allocateClassPair: { args: [FFIType.u64, FFIType.ptr, FFIType.u64], returns: FFIType.u64 },
+  objc_registerClassPair: { args: [FFIType.u64], returns: FFIType.void },
+  class_addMethod: { args: [FFIType.u64, FFIType.u64, FFIType.ptr, FFIType.ptr], returns: FFIType.bool },
+});
+
+export type Id = bigint;
+export const NIL: Id = 0n;
+export const asId = (v: bigint | number | null): Id => (v === null ? NIL : BigInt(v));
+
+// objc_msgSend is effectively variadic; one CFunction per signature we need.
+const msgSendPtr = (objc.symbols.objc_msgSend as unknown as { ptr: Pointer }).ptr;
+if (typeof msgSendPtr !== "number" || msgSendPtr === 0) throw new Error("objc_msgSend address unavailable");
+const fn = (args: FFIType[], returns: FFIType) =>
+  CFunction({ ptr: msgSendPtr, args, returns }) as unknown as (...a: unknown[]) => bigint | number | null;
+
+export const ID = FFIType.u64;
+/** [obj sel] -> id */
+export const send = fn([ID, ID], ID);
+/** [obj sel] -> NSInteger */
+export const sendInt = fn([ID, ID], FFIType.i64);
+/** [obj sel:BOOL] -> void */
+export const sendBool = fn([ID, ID, FFIType.bool], FFIType.void);
+/** [obj sel:NSInteger] -> BOOL */
+export const sendIntRetBool = fn([ID, ID, FFIType.i64], FFIType.bool);
+/** [obj sel:id] -> id */
+export const sendPtr = fn([ID, ID, ID], ID);
+/** [obj sel:id :SEL :id] -> id  (initWithTitle:action:keyEquivalent:) */
+export const sendPtrSelPtr = fn([ID, ID, ID, ID, ID], ID);
+
+/**
+ * NUL-terminated UTF-8. Pass the array itself to an FFIType.ptr parameter, never
+ * `ptr(cstr(..))`: Bun keeps a TypedArray argument alive for the call, while a
+ * bare pointer may be collected by a GC that runs while later arguments are built.
+ */
+export const cstr = (s: string): Uint8Array => new TextEncoder().encode(s + "\0");
+export const sel = (name: string) => asId(objc.symbols.sel_registerName(cstr(name)));
+export function cls(name: string): Id {
+  const c = asId(objc.symbols.objc_getClass(cstr(name)));
+  if (c === NIL) throw new Error(`Objective-C class ${name} not found`);
+  return c;
+}
+/** [obj sel:const char*] -> id  (stringWithUTF8String:) */
+export const sendCStr = fn([ID, ID, FFIType.ptr], ID);
+export const nsString = (s: string) => asId(sendCStr(cls("NSString"), sel("stringWithUTF8String:"), cstr(s)));
+/** JS string from an NSString (UTF8String is a real heap pointer, never tagged). */
+export const jsString = (nsstr: Id): string => {
+  const utf8 = asId(send(nsstr, sel("UTF8String")));
+  return utf8 === NIL ? "" : new CString(Number(utf8) as Pointer).toString();
+};
+/** [[Class alloc] init] */
+export const alloc = (className: string) => asId(send(allocRaw(className), sel("init")));
+/** [Class alloc] only, for objects that get an initWith...: next. */
+export const allocRaw = (className: string) => asId(send(cls(className), sel("alloc")));
+export const sharedApp = () => asId(send(cls("NSApplication"), sel("sharedApplication")));
+
+// Callbacks the runtime may call for the life of the process; keep them alive.
+const retained: JSCallback[] = [];
+
+/** A method body: a one-argument `-(void)name:(id)sender`, or `{ args, impl }` for n object/pointer arguments. */
+export type TargetMethod = ((sender: Id) => void) | { args: number; impl: (...args: Id[]) => void };
+
+/**
+ * Defines an NSObject subclass whose instance methods are JS functions, and
+ * returns one instance of it. Every method returns void and takes object or
+ * pointer arguments (blocks included), which is what menu items, buttons and
+ * delegates call.
+ */
+let targetClasses = 0;
+
+/** Registers a fresh NSObject subclass whose selectors call into JavaScript; the name is made unique, so the same base name can be used again. */
+export function makeTarget(baseName: string, methods: Record<string, TargetMethod>): Id {
+  const className = `${baseName}_${++targetClasses}`;
+  const klass = asId(objc.symbols.objc_allocateClassPair(cls("NSObject"), cstr(className), 0n));
+  if (klass === NIL) throw new Error(`objc_allocateClassPair(${className}) failed (already registered?)`);
+  for (const [selector, method] of Object.entries(methods)) {
+    const argc = typeof method === "function" ? 1 : method.args;
+    const impl = typeof method === "function" ? (sender: Id) => method(sender) : method.impl;
+    const cb = new JSCallback(
+      (_self: bigint, _cmd: bigint, ...args: bigint[]) => {
+        try {
+          impl(...args.map((a) => BigInt(a ?? 0)));
+        } catch (err) {
+          console.error(`sweetnative: ${className} ${selector} threw:`, err);
+        }
+      },
+      { args: [ID, ID, ...Array<FFIType>(argc).fill(ID)], returns: FFIType.void },
+    );
+    retained.push(cb);
+    if (!objc.symbols.class_addMethod(klass, sel(selector), cb.ptr, cstr("v@:" + "@".repeat(argc)))) {
+      throw new Error(`class_addMethod(${className}, ${selector}) failed`);
+    }
+  }
+  objc.symbols.objc_registerClassPair(klass);
+  return asId(send(asId(send(klass, sel("alloc"))), sel("init")));
+}
+
+/**
+ * Register a subclass whose listed selectors answer YES: `defineYesClass("NSWindow",
+ * "SweetnativeKeyWindow", ["canBecomeKeyWindow"])` makes a borderless window
+ * that can take keyboard focus. Once per class name; a second call is a no-op.
+ */
+export function defineYesClass(superclass: string, className: string, selectors: string[]): void {
+  if (asId(objc.symbols.objc_getClass(cstr(className))) !== NIL) return;
+  const klass = asId(objc.symbols.objc_allocateClassPair(cls(superclass), cstr(className), 0n));
+  if (klass === NIL) throw new Error(`objc_allocateClassPair(${className}) failed`);
+  for (const selector of selectors) {
+    const cb = new JSCallback((_self: bigint, _cmd: bigint) => true, { args: [ID, ID], returns: FFIType.bool });
+    retained.push(cb);
+    if (!objc.symbols.class_addMethod(klass, sel(selector), cb.ptr, cstr("B@:"))) throw new Error(`class_addMethod(${className}, ${selector}) failed`);
+  }
+  objc.symbols.objc_registerClassPair(klass);
+}
+
+// ---- Data symbols and blocks ------------------------------------------------
+
+const RTLD_NOW = 2;
+const dl = dlopen("/usr/lib/libSystem.B.dylib", {
+  dlopen: { args: [FFIType.ptr, FFIType.i32], returns: FFIType.ptr },
+  dlsym: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.ptr },
+}).symbols;
+
+/** Address of a data symbol (bun's dlopen binds functions only). */
+export function dataSymbolAddress(library: string, name: string): bigint {
+  const image = dl.dlopen(cstr(library), RTLD_NOW);
+  if (image === null) throw new Error(`dlopen(${library}) failed`);
+  const address = dl.dlsym(image, cstr(name));
+  if (address === null) throw new Error(`dlsym(${name}) in ${library} returned null`);
+  return BigInt(address);
+}
+
+const BLOCK_IS_GLOBAL = 1 << 28;
+const BLOCK_LITERAL_SIZE = 32;
+let globalBlockIsa: bigint | undefined;
+const blockDescriptor = new BigUint64Array([0n, BigInt(BLOCK_LITERAL_SIZE)]); // { reserved, size }
+const retainedBlocks: Uint8Array[] = [];
+
+/**
+ * A global Objective-C block (captures nothing, lives for the process) whose
+ * body is a JS function. `argTypes` are the block's own parameters, after the
+ * implicit block pointer. Object parameters must be FFIType.u64.
+ *
+ * `threadsafe` blocks are for completion handlers that AppKit calls on a
+ * background queue; Bun then queues the JS body for the event loop, which is
+ * blocked while the webview runs, so such a body effectively never runs and
+ * the block is fire-and-forget.
+ */
+export function makeBlock(body: (...args: bigint[]) => void, argTypes: FFIType[], threadsafe = false): Id {
+  globalBlockIsa ??= dataSymbolAddress("/usr/lib/libSystem.B.dylib", "_NSConcreteGlobalBlock");
+  const cb = new JSCallback((_block: bigint, ...args: bigint[]) => body(...args), {
+    args: [FFIType.u64, ...argTypes],
+    returns: FFIType.void,
+    threadsafe,
+  });
+  if (cb.ptr === null) throw new Error("sweetnative: could not allocate a block callback");
+  retained.push(cb);
+  const literal = new Uint8Array(BLOCK_LITERAL_SIZE);
+  const dv = new DataView(literal.buffer);
+  dv.setBigUint64(0, globalBlockIsa, true); // isa
+  dv.setInt32(8, BLOCK_IS_GLOBAL, true); // flags
+  dv.setInt32(12, 0, true); // reserved
+  dv.setBigUint64(16, BigInt(cb.ptr), true); // invoke
+  dv.setBigUint64(24, BigInt(ptr(blockDescriptor)), true); // descriptor
+  retainedBlocks.push(literal);
+  return BigInt(ptr(literal));
+}
+
+/** Calls a block someone handed us (a completion handler): `invoke(block, ...args)`. */
+export function invokeBlock(block: Id, argTypes: FFIType[], ...args: (bigint | number)[]): void {
+  if (block === NIL) return;
+  const invoke = read.ptr(Number(block) as Pointer, 16) as unknown as Pointer | bigint | null;
+  if (invoke === null) throw new Error("sweetnative: block has no invoke pointer");
+  const fn = CFunction({ ptr: Number(invoke) as Pointer, args: [FFIType.u64, ...argTypes], returns: FFIType.void }) as unknown as (...a: unknown[]) => void;
+  fn(block, ...args);
+}
+
+// ---- More objc_msgSend shapes (tray, menus, window) -------------------------
+
+/** [obj sel:double] -> id  (statusItemWithLength:) */
+export const sendF64 = fn([ID, ID, FFIType.f64], ID);
+/** [obj sel] -> double  (doubleClickInterval) */
+export const sendRetF64 = fn([ID, ID], FFIType.f64);
+/** [obj sel] -> BOOL  (isVisible) */
+export const sendRetBool = fn([ID, ID], FFIType.bool);
+/** [obj sel:NSInteger] -> void  (setState:) */
+export const sendIntArg = fn([ID, ID, FFIType.i64], FFIType.void);
+/** [obj sel:NSUInteger :id] -> void  (requestAuthorizationWithOptions:completionHandler:) */
+export const sendUIntPtrVoid = fn([ID, ID, FFIType.u64, ID], FFIType.void);
+/** [obj sel:id :id :id] -> id  (requestWithIdentifier:content:trigger:) */
+export const sendPtrPtrPtr = fn([ID, ID, ID, ID, ID], ID);
+/** [obj sel:NSUInteger] -> id  (standardWindowButton:) */
+export const sendUIntRetPtr = fn([ID, ID, FFIType.u64], ID);
+/** [obj sel:NSUInteger] -> NSInteger  (sendActionOn:) */
+export const sendUInt = fn([ID, ID, FFIType.u64], FFIType.i64);
+/** [obj sel:id :id] -> id  (imageWithSystemSymbolName:accessibilityDescription:) */
+export const sendPtrPtr = fn([ID, ID, ID, ID], ID);
+/** [obj sel:bytes :NSUInteger] -> id  (dataWithBytes:length:) */
+export const sendBytesLen = fn([ID, ID, FFIType.ptr, FFIType.u64], ID);
+/** [obj sel:SEL :id :double] -> void  (performSelector:withObject:afterDelay:) */
+export const sendSelPtrF64 = fn([ID, ID, ID, ID, FFIType.f64], FFIType.void);
+/** [obj sel:id :SEL :id] -> void  (cancelPreviousPerformRequestsWithTarget:selector:object:) */
+export const sendPtrSelPtrVoid = fn([ID, ID, ID, ID, ID], FFIType.void);
+
+// Structs by value. On arm64 an NSRect (4 doubles) and an NSPoint (2 doubles)
+// are passed in d0..d3 exactly like separate double arguments, and integer
+// arguments after them still go in x2.. (Apple Silicon only, as is this package).
+/** [obj sel:NSRect :NSUInteger :NSUInteger :BOOL] -> id  (initWithContentRect:styleMask:backing:defer:) */
+export const sendRectUIntUIntBool = fn([ID, ID, FFIType.f64, FFIType.f64, FFIType.f64, FFIType.f64, FFIType.u64, FFIType.u64, FFIType.bool], ID);
+/** [obj sel:NSRect :BOOL] -> void  (setFrame:display:) */
+export const sendRectBool = fn([ID, ID, FFIType.f64, FFIType.f64, FFIType.f64, FFIType.f64, FFIType.bool], FFIType.void);
+/** [obj sel:NSPoint] -> void  (setFrameOrigin:) */
+export const sendPoint = fn([ID, ID, FFIType.f64, FFIType.f64], FFIType.void);
+/** [obj sel:NSSize] -> void  (setSize:); NSSize is two doubles like NSPoint, so the same call. */
+export const sendSize = sendPoint;
+/** [obj sel:NSUInteger] -> void  (setCollectionBehavior:, setStyleMask:) */
+export const sendUIntArg = fn([ID, ID, FFIType.u64], FFIType.void);
+/** [obj sel:double] -> void  (setAlphaValue:) */
+export const sendF64Void = fn([ID, ID, FFIType.f64], FFIType.void);
+/** [obj sel:void*] -> id  (getReturnValue:, getValue:) */
+export const sendPtrArg = fn([ID, ID, FFIType.ptr], ID);
+/** [obj sel:double :id :SEL :id :BOOL] -> id  (scheduledTimerWithTimeInterval:target:selector:userInfo:repeats:) */
+export const sendF64PtrSelPtrBool = fn([ID, ID, FFIType.f64, ID, ID, ID, FFIType.bool], ID);
+
+export const retain = (obj: Id): Id => asId(send(obj, sel("retain")));
+export const release = (obj: Id): void => {
+  if (obj !== NIL) send(obj, sel("release"));
+};