akanjs 3.0.0-beta.20 → 3.0.0-beta.21

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

@@ -0,0 +1,189 @@
+
+
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { AkanNativeError } from "../../../packages/core/src/index.ts";
+import { type DesktopContext, defineDesktopPlugin } from "../../../packages/desktop/src/plugin.ts";
+import type { AutostartApi, AutostartState, AutostartStatus } from "./index.ts";
+
+export interface ShellError {
+  reason: "alreadyRegistered" | "notRegistered" | "deniedByUser" | "invalidSignature" | "other";
+  code: number;
+  domain: string;
+  message: string;
+}
+
+export interface ShellAnswer {
+  status: AutostartStatus;
+  error?: ShellError | null;
+}
+
+const state = (status: AutostartStatus): AutostartState => ({ enabled: status === "enabled", status });
+
+/** Where the user switches login items on and off. */
+const SETTINGS_PAGE: Partial<Record<NodeJS.Platform, string>> = {
+  darwin: "System Settings › General › Login Items",
+  win32: "Settings › Apps › Startup",
+};
+
+/** The error an enable/disable answer stands for, or null when the app is where it was asked to be. */
+export function failure(
+  op: "enable" | "disable",
+  answer: ShellAnswer,
+  platform: NodeJS.Platform = process.platform,
+): AkanNativeError | null {
+  const { status, error } = answer;
+  const page = SETTINGS_PAGE[platform] ?? SETTINGS_PAGE.darwin!;
+  if (op === "enable" && status === "requiresApproval") {
+    return new AkanNativeError(
+      "PERMISSION_DENIED",
+      `the app is switched off in ${page}; openSettings() opens that page`,
+    );
+  }
+  if (op === "enable" ? status === "enabled" : status === "notRegistered" || status === "notFound") return null;
+  if (!error) return new AkanNativeError("INTERNAL", `${op} did not change the login item (status ${status})`);
+  const detail = `${error.message} (${error.domain} ${error.code})`;
+  switch (error.reason) {
+    case "deniedByUser":
+      return new AkanNativeError("PERMISSION_DENIED", `the user switched the app off in ${page}: ${detail}`);
+    case "invalidSignature":
+      return new AkanNativeError("INTERNAL", `macOS did not accept the app's code signature: ${detail}`);
+    default:
+      return new AkanNativeError("INTERNAL", `${op} failed: ${detail}`);
+  }
+}
+
+type Env = Record<string, string | undefined>;
+
+/** $XDG_CONFIG_HOME/autostart; the base directory must be absolute (XDG Base Directory spec). */
+export function autostartDir(env: Env = process.env, home = homedir()): string {
+  const config = env.XDG_CONFIG_HOME?.startsWith("/") ? env.XDG_CONFIG_HOME : join(home, ".config");
+  return join(config, "autostart");
+}
+
+/**
+ * The Exec= value that runs `path`: one quoted argument (Desktop Entry spec, "The Exec key").
+ * Inside quotes `"`, `` ` ``, `$` and `\` take a backslash; then the string escaping of values
+ * doubles every backslash, and a literal `%` is `%%` (field codes).
+ */
+export function desktopExec(path: string): string {
+  const quoted = `"${path.replace(/["`$\\]/g, (c) => `\\${c}`)}"`;
+  return quoted.replace(/\\/g, "\\\\").replace(/%/g, "%%");
+}
+
+/** Values of the Desktop Entry spec's string type: no line breaks. */
+const oneLine = (value: string) => value.replace(/[\r\n]+/g, " ");
+
+export function desktopEntry(name: string, exec: string): string {
+  return [
+    "[Desktop Entry]",
+    "Type=Application",
+    "Version=1.5",
+    `Name=${oneLine(name)}`,
+    `Exec=${desktopExec(exec)}`,
+    "Terminal=false",
+    "X-GNOME-Autostart-enabled=true",
+    "",
+  ].join("\n");
+}
+
+/**
+ * The state an entry stands for. Hidden=true (the spec's "deleted") or
+ * X-GNOME-Autostart-enabled=false (GNOME's startup settings) is an entry the user switched off.
+ */
+export function entryStatus(text: string | null): AutostartStatus {
+  if (text === null) return "notRegistered";
+  let group = "";
+  const keys = new Map<string, string>();
+  for (const raw of text.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (line.startsWith("[")) group = line;
+    else if (group === "[Desktop Entry]" && line.includes("=") && !line.startsWith("#")) {
+      const at = line.indexOf("=");
+      keys.set(line.slice(0, at).trim(), line.slice(at + 1).trim());
+    }
+  }
+  if (keys.get("Hidden") === "true" || keys.get("X-GNOME-Autostart-enabled") === "false") return "requiresApproval";
+  return "enabled";
+}
+
+/** `executable`: the file the entry starts; an AppImage's mount point changes at every start, $APPIMAGE does not. */
+export function linuxAutostart(
+  dir: () => string = () => autostartDir(),
+  executable: () => string = () => process.env.APPIMAGE || process.execPath,
+) {
+  const file = (ctx: DesktopContext) => join(dir(), `${ctx.app.id}.desktop`);
+  const read = (ctx: DesktopContext) => (existsSync(file(ctx)) ? readFileSync(file(ctx), "utf8") : null);
+  const answer = (status: AutostartStatus, error?: unknown): ShellAnswer => ({
+    status,
+    error: error
+      ? { reason: "other", code: 0, domain: "filesystem", message: (error as Error).message ?? String(error) }
+      : null,
+  });
+  return {
+    status: (ctx: DesktopContext): ShellAnswer => ({ status: entryStatus(read(ctx)) }),
+    
+    enable(ctx: DesktopContext): ShellAnswer {
+      try {
+        mkdirSync(dir(), { recursive: true });
+        writeFileSync(`${file(ctx)}.tmp`, desktopEntry(ctx.app.name, executable()));
+        renameSync(`${file(ctx)}.tmp`, file(ctx));
+      } catch (error) {
+        return answer(entryStatus(read(ctx)), error);
+      }
+      return answer(entryStatus(read(ctx)));
+    },
+    disable(ctx: DesktopContext): ShellAnswer {
+      try {
+        rmSync(file(ctx), { force: true });
+      } catch (error) {
+        return answer(entryStatus(read(ctx)), error);
+      }
+      return answer(entryStatus(read(ctx)));
+    },
+  };
+}
+
+type Backend = {
+  status(ctx: DesktopContext): Promise<ShellAnswer>;
+  change(op: "enable" | "disable", ctx: DesktopContext): Promise<ShellAnswer>;
+};
+
+/** The shell's autostart.* ops (macOS, Windows); `id` names the Windows Run value. */
+const shellBackend: Backend = {
+  status: async (ctx) => (await ctx.shell("autostart.status", { id: ctx.app.id })) as ShellAnswer,
+  change: async (op, ctx) => (await ctx.shell(`autostart.${op}`, { id: ctx.app.id })) as ShellAnswer,
+};
+
+/** `platform` and `linux` are replaceable so tests can check every OS's path on any OS. */
+export function createDesktopAutostart(platform: NodeJS.Platform = process.platform, linux = linuxAutostart()) {
+  const backend: Backend =
+    platform === "linux"
+      ? {
+          status: async (ctx) => linux.status(ctx),
+          change: async (op, ctx) => (op === "enable" ? linux.enable(ctx) : linux.disable(ctx)),
+        }
+      : shellBackend;
+  const change = async (op: "enable" | "disable", ctx: DesktopContext): Promise<AutostartState> => {
+    const answer = await backend.change(op, ctx);
+    const error = failure(op, answer, platform);
+    if (error) throw error;
+    return state(answer.status);
+  };
+  return defineDesktopPlugin<AutostartApi>({
+    id: "autostart",
+    methods: {
+      enable: (_args, ctx) => change("enable", ctx),
+      disable: (_args, ctx) => change("disable", ctx),
+      isEnabled: async (_args, ctx) => state((await backend.status(ctx)).status),
+      openSettings: async (_args, ctx) => {
+        if (platform === "linux")
+          throw new AkanNativeError("UNSUPPORTED", "Linux desktops have no common settings page for startup apps");
+        await ctx.shell("autostart.openSettings");
+      },
+    },
+  });
+}
+
+export default createDesktopAutostart();

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

