akanjs 3.0.0-beta.2 → 3.0.0-beta.21

package/vendor/@akanjs/native/packages/desktop/src/main.ts

@@ -0,0 +1,133 @@
+
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { renderInitScript } from "../../core/src/protocol.ts";
+import { ABI_MAJOR, cstr, lastError, openNative, resolvePaths } from "./ffi.ts";
+import { webviewDataDir } from "./paths.ts";
+import type { Launch, LaunchWindow } from "./plugin.ts";
+
+const ENV_OVERRIDE_PREFIX = "AKAN_NATIVE_PUBLIC_";
+
+/** env.runtime.json, overlaid with AKAN_NATIVE_PUBLIC_* process variables (ENV-1, highest precedence). */
+function runtimeEnv(resources: string): Record<string, string> {
+  const env = JSON.parse(readFileSync(join(resources, "env.runtime.json"), "utf8")) as Record<string, string>;
+  for (const [key, value] of Object.entries(process.env)) {
+    if (key.startsWith(ENV_OVERRIDE_PREFIX) && value !== undefined) env[key.slice("AKAN_NATIVE_".length)] = value;
+  }
+  return env;
+}
+
+interface ShellConfig {
+  title: string;
+  backgroundColor: string;
+  backgroundColorDark: string;
+  devtools: boolean;
+  width?: number;
+  height?: number;
+  /** akan-native dev --hmr (dev builds): the dev gateway every page request outside /__akan_native/* goes to. */
+  devServer?: string;
+  /** With devServer: the main window's first page (akan-native dev --start), else "/". */
+  startPath?: string;
+  /** security.shell.externalSchemes (L0): schemes links may also hand to the OS. */
+  externalSchemes?: string[];
+}
+
+const finite = (v: unknown): v is number => typeof v === "number" && Number.isFinite(v);
+
+/** The launch phase's window bounds that akan_native_run understands (x and y only together). */
+export function launchBounds(window: LaunchWindow): LaunchWindow {
+  const out: LaunchWindow = {};
+  if (finite(window.x) && finite(window.y)) Object.assign(out, { x: window.x, y: window.y });
+  if (finite(window.width) && window.width >= 1) out.width = window.width;
+  if (finite(window.height) && window.height >= 1) out.height = window.height;
+  if (window.maximized === true) out.maximized = true;
+  return out;
+}
+
+function fail(message: string, error?: unknown): never {
+  console.error(`[akan-native] ${message}`, error ?? "");
+  process.exit(1);
+}
+
+export async function startMain(workerUrl: string): Promise<never> {
+  const paths = resolvePaths();
+  let shell: ShellConfig;
+  let initJs: string;
+  let dev = false;
+  let appId = "";
+  try {
+    shell = JSON.parse(readFileSync(join(paths.resources, "shell.json"), "utf8"));
+    const boot = readFileSync(join(paths.resources, "boot.json"), "utf8");
+    initJs = renderInitScript(boot.trim(), JSON.stringify(runtimeEnv(paths.resources)));
+    const parsed = JSON.parse(boot) as { dev?: boolean; app?: { id?: string } };
+    dev = parsed.dev === true;
+    appId = parsed.app?.id ?? "";
+  } catch (error) {
+    fail(`cannot read app resources in ${paths.resources}`, error);
+  }
+
+  let lib: ReturnType<typeof openNative>;
+  try {
+    lib = openNative(paths.lib);
+  } catch (error) {
+    fail(`cannot load ${paths.lib}`, error);
+  }
+  
+  const abi = lib.symbols.akan_native_abi();
+  if (abi >>> 16 !== ABI_MAJOR)
+    fail(`${paths.lib} speaks C ABI ${abi >>> 16}.${abi & 0xffff}; this app needs ${ABI_MAJOR}.x`);
+  
+  lib.symbols.akan_native_init(dev ? 1 : 0);
+  if (!dev)
+    for (const key of Object.keys(process.env))
+      if (/^(WEBVIEW2_|WEBKIT_INSPECTOR|WEBKIT_DISABLE_SANDBOX)|^SSLKEYLOGFILE$/.test(key)) delete process.env[key];
+
+  const worker = new Worker(workerUrl, { argv: process.argv.slice(2) } as WorkerOptions);
+  
+  const launch = await new Promise<Launch>((resolve) => {
+    const timer = setTimeout(() => fail("plugin host did not start within 10 s"), 10_000);
+    worker.addEventListener("error", (event) =>
+      fail("plugin host failed to start", (event as ErrorEvent).message ?? event),
+    );
+    worker.addEventListener("message", (event) => {
+      const data = (event as MessageEvent).data as { type?: string } & Partial<Launch>;
+      if (data?.type === "ready") {
+        clearTimeout(timer);
+        resolve({ window: data.window ?? {}, exit: data.exit });
+      }
+    });
+  });
+  if (typeof launch.exit === "number") {
+    worker.terminate();
+    process.exit(launch.exit);
+  }
+  const bounds = launchBounds(launch.window);
+
+  const config = {
+    title: shell.title,
+    width: shell.width ?? 1024,
+    height: shell.height ?? 720,
+    ...bounds,
+    appDir: paths.appDir,
+    initJs,
+    devtools: shell.devtools,
+    menu: true,
+    backgroundColor: shell.backgroundColor,
+    backgroundColorDark: shell.backgroundColorDark,
+    externalSchemes: shell.externalSchemes ?? [],
+    
+    activation: process.env.AKAN_NATIVE_ACTIVATION ?? "regular",
+    
+    ...(dev && shell.devServer ? { devServer: shell.devServer } : {}),
+    ...(dev && shell.devServer && shell.startPath ? { startPath: shell.startPath } : {}),
+    
+    ...(appId && webviewDataDir(appId) ? { dataDir: webviewDataDir(appId) } : {}),
+    ...(existsSync(join(paths.resources, "icon.rgba")) ? { icon: join(paths.resources, "icon.rgba") } : {}),
+    
+    ...(appId ? { appId } : {}),
+  };
+  const code = lib.symbols.akan_native_run(cstr(JSON.stringify(config)));
+
+  fail(`${code === -5 ? "cannot start: " : `akan_native_run failed with ${code}: `}${lastError(lib)}`);
+}

