akanjs 3.0.0-beta.9 → 3.0.1

package/vendor/@akanjs/native/plugins/updates/src/index.ts

@@ -0,0 +1,107 @@
+import { createLiveValue, definePlugin, isAkanNativeError } from "../../../packages/core/src/index.ts";
+import { useLiveValue } from "../../../packages/react/src/index.ts";
+
+/**
+ * Over-the-air updates. On iOS and Android they replace the web bundle (UP-2); the native code
+ * stays, so a bundle only runs in a binary with the same native API (UP-3, `nativeApi`). On macOS,
+ * Windows and Linux they replace the whole app (UP-1). Releases are made with
+ * `akan-native update publish <platform>` and signed with the key of `akan-native update keygen`.
+ *
+ * A new bundle first runs on trial: the app calls notifyReady() once it works. A trial that does
+ * not confirm within `updates.readyTimeout` (akan-native.config.ts, default 10 s), or that crashes and is
+ * launched again, is rolled back to the previous bundle. On a desktop app that carries a server, the
+ * trial also waits for that server to answer and stay up.
+ */
+export interface UpdateState {
+  /** The downloaded bundle running now; null = the one inside the app. */
+  bundle: string | null;
+  /** Its sequence (publish time, seconds); 0 for the app's own bundle. */
+  sequence: number;
+  /** Downloaded and verified, runs at the next launch or after apply(). */
+  pending: string | null;
+  /** Running for the first time: call notifyReady() once the app works, or it is rolled back. */
+  trial: boolean;
+  /** The last bundle that was rolled back, if any. */
+  rolledBack: string | null;
+  /** The manifest channel (akan-native.config.ts `updates.channel`). */
+  channel: string;
+  /** What this binary provides natively (UP-3); bundles for another value are ignored. */
+  nativeApi: string | null;
+}
+
+export interface UpdateCheck {
+  /**
+   * A newer bundle for this binary exists (not rolled back before). Desktop: never the release on trial, nor one whose
+   * server presence differs from this app's.
+   */
+  available: boolean;
+  bundle: string | null;
+  /** The app version it was published with. */
+  version: string | null;
+  sequence: number | null;
+  /** Bytes still to download; files the running bundle already has are copied. */
+  downloadSize: number | null;
+}
+
+export interface UpdateProgress {
+  received: number;
+  total: number;
+}
+
+export interface UpdatesApi {
+  getState(): Promise<UpdateState>;
+  /** Fetches and verifies the signed manifest. Rejects NOT_FOUND when nothing is published, INTERNAL for a bad signature. */
+  check(): Promise<UpdateCheck>;
+  /** Downloads and verifies the latest bundle; it runs at the next launch (or apply()). */
+  download(): Promise<{ bundle: string }>;
+  /**
+   * Phones: reloads the page into the downloaded bundle now (on trial). Desktop: replaces the app with the download and
+   * relaunches it (on trial); rejects NOT_ALLOWED while the running release is still on trial. Rejects NOT_FOUND
+   * without a download.
+   */
+  apply(): Promise<void>;
+  /** The running bundle works: keep it. Call it once the app has started; harmless otherwise. */
+  notifyReady(): Promise<void>;
+  /**
+   * Phones: back to the app's own bundle from the next launch on. Desktop: drops the download and forgets the refused
+   * releases; the running app stays, and a trial keeps its record.
+   */
+  reset(): Promise<void>;
+}
+
+export interface UpdatesEvents {
+  progress: UpdateProgress;
+}
+
+export const updates = definePlugin<UpdatesApi, UpdatesEvents>("updates", {
+  methods: ["getState", "check", "download", "apply", "notifyReady", "reset"],
+  events: ["progress"],
+});
+
+/**
+ * notifyReady() where updates exist, nothing elsewhere (web, apps without updates configured).
+ * Call it once the app has rendered.
+ */
+export async function markReady(): Promise<void> {
+  if (!updates.isSupported("notifyReady")) return;
+  try {
+    await updates.notifyReady();
+  } catch (error) {
+    if (!isAkanNativeError(error, "UNSUPPORTED")) throw error;
+  }
+}
+
+const state = createLiveValue<UpdateState | null>(null, (set) => {
+  if (updates.isSupported("getState")) updates.getState().then(set, () => set(null));
+});
+
+/** The update state, refreshed after download/apply through `refresh()`. null where updates do not exist. */
+export function useUpdateState(): { state: UpdateState | null; refresh: () => Promise<void> } {
+  const value = useLiveValue(state);
+  return {
+    state: value,
+    refresh: async () => {
+      if (updates.isSupported("getState")) state.set(await updates.getState());
+    },
+  };
+}