@@ -0,0 +1,51 @@
+import { definePlugin } from "../../../packages/core/src/index.ts";
+
+/**
+ * Launch the app when the user logs in (plugins.md §5).
+ *
+ * - macOS 13+: SMAppService.mainApp. The app itself becomes a login item under System Settings ›
+ *   General › Login Items › "Open at Login"; no permission prompt, but macOS shows a "Login Item
+ *   Added" notification. The user can switch it off there: then `status` is "requiresApproval"
+ *   and enable() rejects with PERMISSION_DENIED; openSettings() takes the user to that page.
+ * - `status` is macOS's own (SMAppService.Status):
+ *     "enabled": registered and will launch at login.
+ *     "notRegistered": not registered (typically after disable()).
+ *     "requiresApproval": registered, but switched off by the user in System Settings.
+ *     "notFound": macOS has no login item record for this app, e.g. it never called enable().
+ *       Seen on macOS 26 for an ad-hoc signed bundle that never registered; not an error.
+ *   `enabled` is `status === "enabled"`.
+ * - The registration belongs to the app bundle: enable() it from the copy users run, normally
+ *   the one in /Applications. A bundle whose signature macOS does not accept is refused
+ *   (INTERNAL, "invalid signature").
+ * - enable() when enabled and disable() when not are no-ops that resolve.
+ * - Windows: a value named after the app id under HKCU\Software\Microsoft\Windows\CurrentVersion\Run
+ *   that starts this .exe. The user can switch it off in Settings › Apps › Startup or Task Manager:
+ *   then `status` is "requiresApproval" and enable() rejects with PERMISSION_DENIED; openSettings()
+ *   opens that page. disable() removes the value and that switch. Never "notFound".
+ * - Linux: an XDG autostart entry, ~/.config/autostart/<app id>.desktop, that starts this
+ *   executable ($APPIMAGE for an AppImage). An entry the user switched off (Hidden=true,
+ *   X-GNOME-Autostart-enabled=false) reads "requiresApproval", and enable() switches it on again:
+ *   Linux has no approval system. openSettings() is UNSUPPORTED (no common settings page). Never "notFound".
+ * - Web, iOS and Android: UNSUPPORTED.
+ */
+export type AutostartStatus = "enabled" | "notRegistered" | "requiresApproval" | "notFound";
+
+export interface AutostartState {
+  enabled: boolean;
+  status: AutostartStatus;
+}
+
+export interface AutostartApi {
+  /** Registers the app to open at login. */
+  enable(): Promise<AutostartState>;
+  /** Stops opening at login. The running app keeps running. */
+  disable(): Promise<AutostartState>;
+  /** Reads the state without changing it. */
+  isEnabled(): Promise<AutostartState>;
+  /** Opens System Settings at Login Items, or Settings › Apps › Startup on Windows (to switch a "requiresApproval" item back on). */
+  openSettings(): Promise<void>;
+}
+
+export const autostart = definePlugin<AutostartApi>("autostart", {
+  methods: ["enable", "disable", "isEnabled", "openSettings"],
+});

