akanjs 3.0.0-beta.9 → 3.0.1

package/vendor/@akanjs/native/plugins/accessibility/android/AccessibilityPlugin.kt

@@ -0,0 +1,96 @@
+package com.akanjs.plugins.accessibility
+
+import android.content.res.Configuration
+import android.database.ContentObserver
+import android.net.Uri
+import android.os.Handler
+import android.os.Looper
+import android.provider.Settings
+import android.view.accessibility.AccessibilityManager
+import com.akanjs.runtime.AkanNativePluginContext
+import com.akanjs.runtime.AkanNativeReply
+
+/**
+ * Screen reader, reduced motion and font scale, after
+ * react-native/packages/react-native/ReactAndroid/.../accessibilityinfo/AccessibilityInfoModule.kt:
+ * - screenReader: touch exploration (TalkBack and similar services), :94 and
+ *   capacitor-plugins/screen-reader/android/.../ScreenReader.java:38-40, watched with a
+ *   TouchExplorationStateChangeListener (:32-37).
+ * - reduceMotion: an animation scale of 0. RN reads TRANSITION_ANIMATION_SCALE and parses it with
+ *   ',' as a possible decimal separator (:101-121); "Remove animations" sets it to "0", the
+ *   developer option to "0.0". ANIMATOR_DURATION_SCALE at 0 counts as well: the framework then runs
+ *   no animators (ValueAnimator.areAnimatorsEnabled() is false), the other half of "Remove
+ *   animations". Both are watched with a ContentObserver (:49-61).
+ * - fontScale: Configuration.fontScale, changed through onConfigurationChanged (the shell handles
+ *   fontScale without recreating the activity). Rounded to 3 places: the Float 1.15 would reach
+ *   JSON as 1.149999976; capacitor-plugins/text-zoom/android/.../TextZoom.java:28-30 goes through
+ *   Float.toString for the same reason.
+ * - RN unregisters in onHostPause and compares again on resume (:236-263); here the sources run
+ *   while the page listens, so a change made in Settings arrives when the app comes back.
+ * announce runs in the page (a live region, src/announce.ts): View.announceForAccessibility and
+ * AccessibilityEvent.TYPE_ANNOUNCEMENT, which RN uses (:282-292), are deprecated in API 36.
+ * lynx/.../LynxAccessibilityModule.java:61-65 sets the view's accessibility pane title instead;
+ * that relabels the WebView and does not repeat an identical message, so it is not used.
+ * The state type comes from the generated AccessibilityPluginSpec (PL-10).
+ */
+class AccessibilityPlugin(private val context: AkanNativePluginContext) : AccessibilityPluginSpec {
+    private val manager: AccessibilityManager? = context.activity.getSystemService(AccessibilityManager::class.java)
+    private val resolver = context.activity.contentResolver
+    private val events = AccessibilityEvents(context)
+    private var listening = false
+    private var last: AccessibilityState? = null
+
+    private val touchExploration = AccessibilityManager.TouchExplorationStateChangeListener { report() }
+    private val scales = object : ContentObserver(Handler(Looper.getMainLooper())) {
+        override fun onChange(selfChange: Boolean, uri: Uri?) = report()
+    }
+
+    override fun getState(reply: AkanNativeReply<AccessibilityState>) = reply.resolve(state())
+
+    override fun onConfigurationChanged(config: Configuration) = report()
+
+    override fun startListening(event: String) {
+        if (event != "change" || listening) return
+        listening = true
+        last = state()
+        manager?.addTouchExplorationStateChangeListener(touchExploration)
+        for (name in SCALES) resolver.registerContentObserver(Settings.Global.getUriFor(name), false, scales)
+    }
+
+    override fun stopListening(event: String) {
+        if (event == "change") stop()
+    }
+
+    override fun destroy() = stop()
+
+    private fun stop() {
+        if (!listening) return
+        listening = false
+        last = null
+        manager?.removeTouchExplorationStateChangeListener(touchExploration)
+        resolver.unregisterContentObserver(scales)
+    }
+
+    private fun report() {
+        if (!listening) return
+        val next = state()
+        if (next == last) return
+        last = next
+        events.change(next)
+    }
+
+    private fun state() = AccessibilityState(
+        screenReader = manager?.isTouchExplorationEnabled == true,
+        reduceMotion = SCALES.any { scaleIsZero(it) },
+        fontScale = Math.round(context.activity.resources.configuration.fontScale * 1000.0) / 1000.0,
+    )
+
+    private fun scaleIsZero(name: String): Boolean {
+        val raw = Settings.Global.getString(resolver, name) ?: return false
+        return raw.replace(',', '.').toFloatOrNull() == 0f
+    }
+
+    private companion object {
+        val SCALES = listOf(Settings.Global.TRANSITION_ANIMATION_SCALE, Settings.Global.ANIMATOR_DURATION_SCALE)
+    }
+}

