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

package/types/vendor/@akanjs/native/packages/desktop/src/dispatcher.d.ts

@@ -0,0 +1,95 @@
+import type { AppInfo, FileRef, ResolvedAcl } from "../../core/src/index.ts";
+import { type BridgeEvent, type BridgeRequest, type BridgeResponse } from "../../core/src/protocol.ts";
+import type { Lifecycle } from "./lifecycle.ts";
+import type { DesktopPlugin, Launch, NativeEvent } from "./plugin.ts";
+/** How long the window waits for one plugin's setup. */
+export declare const SETUP_TIMEOUT_MS = 3000;
+/**
+ * How long a page's call to a plugin whose setup is still running (it outlasted SETUP_TIMEOUT_MS)
+ * waits for it before it is answered INTERNAL with `retryable`.
+ */
+export declare const SETUP_WAIT_MS = 5000;
+export interface HostServices {
+    app: AppInfo;
+    appDataDir: string;
+    /** Sends an event (numbered for its document) to a window's page. */
+    emit(window: number, message: BridgeEvent): void;
+    /**
+     * Reserved plugin ids the host answers itself ($console, $host): the result, or a throw. `signal`
+     * fires when the page cancels the call or goes away.
+     */
+    builtins?: Record<string, (req: BridgeRequest, window: number, signal: AbortSignal) => unknown>;
+    /** Windows by last focus, most recent first (SH-6). For EmitTarget "focused". */
+    focusOrder?(): number[];
+    registerFile(path: string, mime: string): FileRef;
+    /** Stops serving a FileRef ($bridge.release). False when the URL is not one of this session's. */
+    releaseFile?(url: string): boolean;
+    shell?(op: string, args?: Record<string, unknown>): Promise<unknown>;
+    onNativeEvent?(type: string, listener: (event: NativeEvent) => void): () => void;
+    deepLinkSchemes?: readonly string[];
+    /** security.shell.externalSchemes from shell.json (L0). */
+    externalSchemes?: readonly string[];
+    openLinks?(args: readonly string[]): void;
+    quit?(code: number): void;
+    /** Quit and close sequence (lifecycle.ts). Without it, quit() ends the app at once and nothing can veto. */
+    lifecycle?: Lifecycle;
+}
+export interface Dispatcher {
+    /** Every plugin's setup finished (or ran out of time): what the window should look like, or exit. */
+    launched: Promise<Launch>;
+    /** Handles one request body (JSON text) from a window's page and returns the response. Never throws. */
+    handle(body: string, window?: number): Promise<BridgeResponse>;
+    /**
+     * A window's page (re)loaded or the window is gone: its document ends, its subscriptions are
+     * gone, and event sources nobody listens to any more stop. Without a window: every page.
+     */
+    reset(window?: number): void;
+    /** Sends an event to a window's current document whether or not it listens (host built-ins). */
+    emitTo(window: number, plugin: string, event: string, data?: unknown): void;
+    /** Table sizes for the document churn check (K13, dev $host.info). */
+    stats(): DispatcherStats;
+}
+export interface DispatcherStats {
+    documents: number;
+    /** Ended document ids remembered, all windows. */
+    ended: number;
+    /** $listen counts, all windows and events. */
+    subscriptions: number;
+    /** Event sources running. */
+    sources: number;
+    /** Calls not answered yet. */
+    running: number;
+    /** Resources owned by live documents (ctx.document.own). */
+    resources: number;
+    /** ctx.onDocumentEnd listeners. */
+    documentListeners: number;
+}
+/**
+ * A document's request ids (bridge v1.1 `once`): each is accepted once. The page numbers its
+ * requests upward, but they arrive over HTTP and can overtake each other, so the recent ids are
+ * kept in a set and older ones are covered by a floor.
+ */
+export declare class CallIds {
+    private floor;
+    private readonly seen;
+    /** Whether the id was received (or is older than what is remembered). */
+    has(id: number): boolean;
+    accept(id: number): boolean;
+}
+/**
+ * How long a coalescing event (manifest `coalesce`, architecture review stage 4) waits for a newer one
+ * before it is sent: about 10 per second at most.
+ */
+export declare const COALESCE_MS = 100;
+export interface DispatcherOptions {
+    setupTimeoutMs?: number;
+    setupWaitMs?: number;
+    /** The app's resolved capabilities from boot.json (PL-11). Absent: everything is allowed. */
+    acl?: ResolvedAcl | null;
+    /**
+     * boot.json `plugins` (L2 declaration gate): a method or event a plugin does not declare for this
+     * platform is NOT_FOUND before the ACL and the plugin, whatever its module implements. Absent: no gate (tests).
+     */
+    declarations?: Record<string, unknown>;
+}
+export declare function createDispatcher(plugins: DesktopPlugin[], services: HostServices, options?: DispatcherOptions): Dispatcher;