package/vendor/@akanjs/native/plugins/badge/ios/BadgePlugin.swift

@@ -0,0 +1,92 @@
+import UserNotifications
+
+/// The app icon badge through UNUserNotificationCenter.setBadgeCount (iOS 16), plugins.md §4.6.
+/// - Not UIApplication.applicationIconBadgeNumber, which tao/src/platform_impl/ios/badge.rs:8-15 and
+///   capacitor-plugins/local-notifications/.../LocalNotificationsPlugin.swift:635 set: it is
+///   deprecated since iOS 17 and has no replacement getter, which is why there is no get().
+/// - Badges belong to the notification permission. tao sets the number without looking and the
+///   badge silently never appears; here set() checks the settings first and rejects
+///   PERMISSION_DENIED, the way plugins/local-notifications answers schedule() without permission.
+///   "granted" needs an authorization that shows badges: provisional authorization delivers quietly
+///   without badges, so it counts as "prompt" (requestPermission asks for the full one).
+/// - requestPermission asks for alerts, sounds and badges together, the set of
+///   plugins/local-notifications and capacitor-plugins/push-notifications/.../PushNotificationsHandler.swift:9.
+///   iOS prompts once per app, and the options of that first request are what the user grants, so a
+///   badge-only request would leave a later notifications prompt without alerts.
+/// - clear() resolves without the permission: no badge can be showing then.
+/// Arguments arrive decoded by the generated BadgePluginSpec (PL-10); the range is checked here.
+final class BadgePlugin: BadgePluginSpec {
+    static let id = "badge"
+    private static let maxCount = 2_147_483_647.0
+
+    init(context: AkanNativePluginContext) {}
+
+    func set(_ args: BadgeSetArgs, _ reply: AkanNativeReply<Void>) {
+        let value = args.count
+        guard value.rounded() == value, value >= 0, value <= Self.maxCount else {
+            return reply.reject(.invalidArgs, "count must be an integer from 0 to 2147483647")
+        }
+        let count = Int(value)
+        Task {
+            let center = UNUserNotificationCenter.current()
+            guard Self.state(await center.notificationSettings()) == .granted else {
+                return reply.reject(.permissionDenied, "badge permission is not granted (call requestPermission)")
+            }
+            do {
+                try await center.setBadgeCount(count)
+                reply.resolve()
+            } catch {
+                reply.reject(Self.code(error), "setting the badge failed: \(error.localizedDescription)")
+            }
+        }
+    }
+
+    func clear(_ reply: AkanNativeReply<Void>) {
+        Task {
+            let center = UNUserNotificationCenter.current()
+            guard Self.state(await center.notificationSettings()) == .granted else { return reply.resolve() }
+            do {
+                try await center.setBadgeCount(0)
+                reply.resolve()
+            } catch {
+                reply.reject(Self.code(error), "clearing the badge failed: \(error.localizedDescription)")
+            }
+        }
+    }
+
+    func checkPermission(_ reply: AkanNativeReply<BadgeCheckPermissionResult>) {
+        Task {
+            reply.resolve(BadgeCheckPermissionResult(badge: Self.state(await UNUserNotificationCenter.current().notificationSettings())))
+        }
+    }
+
+    func requestPermission(_ reply: AkanNativeReply<BadgeRequestPermissionResult>) {
+        Task {
+            let center = UNUserNotificationCenter.current()
+            let status = await center.notificationSettings().authorizationStatus
+            if status == .notDetermined || status == .provisional {
+                do {
+                    _ = try await center.requestAuthorization(options: [.alert, .sound, .badge])
+                } catch {
+                    return reply.reject(.internalError, "requestAuthorization failed: \(error.localizedDescription)")
+                }
+            }
+            reply.resolve(BadgeRequestPermissionResult(badge: Self.state(await center.notificationSettings())))
+        }
+    }
+
+    nonisolated private static func state(_ settings: UNNotificationSettings) -> BadgePermissionState {
+        switch settings.authorizationStatus {
+        case .notDetermined, .provisional:
+            return settings.badgeSetting == .enabled ? .granted : .prompt
+        case .denied:
+            return .denied
+        default: // authorized, ephemeral
+            return settings.badgeSetting == .enabled ? .granted : .denied // badges switched off in Settings
+        }
+    }
+
+    nonisolated private static func code(_ error: any Error) -> AkanNativeErrorCode {
+        (error as? UNError)?.code == .notificationsNotAllowed ? .permissionDenied : .internalError
+    }
+}

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