package/vendor/@akanjs/native/packages/desktop/src/page-veto.ts

@@ -0,0 +1,103 @@
+
+
+import { AkanNativeError } from "../../core/src/index.ts";
+import type { DesktopContext, EmitTarget } from "./plugin.ts";
+
+export const PAGE_ACK_TIMEOUT = 2000;
+
+/** Emit functions from before multi-window return nothing: one page, answering from any window. */
+const ANY_PAGE = -1;
+
+export interface PageVeto<D> {
+  readonly listening: boolean;
+  /**
+   * The plugin's event source: `events: { closeRequested: (emit, ctx) => veto.source(emit, ctx) }`.
+   * With `ctx`, a page that reloads or whose window is destroyed while asked drops the request.
+   */
+  source(emit: (data: D & { id: number }, target?: EmitTarget) => number[] | unknown, ctx?: DesktopContext): () => void;
+  /** Resolves false if a page called preventDefault(). */
+  ask(data: D, target?: EmitTarget): Promise<boolean>;
+  /** The plugin method the pages answer with: { id, allow? }, from `window` (ctx.window). */
+  answer(args: unknown, window?: number): void;
+}
+
+interface Pending {
+  /** Asked pages that have not allowed yet: window → acknowledged. */
+  pages: Map<number, boolean>;
+  timer: ReturnType<typeof setTimeout> | undefined;
+  resolve(allow: boolean): void;
+}
+
+export function createPageVeto<D extends object = {}>(ackTimeout = PAGE_ACK_TIMEOUT): PageVeto<D> {
+  let emit: ((data: D & { id: number }, target?: EmitTarget) => number[] | unknown) | null = null;
+  let seq = 0;
+  const pending = new Map<number, Pending>();
+
+  const settle = (id: number, allow: boolean) => {
+    const entry = pending.get(id);
+    if (!entry) return;
+    pending.delete(id);
+    clearTimeout(entry.timer);
+    entry.resolve(allow);
+  };
+  const gone = (window: number) => {
+    for (const [id, entry] of [...pending]) if (entry.pages.has(window)) settle(id, false);
+  };
+
+  return {
+    get listening() {
+      return emit !== null;
+    },
+    source(send, ctx) {
+      emit = send;
+
+      const stops = ctx ? [ctx.onDocumentEnd((doc) => gone(doc.window))] : [];
+      return () => {
+        for (const stop of stops) stop();
+        if (emit === send) emit = null;
+        for (const id of [...pending.keys()]) settle(id, false);
+      };
+    },
+    ask(data, target) {
+      if (!emit) return Promise.resolve(true);
+      const id = ++seq;
+      return new Promise<boolean>((resolve) => {
+        const entry: Pending = { pages: new Map(), timer: undefined, resolve };
+        pending.set(id, entry);
+        const reached = emit!({ ...data, id }, target);
+        const windows = Array.isArray(reached) ? (reached as number[]) : [ANY_PAGE];
+        if (windows.length === 0) return settle(id, true); 
+        for (const window of windows) entry.pages.set(window, false);
+        entry.timer = setTimeout(() => {
+          for (const [window, acked] of entry.pages) {
+            if (acked) continue;
+            console.warn(
+              `[akan-native] the page${window > 0 ? ` of window ${window}` : ""} did not answer within ${ackTimeout} ms; going on`,
+            );
+            entry.pages.delete(window);
+          }
+          if (entry.pages.size === 0) settle(id, true);
+        }, ackTimeout);
+      });
+    },
+    answer(args, window) {
+      const { id, allow } = (args ?? {}) as { id?: unknown; allow?: unknown };
+      if (typeof id !== "number") throw new AkanNativeError("INVALID_ARGS", "id must be a number");
+      if (allow !== undefined && typeof allow !== "boolean")
+        throw new AkanNativeError("INVALID_ARGS", "allow must be a boolean");
+      const entry = pending.get(id);
+      if (!entry) return; 
+      const page =
+        window !== undefined && entry.pages.has(window) ? window : entry.pages.has(ANY_PAGE) ? ANY_PAGE : undefined;
+      if (page === undefined) return; 
+      if (allow === undefined) {
+        entry.pages.set(page, true); 
+        if ([...entry.pages.values()].every(Boolean)) clearTimeout(entry.timer);
+      } else if (!allow) settle(id, false);
+      else {
+        entry.pages.delete(page);
+        if (entry.pages.size === 0) settle(id, true);
+      }
+    },
+  };
+}