package/vendor/@akanjs/native/plugins/accessibility/ios/AccessibilityPlugin.swift

@@ -0,0 +1,92 @@
+import UIKit
+
+/// VoiceOver, Reduce Motion and Dynamic Type from UIAccessibility and UIApplication, the values
+/// react-native/packages/react-native/React/CoreModules/RCTAccessibilityManager.mm reads (:99-106).
+/// - fontScale: the body text size for the content size category / 17 pt (the size at the default
+///   "Large"), as capacitor-plugins/text-zoom/ios/Sources/TextZoomPlugin/TextZoom.swift:5-8 computes
+///   it. RN keeps a fixed table (RCTAccessibilityManager.mm:261-279) that matches for the standard
+///   sizes but not for the accessibility sizes (AX1: RN 1.786, the body font 28 / 17 = 1.647); the
+///   font follows Apple's own ramp, which is also what CSS `font: -apple-system-body` gets.
+/// - change: the three notifications RN observes (:54-97), only while the page listens, reported
+///   when a field really changed (RN filters the same way, :170-181).
+/// - announce: UIAccessibility.post(.announcement), RN :323-363 with its queue / priority attributes:
+///   "polite" queues behind current speech, "assertive" interrupts with high priority (iOS 17).
+///   Posted 0.1 s later, as capacitor-plugins/screen-reader/.../ScreenReaderPlugin.swift:39-43 does:
+///   VoiceOver cuts an announcement off when it starts reading the element that was just tapped.
+/// Arguments arrive decoded by the generated AccessibilityPluginSpec (PL-10); empty text is checked here.
+final class AccessibilityPlugin: AccessibilityPluginSpec {
+    static let id = "accessibility"
+    private static let baseBodySize: Double = 17
+
+    private let context: AkanNativePluginContext
+    private var observers: [any NSObjectProtocol] = []
+    private var last: AccessibilityState?
+
+    init(context: AkanNativePluginContext) {
+        self.context = context
+    }
+
+    func getState(_ reply: AkanNativeReply<AccessibilityState>) {
+        reply.resolve(Self.state())
+    }
+
+    func announce(_ args: AccessibilityAnnounceArgs, _ reply: AkanNativeReply<Void>) {
+        let text = args.text
+        guard !text.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
+            return reply.reject(.invalidArgs, "text must not be empty")
+        }
+        let priority = args.priority ?? .polite
+        Task {
+            try? await Task.sleep(for: .milliseconds(100))
+            var attributes: [NSAttributedString.Key: Any] = [.accessibilitySpeechQueueAnnouncement: priority == .polite]
+            // iOS 16 has no announcement priority: an assertive announcement only skips the queue.
+            if priority == .assertive, #available(iOS 17.0, *) { attributes[.accessibilitySpeechAnnouncementPriority] = UIAccessibilityPriority.high }
+            UIAccessibility.post(notification: .announcement, argument: NSAttributedString(string: text, attributes: attributes))
+            reply.resolve()
+        }
+    }
+
+    func startListening(_ event: String) {
+        guard event == "change", observers.isEmpty else { return }
+        last = Self.state()
+        let names: [Notification.Name] = [
+            UIAccessibility.voiceOverStatusDidChangeNotification,
+            UIAccessibility.reduceMotionStatusDidChangeNotification,
+            UIContentSizeCategory.didChangeNotification,
+        ]
+        observers = names.map { name in
+            NotificationCenter.default.addObserver(forName: name, object: nil, queue: .main) { [weak self] _ in
+                MainActor.assumeIsolated { self?.report() }
+            }
+        }
+    }
+
+    func stopListening(_ event: String) {
+        guard event == "change" else { return }
+        for observer in observers { NotificationCenter.default.removeObserver(observer) }
+        observers = []
+        last = nil
+    }
+
+    private func report() {
+        guard !observers.isEmpty else { return }
+        let next = Self.state()
+        if next == last { return }
+        last = next
+        AccessibilityEvents(context).change(next)
+    }
+
+    private static func state() -> AccessibilityState {
+        AccessibilityState(
+            screenReader: UIAccessibility.isVoiceOverRunning,
+            reduceMotion: UIAccessibility.isReduceMotionEnabled,
+            fontScale: fontScale(UIApplication.shared.preferredContentSizeCategory)
+        )
+    }
+
+    private static func fontScale(_ category: UIContentSizeCategory) -> Double {
+        let traits = UITraitCollection(preferredContentSizeCategory: category)
+        let body = Double(UIFont.preferredFont(forTextStyle: .body, compatibleWith: traits).pointSize)
+        return (body / baseBodySize * 1000).rounded() / 1000
+    }
+}

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