package/types/vendor/@akanjs/native/packages/desktop/src/ffi.d.ts

@@ -0,0 +1,144 @@
+export interface DesktopPaths {
+    /** The native library: libakan_native_desktop.dylib, akan_native_desktop.dll or libakan_native_desktop.so */
+    lib: string;
+    /** boot.json, env.runtime.json, shell.json, app/ (platforms/desktop.ts in the CLI) */
+    resources: string;
+    appDir: string;
+}
+/**
+ * Paths relative to the executable, as the CLI lays them out (packages/cli/src/platforms/*.ts):
+ *   macOS    <App>.app/Contents/MacOS/<exe>, Frameworks/libakan_native_desktop.dylib, Resources/
+ *   Windows  <App>\<exe>.exe, akan_native_desktop.dll, resources\
+ *   Linux    <app>/<exe>, lib/libakan_native_desktop.so, resources/
+ * process.execPath is absolute even when the app is started with `open` (cwd = /) or through a
+ * symlink. Nothing in the environment overrides them: the app would load whatever library a
+ * variable (or a .env file next to it, before the build turned autoloading off) names.
+ */
+export declare function resolvePaths(platform?: NodeJS.Platform, execPath?: string): DesktopPaths;
+/** The C ABI major version this code speaks (lib.rs ABI >> 16). */
+export declare const ABI_MAJOR = 0;
+export declare const SYMBOLS: {
+    readonly akan_native_abi: {
+        readonly args: readonly [];
+        readonly returns: "u32";
+    };
+    readonly akan_native_init: {
+        readonly args: readonly ["u8"];
+        readonly returns: "i32";
+    };
+    readonly akan_native_last_error: {
+        readonly args: readonly ["ptr", "u64"];
+        readonly returns: "u64";
+    };
+    readonly akan_native_run: {
+        readonly args: readonly ["ptr"];
+        readonly returns: "i32";
+    };
+    readonly akan_native_set_wake: {
+        readonly args: readonly ["ptr"];
+        readonly returns: "void";
+    };
+    readonly akan_native_poll: {
+        readonly args: readonly ["ptr", "u32"];
+        readonly returns: "u32";
+    };
+    readonly akan_native_respond: {
+        readonly args: readonly ["u64", "u16", "ptr", "ptr", "u32"];
+        readonly returns: "void";
+    };
+    readonly akan_native_emit: {
+        readonly args: readonly ["u32", "ptr"];
+        readonly returns: "void";
+    };
+    readonly akan_native_register_file: {
+        readonly args: readonly ["ptr", "ptr", "ptr"];
+        readonly returns: "void";
+    };
+    readonly akan_native_unregister_file: {
+        readonly args: readonly ["ptr"];
+        readonly returns: "u8";
+    };
+    readonly akan_native_quit: {
+        readonly args: readonly ["i32"];
+        readonly returns: "void";
+    };
+    readonly akan_native_quit_cancel: {
+        readonly args: readonly [];
+        readonly returns: "void";
+    };
+    readonly akan_native_external_open_allowed: {
+        readonly args: readonly [];
+        readonly returns: "u8";
+    };
+    readonly akan_native_shell: {
+        readonly args: readonly ["u64", "ptr"];
+        readonly returns: "void";
+    };
+};
+export declare function openNative(libPath: string): import("bun:ffi").Library<{
+    readonly akan_native_abi: {
+        readonly args: readonly [];
+        readonly returns: "u32";
+    };
+    readonly akan_native_init: {
+        readonly args: readonly ["u8"];
+        readonly returns: "i32";
+    };
+    readonly akan_native_last_error: {
+        readonly args: readonly ["ptr", "u64"];
+        readonly returns: "u64";
+    };
+    readonly akan_native_run: {
+        readonly args: readonly ["ptr"];
+        readonly returns: "i32";
+    };
+    readonly akan_native_set_wake: {
+        readonly args: readonly ["ptr"];
+        readonly returns: "void";
+    };
+    readonly akan_native_poll: {
+        readonly args: readonly ["ptr", "u32"];
+        readonly returns: "u32";
+    };
+    readonly akan_native_respond: {
+        readonly args: readonly ["u64", "u16", "ptr", "ptr", "u32"];
+        readonly returns: "void";
+    };
+    readonly akan_native_emit: {
+        readonly args: readonly ["u32", "ptr"];
+        readonly returns: "void";
+    };
+    readonly akan_native_register_file: {
+        readonly args: readonly ["ptr", "ptr", "ptr"];
+        readonly returns: "void";
+    };
+    readonly akan_native_unregister_file: {
+        readonly args: readonly ["ptr"];
+        readonly returns: "u8";
+    };
+    readonly akan_native_quit: {
+        readonly args: readonly ["i32"];
+        readonly returns: "void";
+    };
+    readonly akan_native_quit_cancel: {
+        readonly args: readonly [];
+        readonly returns: "void";
+    };
+    readonly akan_native_external_open_allowed: {
+        readonly args: readonly [];
+        readonly returns: "u8";
+    };
+    readonly akan_native_shell: {
+        readonly args: readonly ["u64", "ptr"];
+        readonly returns: "void";
+    };
+}>;
+/** The native library's last error (akan_native_last_error), or "". */
+export declare function lastError(lib: NativeLib): string;
+export type NativeLib = ReturnType<typeof openNative>;
+/** NUL-terminated UTF-8. Native code copies it during the call, so it may be collected afterwards. */
+export declare const cstr: (text: string) => Uint8Array<ArrayBuffer>;
+/** Message kinds in akan_native_poll frames: [u8 kind][u64 reqId LE][u32 webviewId LE][body]. */
+export declare const FRAME_IPC = 1;
+export declare const FRAME_EVENT = 2;
+export declare const FRAME_HEADER = 13;

