@auraindustry/aurajs 0.0.7 → 0.1.1

package/src/retro/diagnostics/catalog.mjs

@@ -0,0 +1,110 @@
+export const RETRO_DIAGNOSTIC_DEFINITIONS = Object.freeze({
+  retro_module_syntax_error: Object.freeze({
+    message: 'Module syntax is not valid for the Aura Retro compiler lane.',
+    hint: 'Fix the syntax error before retrying the retro target.',
+    doc: 'docs/retro/diagnostics.md#syntax-and-module-loading',
+  }),
+  retro_module_not_found: Object.freeze({
+    message: 'A referenced module could not be resolved inside the retro source boundary.',
+    hint: 'Use relative imports that stay inside the authored source boundary.',
+    doc: 'docs/retro/diagnostics.md#syntax-and-module-loading',
+  }),
+  retro_import_specifier_unsupported: Object.freeze({
+    message: 'Only static relative imports are supported in Aura Retro.',
+    hint: 'Replace package or bare specifiers with relative source modules.',
+    doc: 'docs/retro/language-subset.md#module-rules',
+  }),
+  retro_import_path_escape: Object.freeze({
+    message: 'Retro source files must stay inside the authored source boundary.',
+    hint: 'Move the imported module into the project source boundary or remove the import.',
+    doc: 'docs/retro/language-subset.md#module-rules',
+  }),
+  retro_dynamic_import_unsupported: Object.freeze({
+    message: 'Dynamic import() is not supported in Aura Retro.',
+    hint: 'Use static imports so the compiler can build a deterministic cartridge graph.',
+    doc: 'docs/retro/language-subset.md#forbidden-constructs',
+  }),
+  retro_circular_dependency_unsupported: Object.freeze({
+    message: 'Circular module dependencies are not supported in Aura Retro.',
+    hint: 'Break the cycle so setup, update, and draw dependencies stay explicit.',
+    doc: 'docs/retro/diagnostics.md#syntax-and-module-loading',
+  }),
+  retro_async_unsupported: Object.freeze({
+    message: 'Async control flow is not supported in Aura Retro.',
+    hint: 'Rewrite the logic to use synchronous state updates.',
+    doc: 'docs/retro/language-subset.md#forbidden-constructs',
+  }),
+  retro_eval_unsupported: Object.freeze({
+    message: 'Runtime code evaluation is not supported in Aura Retro.',
+    hint: 'Use plain functions and explicit state instead of eval.',
+    doc: 'docs/retro/language-subset.md#forbidden-constructs',
+  }),
+  retro_dynamic_property_access_unsupported: Object.freeze({
+    message: 'Dynamic computed property access is not supported in Aura Retro.',
+    hint: 'Use explicit object fields or fixed lookup tables with static keys.',
+    doc: 'docs/retro/language-subset.md#memory-shape-and-mutation',
+  }),
+  retro_runtime_asset_load_unsupported: Object.freeze({
+    message: 'Runtime asset loading is not supported in Aura Retro.',
+    hint: 'Move assets into compile-time project content instead of loading them at runtime.',
+    doc: 'docs/retro/api-subset.md#excluded-namespaces-and-behaviors',
+  }),
+  retro_3d_api_unsupported: Object.freeze({
+    message: 'Current AuraScript 3D APIs are outside the Aura Retro subset.',
+    hint: 'Stay inside the 2D tile, sprite, text, and audio subset for retro targets.',
+    doc: 'docs/retro/api-subset.md#excluded-namespaces-and-behaviors',
+  }),
+  retro_desktop_api_unsupported: Object.freeze({
+    message: 'Desktop-only Aura APIs are outside the Aura Retro subset.',
+    hint: 'Remove filesystem, networking, multiplayer, and platform-specific calls from retro builds.',
+    doc: 'docs/retro/api-subset.md#excluded-namespaces-and-behaviors',
+  }),
+  retro_gb_color_feature_unsupported: Object.freeze({
+    message: 'The original GB target does not support GBC-only color feature usage.',
+    hint: 'Build with `--target gbc` or remove palette/color-specific authored data.',
+    doc: 'docs/retro/target-profiles.md#gb-vs-gbc',
+  }),
+  retro_asset_format_unsupported: Object.freeze({
+    message: 'Retro asset content does not match the Aura Retro asset manifest contract.',
+    hint: 'Fix the asset manifest shape or pixel rows so the selected retro target can compile deterministic assets.',
+    doc: 'docs/retro/diagnostics.md#target-and-assets',
+  }),
+  retro_asset_budget_exceeded: Object.freeze({
+    message: 'Retro asset content exceeds the selected target profile budget.',
+    hint: 'Reduce palettes, tiles, sprites, or font glyph counts until the project fits the target profile.',
+    doc: 'docs/retro/diagnostics.md#target-and-assets',
+  }),
+  retro_build_blocked_by_diagnostics: Object.freeze({
+    message: 'Aura Retro build is blocked by compiler diagnostics.',
+    hint: 'Run `aura retro check` first and fix the reported unsupported code.',
+    doc: 'docs/retro/diagnostics.md#payload-shape',
+  }),
+  retro_emulator_not_found: Object.freeze({
+    message: 'No supported Aura Retro emulator was found.',
+    hint: 'Install mGBA or pass an explicit emulator path with `aura retro run --emulator <path>`.',
+    doc: 'docs/retro/emulator.md#discovery-order',
+  }),
+  retro_emulator_target_unsupported: Object.freeze({
+    message: 'The selected emulator does not support the requested Aura Retro target.',
+    hint: 'Switch to an emulator that supports the target or change the build target.',
+    doc: 'docs/retro/emulator.md#supported-emulators',
+  }),
+  retro_emulator_rom_not_found: Object.freeze({
+    message: 'Aura Retro could not find a ROM artifact to launch.',
+    hint: 'Run `aura build --target <gb|gbc|gba>` first or pass `--rom <path>`.',
+    doc: 'docs/retro/emulator.md#run-and-smoke-commands',
+  }),
+  retro_emulator_launch_failed: Object.freeze({
+    message: 'Aura Retro failed to launch the selected emulator.',
+    hint: 'Check the emulator path, ROM path, and CLI flags, then retry with `aura retro smoke --json` for details.',
+    doc: 'docs/retro/emulator.md#run-and-smoke-commands',
+  }),
+});
+
+export function getRetroDiagnosticDefinition(reasonCode) {
+  return RETRO_DIAGNOSTIC_DEFINITIONS[reasonCode] || {
+    message: 'Aura Retro reported an unknown compiler diagnostic.',
+    hint: 'Inspect the diagnostic payload and update the compiler contract if needed.',
+    doc: 'docs/retro/diagnostics.md',
+  };
+}