@@ -0,0 +1,21 @@
+{
+  "id": "accessibility",
+  "apiVersion": 1,
+  "methods": ["getState", "announce"],
+  "events": ["change"],
+  "codegen": true,
+  "web": "./src/web.ts",
+  "desktop": "web",
+  "ios": {
+    "sources": ["ios/*.swift"],
+    "class": "AccessibilityPlugin",
+    "frameworks": ["UIKit"]
+  },
+  "android": {
+    "sources": ["android/*.kt"],
+    "class": "com.akanjs.plugins.accessibility.AccessibilityPlugin",
+    "methods": ["getState"],
+    "events": ["change"],
+    "web": true
+  }
+}

package/vendor/@akanjs/native/plugins/accessibility/src/announce.ts

@@ -0,0 +1,71 @@
+import { AkanNativeError } from "../../../packages/core/src/index.ts";
+import type { AnnouncePriority } from "./index.ts";
+
+const PRIORITIES: readonly AnnouncePriority[] = ["polite", "assertive"];
+const HIDDEN =
+  "position:fixed;left:0;top:0;width:1px;height:1px;margin:-1px;padding:0;border:0;overflow:hidden;clip-path:inset(50%);white-space:nowrap";
+const REGISTER_MS = 100;
+const KEEP_MS = 7000;
+
+/** Checks announce()'s options; the iOS plugin checks the same. */
+export function checkAnnounce(options: unknown): { text: string; priority: AnnouncePriority } {
+  if (typeof options !== "object" || options === null) throw new AkanNativeError("INVALID_ARGS", "text is required");
+  const { text, priority } = options as Record<string, unknown>;
+  if (text === undefined || text === null) throw new AkanNativeError("INVALID_ARGS", "text is required");
+  if (typeof text !== "string") throw new AkanNativeError("INVALID_ARGS", "text must be a string");
+  if (text.trim() === "") throw new AkanNativeError("INVALID_ARGS", "text must not be empty");
+  if (priority !== undefined && priority !== null && !(PRIORITIES as readonly unknown[]).includes(priority)) {
+    throw new AkanNativeError("INVALID_ARGS", `priority must be one of ${PRIORITIES.join(", ")}`);
+  }
+  return { text, priority: (priority as AnnouncePriority | null | undefined) ?? "polite" };
+}
+
+const regions = new Map<AnnouncePriority, HTMLElement>();
+
+function topModal(): Element | null {
+  try {
+    const open = document.querySelectorAll("dialog:modal");
+    return open.length > 0 ? open[open.length - 1]! : null;
+  } catch {
+    return null; 
+  }
+}
+
+function region(priority: AnnouncePriority): { el: HTMLElement; fresh: boolean } {
+  const host = topModal() ?? document.body ?? document.documentElement;
+  let el = regions.get(priority);
+  if (el && el.parentNode === host) return { el, fresh: false };
+  if (!el) {
+    el = document.createElement("div");
+    el.setAttribute("aria-live", priority);
+    el.setAttribute("aria-relevant", "additions");
+    el.setAttribute("data-akan-native-announcer", priority);
+    el.style.cssText = HIDDEN;
+    regions.set(priority, el);
+  }
+  host.append(el);
+  return { el, fresh: true };
+}
+
+/** Adds `text` to the live region of `priority`; resolves once it is in the page. */
+export function announceInPage(text: string, priority: AnnouncePriority): Promise<void> {
+  if (typeof document === "undefined")
+    return Promise.reject(new AkanNativeError("UNSUPPORTED", "announcements need a document"));
+  const { el, fresh } = region(priority);
+  const message = document.createElement("div");
+  message.textContent = text;
+  const add = () => {
+    el.append(message);
+    setTimeout(() => message.remove(), KEEP_MS);
+  };
+  if (!fresh) {
+    add();
+    return Promise.resolve();
+  }
+  return new Promise((resolve) =>
+    setTimeout(() => {
+      add();
+      resolve();
+    }, REGISTER_MS),
+  );
+}

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