package/types/vendor/@akanjs/native/packages/desktop/src/host.d.ts

@@ -0,0 +1,11 @@
+import { AkanNativeError } from "../../core/src/index.ts";
+import { type DesktopPlugin } from "./plugin.ts";
+/** A drain handles at most this many frames, or runs this long, before it yields (see drain). */
+export declare const DRAIN_FRAMES = 256;
+export declare const DRAIN_MS = 4;
+/**
+ * A failed shell op. Ops may name the error code first ("UNSUPPORTED: no tray on this desktop");
+ * other messages are about the arguments.
+ */
+export declare function shellError(message: string): AkanNativeError;
+export declare function startHost(plugins: DesktopPlugin[]): void;

package/types/vendor/@akanjs/native/packages/desktop/src/lifecycle.d.ts

@@ -0,0 +1,40 @@
+export type QuitReason = "user" | "session" | "lastWindowClosed";
+/** Return false (or resolve to false) to keep the app running / the window open. */
+export type Veto<E> = (event: E) => boolean | void | Promise<boolean | void>;
+export interface LifecycleOptions {
+    quitOnLastWindowClosed: boolean;
+    /** Ends the process (akan_native_quit). */
+    exit(code: number): void;
+    /** The app stays after a logout asked it to quit (akan_native_quit_cancel). */
+    cancelSessionEnd(): void;
+    /** Hides the last window instead of quitting (quitOnLastWindowClosed: false). */
+    hideWindow(window: number): Promise<unknown>;
+    /** Destroys a window that is not the last one. */
+    destroyWindow?(window: number): Promise<unknown>;
+    /** The windows that exist, hidden ones included. Default: only the one being closed. */
+    windows?(): Promise<number[]>;
+    /** How long quit() waits for the onQuit hooks, all together. Default QUIT_HOOK_TIMEOUT. */
+    quitHookTimeout?: number;
+}
+export interface Lifecycle {
+    onQuit(fn: () => void | Promise<void>): () => void;
+    onBeforeQuit(fn: Veto<{
+        reason: QuitReason;
+    }>): () => void;
+    onCloseRequested(fn: Veto<{
+        window: number;
+    }>): () => void;
+    /** A window's close button or Cmd+W: asks the close vetoes, then closeWindow(window). */
+    closeRequested(window?: number): Promise<void>;
+    /**
+     * Closes a window without asking: destroys it while another window exists, else a quit
+     * request, or hide (quitOnLastWindowClosed: false).
+     */
+    closeWindow(window?: number): Promise<void>;
+    /** Asks the quit vetoes, then quits. Resolves true when the app quits. */
+    requestQuit(reason: QuitReason): Promise<boolean>;
+    /** Quits without asking: onQuit hooks, then exit. */
+    quit(code?: number): Promise<void>;
+}
+export declare const QUIT_HOOK_TIMEOUT = 2000;
+export declare function createLifecycle(options: LifecycleOptions): Lifecycle;

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