package/vendor/@akanjs/native/plugins/volume/android/VolumePlugin.kt

@@ -0,0 +1,107 @@
+package com.akanjs.plugins.volume
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.media.AudioManager
+import com.akanjs.runtime.AkanNativeErrorCode
+import com.akanjs.runtime.AkanNativePluginContext
+import com.akanjs.runtime.AkanNativeReply
+import kotlin.math.roundToInt
+
+/**
+ * The media volume (STREAM_MUSIC), what the volume keys move while the app plays: the level and mute the
+ * desktop reports for the default output.
+ * - A volume change unmutes a muted stream (AudioService), so setVolume mutes it again: the desktop keeps
+ *   the mute apart from the level.
+ * - VOLUME_CHANGED_ACTION and STREAM_MUTE_CHANGED_ACTION are the system's own broadcasts, public only as
+ *   strings. A receiver registered with RECEIVER_NOT_EXPORTED still gets them (they come from the system).
+ * - A fixed volume (isVolumeFixed: a TV box whose HDMI sink sets it) reads, but setVolume and setMuted
+ *   answer UNSUPPORTED.
+ */
+class VolumePlugin(private val context: AkanNativePluginContext) : VolumePluginSpec {
+    private val audio: AudioManager? = context.activity.getSystemService(AudioManager::class.java)
+    private val events = VolumeEvents(context)
+    private var receiver: BroadcastReceiver? = null
+    private var last: VolumeState? = null
+
+    override fun getVolume(reply: AkanNativeReply<VolumeState>) {
+        val am = audio ?: return reply.reject(AkanNativeErrorCode.UNSUPPORTED, "this device has no audio service")
+        reply.resolve(state(am))
+    }
+
+    override fun setVolume(args: VolumeSetVolumeArgs, reply: AkanNativeReply<VolumeState>) {
+        val am = settable(reply) ?: return
+        if (!(args.level >= 0.0 && args.level <= 1.0))
+            return reply.reject(AkanNativeErrorCode.INVALID_ARGS, "level must be a number from 0 to 1")
+        val muted = am.isStreamMute(STREAM)
+        val min = am.getStreamMinVolume(STREAM)
+        val max = am.getStreamMaxVolume(STREAM)
+        am.setStreamVolume(STREAM, min + ((max - min) * args.level).roundToInt(), 0)
+        if (muted && !am.isStreamMute(STREAM)) am.adjustStreamVolume(STREAM, AudioManager.ADJUST_MUTE, 0)
+        reply.resolve(state(am))
+    }
+
+    override fun setMuted(args: VolumeSetMutedArgs, reply: AkanNativeReply<VolumeState>) {
+        val am = settable(reply) ?: return
+        am.adjustStreamVolume(STREAM, if (args.muted) AudioManager.ADJUST_MUTE else AudioManager.ADJUST_UNMUTE, 0)
+        reply.resolve(state(am))
+    }
+
+    override fun startListening(event: String) {
+        val am = audio
+        if (event != "change" || receiver != null || am == null) return
+        last = state(am)
+        val r = object : BroadcastReceiver() {
+            override fun onReceive(c: Context, intent: Intent) {
+                val next = state(am)
+                if (next == last) return
+                last = next
+                events.change(next)
+            }
+        }
+        val filter = IntentFilter().apply {
+            addAction(VOLUME_CHANGED)
+            addAction(MUTE_CHANGED)
+        }
+        context.activity.registerReceiver(r, filter, Context.RECEIVER_NOT_EXPORTED)
+        receiver = r
+    }
+
+    override fun stopListening(event: String) {
+        val r = receiver
+        if (event != "change" || r == null) return
+        context.activity.unregisterReceiver(r)
+        receiver = null
+    }
+
+    override fun destroy() = stopListening("change")
+
+    private fun settable(reply: AkanNativeReply<VolumeState>): AudioManager? {
+        val am = audio
+        when {
+            am == null -> reply.reject(AkanNativeErrorCode.UNSUPPORTED, "this device has no audio service")
+            am.isVolumeFixed -> reply.reject(AkanNativeErrorCode.UNSUPPORTED, "this device's volume is fixed")
+            else -> return am
+        }
+        return null
+    }
+
+    private fun state(am: AudioManager): VolumeState {
+        val min = am.getStreamMinVolume(STREAM)
+        val max = am.getStreamMaxVolume(STREAM)
+        val level = if (max > min) (am.getStreamVolume(STREAM) - min).toDouble() / (max - min) else null
+        return VolumeState(
+            level = level?.let { Math.round(it * 1000) / 1000.0 },
+            muted = am.isStreamMute(STREAM),
+            settable = !am.isVolumeFixed,
+        )
+    }
+
+    private companion object {
+        const val STREAM = AudioManager.STREAM_MUSIC
+        const val VOLUME_CHANGED = "android.media.VOLUME_CHANGED_ACTION"
+        const val MUTE_CHANGED = "android.media.STREAM_MUTE_CHANGED_ACTION"
+    }
+}