@@ -0,0 +1,15 @@
+{
+  "id": "badge",
+  "apiVersion": 1,
+  "methods": ["set", "clear", "checkPermission", "requestPermission"],
+  "events": [],
+  "codegen": true,
+  "web": "./src/web.ts",
+  "desktop": "./src/desktop.ts",
+  "ios": {
+    "sources": ["ios/*.swift"],
+    "class": "BadgePlugin",
+    "frameworks": ["UserNotifications"]
+  },
+  "android": null
+}

package/vendor/@akanjs/native/plugins/badge/src/count.ts

@@ -0,0 +1,12 @@
+import { AkanNativeError } from "../../../packages/core/src/index.ts";
+
+/** The largest count: badges are 32-bit integers on iOS (UNUserNotificationCenter.setBadgeCount takes an NSInteger, tauri clamps to i32). */
+export const MAX_BADGE_COUNT = 2147483647;
+
+/** Checks set()'s count; the native implementation checks the same range. */
+export function checkCount(count: unknown): number {
+  if (typeof count !== "number" || !Number.isInteger(count) || count < 0 || count > MAX_BADGE_COUNT) {
+    throw new AkanNativeError("INVALID_ARGS", `count must be an integer from 0 to ${MAX_BADGE_COUNT}`);
+  }
+  return count;
+}

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