package/vendor/@akanjs/native/packages/desktop/src/paths.ts

@@ -0,0 +1,59 @@
+
+
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+type Env = Record<string, string | undefined>;
+
+/** XDG base directories must be absolute; anything else is ignored (XDG Base Directory spec). */
+const xdg = (value: string | undefined, fallback: string) => (value?.startsWith("/") ? value : fallback);
+
+/**
+ * Settings and state the app keeps (preferences, window state, files):
+ *   macOS    ~/Library/Application Support/<id>
+ *   Windows  %APPDATA%\<id>          (Roaming: follows the user between PCs)
+ *   Linux    $XDG_DATA_HOME/<id>     (~/.local/share/<id>)
+ */
+export function appDataDir(
+  id: string,
+  platform: NodeJS.Platform = process.platform,
+  env: Env = process.env,
+  home = homedir(),
+): string {
+  if (platform === "darwin") return join(home, "Library", "Application Support", id);
+  if (platform === "win32") return join(env.APPDATA || join(home, "AppData", "Roaming"), id);
+  return join(xdg(env.XDG_DATA_HOME, join(home, ".local", "share")), id);
+}
+
+/**
+ * The webview's own storage and caches (Windows, Linux; WKWebView chooses its own on macOS):
+ *   Windows  %LOCALAPPDATA%\<id>\WebView2   (large and machine-specific: not Roaming)
+ *   Linux    $XDG_DATA_HOME/<id>/webview
+ * WebView2's default would be next to the .exe, which is not writable once installed.
+ */
+export function webviewDataDir(
+  id: string,
+  platform: NodeJS.Platform = process.platform,
+  env: Env = process.env,
+  home = homedir(),
+): string | undefined {
+  if (platform === "win32") return join(env.LOCALAPPDATA || join(home, "AppData", "Local"), id, "WebView2");
+  if (platform === "linux") return join(appDataDir(id, platform, env, home), "webview");
+  return undefined;
+}
+
+/**
+ * Folders whose files no FileRef may serve (L4): the shell's and the plugins' own storage
+ * (preferences, secure storage, databases, update bundles, window state, the webview's data). Only
+ * the filesystem plugin's `data` base (<app data>/files) is servable inside the app data folder.
+ */
+export function reservedDirs(
+  id: string,
+  platform: NodeJS.Platform = process.platform,
+  env: Env = process.env,
+  home = homedir(),
+): { root: string; except: string[] }[] {
+  const data = appDataDir(id, platform, env, home);
+  const webview = webviewDataDir(id, platform, env, home);
+  return [{ root: data, except: [join(data, "files")] }, ...(webview ? [{ root: webview, except: [] }] : [])];
+}