package/vendor/@akanjs/native/plugins/volume/native-plugin.json

@@ -0,0 +1,14 @@
+{
+  "id": "volume",
+  "apiVersion": 1,
+  "methods": ["getVolume", "setVolume", "setMuted"],
+  "events": ["change"],
+  "codegen": true,
+  "web": null,
+  "desktop": "./src/desktop.ts",
+  "ios": null,
+  "android": {
+    "sources": ["android/*.kt"],
+    "class": "com.akanjs.plugins.volume.VolumePlugin"
+  }
+}

package/vendor/@akanjs/native/plugins/volume/src/common.ts

@@ -0,0 +1,28 @@
+import { AkanNativeError } from "../../../packages/core/src/index.ts";
+import type { VolumeState } from "./index.ts";
+
+export function checkLevel(value: unknown): number {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1)
+    throw new AkanNativeError("INVALID_ARGS", "level must be a number from 0 to 1");
+  return value;
+}
+
+export function checkMuted(value: unknown): boolean {
+  if (typeof value !== "boolean") throw new AkanNativeError("INVALID_ARGS", "muted must be a boolean");
+  return value;
+}
+
+export const sameVolume = (a: VolumeState, b: VolumeState) =>
+  a.level === b.level && a.muted === b.muted && a.settable === b.settable;
+
+/**
+ * `pactl get-sink-volume @DEFAULT_SINK@` ("Volume: front-left: 32768 /  50% / -18.06 dB, front-right: …"):
+ * the channels' mean. PulseAudio can boost past 100%, which reads as 1.
+ */
+export function pactlLevel(output: string): number | null {
+  const percents = [...output.matchAll(/(\d+)%/g)].map((match) => Number(match[1]));
+  if (!percents.length) return null;
+  return Math.min(1, Math.round((percents.reduce((sum, p) => sum + p, 0) / percents.length) * 10) / 1000);
+}
+
+export const pactlMuted = (output: string) => /Mute:\s*yes/i.test(output);

package/vendor/@akanjs/native/plugins/volume/src/desktop.ts