@@ -0,0 +1,24 @@
+
+
+import { defineDesktopPlugin } from "../../../packages/desktop/src/plugin.ts";
+import { checkCount } from "./count.ts";
+import type { BadgeApi } from "./index.ts";
+
+export default defineDesktopPlugin<BadgeApi>({
+  id: "badge",
+  methods: {
+    async set(options, ctx) {
+      const count = checkCount(options?.count);
+      await ctx.shell("dock.setBadge", { label: count === 0 ? null : String(count) });
+    },
+    async clear(_args, ctx) {
+      await ctx.shell("dock.setBadge", { label: null });
+    },
+    async checkPermission() {
+      return { badge: "granted" as const };
+    },
+    async requestPermission() {
+      return { badge: "granted" as const };
+    },
+  },
+});

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

@@ -0,0 +1,40 @@
+import { definePlugin } from "../../../packages/core/src/index.ts";
+import { web } from "./web.ts";
+
+export { checkCount, MAX_BADGE_COUNT } from "./count.ts";
+
+export type PermissionState = "granted" | "denied" | "prompt";
+
+/**
+ * The number on the app icon (plugins.md §4.6).
+ *
+ * - iOS: UNUserNotificationCenter.setBadgeCount. Badges are part of the notification permission:
+ *   set() rejects PERMISSION_DENIED until requestPermission() was granted, or when the user
+ *   switched badges off for the app. The prompt asks for alerts, sounds and badges together
+ *   (one prompt per app), the same set as @akanjs/native/plugins/local-notifications.
+ * - Web: the Badging API (navigator.setAppBadge), shown for installed web apps (Chromium PWAs;
+ *   Safari home screen / Dock web apps, which also need the notification permission). Browsers
+ *   without it reject UNSUPPORTED. The API has no permission of its own, so the permission
+ *   methods answer "granted" there.
+ * - Desktop, through the dock plugin's badge (no permission, "granted"): the Dock tile's label on
+ *   macOS; on Windows the taskbar buttons' overlay icon (counts over 99 as "99+"); on Linux the
+ *   launcher entry's count, shown by docks that support it once the app is installed with its
+ *   desktop file (@akanjs/native/plugins/dock).
+ * - Android has no badge API (launchers draw dots for notifications): every method rejects
+ *   UNSUPPORTED there.
+ */
+export interface BadgeApi {
+  /** Shows `count` (an integer from 0 to 2147483647) on the app icon; 0 removes the badge. */
+  set(options: { count: number }): Promise<void>;
+  /** Removes the badge. Resolves without the permission as well (no badge can be shown then). */
+  clear(): Promise<void>;
+  /** Never prompts. */
+  checkPermission(): Promise<{ badge: PermissionState }>;
+  /** Prompts when the state is "prompt"; otherwise answers like checkPermission. */
+  requestPermission(): Promise<{ badge: PermissionState }>;
+}
+
+export const badge = definePlugin<BadgeApi>("badge", {
+  methods: ["set", "clear", "checkPermission", "requestPermission"],
+  web,
+});

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

@@ -0,0 +1,37 @@
+import { AkanNativeError, defineWebPlugin } from "../../../packages/core/src/index.ts";
+import { checkCount } from "./count.ts";
+import type { BadgeApi } from "./index.ts";
+
+interface BadgingNavigator {
+  setAppBadge?: (count?: number) => Promise<void>;
+  clearAppBadge?: () => Promise<void>;
+}
+
+function badging(): Required<BadgingNavigator> {
+  const nav = (typeof navigator === "undefined" ? undefined : navigator) as BadgingNavigator | undefined;
+  if (typeof nav?.setAppBadge !== "function" || typeof nav.clearAppBadge !== "function") {
+    throw new AkanNativeError("UNSUPPORTED", "this browser has no Badging API (navigator.setAppBadge)");
+  }
+  return { setAppBadge: nav.setAppBadge.bind(nav), clearAppBadge: nav.clearAppBadge.bind(nav) };
+}
+
+export const web = defineWebPlugin<BadgeApi>({
+  methods: {
+    async set(options) {
+      const count = checkCount(options?.count);
+      const api = badging();
+      await (count === 0 ? api.clearAppBadge() : api.setAppBadge(count));
+    },
+    async clear() {
+      await badging().clearAppBadge();
+    },
+    async checkPermission() {
+      badging();
+      return { badge: "granted" };
+    },
+    async requestPermission() {
+      badging();
+      return { badge: "granted" };
+    },
+  },
+});