@@ -0,0 +1,77 @@
+import { createLiveValue, definePlugin, shallowEqual } from "../../../packages/core/src/index.ts";
+import { useLiveValue } from "../../../packages/react/src/index.ts";
+import { readWebState, web } from "./web.ts";
+
+export { checkAnnounce } from "./announce.ts";
+
+export interface AccessibilityState {
+  /**
+   * A screen reader is on: VoiceOver on iOS, a touch-exploration service such as TalkBack on
+   * Android. null where the host cannot tell: browsers and macOS (a page cannot see VoiceOver).
+   */
+  screenReader: boolean | null;
+  /**
+   * The user asked for less motion: Reduce Motion on iOS, "Remove animations" (animation scales
+   * at 0) on Android, `prefers-reduced-motion` on the web and macOS.
+   */
+  reduceMotion: boolean;
+  /**
+   * The user's text size as a factor of the default size (1): iOS Dynamic Type (the body text
+   * size / 17 pt), Android Configuration.fontScale, the browser's default font size / 16 px on the
+   * web and macOS (1 unless the user changed it; iOS browsers always report 1).
+   */
+  fontScale: number;
+}
+
+/** "polite" waits until the screen reader finished speaking, "assertive" interrupts it. */
+export type AnnouncePriority = "polite" | "assertive";
+
+/** Screen reader state and announcements (plugins.md §4.1). */
+export interface AccessibilityApi {
+  getState(): Promise<AccessibilityState>;
+  /**
+   * Makes the running screen reader speak `text` (e.g. "3 results", "Saved"), for changes that
+   * have no focusable element of their own. Resolves once handed over, also when no screen
+   * reader runs (then nothing is spoken). Default priority "polite".
+   * iOS: UIAccessibility announcement. Web, macOS and Android: a live region in the page
+   * (Android's own announcement API is deprecated in API 36); inside a modal <dialog> the region
+   * moves into the dialog, since the rest of the page is inert then.
+   */
+  announce(options: { text: string; priority?: AnnouncePriority }): Promise<void>;
+}
+
+export interface AccessibilityEvents {
+  /** One of the state's fields changed. */
+  change: AccessibilityState;
+}
+
+export const accessibility = definePlugin<AccessibilityApi, AccessibilityEvents>("accessibility", {
+  methods: ["getState", "announce"],
+  events: ["change"],
+  web,
+});
+
+const current = createLiveValue<AccessibilityState>(
+  readWebState(),
+  (set) => {
+    let live = true;
+    const stop = accessibility.listen("change", set);
+    accessibility
+      .getState()
+      .then((state) => live && set(state))
+      .catch(() => {});
+    return () => {
+      live = false;
+      stop();
+    };
+  },
+  shallowEqual,
+);
+
+/**
+ * The current accessibility state. Re-renders on every change. Until the host answered, it is
+ * the page's own reading (screenReader null, reduceMotion from `prefers-reduced-motion`).
+ */
+export function useAccessibility(): AccessibilityState {
+  return useLiveValue(current);
+}

package/vendor/@akanjs/native/plugins/accessibility/src/web.ts