@@ -0,0 +1,185 @@
+
+
+import { AkanNativeError } from "../../../packages/core/src/index.ts";
+import { type DesktopContext, defineDesktopPlugin } from "../../../packages/desktop/src/plugin.ts";
+import { checkLevel, checkMuted, pactlLevel, pactlMuted, sameVolume } from "./common.ts";
+import type { VolumeApi, VolumeEvents, VolumeState } from "./index.ts";
+
+const POLL_MS = 1000;
+
+/** Runs pactl and answers its stdout. */
+export type Pactl = (...args: string[]) => Promise<string>;
+
+/** Answers stdout lines of `pactl subscribe` until the returned function stops it. */
+export type PactlSubscribe = (onLine: (line: string) => void) => () => void;
+
+const pactlPath = () => Bun.which("pactl") ?? "/usr/bin/pactl";
+
+const pactlEnv = () => ({ ...process.env, LC_ALL: "C" });
+
+export const resubscribeDelay = (ends: number) => Math.min(1000 * 2 ** Math.max(ends - 1, 0), 30_000);
+
+export const runPactl: Pactl = async (...args) => {
+  let proc: Bun.Subprocess<"ignore", "pipe", "pipe">;
+  try {
+    proc = Bun.spawn([pactlPath(), ...args], { stdin: "ignore", stdout: "pipe", stderr: "pipe", env: pactlEnv() });
+  } catch {
+    throw new AkanNativeError("UNSUPPORTED", "there is no pactl (PulseAudio's or PipeWire's pulseaudio-utils)");
+  }
+  const [out, err, code] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited,
+  ]);
+  if (code !== 0) throw new AkanNativeError("NOT_FOUND", `no audio server answers: ${err.trim() || `exit ${code}`}`);
+  return out;
+};
+
+/** One `pactl subscribe`: its lines until it ends; `stop` ends it. */
+export type PactlSubscription = (onLine: (line: string) => void) => { ended: Promise<void>; stop(): void } | null;
+
+const pactlSubscription: PactlSubscription = (onLine) => {
+  let proc: Bun.Subprocess<"ignore", "pipe", "ignore">;
+  try {
+    proc = Bun.spawn([pactlPath(), "subscribe"], {
+      stdin: "ignore",
+      stdout: "pipe",
+      stderr: "ignore",
+      env: pactlEnv(),
+    });
+  } catch {
+    return null;
+  }
+  const ended = (async () => {
+    const decoder = new TextDecoder();
+    let pending = "";
+    for await (const chunk of proc.stdout) {
+      const lines = (pending + decoder.decode(chunk, { stream: true })).split("\n");
+      pending = lines.pop() ?? "";
+      for (const line of lines) onLine(line);
+    }
+  })().catch(() => {});
+  return { ended, stop: () => proc.kill() };
+};
+
+/** `pactl subscribe`, started again (resubscribeDelay) whenever it ends until stopped: a restarted audio server ends it. */
+export function resubscribing(
+  subscription: PactlSubscription = pactlSubscription,
+  delay = resubscribeDelay,
+): PactlSubscribe {
+  return (onLine) => {
+    let stopped = false;
+    let current: ReturnType<PactlSubscription> = null;
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    let ends = 0;
+    const start = () => {
+      if (stopped) return;
+      const startedAt = Date.now();
+      current = subscription(onLine);
+      if (!current) return;
+      void current.ended.then(() => {
+        if (stopped) return;
+        ends = Date.now() - startedAt >= 60_000 ? 1 : ends + 1;
+        timer = setTimeout(start, delay(ends));
+      });
+    };
+    start();
+    return () => {
+      stopped = true;
+      clearTimeout(timer);
+      current?.stop();
+    };
+  };
+}
+
+export const subscribePactl: PactlSubscribe = resubscribing();
+
+export function createDesktopVolume(
+  platform: NodeJS.Platform = process.platform,
+  pactl: Pactl = runPactl,
+  subscribe: PactlSubscribe = subscribePactl,
+) {
+  const linux = platform === "linux";
+
+  async function linuxState(): Promise<VolumeState> {
+    const [volume, mute] = await Promise.all([
+      pactl("get-sink-volume", "@DEFAULT_SINK@"),
+      pactl("get-sink-mute", "@DEFAULT_SINK@"),
+    ]);
+    const level = pactlLevel(volume);
+    return { level, muted: pactlMuted(mute), settable: level !== null };
+  }
+
+  const read = (ctx: DesktopContext) => (linux ? linuxState() : (ctx.shell("volume.get") as Promise<VolumeState>));
+
+  /** Starts hearing changes; the shell's notices and pactl's lines only say that something changed. */
+  function watch(ctx: DesktopContext, changed: () => void): () => void {
+    if (platform === "darwin") {
+      const stop = ctx.onNativeEvent("volume", changed);
+      ctx.shell("volume.watch").catch((error) => console.warn("[akan-native] volume: cannot watch changes", error));
+      return stop;
+    }
+    if (linux)
+      return subscribe((line) => {
+        if (/'change' on (sink|server)/.test(line)) changed();
+      });
+    const timer = setInterval(changed, POLL_MS);
+    return () => clearInterval(timer);
+  }
+
+  return defineDesktopPlugin<VolumeApi, VolumeEvents>({
+    id: "volume",
+    methods: {
+      getVolume: (_args, ctx) => read(ctx),
+      async setVolume(args, ctx) {
+        const level = checkLevel(args?.level);
+        if (!linux) return (await ctx.shell("volume.set", { level })) as VolumeState;
+        await pactl("set-sink-volume", "@DEFAULT_SINK@", `${Math.round(level * 100)}%`);
+        return linuxState();
+      },
+      async setMuted(args, ctx) {
+        const muted = checkMuted(args?.muted);
+        if (!linux) return (await ctx.shell("volume.mute", { muted })) as VolumeState;
+        await pactl("set-sink-mute", "@DEFAULT_SINK@", muted ? "1" : "0");
+        return linuxState();
+      },
+    },
+    events: {
+      change(emit, ctx) {
+        let active = true;
+        let last: VolumeState | null = null;
+        let reading = false;
+        let again = false;
+        
+        const refresh = async () => {
+          if (reading) {
+            again = true;
+            return;
+          }
+          reading = true;
+          try {
+            do {
+              again = false;
+              const state = await read(ctx);
+              if (!active) return;
+              if (last && !sameVolume(last, state)) emit(state);
+              last = state;
+            } while (again && active);
+          } catch (error) {
+            if (last) console.warn("[akan-native] volume: reading the volume failed", error);
+          } finally {
+            reading = false;
+          }
+        };
+        const stop = watch(ctx, () => void refresh());
+        void refresh();
+        return () => {
+          active = false;
+          stop();
+        };
+      },
+    },
+  });
+}
+
+export default createDesktopVolume();