package/vendor/@akanjs/native/plugins/biometric/android/BiometricPlugin.kt

@@ -0,0 +1,179 @@
+package com.akanjs.plugins.biometric
+
+import android.app.Activity
+import android.app.KeyguardManager
+import android.content.pm.PackageManager
+import android.hardware.biometrics.BiometricManager
+import android.hardware.biometrics.BiometricManager.Authenticators.BIOMETRIC_WEAK
+import android.hardware.biometrics.BiometricManager.Authenticators.DEVICE_CREDENTIAL
+import android.hardware.biometrics.BiometricPrompt
+import android.os.Build
+import android.os.CancellationSignal
+import com.akanjs.runtime.AkanNativeErrorCode
+import com.akanjs.runtime.AkanNativePluginContext
+import com.akanjs.runtime.AkanNativeReply
+import com.akanjs.runtime.AkanNativeVoidReply
+
+/**
+ * Framework android.hardware.biometrics.BiometricPrompt instead of androidx.biometric (plugins.md §2).
+ * tauri-plugins-workspace/plugins/biometric/android needs a separate AppCompat BiometricActivity
+ * because the androidx prompt is a Fragment; the framework prompt is system UI started from any
+ * Context, so it runs straight from the shell's Activity. Kept from Tauri:
+ * - BIOMETRIC_WEAK (Class 2) like Tauri's status(): plain presence checks need no Class 3 sensor.
+ *   BIOMETRIC_STRONG only matters for a CryptoObject-bound key, which this API does not offer.
+ * - A negative button cannot be combined with DEVICE_CREDENTIAL (the builder throws).
+ * - The sensor kind comes from PackageManager features (first of fingerprint, face, iris).
+ * - KeyguardManager.isDeviceSecure tells whether a PIN / pattern / password exists.
+ * USE_BIOMETRIC is a normal permission (granted at install).
+ * API 29 has one tier and no authenticator types (both 30): canAuthenticate() counts only strong
+ * biometrics and never the screen lock, so "credential allowed" is answered with isDeviceSecure, and
+ * without a usable biometric the screen lock is asked through KeyguardManager's confirm intent, as
+ * androidx.biometric does there (Tauri BiometricPlugin.kt:115-120, BiometricActivity.kt:56-65).
+ * Arguments arrive decoded and type-checked by the generated BiometricPluginSpec (PL-10).
+ */
+class BiometricPlugin(private val context: AkanNativePluginContext) : BiometricPluginSpec {
+    private var pending: CancellationSignal? = null
+
+    override fun isAvailable(reply: AkanNativeReply<BiometricStatus>) = reply.resolve(status())
+
+    override fun destroy() {
+        pending?.cancel()
+        pending = null
+    }
+
+    private val manager: BiometricManager? get() = context.activity.getSystemService(BiometricManager::class.java)
+
+    private fun sensor(): BiometricBiometryType {
+        val pm = context.activity.packageManager
+        return when {
+            pm.hasSystemFeature(PackageManager.FEATURE_FINGERPRINT) -> BiometricBiometryType.FINGERPRINT
+            pm.hasSystemFeature(PackageManager.FEATURE_FACE) -> BiometricBiometryType.FACE
+            pm.hasSystemFeature(PackageManager.FEATURE_IRIS) -> BiometricBiometryType.IRIS
+            else -> BiometricBiometryType.NONE
+        }
+    }
+
+    private fun deviceSecure(): Boolean = context.activity.getSystemService(KeyguardManager::class.java)?.isDeviceSecure == true
+
+    /** Biometrics only (BIOMETRIC_WEAK on 30+; API 29's single tier). */
+    private fun biometricCode(): Int {
+        val m = manager ?: return BiometricManager.BIOMETRIC_ERROR_NO_HARDWARE
+        return if (Build.VERSION.SDK_INT >= 30) Api30.canAuthenticate(m, BIOMETRIC_WEAK) else @Suppress("DEPRECATION") m.canAuthenticate()
+    }
+
+    private fun status(): BiometricStatus {
+        val code = biometricCode()
+        val reason = when (code) {
+            BiometricManager.BIOMETRIC_SUCCESS -> null
+            BiometricManager.BIOMETRIC_ERROR_NONE_ENROLLED -> BiometricUnavailableReason.NOT_ENROLLED
+            BiometricManager.BIOMETRIC_ERROR_NO_HARDWARE -> BiometricUnavailableReason.NO_HARDWARE
+            BiometricManager.BIOMETRIC_ERROR_NOT_ENABLED_FOR_APPS -> BiometricUnavailableReason.DENIED // Settings: "use for apps" off
+            else -> BiometricUnavailableReason.UNAVAILABLE // HW_UNAVAILABLE, SECURITY_UPDATE_REQUIRED, IDENTITY_CHECK_NOT_ACTIVE
+        }
+        return BiometricStatus(
+            available = code == BiometricManager.BIOMETRIC_SUCCESS,
+            type = if (code == BiometricManager.BIOMETRIC_ERROR_NO_HARDWARE) BiometricBiometryType.NONE else sensor(),
+            reason = reason,
+            deviceCredential = deviceSecure(),
+        )
+    }
+
+    override fun authenticate(args: BiometricAuthenticateOptions, reply: AkanNativeVoidReply) {
+        val reason = args.reason
+        if (reason.isEmpty()) return reply.reject(AkanNativeErrorCode.INVALID_ARGS, "reason must be a non-empty string")
+        if (pending != null) return reply.reject(AkanNativeErrorCode.CANCELLED, "another authentication is in progress")
+        val allowCredential = args.allowDeviceCredential == true
+        val authenticators = if (allowCredential) BIOMETRIC_WEAK or DEVICE_CREDENTIAL else BIOMETRIC_WEAK
+        val activity = context.activity
+        val title = args.title?.takeIf { it.isNotEmpty() }
+        val code = when {
+            Build.VERSION.SDK_INT >= 30 -> manager?.let { Api30.canAuthenticate(it, authenticators) } ?: BiometricManager.BIOMETRIC_ERROR_NO_HARDWARE
+            else -> biometricCode()
+        }
+        if (code != BiometricManager.BIOMETRIC_SUCCESS) {
+            // API 29: the screen lock alone, when allowed and set up.
+            if (Build.VERSION.SDK_INT < 30 && allowCredential && deviceSecure()) return confirmCredential(activity, title, reason, reply)
+            val (error, message) = unavailable(code, allowCredential)
+            return reply.reject(error, message)
+        }
+
+        val builder = BiometricPrompt.Builder(activity)
+            .setTitle(title ?: reason) // required: build() throws without a title
+        if (Build.VERSION.SDK_INT >= 30) Api30.allow(builder, authenticators)
+        else @Suppress("DEPRECATION") builder.setDeviceCredentialAllowed(allowCredential)
+        if (title != null) builder.setSubtitle(reason)
+        val signal = CancellationSignal()
+        var done = false
+        val finish = { settle: AkanNativeVoidReply.() -> Unit ->
+            if (!done) {
+                done = true
+                if (pending === signal) pending = null
+                reply.settle()
+            }
+        }
+        if (!allowCredential) {
+            val cancel = args.cancelTitle?.takeIf { it.isNotEmpty() } ?: activity.getString(android.R.string.cancel)
+            builder.setNegativeButton(cancel, activity.mainExecutor) { _, _ -> finish { reject(AkanNativeErrorCode.CANCELLED, "authentication was cancelled") } }
+        }
+        pending = signal
+        // The prompt belongs to its call: cancelled (AbortSignal) or with its page gone, it goes away.
+        reply.onCancel {
+            done = true
+            if (pending === signal) pending = null
+            signal.cancel()
+        }
+        try {
+            builder.build().authenticate(signal, activity.mainExecutor, object : BiometricPrompt.AuthenticationCallback() {
+                override fun onAuthenticationSucceeded(result: BiometricPrompt.AuthenticationResult) = finish { resolve() }
+
+                override fun onAuthenticationError(errorCode: Int, errString: CharSequence) =
+                    finish { reject(errorFor(errorCode), errString.toString()) }
+
+                // onAuthenticationFailed: one attempt did not match; the prompt stays up for another try.
+            })
+        } catch (e: RuntimeException) { // IllegalArgumentException from the builder, SecurityException without USE_BIOMETRIC
+            finish { reject(AkanNativeErrorCode.INTERNAL, e.toString()) }
+        }
+    }
+
+    /** API 29 without a usable biometric: the system's screen lock confirmation. */
+    private fun confirmCredential(activity: Activity, title: String?, reason: String, reply: AkanNativeVoidReply) {
+        @Suppress("DEPRECATION")
+        val intent = activity.getSystemService(KeyguardManager::class.java)?.createConfirmDeviceCredentialIntent(title ?: reason, if (title != null) reason else null)
+            ?: return reply.reject(AkanNativeErrorCode.PERMISSION_DENIED, "no screen lock is set up")
+        try {
+            context.startActivityForResult("credential", intent) { result, _ ->
+                if (result == Activity.RESULT_OK) reply.resolve() else reply.reject(AkanNativeErrorCode.CANCELLED, "authentication was cancelled")
+            }
+        } catch (e: RuntimeException) {
+            reply.reject(AkanNativeErrorCode.INTERNAL, e.toString())
+        }
+    }
+
+    private object Api30 {
+        fun canAuthenticate(manager: BiometricManager, authenticators: Int): Int = manager.canAuthenticate(authenticators)
+
+        fun allow(builder: BiometricPrompt.Builder, authenticators: Int) {
+            builder.setAllowedAuthenticators(authenticators)
+        }
+    }
+
+    private fun unavailable(code: Int, allowCredential: Boolean): Pair<String, String> = when (code) {
+        BiometricManager.BIOMETRIC_ERROR_NONE_ENROLLED ->
+            AkanNativeErrorCode.PERMISSION_DENIED to if (allowCredential) "no biometrics and no screen lock are set up" else "no biometrics are enrolled"
+        BiometricManager.BIOMETRIC_ERROR_NO_HARDWARE -> AkanNativeErrorCode.UNSUPPORTED to "this device has no biometric sensor"
+        BiometricManager.BIOMETRIC_ERROR_HW_UNAVAILABLE -> AkanNativeErrorCode.UNSUPPORTED to "the biometric sensor is unavailable"
+        BiometricManager.BIOMETRIC_ERROR_NOT_ENABLED_FOR_APPS -> AkanNativeErrorCode.PERMISSION_DENIED to "biometrics are turned off for apps"
+        else -> AkanNativeErrorCode.INTERNAL to "biometrics cannot be used (code $code)"
+    }
+
+    private fun errorFor(code: Int): String = when (code) {
+        BiometricPrompt.BIOMETRIC_ERROR_USER_CANCELED, BiometricPrompt.BIOMETRIC_ERROR_CANCELED, BiometricPrompt.BIOMETRIC_ERROR_TIMEOUT ->
+            AkanNativeErrorCode.CANCELLED
+        BiometricPrompt.BIOMETRIC_ERROR_LOCKOUT, BiometricPrompt.BIOMETRIC_ERROR_LOCKOUT_PERMANENT, BiometricPrompt.BIOMETRIC_ERROR_NO_BIOMETRICS,
+        BiometricPrompt.BIOMETRIC_ERROR_NO_DEVICE_CREDENTIAL, BiometricPrompt.BIOMETRIC_ERROR_NOT_ENABLED_FOR_APPS ->
+            AkanNativeErrorCode.PERMISSION_DENIED
+        BiometricPrompt.BIOMETRIC_ERROR_HW_NOT_PRESENT, BiometricPrompt.BIOMETRIC_ERROR_HW_UNAVAILABLE -> AkanNativeErrorCode.UNSUPPORTED
+        else -> AkanNativeErrorCode.INTERNAL
+    }
+}