@@ -0,0 +1,52 @@
+import { defineWebPlugin, shallowEqual } from "../../../packages/core/src/index.ts";
+import { announceInPage, checkAnnounce } from "./announce.ts";
+import type { AccessibilityApi, AccessibilityEvents, AccessibilityState } from "./index.ts";
+
+function motionQuery(): MediaQueryList | null {
+  return typeof matchMedia === "function" ? matchMedia("(prefers-reduced-motion: reduce)") : null;
+}
+
+export function readFontScale(): number {
+  if (typeof document === "undefined" || typeof getComputedStyle !== "function") return 1;
+  const probe = document.createElement("div");
+  probe.style.cssText = "position:absolute;visibility:hidden;width:0;height:0;overflow:hidden;font-size:medium";
+  (document.body ?? document.documentElement).append(probe);
+  const px = Number.parseFloat(getComputedStyle(probe).fontSize);
+  probe.remove();
+  return Number.isFinite(px) && px > 0 ? Math.round((px / 16) * 1000) / 1000 : 1;
+}
+
+export function readWebState(): AccessibilityState {
+  return { screenReader: null, reduceMotion: motionQuery()?.matches ?? false, fontScale: readFontScale() };
+}
+
+export const web = defineWebPlugin<AccessibilityApi, AccessibilityEvents>({
+  methods: {
+    getState: async () => readWebState(),
+    announce(options) {
+      const { text, priority } = checkAnnounce(options);
+      return announceInPage(text, priority);
+    },
+  },
+  events: {
+    change(emit) {
+      let last = readWebState();
+      const check = () => {
+        const next = readWebState();
+        if (shallowEqual(next, last)) return;
+        last = next;
+        emit(next);
+      };
+      const onVisible = () => {
+        if (document.visibilityState === "visible") check();
+      };
+      const q = motionQuery();
+      q?.addEventListener("change", check);
+      if (typeof document !== "undefined") document.addEventListener("visibilitychange", onVisible);
+      return () => {
+        q?.removeEventListener("change", check);
+        if (typeof document !== "undefined") document.removeEventListener("visibilitychange", onVisible);
+      };
+    },
+  },
+});

package/vendor/@akanjs/native/plugins/app/android/AppPlugin.kt

@@ -0,0 +1,106 @@
+package com.akanjs.plugins.app
+
+import android.content.ComponentName
+import android.content.Intent
+import android.os.Handler
+import android.os.Looper
+import com.akanjs.runtime.AkanNativeActivity
+import com.akanjs.runtime.AkanNativeBackProgress
+import com.akanjs.runtime.AkanNativeLinks
+import com.akanjs.runtime.AkanNativePluginContext
+import com.akanjs.runtime.AkanNativeReply
+import com.akanjs.runtime.AkanNativeVoidReply
+
+/**
+ * App info, deep links (ACTION_VIEW intents, plugins.md S4) and the back button (S3).
+ * - Links come from the shell's AkanNativeLinks (App scope): the launch URL is the process's and never
+ *   changes; every link, the launch URL included, is delivered once as urlOpen, kept until the page
+ *   listens (C2). react-native IntentModule / capacitor-plugins/app only take ACTION_VIEW intents too.
+ * - backButton: while the page listens, the shell hands back gestures to us instead of going back
+ *   in the WebView history (capacitor-plugins/app AppPlugin.java does the same with AndroidX).
+ *   setBackEnabled(false) gives back to the system while the page has nothing to go back to, and
+ *   backProgress follows the swipe (API 34+) of a back the page will take.
+ * The result and event types come from the generated AppPluginSpec (PL-10).
+ */
+class AppPlugin(private val context: AkanNativePluginContext) : AppPluginSpec {
+    private val events = AppEvents(context)
+    private var linksListening = false
+
+    override fun getInfo(reply: AkanNativeReply<AppInfoResult>) {
+        val activity = context.activity
+        val info = activity.packageManager.getPackageInfo(activity.packageName, 0)
+        reply.resolve(
+            AppInfoResult(
+                id = activity.packageName,
+                name = activity.applicationInfo.loadLabel(activity.packageManager).toString(),
+                version = info.versionName ?: "",
+                build = info.longVersionCode.toDouble(),
+            ),
+        )
+    }
+
+    override fun getLaunchUrl(reply: AkanNativeReply<AppGetLaunchUrlResult>) = reply.resolve(AppGetLaunchUrlResult(url = AkanNativeLinks.launchUrl))
+
+    override fun exit(reply: AkanNativeVoidReply) {
+        reply.resolve()
+        context.activity.finishAndRemoveTask()
+    }
+
+    override fun relaunch(reply: AkanNativeVoidReply) {
+        val activity = context.activity
+        reply.resolve()
+        // The system starts the new task once this process is gone, in a new one (the answer reaches the page first).
+        Handler(Looper.getMainLooper()).postDelayed({
+            activity.startActivity(Intent.makeRestartActivityTask(ComponentName(activity, activity.javaClass)))
+            Runtime.getRuntime().exit(0)
+        }, 100)
+    }
+
+    override fun minimize(reply: AkanNativeVoidReply) {
+        context.activity.moveTaskToBack(true)
+        reply.resolve()
+    }
+
+    override fun setBackEnabled(args: AppSetBackEnabledArgs, reply: AkanNativeVoidReply) {
+        context.setBackEnabled(args.enabled)
+        reply.resolve()
+    }
+
+    private fun backProgressEvent(progress: AkanNativeBackProgress) = AppBackProgressEvent(
+        phase = when (progress.phase) {
+            AkanNativeBackProgress.Phase.STARTED -> AppBackProgressPhase.STARTED
+            AkanNativeBackProgress.Phase.PROGRESSED -> AppBackProgressPhase.PROGRESSED
+            AkanNativeBackProgress.Phase.CANCELLED -> AppBackProgressPhase.CANCELLED
+        },
+        progress = progress.progress.toDouble(),
+        swipeEdge = if (progress.fromRightEdge) AppBackProgressEventSwipeEdge.RIGHT else AppBackProgressEventSwipeEdge.LEFT,
+    )
+
+    override fun startListening(event: String) {
+        when (event) {
+            "urlOpen" -> {
+                linksListening = true
+                AkanNativeLinks.listen(this, context.activity) { url ->
+                    if (linksListening) events.urlOpen(AppUrlOpenEvent(url = url))
+                    linksListening
+                }
+            }
+            "backButton" -> context.setBackInterceptor {
+                val canGoBack = (context.activity as? AkanNativeActivity)?.canGoBack() ?: false
+                events.backButton(AppBackButtonEvent(canGoBack = canGoBack))
+            }
+            "backProgress" -> context.setBackProgressListener { progress -> events.backProgress(backProgressEvent(progress)) }
+        }
+    }
+
+    override fun stopListening(event: String) {
+        when (event) {
+            "urlOpen" -> {
+                linksListening = false
+                AkanNativeLinks.unlisten(this)
+            }
+            "backButton" -> context.setBackInterceptor(null)
+            "backProgress" -> context.setBackProgressListener(null)
+        }
+    }
+}