package/vendor/@akanjs/native/plugins/volume/src/index.ts

@@ -0,0 +1,32 @@
+import { definePlugin } from "../../../packages/core/src/index.ts";
+
+/** The default output's volume, as the system's own volume control shows it. */
+export interface VolumeState {
+  /** 0 (silent) to 1 (full); null when the output takes no volume from the computer (HDMI audio on macOS). */
+  level: number | null;
+  muted: boolean;
+  /** False when setVolume is refused for this output. */
+  settable: boolean;
+}
+
+export interface VolumeApi {
+  getVolume(): Promise<VolumeState>;
+  /** `level` from 0 to 1. */
+  setVolume(args: { level: number }): Promise<VolumeState>;
+  setMuted(args: { muted: boolean }): Promise<VolumeState>;
+}
+
+export interface VolumeEvents {
+  /** The default output, its volume or its mute changed, whoever changed it. */
+  change: VolumeState;
+}
+
+/**
+ * The system's output volume: CoreAudio's default output device (macOS), the default render endpoint the taskbar
+ * slider moves (Windows), the default sink of PulseAudio or PipeWire through pactl (Linux), and on Android the
+ * media volume the volume keys move while the app plays. iOS and the web answer UNSUPPORTED.
+ */
+export const volume = definePlugin<VolumeApi, VolumeEvents>("volume", {
+  methods: ["getVolume", "setVolume", "setMuted"],
+  events: ["change"],
+});

package/vendor/@akanjs/native/plugins/window/native-plugin.json

@@ -0,0 +1,32 @@
+{
+  "id": "window",
+  "apiVersion": 1,
+  "methods": [
+    "getState",
+    "setTitle",
+    "setSize",
+    "setPosition",
+    "center",
+    "minimize",
+    "maximize",
+    "unmaximize",
+    "restore",
+    "setFullscreen",
+    "setAlwaysOnTop",
+    "show",
+    "hide",
+    "focus",
+    "close",
+    "startDragging",
+    "toggleMaximize",
+    "answerCloseRequested",
+    "create",
+    "list"
+  ],
+  "events": ["resize", "move", "focus", "closeRequested", "created", "destroyed", "dragDrop"],
+  "coalesce": ["resize", "move"],
+  "web": "./src/web.ts",
+  "desktop": "./src/desktop.ts",
+  "ios": null,
+  "android": null
+}