package/src/retro/diagnostics/emit.mjs

@@ -0,0 +1,72 @@
+import { getRetroDiagnosticDefinition } from './catalog.mjs';
+import { relFile } from '../shared/span.mjs';
+
+export class RetroCompileError extends Error {
+  constructor(reasonCode, message, details = {}) {
+    super(message);
+    this.name = 'RetroCompileError';
+    this.reasonCode = reasonCode;
+    this.details = details;
+  }
+}
+
+export function createRetroDiagnostic({
+  reasonCode,
+  filePath,
+  span,
+  message = null,
+  hint = null,
+  doc = null,
+  source = null,
+}) {
+  const definition = getRetroDiagnosticDefinition(reasonCode);
+  return {
+    severity: 'error',
+    reasonCode,
+    filePath,
+    span: span || null,
+    message: message || definition.message,
+    hint: hint || definition.hint,
+    doc: doc || definition.doc,
+    source: source || 'retro-validator',
+  };
+}
+
+export function formatRetroDiagnostic(diagnostic, projectRoot = process.cwd()) {
+  const file = diagnostic.filePath ? relFile(projectRoot, diagnostic.filePath) : '<unknown>';
+  const span = diagnostic.span && diagnostic.span.line
+    ? `${file}:${diagnostic.span.line}:${diagnostic.span.column || 1}`
+    : file;
+  const detail = [`${diagnostic.reasonCode}: ${diagnostic.message}`, `at ${span}`];
+  if (diagnostic.hint) {
+    detail.push(`hint: ${diagnostic.hint}`);
+  }
+  if (diagnostic.doc) {
+    detail.push(`docs: ${diagnostic.doc}`);
+  }
+  return detail.join('\n');
+}
+
+export function formatRetroDiagnosticReport(report, projectRoot = process.cwd()) {
+  const lines = [];
+  const diagnostics = Array.isArray(report?.diagnostics) ? report.diagnostics : [];
+  lines.push(
+    report?.ok
+      ? `Aura Retro check passed (${report.target}, modules=${report.moduleCount}).`
+      : `Aura Retro check failed (${report?.target || 'unknown'}, diagnostics=${diagnostics.length}).`,
+  );
+  for (const diagnostic of diagnostics) {
+    lines.push('');
+    lines.push(formatRetroDiagnostic(diagnostic, projectRoot));
+  }
+  return lines.join('\n');
+}
+
+export function formatRetroCompileError(error, projectRoot = process.cwd()) {
+  const diagnostics = Array.isArray(error?.details?.diagnostics) ? error.details.diagnostics : [];
+  const header = `${error.reasonCode || 'retro_compile_failed'}: ${error.message}`;
+  if (diagnostics.length === 0) {
+    return header;
+  }
+  return [header, ...diagnostics.map((diagnostic) => formatRetroDiagnostic(diagnostic, projectRoot))].join('\n\n');
+}

