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

package/vendor/@akanjs/native/plugins/device/ios/DevicePlugin.swift

@@ -0,0 +1,80 @@
+import UIKit
+
+/// Device facts from UIDevice, following capacitor-plugins/device/ios/Sources/DevicePlugin/DevicePlugin.swift:
+/// - model: in the simulator hw.machine is the Mac's ("arm64"), so the simulated model comes from
+///   SIMULATOR_MODEL_IDENTIFIER (:29-34). UIDevice.name is not used: without an entitlement it is
+///   the generic "iPhone" since iOS 16.
+/// - webViewVersion: WebKit ships with the OS, so it is the OS version (:49).
+/// - battery: monitoring is switched on only to read, then restored (Capacitor switches it off,
+///   which would break app code that had it on). The simulator reports level -1 / state unknown.
+/// - language: Locale.preferredLanguages keeps the user's order. The code is the tag's first
+///   subtag; Capacitor's `prefix(2)` (Device.swift:24-26) cuts three-letter codes such as "fil".
+/// The result types come from the generated DevicePluginSpec (PL-10).
+final class DevicePlugin: DevicePluginSpec {
+    static let id = "device"
+
+    init(context: AkanNativePluginContext) {}
+
+    func getInfo(_ reply: AkanNativeReply<DeviceInfo>) {
+        let device = UIDevice.current
+        reply.resolve(DeviceInfo(
+            platform: .ios,
+            model: Self.model,
+            manufacturer: "Apple",
+            osName: device.systemName,
+            osVersion: device.systemVersion,
+            isVirtual: Self.isSimulator,
+            webViewVersion: device.systemVersion
+        ))
+    }
+
+    func getId(_ reply: AkanNativeReply<DeviceGetIdResult>) {
+        // nil after a restart until the device is first unlocked (Apple's documentation).
+        guard let id = UIDevice.current.identifierForVendor else {
+            return reply.reject(.internalError, "identifierForVendor is not available yet, try again later")
+        }
+        reply.resolve(DeviceGetIdResult(identifier: id.uuidString))
+    }
+
+    func getLanguage(_ reply: AkanNativeReply<DeviceGetLanguageResult>) {
+        let tag = (Locale.preferredLanguages.first ?? Locale.current.identifier(.bcp47)).replacingOccurrences(of: "_", with: "-")
+        reply.resolve(DeviceGetLanguageResult(tag: tag, code: tag.split(separator: "-").first.map { $0.lowercased() } ?? tag))
+    }
+
+    func getBattery(_ reply: AkanNativeReply<DeviceBatteryInfo>) {
+        reply.resolve(Self.battery())
+    }
+
+    private static var isSimulator: Bool {
+        #if targetEnvironment(simulator)
+            true
+        #else
+            false
+        #endif
+    }
+
+    private static var model: String {
+        #if targetEnvironment(simulator)
+            return ProcessInfo.processInfo.environment["SIMULATOR_MODEL_IDENTIFIER"] ?? "Simulator"
+        #else
+            var size = 0
+            sysctlbyname("hw.machine", nil, &size, nil, 0)
+            var machine = [UInt8](repeating: 0, count: size)
+            sysctlbyname("hw.machine", &machine, &size, nil, 0)
+            return String(decoding: machine.prefix { $0 != 0 }, as: UTF8.self)
+        #endif
+    }
+
+    private static func battery() -> DeviceBatteryInfo {
+        let device = UIDevice.current
+        let wasMonitoring = device.isBatteryMonitoringEnabled
+        device.isBatteryMonitoringEnabled = true
+        let level = device.batteryLevel
+        let state = device.batteryState
+        device.isBatteryMonitoringEnabled = wasMonitoring
+        return DeviceBatteryInfo(
+            level: level < 0 ? nil : (Double(level) * 100).rounded() / 100,
+            charging: state == .unknown ? nil : state == .charging || state == .full
+        )
+    }
+}

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

@@ -0,0 +1,18 @@
+{
+  "id": "device",
+  "apiVersion": 1,
+  "methods": ["getInfo", "getId", "getLanguage", "getBattery"],
+  "events": [],
+  "codegen": true,
+  "web": "./src/web.ts",
+  "desktop": "./src/desktop.ts",
+  "ios": {
+    "sources": ["ios/*.swift"],
+    "class": "DevicePlugin",
+    "frameworks": ["UIKit"]
+  },
+  "android": {
+    "sources": ["android/*.kt"],
+    "class": "com.akanjs.plugins.device.DevicePlugin"
+  }
+}

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