package/vendor/@akanjs/native/packages/desktop/src/plugin.ts

@@ -0,0 +1,232 @@
+
+
+import { EXTERNAL_OPENS_PER_SECOND } from "../../core/src/contract.ts";
+import type { AppInfo, CallScope, FileRef } from "../../core/src/index.ts";
+import type { QuitReason, Veto } from "./lifecycle.ts";
+
+export type { QuitReason, Veto } from "./lifecycle.ts";
+export { createPageVeto, type PageVeto } from "./page-veto.ts";
+
+/**
+ * Which pages an event goes to. Default: every page that listens. `{ window }`: only that
+ * window's page (window events). "focused": only the most recently focused window that listens
+ * (something to handle once, like a deep link).
+ */
+export type EmitTarget = { window: number } | "focused";
+
+export interface DesktopContext {
+  app: AppInfo;
+  /**
+   * The window whose page made this call (SH-6; 1 = the window the app opened). Only in method
+   * calls; undefined in setup and event sources.
+   */
+  readonly window?: number;
+  /**
+   * What the app's capabilities allow this method call (PL-11): enforce it with
+   * `scopePermits(ctx.scope, { field: value }, pathFields, urlFields)` from @akanjs/native/core. Undefined when no
+   * matching grant carries scopes (only the plugin's own rules apply). Only in method calls.
+   */
+  readonly scope?: CallScope;
+  /**
+   * Fires when the page gives up on this call (its AbortSignal: v1.1 `cancel`) or the page is gone.
+   * The page has its answer by then (CANCELLED or TIMEOUT); stop the work and release what it
+   * holds. Only in method calls.
+   */
+  readonly signal?: AbortSignal;
+  /**
+   * The calling page's document (one page load; bridge v1.1 `doc`), for what must not outlive it:
+   * `ctx.document.own(() => db.close())`. Only in method calls.
+   */
+  readonly document?: DocumentScope;
+  /** Per-app data folder, e.g. ~/Library/Application Support/<app id>. Created on first access. */
+  readonly appDataDir: string;
+  /** Pushes an event of this plugin to the pages that listen. Returns the windows reached. */
+  emit(event: string, data?: unknown, target?: EmitTarget): number[];
+  /** Serves a local file at /__akan_native/file/<id> for the rest of the session (PL-7). */
+  registerFile(path: string, mime: string): FileRef;
+  /**
+   * Runs a native shell command on the main thread, e.g. shell("window.setTitle", { title }).
+   * Window ops act on `args.window`; without it, on the calling window in a method call, else on
+   * the most recently focused window.
+   */
+  shell(op: string, args?: Record<string, unknown>): Promise<unknown>;
+  /** Native shell events ("window", "opened", "pageLoad", …). Returns an unsubscribe function. */
+  onNativeEvent(type: string, listener: (event: NativeEvent) => void): () => void;
+  /** The app's deep link schemes (deepLinks.schemes in akan-native.config.ts), lowercase. */
+  readonly deepLinkSchemes: readonly string[];
+  /**
+   * What may be handed to the OS (L0): http, https, mailto, tel and security.shell.externalSchemes.
+   * Plugins that open URLs outside the app check them and call `externalOpenAllowed()` first.
+   */
+  readonly externalSchemes: readonly string[];
+  /**
+   * Hands a launch's arguments to the "opened" listeners when they are a deep link (D6). Windows
+   * and Linux start a new process for a link; single-instance passes that process's arguments
+   * here. Anything but a single URL of one of the app's schemes is ignored (deeplinks.ts).
+   */
+  openLinks(args: readonly string[]): void;
+  /** Ends the app with an exit code, after the onQuit hooks. Does not ask onBeforeQuit. */
+  quit(code?: number): void;
+  /**
+   * Cleanup before the app quits, however it quits (Cmd+Q, window close, app.exit(), logout).
+   * All hooks run together and the app waits for them at most 2 s. Returns an unregister function.
+   */
+  onQuit(fn: () => void | Promise<void>): () => void;
+  /**
+   * Runs when any window's page document ends (reload, navigation, window destroyed, renderer
+   * gone), after its calls, subscriptions and owned resources were closed. For a plugin's own
+   * per-window tables. Returns an unregister function.
+   */
+  onDocumentEnd(fn: (doc: DocumentInfo) => void): () => void;
+  /** Veto for quit requests (Cmd+Q, Dock, AppleScript, logout, last window closed): return false to keep running. */
+  onBeforeQuit(fn: Veto<{ reason: QuitReason }>): () => void;
+  /** Veto for a window's close button and Cmd+W: return false to keep that window open. */
+  onCloseRequested(fn: Veto<{ window: number }>): () => void;
+  /**
+   * Closes a window without asking (default: the calling window in a method call, else window 1).
+   * Another window is left: it is destroyed. It was the last one: the app quits, or hides it when
+   * desktop.quitOnLastWindowClosed is false.
+   */
+  closeWindow(window?: number): void;
+  /**
+   * Launch phase: only while setup runs, before the window exists. The host waits for every
+   * plugin's setup (async allowed, at most 3 s each) before it creates the window. Calls after
+   * that are ignored with a warning.
+   */
+  readonly launch: {
+    /** Creates the window at these bounds (logical points) instead of the configured size (window-state). */
+    setWindow(bounds: LaunchWindow): void;
+    /** Ends the app before a window is created; onQuit hooks do not run (single-instance). */
+    exit(code?: number): void;
+  };
+}
+
+/** Which page load ended. `id` is "" for a page that sends no document id (v1 callers, tests). */
+export interface DocumentInfo {
+  window: number;
+  id: string;
+}
+
+/**
+ * One page load of a window (architecture §3.7 Document scope). Module state of a desktop plugin is
+ * App scope: keep per-page state here, or keyed by window and cleared in onDocumentEnd.
+ */
+export interface DocumentScope extends DocumentInfo {
+  /** True once the page is gone. */
+  readonly ended: boolean;
+  /**
+   * Ties a resource to this page: `dispose` runs when it ends (the last owned first), or right away
+   * if it already has (a call that finished after its page left). Returns a function that forgets
+   * the resource without disposing it (it was closed on request).
+   */
+  own(dispose: () => unknown): () => void;
+}
+
+/** Initial window bounds from the launch phase. The shell drops a position that is on no display. */
+export interface LaunchWindow {
+  x?: number;
+  y?: number;
+  width?: number;
+  height?: number;
+  maximized?: boolean;
+}
+
+/** What the launch phase decided; sent to the main thread with "ready". */
+export interface Launch {
+  window: LaunchWindow;
+  exit?: number;
+}
+
+export interface NativeEvent {
+  type: string;
+  [key: string]: unknown;
+}
+
+type MethodImpl<F> = F extends (args: infer A) => Promise<infer R>
+  ? (args: A, ctx: DesktopContext) => R | Promise<R>
+  : F extends () => Promise<infer R>
+    ? (args: undefined, ctx: DesktopContext) => R | Promise<R>
+    : never;
+
+export interface DesktopPlugin<Api = any, Events = any> {
+  id: string;
+  /**
+   * Runs once when the plugin host starts, before the window exists and before any page call
+   * (e.g. to catch launch events). May be async: the window waits for it (ctx.launch).
+   */
+  setup?(ctx: DesktopContext): void | Promise<void>;
+  /**
+   * "gate": this setup runs before every other one, one gate plugin after the other, and when one
+   * decides the launch exits (ctx.launch.exit, e.g. single-instance handing over to the running
+   * instance), the other setups do not run at all.
+   */
+  launchPhase?: "gate";
+  /** A window's page document ended (see DesktopContext.onDocumentEnd). */
+  onDocumentEnd?(doc: DocumentInfo, ctx: DesktopContext): void;
+  methods: { [K in keyof Api]?: MethodImpl<Api[K]> };
+  /**
+   * Event sources, started for the first $listen from any page and stopped after the last
+   * $unlisten. `emit` reaches the pages that listen (see EmitTarget) and returns their windows
+   * (typed `| void` so tests can pass a plain function).
+   */
+  events?: {
+    [E in keyof Events]?: (
+      emit: (data: Events[E], target?: EmitTarget) => number[] | void,
+      ctx: DesktopContext,
+    ) => () => void;
+  };
+}
+
+/**
+ * Plugins' external opens (opener, browser, auth-session, …) happen at most
+ * EXTERNAL_OPENS_PER_SECOND times a second, whichever plugin asks (L0; the shell limits the page's
+ * links the same way). false: refuse the open (NOT_ALLOWED).
+ */
+let lastExternalOpen = -Infinity;
+const linkClaimers = new Set<(url: string) => boolean>();
+
+/**
+ * A plugin that answers some links itself (auth-session's sign-in callback, R10) takes them before
+ * the app plugin turns them into urlOpen. `claim` says whether a URL is its own; returns the removal.
+ */
+export function claimLinks(claim: (url: string) => boolean): () => void {
+  linkClaimers.add(claim);
+  return () => linkClaimers.delete(claim);
+}
+
+/** Whether a plugin took this link (the app plugin then does not deliver it). */
+export function linkClaimed(url: string): boolean {
+  for (const claim of linkClaimers) {
+    try {
+      if (claim(url)) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+
+let limitOpens = true;
+/** The shell's own counter (akan_native_external_open_allowed), which the page's links use too. */
+let shellLimiter: (() => boolean) | null = null;
+export function externalOpenAllowed(now = performance.now()): boolean {
+  if (!limitOpens) return true;
+  if (shellLimiter) return shellLimiter();
+  if (now - lastExternalOpen < 1000 / EXTERNAL_OPENS_PER_SECOND) return false;
+  lastExternalOpen = now;
+  return true;
+}
+
+/** The plugin host: plugins' opens share the shell's counter with the page's links. */
+export function useShellOpenLimit(limiter: () => boolean): void {
+  shellLimiter = limiter;
+}
+
+/** Unit tests only: plugins' tests open many URLs in a row. */
+export function limitExternalOpens(enabled: boolean): void {
+  limitOpens = enabled;
+  lastExternalOpen = -Infinity;
+}
+
+export function defineDesktopPlugin<Api, Events = {}>(plugin: DesktopPlugin<Api, Events>): DesktopPlugin<Api, Events> {
+  return plugin;
+}

package/vendor/@akanjs/native/packages/react/src/index.ts

@@ -0,0 +1,23 @@
+
+
+import * as React from "react";
+import type { LiveValue, PluginHandle } from "../../core/src/index.ts";
+
+/** Reads a LiveValue and re-renders when it changes. */
+export function useLiveValue<T>(value: LiveValue<T>): T {
+  return React.useSyncExternalStore(value.subscribe, value.get, value.get);
+}
+
+/**
+ * Subscribes to a plugin event while the component is mounted (PL-6).
+ * The handler may change between renders without resubscribing.
+ */
+export function usePluginEvent<Events, E extends keyof Events & string>(
+  plugin: PluginHandle<any, Events>,
+  event: E,
+  handler: (data: Events[E]) => void,
+): void {
+  const ref = React.useRef(handler);
+  ref.current = handler;
+  React.useEffect(() => plugin.listen(event, (data) => ref.current(data)), [plugin, event]);
+}

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)
+    }
+}