@@ -0,0 +1,4 @@
+import type { LaunchWindow } from "./plugin.ts";
+/** The launch phase's window bounds that akan_native_run understands (x and y only together). */
+export declare function launchBounds(window: LaunchWindow): LaunchWindow;
+export declare function startMain(workerUrl: string): Promise<never>;

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

@@ -0,0 +1,17 @@
+import type { DesktopContext, EmitTarget } from "./plugin.ts";
+export declare const PAGE_ACK_TIMEOUT = 2000;
+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;
+}
+export declare function createPageVeto<D extends object = {}>(ackTimeout?: number): PageVeto<D>;

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

@@ -0,0 +1,25 @@
+type Env = Record<string, string | undefined>;
+/**
+ * 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 declare function appDataDir(id: string, platform?: NodeJS.Platform, env?: Env, home?: string): string;
+/**
+ * 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 declare function webviewDataDir(id: string, platform?: NodeJS.Platform, env?: Env, home?: string): string | 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 declare function reservedDirs(id: string, platform?: NodeJS.Platform, env?: Env, home?: string): {
+    root: string;
+    except: string[];
+}[];
+export {};

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

@@ -0,0 +1,179 @@
+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;
+    };
+}
+/**
+ * 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 declare function claimLinks(claim: (url: string) => boolean): () => void;
+/** Whether a plugin took this link (the app plugin then does not deliver it). */
+export declare function linkClaimed(url: string): boolean;
+export declare function externalOpenAllowed(now?: number): boolean;
+/** The plugin host: plugins' opens share the shell's counter with the page's links. */
+export declare function useShellOpenLimit(limiter: () => boolean): void;
+/** Unit tests only: plugins' tests open many URLs in a row. */
+export declare function limitExternalOpens(enabled: boolean): void;
+export declare function defineDesktopPlugin<Api, Events = {}>(plugin: DesktopPlugin<Api, Events>): DesktopPlugin<Api, Events>;

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

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

package/types/vendor/@akanjs/native/packages/react/src.d.ts

@@ -0,0 +1 @@
+export * from "./src/index.d.ts";

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

@@ -0,0 +1,8 @@
+import type { AnnouncePriority } from "./index.ts";
+/** Checks announce()'s options; the iOS plugin checks the same. */
+export declare function checkAnnounce(options: unknown): {
+    text: string;
+    priority: AnnouncePriority;
+};
+/** Adds `text` to the live region of `priority`; resolves once it is in the page. */
+export declare function announceInPage(text: string, priority: AnnouncePriority): Promise<void>;

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

@@ -0,0 +1,47 @@
+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 declare const accessibility: import("../../../packages/core/src/plugin.ts").Plugin<AccessibilityApi, AccessibilityEvents>;
+/**
+ * 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 declare function useAccessibility(): AccessibilityState;

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

@@ -0,0 +1,4 @@
+import type { AccessibilityApi, AccessibilityEvents, AccessibilityState } from "./index.ts";
+export declare function readFontScale(): number;
+export declare function readWebState(): AccessibilityState;
+export declare const web: import("../../../packages/core/src/plugin.ts").WebPlugin<AccessibilityApi, AccessibilityEvents>;

package/types/vendor/@akanjs/native/plugins/accessibility/src.d.ts

@@ -0,0 +1 @@
+export * from "./src/index.d.ts";

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

@@ -0,0 +1,3 @@
+import type { AppApi, AppEvents } from "./index.ts";
+declare const _default: import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<AppApi, AppEvents>;
+export default _default;