@@ -0,0 +1,276 @@
+
+
+import { randomUUID } from "node:crypto";
+import { existsSync, readdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { release } from "node:os";
+import { join } from "node:path";
+import type { Platform } from "../../../packages/core/src/index.ts";
+import { AkanNativeError } from "../../../packages/core/src/index.ts";
+import { type DesktopContext, defineDesktopPlugin } from "../../../packages/desktop/src/plugin.ts";
+import type { BatteryInfo, DeviceApi, DeviceInfo } from "./index.ts";
+
+async function run(cmd: string[]): Promise<string> {
+  try {
+    const proc = Bun.spawn(cmd, { stdout: "pipe", stderr: "ignore" });
+    const [out, code] = await Promise.all([new Response(proc.stdout).text(), proc.exited]);
+    return code === 0 ? out : "";
+  } catch {
+    return ""; 
+  }
+}
+
+function readText(path: string): string {
+  try {
+    return readFileSync(path, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+/** A <string> value from an XML property list (SystemVersion.plist and Safari's Info.plist are XML). */
+export function plistString(xml: string, key: string): string | null {
+  const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return xml.match(new RegExp(`<key>${escaped}</key>\\s*<string>([^<]*)</string>`))?.[1] ?? null;
+}
+
+/**
+ * `pmset -g batt`, e.g.
+ *   Now drawing from 'AC Power'
+ *    -InternalBattery-0 (id=22806627)	100%; charged; 0:00 remaining present: true
+ * Desktop Macs print only the first line (a UPS may add its own line, which is not the Mac's battery).
+ */
+export function parsePmset(out: string): BatteryInfo {
+  const line = out.split("\n").find((l) => l.includes("InternalBattery"));
+  const percent = line?.match(/(\d+)%/)?.[1];
+  if (!line || percent === undefined || /present: false/.test(line)) return { level: null, charging: null };
+  return { level: Math.min(100, Number(percent)) / 100, charging: /'AC Power'/.test(out) };
+}
+
+/** The first entry of `defaults read -g AppleLanguages`: ( "en-KR", en, ... ). */
+export function parseAppleLanguages(out: string): string | null {
+  const first = out
+    .replace(/^[\s(]+/, "")
+    .split(/[,\n)]/)[0]
+    ?.trim()
+    .replace(/^"|"$/g, "");
+  return first ? first.replace(/_/g, "-") : null;
+}
+
+/** One entry of /sys/class/power_supply: the attribute files it has (sysfs-class-power ABI). */
+export type PowerSupply = Partial<
+  Record<
+    "type" | "scope" | "status" | "capacity" | "online" | "energy_now" | "energy_full" | "charge_now" | "charge_full",
+    string
+  >
+>;
+
+/**
+ * The system's batteries (type Battery; scope Device is a mouse or headset) as one reading: the
+ * summed energy (or charge) where every battery reports it, else the mean capacity. Connected to
+ * power: a mains or USB supply online, else the batteries' status ("Not charging" is a full or
+ * held battery on AC, as macOS's "AC attached").
+ */
+export function parsePowerSupplies(supplies: PowerSupply[]): BatteryInfo {
+  const batteries = supplies.filter((s) => s.type === "Battery" && s.scope !== "Device");
+  if (batteries.length === 0) return { level: null, charging: null };
+  const num = (v: string | undefined) => (v === undefined || v.trim() === "" ? NaN : Number(v));
+  const ratio = (now: "energy_now" | "charge_now", full: "energy_full" | "charge_full") => {
+    const pairs = batteries.map((b) => [num(b[now]), num(b[full])] as const);
+    if (!pairs.every(([n, f]) => Number.isFinite(n) && f > 0)) return null;
+    return pairs.reduce((sum, [n]) => sum + n, 0) / pairs.reduce((sum, [, f]) => sum + f, 0);
+  };
+  const capacities = batteries.map((b) => num(b.capacity)).filter(Number.isFinite);
+  const level =
+    ratio("energy_now", "energy_full") ??
+    ratio("charge_now", "charge_full") ??
+    (capacities.length ? capacities.reduce((a, b) => a + b, 0) / capacities.length / 100 : null);
+  const external = supplies.filter((s) => s.type !== "Battery" && s.scope !== "Device" && s.online !== undefined);
+  const statuses = batteries.map((b) => b.status?.trim());
+  const charging = external.length
+    ? external.some((s) => s.online!.trim() === "1")
+    : statuses.some((s) => s === "Charging" || s === "Full" || s === "Not charging")
+      ? true
+      : statuses.includes("Discharging")
+        ? false
+        : null;
+  return { level: level === null ? null : Math.min(1, Math.max(0, level)), charging };
+}
+
+const SUPPLY_FILES = [
+  "type",
+  "scope",
+  "status",
+  "capacity",
+  "online",
+  "energy_now",
+  "energy_full",
+  "charge_now",
+  "charge_full",
+] as const;
+
+function readPowerSupplies(dir: string): PowerSupply[] {
+  let names: string[];
+  try {
+    names = readdirSync(dir);
+  } catch {
+    return [];
+  }
+  return names.map((name) => {
+    const supply: PowerSupply = {};
+    for (const file of SUPPLY_FILES) {
+      const value = readText(join(dir, name, file));
+      if (value) supply[file] = value.trim();
+    }
+    return supply;
+  });
+}
+
+/**
+ * The user's language from the POSIX locale variables, in gettext's order for messages:
+ * LANGUAGE (a list), LC_ALL, LC_MESSAGES, LANG. "ko_KR.UTF-8" → "ko-KR", "sr_RS@latin" →
+ * "sr-Latn-RS"; C and POSIX are no language.
+ */
+export function posixLanguage(env: Record<string, string | undefined>): string | null {
+  const candidates = [...(env.LANGUAGE ?? "").split(":"), env.LC_ALL, env.LC_MESSAGES, env.LANG];
+  for (const value of candidates) {
+    const m = value?.trim().match(/^([A-Za-z]{2,3})(?:_([A-Za-z]{2}|\d{3}))?(?:\.[^@]*)?(?:@(\w+))?$/);
+    if (!m || /^(c|posix)$/i.test(m[1]!)) continue;
+    const script = { latin: "Latn", cyrillic: "Cyrl" }[m[3]?.toLowerCase() ?? ""];
+    return [m[1]!.toLowerCase(), script, m[2]?.toUpperCase()].filter(Boolean).join("-");
+  }
+  return null;
+}
+
+/** Vendor and product names of hypervisors in DMI/SMBIOS (QEMU, KVM, VMware, VirtualBox, Hyper-V, Parallels, Xen, Apple's Virtualization framework). */
+export function isVirtualMachine(manufacturer: string, model: string): boolean {
+  return /qemu|kvm|vmware|virtualbox|innotek|parallels|xen|bochs|bhyve|virtual machine|apple virtualization/i.test(
+    `${manufacturer} ${model}`,
+  );
+}
+
+/** Firmware placeholders that name no product. */
+const PLACEHOLDER =
+  /^(to be filled by o\.?e\.?m\.?|system (product name|manufacturer)|default string|not specified|not applicable|none|o\.?e\.?m\.?|)$/i;
+const named = (value: string | null | undefined) => {
+  const v = value?.replace(/\0/g, "").trim();
+  return v && !PLACEHOLDER.test(v) ? v : null;
+};
+
+async function webViewVersion(ctx: DesktopContext): Promise<string | null> {
+  try {
+    return ((await ctx.shell("webview.version")) as { version: string | null }).version ?? null;
+  } catch {
+    return null; 
+  }
+}
+
+/** `platform` and `root` (prefix of /sys, /proc) are replaceable so tests can read a fake Linux on any OS. */
+export function createDesktopDevice(
+  platform: NodeJS.Platform = process.platform,
+  root = "/",
+  env: Record<string, string | undefined> = process.env,
+) {
+  const mac = platform === "darwin";
+  const akanNativePlatform: Platform = mac ? "macos" : platform === "win32" ? "windows" : "linux";
+  const sys = (path: string) => join(root, path);
+
+  const readInfo = async (ctx: DesktopContext): Promise<DeviceInfo> => {
+    if (platform === "win32") {
+      const hw = (await ctx.shell("device.info")) as { manufacturer: string | null; model: string | null };
+      const manufacturer = named(hw.manufacturer) ?? "unknown";
+      const model = named(hw.model) ?? "unknown";
+      return {
+        platform: "windows",
+        model,
+        manufacturer,
+        osName: "Windows",
+        osVersion: release(),
+        isVirtual: isVirtualMachine(manufacturer, model),
+        webViewVersion: await webViewVersion(ctx),
+      };
+    }
+    if (!mac) {
+      
+      const manufacturer = named(readText(sys("sys/class/dmi/id/sys_vendor"))) ?? "unknown";
+      const model =
+        named(readText(sys("sys/class/dmi/id/product_name"))) ??
+        named(readText(sys("proc/device-tree/model"))) ??
+        "unknown";
+      
+      const flagged =
+        /^flags\s*:.*\bhypervisor\b/m.test(readText(sys("proc/cpuinfo"))) ||
+        readText(sys("sys/hypervisor/type")).trim() !== "";
+      return {
+        platform: akanNativePlatform,
+        model,
+        manufacturer,
+        osName: "Linux",
+        osVersion: release(),
+        isVirtual: flagged || isVirtualMachine(manufacturer, model),
+        webViewVersion: await webViewVersion(ctx),
+      };
+    }
+    
+    const [model = "", vmm = ""] = (await run(["/usr/sbin/sysctl", "-n", "hw.model", "kern.hv_vmm_present"])).split(
+      "\n",
+    );
+    
+    const osVersion = plistString(readText("/System/Library/CoreServices/SystemVersion.plist"), "ProductVersion") ?? "";
+    
+    const safari = plistString(readText("/Applications/Safari.app/Contents/Info.plist"), "CFBundleShortVersionString");
+    return {
+      platform: "macos",
+      model: model.trim() || "Mac",
+      manufacturer: "Apple",
+      osName: "macOS",
+      osVersion,
+      isVirtual: vmm.trim() === "1",
+      webViewVersion: safari,
+    };
+  };
+
+  let info: Promise<DeviceInfo> | null = null;
+
+  return defineDesktopPlugin<DeviceApi>({
+    id: "device",
+    methods: {
+      getInfo(_args, ctx) {
+        info ??= readInfo(ctx).catch((error) => {
+          info = null;
+          throw error;
+        });
+        return info;
+      },
+      getId(_args, ctx) {
+        
+        const file = join(ctx.appDataDir, "device-id");
+        if (existsSync(file)) {
+          const stored = readText(file).trim();
+          if (stored) return { identifier: stored };
+        }
+        const identifier = randomUUID();
+        writeFileSync(`${file}.tmp`, identifier);
+        renameSync(`${file}.tmp`, file);
+        return { identifier };
+      },
+      async getLanguage(_args, ctx) {
+        
+        const tag =
+          (mac
+            ? parseAppleLanguages(await run(["/usr/bin/defaults", "read", "-g", "AppleLanguages"]))
+            : platform === "win32"
+              ? ((await ctx.shell("device.language")) as { tag: string | null }).tag
+              : posixLanguage(env)) ?? Intl.DateTimeFormat().resolvedOptions().locale;
+        return { tag, code: tag.split("-")[0]!.toLowerCase() };
+      },
+      async getBattery(_args, ctx) {
+        if (mac) return parsePmset(await run(["/usr/bin/pmset", "-g", "batt"]));
+        if (platform === "win32") return (await ctx.shell("device.battery")) as BatteryInfo;
+        if (platform === "linux") return parsePowerSupplies(readPowerSupplies(sys("sys/class/power_supply")));
+        throw new AkanNativeError("UNSUPPORTED", `device.getBattery() is not implemented on ${platform}`);
+      },
+    },
+  });
+}
+
+export default createDesktopDevice();

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

@@ -0,0 +1,72 @@
+import { createLiveValue, definePlugin, type Platform } from "../../../packages/core/src/index.ts";
+import { useLiveValue } from "../../../packages/react/src/index.ts";
+import { web } from "./web.ts";
+
+export interface DeviceInfo {
+  /** The akan-native platform: "web" in a browser, otherwise the app host. */
+  platform: Platform;
+  /** Hardware model identifier, e.g. "iPhone17,1", "Pixel 9", "Mac16,7". Best effort on the web. */
+  model: string;
+  /** e.g. "Apple", "Google", "samsung". "unknown" where the host cannot tell (most browsers). */
+  manufacturer: string;
+  /** "iOS", "iPadOS", "Android", "macOS", "Windows", "Linux", "ChromeOS" or "unknown". */
+  osName: string;
+  /** e.g. "26.0", "16". Browsers freeze the version in the user agent, so it may be stale on the web. */
+  osVersion: string;
+  /**
+   * True in the iOS simulator, the Android emulator and virtual machines (macOS: the hypervisor
+   * flag; Windows and Linux: the firmware's vendor and product names, and the CPU's hypervisor flag
+   * on Linux). Always false on the web.
+   */
+  isVirtual: boolean;
+  /**
+   * Version of the engine rendering the page: WebKit ships with iOS, the WebView package on Android,
+   * Safari on macOS, the WebView2 runtime on Windows, WebKitGTK on Linux, the browser on the web.
+   */
+  webViewVersion: string | null;
+}
+
+export interface BatteryInfo {
+  /** Charge from 0 to 1, or null without a battery (iOS simulator, desktop Macs) or a reading. iOS reports 5% steps. */
+  level: number | null;
+  /** True while connected to power (charging or full), null without a battery. */
+  charging: boolean | null;
+}
+
+export interface DeviceApi {
+  getInfo(): Promise<DeviceInfo>;
+  /**
+   * A stable identifier for this app on this device. Not a hardware id:
+   * iOS identifierForVendor (reset when all of the vendor's apps are removed), Android ANDROID_ID
+   * (differs per signing key and user), desktop and web a random UUID stored with the app data.
+   */
+  getId(): Promise<{ identifier: string }>;
+  /**
+   * The user's preferred language as a BCP 47 tag ("ko-KR", "zh-Hans-CN") and its language subtag ("ko").
+   * Prefer this over navigator.language inside apps: WKWebView answers from the app bundle's
+   * localizations, not the user's language list (an app without any reports "en-US"; verified on macOS).
+   */
+  getLanguage(): Promise<{ tag: string; code: string }>;
+  /** Rejects UNSUPPORTED where the host cannot read the battery (Safari, Firefox). */
+  getBattery(): Promise<BatteryInfo>;
+}
+
+export const device = definePlugin<DeviceApi>("device", {
+  methods: ["getInfo", "getId", "getLanguage", "getBattery"],
+  web,
+});
+
+let requested = false;
+const info = createLiveValue<DeviceInfo | null>(null, (set) => {
+  if (requested) return;
+  requested = true;
+  device.getInfo().then(set, (error) => {
+    requested = false;
+    console.warn("[akan-native] device.getInfo failed", error);
+  });
+});
+
+/** Device information, or null until it has loaded. */
+export function useDeviceInfo(): DeviceInfo | null {
+  return useLiveValue(info);
+}

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

@@ -0,0 +1,162 @@
+import { AkanNativeError, defineWebPlugin } from "../../../packages/core/src/index.ts";
+import type { BatteryInfo, DeviceApi, DeviceInfo } from "./index.ts";
+
+export interface UserAgentFields {
+  osName: string;
+  osVersion: string;
+  model: string;
+  manufacturer: string;
+  browserVersion: string | null;
+}
+
+const version = (s: string | undefined) => (s ?? "").replace(/_/g, ".");
+
+/** OS and browser from a user agent string. `touchPoints` tells iPads in desktop mode from Macs. */
+export function parseUserAgent(ua: string, touchPoints = 0): UserAgentFields {
+  const browserVersion =
+    ua.match(/\b(?:Edg|EdgA|EdgiOS|CriOS|FxiOS|Firefox|OPR)\/([\d.]+)/)?.[1] ??
+    ua.match(/\b(?:Headless)?Chrome\/([\d.]+)/)?.[1] ??
+    ua.match(/\bVersion\/([\d.]+)/)?.[1] ??
+    null;
+  const safari = ua.match(/\bVersion\/([\d.]+)/)?.[1]; 
+
+  const apple = ua.match(/\b(iPhone|iPad|iPod)\b[^)]*? OS ([\d_]+)/);
+  if (apple) {
+    return {
+      osName: apple[1] === "iPad" ? "iPadOS" : "iOS",
+      osVersion: safari ?? version(apple[2]),
+      model: apple[1]!,
+      manufacturer: "Apple",
+      browserVersion,
+    };
+  }
+  const android = ua.match(/\bAndroid ([\d.]+)(?:; ([^;)]+))?/);
+  if (android) {
+    const model = (android[2] ?? "").replace(/\s*Build\/.*$/, "").trim();
+    return {
+      osName: "Android",
+      osVersion: android[1]!,
+      model: model && model !== "K" ? model : "unknown",
+      manufacturer: "unknown",
+      browserVersion,
+    };
+  }
+  const chromeOs = ua.match(/\bCrOS \S+ ([\d.]+)/);
+  if (chromeOs) {
+    return { osName: "ChromeOS", osVersion: chromeOs[1]!, model: "unknown", manufacturer: "unknown", browserVersion };
+  }
+  const mac = ua.match(/\bMac OS X ([\d_.]+)/);
+  if (mac) {
+    if (touchPoints > 1)
+      return { osName: "iPadOS", osVersion: safari ?? "", model: "iPad", manufacturer: "Apple", browserVersion };
+    return { osName: "macOS", osVersion: version(mac[1]), model: "Macintosh", manufacturer: "Apple", browserVersion };
+  }
+  const windows = ua.match(/\bWindows NT ([\d.]+)/);
+  if (windows) {
+    return { osName: "Windows", osVersion: windows[1]!, model: "unknown", manufacturer: "unknown", browserVersion };
+  }
+  if (/\b(Linux|X11)\b/.test(ua))
+    return { osName: "Linux", osVersion: "", model: "unknown", manufacturer: "unknown", browserVersion };
+  return { osName: "unknown", osVersion: "", model: "unknown", manufacturer: "unknown", browserVersion };
+}
+
+interface HighEntropyValues {
+  model?: string;
+  platformVersion?: string;
+  fullVersionList?: { brand: string; version: string }[];
+}
+
+interface UserAgentData {
+  getHighEntropyValues(hints: string[]): Promise<HighEntropyValues>;
+}
+
+/** Applies Client Hints on top of the user agent fields. */
+export function applyClientHints(fields: UserAgentFields, hints: HighEntropyValues): UserAgentFields {
+  const next = { ...fields };
+  if (hints.platformVersion) {
+    
+    const major = Number.parseInt(hints.platformVersion, 10);
+    next.osVersion =
+      fields.osName === "Windows" ? (major >= 13 ? "11" : major > 0 ? "10" : fields.osVersion) : hints.platformVersion;
+  }
+  if (hints.model) next.model = hints.model;
+  const brands = (hints.fullVersionList ?? []).filter((b) => !/not.?a.?brand/i.test(b.brand));
+  const brand = brands.find((b) => b.brand !== "Chromium") ?? brands[0];
+  if (brand) next.browserVersion = brand.version;
+  return next;
+}
+
+async function getInfo(): Promise<DeviceInfo> {
+  let fields = parseUserAgent(navigator.userAgent, navigator.maxTouchPoints ?? 0);
+  const data = (navigator as Navigator & { userAgentData?: UserAgentData }).userAgentData;
+  if (typeof data?.getHighEntropyValues === "function") {
+    try {
+      fields = applyClientHints(
+        fields,
+        await data.getHighEntropyValues(["model", "platformVersion", "fullVersionList"]),
+      );
+    } catch {
+    }
+  }
+  return {
+    platform: "web",
+    model: fields.model,
+    manufacturer: fields.manufacturer,
+    osName: fields.osName,
+    osVersion: fields.osVersion,
+    isVirtual: false,
+    webViewVersion: fields.browserVersion,
+  };
+}
+
+const ID_KEY = "akan-native.device.id";
+let sessionId: string | null = null;
+
+function uuid(): string {
+  if (typeof crypto.randomUUID === "function") return crypto.randomUUID(); 
+  const b = crypto.getRandomValues(new Uint8Array(16));
+  b[6] = (b[6]! & 0x0f) | 0x40;
+  b[8] = (b[8]! & 0x3f) | 0x80;
+  const h = Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("");
+  return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`;
+}
+
+function getId(): { identifier: string } {
+  try {
+    const stored = localStorage.getItem(ID_KEY);
+    if (stored) return { identifier: stored };
+    const id = uuid();
+    localStorage.setItem(ID_KEY, id);
+    return { identifier: id };
+  } catch {
+    
+    sessionId ??= uuid();
+    return { identifier: sessionId };
+  }
+}
+
+interface BatteryManager {
+  level: number;
+  charging: boolean;
+}
+
+async function getBattery(): Promise<BatteryInfo> {
+  const nav = navigator as Navigator & { getBattery?: () => Promise<BatteryManager> };
+  if (typeof nav.getBattery !== "function")
+    throw new AkanNativeError("UNSUPPORTED", "the Battery Status API is not available in this browser");
+  const battery = await nav.getBattery();
+  
+  return { level: Math.round(battery.level * 100) / 100, charging: battery.charging };
+}
+
+export const web = defineWebPlugin<DeviceApi>({
+  methods: {
+    getInfo,
+    getId: async () => getId(),
+    async getLanguage() {
+      const tag = navigator.languages?.[0] || navigator.language || "en";
+      return { tag, code: tag.split(/[-_]/)[0]!.toLowerCase() };
+    },
+    getBattery,
+  },
+});