package/vendor/@akanjs/native/plugins/app/ios/AppPlugin.swift

@@ -0,0 +1,52 @@
+import UIKit
+
+/// App info from the bundle and deep links from the scene (AkanNativeLinks, plugins.md S4).
+/// iOS apps must not quit or minimize themselves: exit/minimize are UNSUPPORTED
+/// (capacitor-plugins/app does the same).
+/// The result and event types come from the generated AppPluginSpec (PL-10).
+final class AppPlugin: AppPluginSpec {
+    static let id = "app"
+    private let context: AkanNativePluginContext
+    private var subscription: UUID?
+
+    init(context: AkanNativePluginContext) {
+        self.context = context
+    }
+
+    func getInfo(_ reply: AkanNativeReply<AppInfoResult>) {
+        let info = Bundle.main.infoDictionary ?? [:]
+        reply.resolve(AppInfoResult(
+            id: Bundle.main.bundleIdentifier ?? "",
+            name: info["CFBundleDisplayName"] as? String ?? info["CFBundleName"] as? String ?? "",
+            version: info["CFBundleShortVersionString"] as? String ?? "",
+            build: Double(Int(info["CFBundleVersion"] as? String ?? "") ?? 1)
+        ))
+    }
+
+    func getLaunchUrl(_ reply: AkanNativeReply<AppGetLaunchUrlResult>) {
+        reply.resolve(AppGetLaunchUrlResult(url: AkanNativeLinks.shared.launchURL?.absoluteString))
+    }
+
+    func exit(_ reply: AkanNativeReply<Void>) {
+        reply.reject(.unsupported, "iOS apps cannot exit themselves")
+    }
+
+    func minimize(_ reply: AkanNativeReply<Void>) {
+        reply.reject(.unsupported, "iOS apps cannot minimize themselves")
+    }
+
+    func startListening(_ event: String) {
+        guard event == "urlOpen", subscription == nil else { return }
+        subscription = AkanNativeLinks.shared.listen(owner: context.owner) { [weak self] url in
+            guard let self else { return false }
+            AppEvents(self.context).urlOpen(AppUrlOpenEvent(url: url.absoluteString))
+            return true
+        }
+    }
+
+    func stopListening(_ event: String) {
+        guard event == "urlOpen", let subscription else { return }
+        AkanNativeLinks.shared.unlisten(subscription)
+        self.subscription = nil
+    }
+}

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