package/vendor/@akanjs/native/plugins/window/src/desktop.ts

@@ -0,0 +1,170 @@
+
+
+import { statSync } from "node:fs";
+import { basename } from "node:path";
+import { AkanNativeError, mimeFor } from "../../../packages/core/src/index.ts";
+import { createPageVeto, type DesktopContext, defineDesktopPlugin } from "../../../packages/desktop/src/plugin.ts";
+import type { DragDropEvent, WindowApi, WindowEvents, WindowInfo, WindowState } from "./index.ts";
+
+const closeVeto = createPageVeto();
+
+function finite(value: unknown, name: string): number {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    throw new AkanNativeError("INVALID_ARGS", `${name} must be a number`);
+  return value;
+}
+
+function bool(value: unknown, name: string): boolean {
+  if (typeof value !== "boolean") throw new AkanNativeError("INVALID_ARGS", `${name} must be a boolean`);
+  return value;
+}
+
+/** `{ window }` when the call names a target window, else {} (the calling window). */
+function target(args: unknown): { window?: number } {
+  const window = (args as { window?: unknown } | undefined)?.window;
+  if (window === undefined) return {};
+  if (typeof window !== "number" || !Number.isInteger(window) || window < 1)
+    throw new AkanNativeError("INVALID_ARGS", "window must be a window id");
+  return { window };
+}
+
+/** Regular files among the dropped paths, served at /__akan_native/file/<id>; folders and unreadable paths are left out. */
+export function droppedFiles(
+  ctx: Pick<DesktopContext, "registerFile">,
+  paths: string[],
+): NonNullable<DragDropEvent["files"]> {
+  const files: NonNullable<DragDropEvent["files"]> = [];
+  for (const path of paths) {
+    try {
+      if (!statSync(path).isFile()) continue;
+    } catch {
+      continue;
+    }
+    const name = basename(path);
+    files.push({ ...ctx.registerFile(path, mimeFor(name)), path, name });
+  }
+  return files;
+}
+
+/** The shell says "no window 7" for a window that is gone. */
+function shell(ctx: DesktopContext, op: string, args: unknown, extra: Record<string, unknown> = {}): Promise<unknown> {
+  return ctx.shell(`window.${op}`, { ...extra, ...target(args) }).catch((error) => {
+    const message = String((error as Error)?.message ?? error);
+    throw /^no window/.test(message) ? new AkanNativeError("NOT_FOUND", message) : error;
+  });
+}
+
+const op = (name: string) => (args: unknown, ctx: DesktopContext) => shell(ctx, name, args) as Promise<WindowState>;
+
+function createOptions(args: unknown): Record<string, unknown> {
+  const a = (args ?? {}) as Record<string, unknown>;
+  const out: Record<string, unknown> = {};
+  if (a.path !== undefined) {
+    if (typeof a.path !== "string" || !a.path.startsWith("/") || a.path.startsWith("//")) {
+      throw new AkanNativeError("INVALID_ARGS", "path must be an app path like /settings");
+    }
+    out.path = a.path;
+  }
+  if (a.title !== undefined) {
+    if (typeof a.title !== "string") throw new AkanNativeError("INVALID_ARGS", "title must be a string");
+    out.title = a.title;
+  }
+  for (const [x, y] of [
+    ["width", "height"],
+    ["x", "y"],
+  ] as const) {
+    if (a[x] === undefined && a[y] === undefined) continue;
+    out[x] = finite(a[x], x);
+    out[y] = finite(a[y], y);
+  }
+  if (out.width !== undefined && ((out.width as number) < 1 || (out.height as number) < 1)) {
+    throw new AkanNativeError("INVALID_ARGS", "width and height must be positive");
+  }
+  return out;
+}
+
+export default defineDesktopPlugin<WindowApi, WindowEvents>({
+  id: "window",
+  setup(ctx) {
+    ctx.onCloseRequested(({ window }) => closeVeto.ask({}, { window }));
+  },
+  methods: {
+    getState: op("getState"),
+    setTitle: (args, ctx) => {
+      if (typeof args?.title !== "string") throw new AkanNativeError("INVALID_ARGS", "title must be a string");
+      return shell(ctx, "setTitle", args, { title: args.title }) as Promise<WindowState>;
+    },
+    setSize: (args, ctx) => {
+      const width = finite(args?.width, "width");
+      const height = finite(args?.height, "height");
+      if (width < 1 || height < 1) throw new AkanNativeError("INVALID_ARGS", "width and height must be positive");
+      return shell(ctx, "setSize", args, { width, height }) as Promise<WindowState>;
+    },
+    setPosition: (args, ctx) =>
+      shell(ctx, "setPosition", args, { x: finite(args?.x, "x"), y: finite(args?.y, "y") }) as Promise<WindowState>,
+    center: op("center"),
+    minimize: op("minimize"),
+    maximize: op("maximize"),
+    unmaximize: op("unmaximize"),
+    restore: op("restore"),
+    setFullscreen: (args, ctx) =>
+      shell(ctx, "setFullscreen", args, { value: bool(args?.value, "value") }) as Promise<WindowState>,
+    setAlwaysOnTop: (args, ctx) =>
+      shell(ctx, "setAlwaysOnTop", args, { value: bool(args?.value, "value") }) as Promise<WindowState>,
+    show: op("show"),
+    hide: op("hide"),
+    focus: op("focus"),
+    startDragging: async (args, ctx) => {
+      await shell(ctx, "startDragging", args);
+    },
+    toggleMaximize: async (args, ctx) => {
+      const state = (await shell(ctx, "getState", args)) as WindowState;
+      return shell(ctx, state.maximized ? "unmaximize" : "maximize", args) as Promise<WindowState>;
+    },
+    close: async (args, ctx) => {
+      const named = target(args).window;
+      if (named !== undefined) await shell(ctx, "getState", args); 
+      const window = named ?? ctx.window ?? 1;
+      
+      setTimeout(() => ctx.closeWindow(window), 50);
+    },
+    create: (args, ctx) => ctx.shell("window.create", createOptions(args)) as Promise<WindowInfo>,
+    list: (_args, ctx) => ctx.shell("window.list") as Promise<WindowInfo[]>,
+    answerCloseRequested: (args, ctx) => closeVeto.answer(args, ctx.window),
+  },
+  events: {
+    
+    resize: (emit, ctx) =>
+      ctx.onNativeEvent("window", (e) => {
+        if (e.event === "resized")
+          emit({ width: e.width as number, height: e.height as number }, { window: (e.window as number) ?? 1 });
+      }),
+    move: (emit, ctx) =>
+      ctx.onNativeEvent("window", (e) => {
+        if (e.event === "moved") emit({ x: e.x as number, y: e.y as number }, { window: (e.window as number) ?? 1 });
+      }),
+    focus: (emit, ctx) =>
+      ctx.onNativeEvent("window", (e) => {
+        if (e.event === "focused") emit({ focused: e.value === true }, { window: (e.window as number) ?? 1 });
+      }),
+    closeRequested: (emit, ctx) => closeVeto.source(emit, ctx),
+    
+    created: (emit, ctx) =>
+      ctx.onNativeEvent("window", (e) => {
+        if (e.event === "created") emit({ id: e.window as number });
+      }),
+    destroyed: (emit, ctx) =>
+      ctx.onNativeEvent("window", (e) => {
+        if (e.event === "destroyed") emit({ id: e.window as number });
+      }),
+    
+    dragDrop: (emit, ctx) =>
+      ctx.onNativeEvent("dragDrop", (e) => {
+        const data: DragDropEvent = { type: e.event as DragDropEvent["type"] };
+        if (Array.isArray(e.paths)) data.paths = e.paths as string[];
+        if (typeof e.x === "number" && typeof e.y === "number") data.position = { x: e.x, y: e.y };
+        if (data.type === "drop") data.files = droppedFiles(ctx, data.paths ?? []);
+        emit(data, { window: (e.window as number) ?? 1 });
+      }),
+  },
+});