package/src/retro/emulator/case-overlay.mjs

@@ -0,0 +1,64 @@
+import { existsSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { spawn } from 'node:child_process';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const DEFAULT_SWIFT_HELPER_PATH = resolve(here, 'macos-case-overlay.swift');
+const SUPPORTED_PROFILE_IDS = new Set(['mgba', 'mgba-qt']);
+
+function isSupportedProfile(profileId) {
+  return SUPPORTED_PROFILE_IDS.has(String(profileId || '').trim());
+}
+
+function resolveCaseHelperPath() {
+  const override = String(process.env.AURA_RETRO_CASE_HELPER || '').trim();
+  if (override) {
+    return resolve(process.cwd(), override);
+  }
+  return DEFAULT_SWIFT_HELPER_PATH;
+}
+
+function createHelperArgs({ emulatorPid, caseStyle = 'gba' }) {
+  return [
+    '--pid',
+    String(emulatorPid),
+    '--style',
+    String(caseStyle || 'gba'),
+  ];
+}
+
+export function shouldUseRetroCaseOverlay({ caseEnabled = false, profileId = null, headless = false } = {}) {
+  return Boolean(caseEnabled)
+    && process.platform === 'darwin'
+    && !headless
+    && isSupportedProfile(profileId);
+}
+
+export function launchRetroCaseOverlay({
+  emulatorPid,
+  profileId,
+  caseStyle = 'gba',
+  stdio = 'ignore',
+} = {}) {
+  if (!shouldUseRetroCaseOverlay({ caseEnabled: true, profileId, headless: false })) {
+    return null;
+  }
+  const helperPath = resolveCaseHelperPath();
+  if (!existsSync(helperPath)) {
+    return null;
+  }
+  const command = helperPath.endsWith('.swift')
+    ? 'swift'
+    : helperPath;
+  const args = helperPath.endsWith('.swift')
+    ? [helperPath, ...createHelperArgs({ emulatorPid, caseStyle })]
+    : createHelperArgs({ emulatorPid, caseStyle });
+  const child = spawn(command, args, {
+    cwd: process.cwd(),
+    stdio,
+    env: process.env,
+  });
+  child.once('error', () => {});
+  return child;
+}

package/src/retro/emulator/discovery.mjs

@@ -0,0 +1,158 @@
+import { accessSync, constants, existsSync } from 'node:fs';
+import { delimiter, extname, isAbsolute, join, resolve } from 'node:path';
+import {
+  buildRetroEmulatorArgs,
+  detectRetroEmulatorProfile,
+  getRetroEmulatorCandidateNames,
+  supportsRetroEmulatorTarget,
+} from './profiles.mjs';
+
+function isExecutableFile(filePath) {
+  try {
+    accessSync(filePath, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function isExplicitCommand(value) {
+  const normalized = String(value || '').trim();
+  return normalized.includes('/') || normalized.includes('\\') || normalized.startsWith('.');
+}
+
+function getWindowsExecutableVariants(commandName) {
+  if (process.platform !== 'win32') {
+    return [commandName];
+  }
+  const pathExt = String(process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM')
+    .split(';')
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+  if (extname(commandName)) {
+    return [commandName];
+  }
+  return pathExt.map((entry) => `${commandName}${entry.toLowerCase()}`);
+}
+
+function resolveCommandPath(commandName) {
+  const normalized = String(commandName || '').trim();
+  if (!normalized) {
+    return null;
+  }
+  if (isExplicitCommand(normalized)) {
+    const absolute = isAbsolute(normalized) ? normalized : resolve(process.cwd(), normalized);
+    return existsSync(absolute) && isExecutableFile(absolute) ? absolute : null;
+  }
+  const pathEntries = String(process.env.PATH || '')
+    .split(delimiter)
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+  for (const directory of pathEntries) {
+    for (const candidateName of getWindowsExecutableVariants(normalized)) {
+      const candidatePath = join(directory, candidateName);
+      if (existsSync(candidatePath) && isExecutableFile(candidatePath)) {
+        return candidatePath;
+      }
+    }
+  }
+  return null;
+}
+
+function buildDiscoveryRecord({ source, command, executablePath, profile }) {
+  return {
+    source,
+    command,
+    executablePath,
+    profileId: profile?.id || 'custom',
+  };
+}
+
+function resolveExplicitEmulator(command, target) {
+  const executablePath = resolveCommandPath(command);
+  if (!executablePath) {
+    return {
+      emulator: null,
+      checked: [buildDiscoveryRecord({ source: 'explicit', command, executablePath: null, profile: null })],
+    };
+  }
+  const profile = detectRetroEmulatorProfile(executablePath);
+  if (profile && !supportsRetroEmulatorTarget(profile, target)) {
+    return {
+      emulator: null,
+      checked: [buildDiscoveryRecord({ source: 'explicit', command, executablePath, profile })],
+      unsupportedProfile: profile,
+    };
+  }
+  return {
+    emulator: {
+        command,
+        executablePath,
+        profile,
+        argsFor(options) {
+          return buildRetroEmulatorArgs(profile, options);
+        },
+      },
+    checked: [buildDiscoveryRecord({ source: 'explicit', command, executablePath, profile })],
+  };
+}
+
+export function discoverRetroEmulator({
+  target,
+  explicitEmulator = null,
+  smoke = false,
+  env = process.env,
+} = {}) {
+  const checked = [];
+  const requested = String(explicitEmulator || '').trim();
+  if (requested) {
+    const result = resolveExplicitEmulator(requested, target);
+    return {
+      emulator: result.emulator,
+      checked: checked.concat(result.checked),
+      unsupportedProfile: result.unsupportedProfile || null,
+    };
+  }
+
+  const envCommand = String(env.AURA_RETRO_EMULATOR || '').trim();
+  if (envCommand) {
+    const result = resolveExplicitEmulator(envCommand, target);
+    return {
+      emulator: result.emulator,
+      checked: checked.concat(result.checked.map((entry) => ({ ...entry, source: 'env' }))),
+      unsupportedProfile: result.unsupportedProfile || null,
+    };
+  }
+
+  for (const commandName of getRetroEmulatorCandidateNames({ target, smoke })) {
+    const executablePath = resolveCommandPath(commandName);
+    const profile = executablePath ? detectRetroEmulatorProfile(executablePath) : null;
+    checked.push(buildDiscoveryRecord({
+      source: 'candidate',
+      command: commandName,
+      executablePath,
+      profile,
+    }));
+    if (!executablePath) {
+      continue;
+    }
+    return {
+      emulator: {
+        command: commandName,
+        executablePath,
+        profile,
+        argsFor(options) {
+          return buildRetroEmulatorArgs(profile, options);
+        },
+      },
+      checked,
+      unsupportedProfile: null,
+    };
+  }
+
+  return {
+    emulator: null,
+    checked,
+    unsupportedProfile: null,
+  };
+}

package/src/retro/emulator/macos-case-overlay.swift

@@ -0,0 +1,220 @@
+import AppKit
+import CoreGraphics
+import Foundation
+
+struct Options {
+    let pid: pid_t
+    let style: String
+}
+
+func parseOptions() -> Options? {
+    var pid: pid_t?
+    var style = "gba"
+    var index = 1
+    while index < CommandLine.arguments.count {
+        let token = CommandLine.arguments[index]
+        switch token {
+        case "--pid":
+            guard index + 1 < CommandLine.arguments.count,
+                  let value = Int32(CommandLine.arguments[index + 1]) else { return nil }
+            pid = value
+            index += 2
+        case "--style":
+            guard index + 1 < CommandLine.arguments.count else { return nil }
+            style = CommandLine.arguments[index + 1]
+            index += 2
+        default:
+            index += 1
+        }
+    }
+    guard let resolvedPid = pid else { return nil }
+    return Options(pid: resolvedPid, style: style)
+}
+
+func findWindowBounds(for pid: pid_t) -> CGRect? {
+    guard let info = CGWindowListCopyWindowInfo([.optionOnScreenOnly], kCGNullWindowID) as? [[String: Any]] else {
+        return nil
+    }
+    for entry in info {
+        guard let ownerPid = entry[kCGWindowOwnerPID as String] as? pid_t,
+              ownerPid == pid,
+              let layer = entry[kCGWindowLayer as String] as? Int,
+              layer == 0,
+              let boundsDictionary = entry[kCGWindowBounds as String] as? NSDictionary,
+              let bounds = CGRect(dictionaryRepresentation: boundsDictionary) else {
+            continue
+        }
+        if bounds.width > 100 && bounds.height > 80 {
+            return bounds
+        }
+    }
+    return nil
+}
+
+final class CaseView: NSView {
+    private let style: String
+    private var screenRect = CGRect.zero
+
+    init(frame frameRect: NSRect, style: String) {
+        self.style = style
+        super.init(frame: frameRect)
+        wantsLayer = true
+        layer?.backgroundColor = NSColor.clear.cgColor
+    }
+
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+
+    func updateScreenRect(_ rect: CGRect) {
+        screenRect = rect
+        needsDisplay = true
+    }
+
+    override func draw(_ dirtyRect: NSRect) {
+        NSColor.clear.setFill()
+        dirtyRect.fill()
+
+        let bounds = self.bounds
+        let shellPath = NSBezierPath(roundedRect: bounds.insetBy(dx: 6, dy: 6), xRadius: 48, yRadius: 48)
+        let cutout = NSBezierPath(roundedRect: screenRect, xRadius: 18, yRadius: 18)
+        shellPath.append(cutout)
+        shellPath.windingRule = .evenOdd
+
+        NSColor(calibratedRed: 0.92, green: 0.92, blue: 0.86, alpha: 0.96).setFill()
+        shellPath.fill()
+
+        let stroke = NSBezierPath(roundedRect: bounds.insetBy(dx: 6, dy: 6), xRadius: 48, yRadius: 48)
+        NSColor(calibratedRed: 0.70, green: 0.70, blue: 0.64, alpha: 1.0).setStroke()
+        stroke.lineWidth = 6
+        stroke.stroke()
+
+        drawControls(in: bounds)
+    }
+
+    private func drawControls(in bounds: CGRect) {
+        let dpadCenter = CGPoint(x: bounds.minX + bounds.width * 0.18, y: bounds.minY + bounds.height * 0.28)
+        drawDPad(center: dpadCenter, size: min(bounds.width, bounds.height) * 0.14)
+
+        let aCenter = CGPoint(x: bounds.maxX - bounds.width * 0.18, y: bounds.minY + bounds.height * 0.31)
+        drawButton(center: CGPoint(x: aCenter.x + 28, y: aCenter.y), radius: 26)
+        drawButton(center: CGPoint(x: aCenter.x - 6, y: aCenter.y + 26), radius: 26)
+
+        drawPill(CGRect(x: bounds.midX - 58, y: bounds.minY + bounds.height * 0.15, width: 42, height: 14))
+        drawPill(CGRect(x: bounds.midX + 16, y: bounds.minY + bounds.height * 0.15, width: 42, height: 14))
+
+        if style == "gba" {
+            let speakerStartX = bounds.maxX - bounds.width * 0.14
+            let speakerStartY = bounds.minY + bounds.height * 0.16
+            for row in 0..<3 {
+                for col in 0..<5 {
+                    let circle = NSBezierPath(ovalIn: CGRect(x: speakerStartX + CGFloat(col * 10), y: speakerStartY + CGFloat(row * 10), width: 4, height: 4))
+                    NSColor(calibratedRed: 0.62, green: 0.62, blue: 0.57, alpha: 1).setFill()
+                    circle.fill()
+                }
+            }
+        }
+    }
+
+    private func drawDPad(center: CGPoint, size: CGFloat) {
+        let thickness = size * 0.34
+        let vertical = NSBezierPath(roundedRect: CGRect(x: center.x - thickness / 2, y: center.y - size / 2, width: thickness, height: size), xRadius: 10, yRadius: 10)
+        let horizontal = NSBezierPath(roundedRect: CGRect(x: center.x - size / 2, y: center.y - thickness / 2, width: size, height: thickness), xRadius: 10, yRadius: 10)
+        NSColor(calibratedRed: 0.47, green: 0.47, blue: 0.44, alpha: 1).setFill()
+        vertical.fill()
+        horizontal.fill()
+    }
+
+    private func drawButton(center: CGPoint, radius: CGFloat) {
+        let circle = NSBezierPath(ovalIn: CGRect(x: center.x - radius, y: center.y - radius, width: radius * 2, height: radius * 2))
+        NSColor(calibratedRed: 0.72, green: 0.46, blue: 0.55, alpha: 1).setFill()
+        circle.fill()
+        NSColor(calibratedRed: 0.55, green: 0.32, blue: 0.40, alpha: 1).setStroke()
+        circle.lineWidth = 3
+        circle.stroke()
+    }
+
+    private func drawPill(_ rect: CGRect) {
+        let pill = NSBezierPath(roundedRect: rect, xRadius: rect.height / 2, yRadius: rect.height / 2)
+        NSColor(calibratedRed: 0.63, green: 0.63, blue: 0.59, alpha: 1).setFill()
+        pill.fill()
+    }
+}
+
+final class OverlayController: NSObject, NSApplicationDelegate {
+    private let options: Options
+    private var window: NSWindow?
+    private var view: CaseView?
+    private var timer: Timer?
+    private let padding = NSEdgeInsets(top: 48, left: 120, bottom: 120, right: 120)
+
+    init(options: Options) {
+        self.options = options
+        super.init()
+    }
+
+    func applicationDidFinishLaunching(_ notification: Notification) {
+        guard let bounds = findWindowBounds(for: options.pid) else {
+            NSApp.terminate(nil)
+            return
+        }
+        let frame = expandedFrame(for: bounds)
+        let window = NSWindow(contentRect: frame, styleMask: [.borderless], backing: .buffered, defer: false)
+        window.isOpaque = false
+        window.backgroundColor = .clear
+        window.level = .statusBar
+        window.ignoresMouseEvents = true
+        window.hasShadow = false
+        window.collectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary]
+
+        let view = CaseView(frame: NSRect(origin: .zero, size: frame.size), style: options.style)
+        window.contentView = view
+        window.orderFrontRegardless()
+        self.window = window
+        self.view = view
+        updateOverlayFrame(windowBounds: bounds)
+
+        timer = Timer.scheduledTimer(withTimeInterval: 0.1, repeats: true) { [weak self] _ in
+            guard let self else { return }
+            if NSRunningApplication(processIdentifier: self.options.pid) == nil {
+                NSApp.terminate(nil)
+                return
+            }
+            guard let nextBounds = findWindowBounds(for: self.options.pid) else { return }
+            self.updateOverlayFrame(windowBounds: nextBounds)
+        }
+    }
+
+    private func expandedFrame(for bounds: CGRect) -> NSRect {
+        NSRect(
+            x: bounds.origin.x - padding.left,
+            y: bounds.origin.y - padding.bottom,
+            width: bounds.width + padding.left + padding.right,
+            height: bounds.height + padding.top + padding.bottom
+        )
+    }
+
+    private func updateOverlayFrame(windowBounds: CGRect) {
+        guard let window, let view else { return }
+        let frame = expandedFrame(for: windowBounds)
+        window.setFrame(frame, display: true)
+        view.frame = NSRect(origin: .zero, size: frame.size)
+        view.updateScreenRect(CGRect(
+            x: padding.left,
+            y: padding.bottom,
+            width: windowBounds.width,
+            height: windowBounds.height
+        ))
+    }
+}
+
+guard let options = parseOptions() else {
+    fputs("Usage: macos-case-overlay.swift --pid <pid> [--style gba]\n", stderr)
+    exit(2)
+}
+
+let app = NSApplication.shared
+let delegate = OverlayController(options: options)
+app.setActivationPolicy(.accessory)
+app.delegate = delegate
+app.run()