@@ -0,0 +1,21 @@
+{
+  "id": "app",
+  "apiVersion": 1,
+  "methods": ["getInfo", "getLaunchUrl", "exit", "relaunch", "minimize", "answerBeforeQuit", "setBackEnabled"],
+  "events": ["urlOpen", "backButton", "beforeQuit", "backProgress", "serverState"],
+  "codegen": true,
+  "web": "./src/web.ts",
+  "desktop": "./src/desktop.ts",
+  "ios": {
+    "sources": ["ios/*.swift"],
+    "class": "AppPlugin",
+    "methods": ["getInfo", "getLaunchUrl", "exit", "minimize"],
+    "events": ["urlOpen", "backButton"]
+  },
+  "android": {
+    "sources": ["android/*.kt"],
+    "class": "com.akanjs.plugins.app.AppPlugin",
+    "methods": ["getInfo", "getLaunchUrl", "exit", "relaunch", "minimize", "setBackEnabled"],
+    "events": ["urlOpen", "backButton", "backProgress"]
+  }
+}

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

@@ -0,0 +1,77 @@
+
+
+import { RetainedEvents } from "../../../packages/core/src/kernel.ts";
+import {
+  createPageVeto,
+  type DesktopContext,
+  defineDesktopPlugin,
+  linkClaimed,
+  type QuitReason,
+} from "../../../packages/desktop/src/plugin.ts";
+import { relaunchAfterExit } from "../../../packages/desktop/src/relaunch.ts";
+import type { AppApi, AppEvents } from "./index.ts";
+
+const quitVeto = createPageVeto<{ reason: QuitReason }>();
+
+let launchUrl: string | null = null;
+let launched = false;
+/** Every link, the launch link too, retained until a page listens (the shared C2 rule, kernel RetainedEvents). */
+const links = new RetainedEvents<string>();
+
+export default defineDesktopPlugin<AppApi, AppEvents>({
+  id: "app",
+  setup(ctx: DesktopContext) {
+    ctx.onBeforeQuit(({ reason }) => quitVeto.ask({ reason }));
+    ctx.onNativeEvent("opened", (event) => {
+      for (const url of (event.urls as string[] | undefined) ?? []) {
+        
+        if (linkClaimed(url)) continue;
+
+        if (!launched) {
+          launched = true;
+          launchUrl = url;
+        }
+        links.emit(url, true);
+      }
+    });
+  },
+  methods: {
+    getInfo: (_args, ctx) => ({
+      id: ctx.app.id,
+      name: ctx.app.name,
+      version: ctx.app.version,
+      build: ctx.app.build ?? 1,
+    }),
+    getLaunchUrl: () => ({ url: launchUrl }),
+    exit: (_args, ctx) => {
+      setTimeout(() => ctx.quit(0), 50); 
+    },
+    relaunch: async (_args, ctx) => {
+      await relaunchAfterExit(process.execPath);
+      setTimeout(() => ctx.quit(0), 50);
+    },
+    answerBeforeQuit: (args, ctx) => quitVeto.answer(args, ctx.window),
+    minimize: async (_args, ctx) => {
+      await ctx.shell("window.minimize");
+    },
+    
+    setBackEnabled: () => undefined,
+  },
+  events: {
+    urlOpen(send) {
+      launched = true;
+
+      links.listen("pages", (url) => (send({ url }, "focused")?.length ?? 1) > 0);
+      return () => links.unlisten("pages");
+    },
+    beforeQuit: (send, ctx) => quitVeto.source(send, ctx),
+    
+    backButton: () => () => {},
+    backProgress: () => () => {},
+    serverState(send, ctx) {
+      if (!ctx.server) return () => {};
+      send({ state: ctx.server.state });
+      return ctx.server.onState((state) => void send({ state }));
+    },
+  },
+});