akanjs 3.0.0-beta.8 → 3.0.0

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,15 @@
+import type { LaunchWindow } from "./plugin.ts";
+/**
+ * env.runtime.json, overlaid with what the launch phase learned (the carried server's URL), then with
+ * AKAN_NATIVE_PUBLIC_* process variables (ENV-1, highest precedence).
+ */
+export declare function runtimeEnv(file: Record<string, string>, launched?: Record<string, string>, processEnv?: Record<string, string | undefined>): Record<string, string>;
+/** The launch phase's window bounds that akan_native_run understands (x and y only together). */
+export declare function launchBounds(window: LaunchWindow): LaunchWindow;
+/**
+ * Windows renames no folder that is some process's working folder: an app started from its install folder (the
+ * installer, a shortcut, Explorer) would hand it to the webview's processes, and an update could never swap it
+ * (plugins/updates). Called after the launch phase, where single-instance forwards a second launch's folder.
+ */
+export declare function leaveInstallFolder(appId: string, platform?: NodeJS.Platform): void;
+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,36 @@
+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;
+/**
+ * What is large and belongs to this PC: the webview's storage, the carried server's databases and logs.
+ *   Windows  %LOCALAPPDATA%\<id>    (never Roaming, which follows the user and may be a network share)
+ *   macOS, Linux  appDataDir
+ */
+export declare function appLocalDataDir(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
+ *   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;
+/**
+ * The carried server's folder (server.ts): <app local data>/server. A debug build has the release app's id, so
+ * its server keeps its own folder and never opens the databases of the release app on the same PC.
+ */
+export declare function serverDataDir(id: string, dev: boolean, platform?: NodeJS.Platform, env?: Env, home?: string): string;
+/**
+ * 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, the server's). 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,220 @@
+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;
+    /**
+     * A debug build (boot.json `dev`: `--debug`, and every dev build, whose pages come from a dev server the shell did not
+     * start). It has the release app's id, so what it keeps apart goes in folders of its own.
+     */
+    readonly dev: boolean;
+    /**
+     * 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;
+    /**
+     * For what is large and belongs to this PC (caches, downloads, databases): %LOCALAPPDATA%\<app id> on Windows,
+     * where appDataDir roams with the user; appDataDir on macOS and Linux. Created on first access.
+     */
+    readonly appLocalDataDir: string;
+    /**
+     * The executables the app carries (desktop.bin, akanjs `bin`), or null. The host puts the folder first on
+     * process.env.PATH, which node:child_process and `Bun.spawn(cmd, { env: process.env })` use; a Bun.spawn or
+     * Bun.which without `env` reads the environment the app started with, so name a file here or pass the env.
+     */
+    readonly binDir: string | null;
+    /**
+     * The server the app carries (desktop.server), or null. `ready` settles once per session: true when the server
+     * first answered ready, false when it could not start or gave up before that; `state` and `onState` follow it after.
+     */
+    readonly server: DesktopServerStatus | null;
+    /** 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. setWindow after
+     * that is 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). A setup that ran past its
+         * time quits the app instead, since its window exists by then.
+         */
+        exit(code?: number): void;
+    };
+}
+/**
+ * "starting" until the server answers ready (again after a crash before that), "up" while it answers, "restarting"
+ * after a crash once it had been up, "gaveUp" when it is not started again this session, "stopped" as the app quits.
+ */
+export type DesktopServerState = "starting" | "up" | "restarting" | "gaveUp" | "stopped";
+export interface DesktopServerStatus {
+    readonly ready: Promise<boolean>;
+    readonly state: DesktopServerState;
+    /** Every later change of `state`. Returns an unsubscribe function. */
+    onState(listener: (state: DesktopServerState) => void): () => 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;
+    /** Borderless fullscreen from the first frame, on the display x and y are on (else the primary one). */
+    fullscreen?: boolean;
+    /** No taskbar button (Windows, Linux; macOS has none). */
+    skipTaskbar?: boolean;
+}
+/** What the launch phase decided; sent to the main thread with "ready". */
+export interface Launch {
+    window: LaunchWindow;
+    exit?: number;
+    /** PUBLIC_* values for the page known only at launch (the carried server's URL), under AKAN_NATIVE_PUBLIC_*. */
+    env?: Record<string, string>;
+}
+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/desktop/src/relaunch.d.ts

@@ -0,0 +1,40 @@
+export interface RelaunchOptions {
+    /** How long the helper waits after this process exited before it starts the app. */
+    delayMs?: number;
+    /**
+     * Windows, a swap: while the helper moves the folders, a RunOnce value named `name` runs `script` (written here) at
+     * the next logon, which puts back what a shutdown or a killed helper left half moved and starts the app. The helper
+     * removes the value once the moves are done or undone.
+     */
+    recover?: {
+        script: string;
+        name: string;
+    };
+}
+/**
+ * The recovery `recover.script` holds: when `exe` is missing, every move whose source is gone and whose target is
+ * there goes back, newest first, and the app starts. An app that is there was never half moved: it is left alone.
+ */
+export declare function recoveryScript(exe: string, moves: [string, string][]): string;
+/**
+ * The RunOnce command for a recovery script, or null past the 260 characters Windows runs from there. The script is
+ * read as text: an execution policy that refuses .ps1 files does not apply to it, as it does not to -EncodedCommand.
+ */
+export declare function recoveryCommand(script: string): string | null;
+/**
+ * Once this process has exited: renames `moves` in order and starts `exe` with this environment. macOS and
+ * Linux rename a running app's folder right away, so only the start waits; Windows refuses that, so a helper
+ * does the renames too (and on a failed rename puts back what it moved, so there is always an app to start).
+ * Only the first call of a process starts a helper; later ones answer the same promise.
+ */
+export declare function relaunchAfterExit(exe: string, moves?: [string, string][], { delayMs, recover }?: RelaunchOptions): Promise<void>;
+/** Relaunches after the browser process ended, in a row: each one's app ran less than RELAUNCH_HEALTHY. */
+export declare const RELAUNCH_LIMIT = 10;
+export declare const RELAUNCH_HEALTHY = 60000;
+/**
+ * desktop.recovery "reload" after the webview's browser process ended: how long the relaunched app waits, or null
+ * once RELAUNCH_LIMIT relaunches in a row did not help. The first relaunch is immediate, then 1 s doubling to a
+ * minute (lib.rs recovery_wait); an app that ran for RELAUNCH_HEALTHY starts the count again. `file` keeps the
+ * count across the processes.
+ */
+export declare function nextRelaunchDelay(file: string, now?: number): number | null;

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

@@ -0,0 +1,97 @@
+import type { DesktopServerState, DesktopServerStatus } from "./plugin.ts";
+export interface ServerManifest {
+    /** The file in resources/server that starts the server. */
+    entry: string;
+    env: Record<string, string>;
+}
+/** Set by the launcher at every start, so desktop.server.env may not name them (cli lib/desktop-server.ts). */
+export declare const LAUNCHER_ENV_KEYS: readonly ["BUN_BE_BUN", "BUN_RUNTIME_TRANSPILER_CACHE_PATH", "PORT", "JWT_SECRET", "AKAN_LISTEN_HOST", "AKAN_ALLOWED_HOSTS", "AKAN_SQLITE_DIR", "AKAN_WORKSPACE_ROOT", "AKAN_RUNTIME_DIR"];
+/** How long the window waits for the server; after that it opens and the first calls may fail. */
+export declare const READY_TIMEOUT = 8000;
+/** Within the onQuit budget (lifecycle.ts QUIT_HOOK_TIMEOUT, 2 s). */
+export declare const STOP_GRACE = 1500;
+export declare const MAX_FAILURES = 5;
+/** Between restarts of a server that has not been ready yet: MAX_FAILURES of them end well within READY_TIMEOUT. */
+export declare const BOOT_RESTART_DELAY = 250;
+/** A run that stayed up this long was healthy: its crash starts the count again. */
+export declare const HEALTHY_RUN = 60000;
+/** server-output.log moves to server-output.log.1 past this size. */
+export declare const OUTPUT_LOG_LIMIT: number;
+export interface ServerProcess {
+    readonly exited: Promise<number | null>;
+    send(message: unknown): void;
+    kill(signal?: NodeJS.Signals): void;
+    /** Signals what is left of the server's process group (macOS, Linux). */
+    killGroup?(signal: NodeJS.Signals): void;
+}
+export interface SpawnOptions {
+    cwd: string;
+    env: Record<string, string>;
+    onMessage(message: unknown): void;
+    onLine(line: string, stream: "stdout" | "stderr"): void;
+}
+export interface DesktopServerOptions {
+    resources: string;
+    /** Where the server keeps everything: its working folder, databases, logs, secret (paths.ts serverDataDir). */
+    dataDir: string;
+    manifest: ServerManifest;
+    /** The app's executables (resources/bin), first on the server's PATH. */
+    binDir?: string | null;
+    execPath?: string;
+    env?: Record<string, string | undefined>;
+    spawn?(argv: string[], options: SpawnOptions): ServerProcess;
+    /** A free loopback port: `preferred` when it is free. */
+    freePort?(preferred?: number): Promise<number>;
+    /** The server gave up: MAX_FAILURES crashes in a row, or it could not start at all. */
+    onGiveUp?(message: string): void;
+    /** Every change of `state`. */
+    onState?(state: DesktopServerState): void;
+    readyTimeout?: number;
+    stopGrace?: number;
+    restartDelay?(failures: number, everReady: boolean): number;
+    now?(): number;
+}
+export interface DesktopServer {
+    /**
+     * The server's URL, once it is ready or readyTimeout passed (it keeps starting then), or at once when it gave up.
+     * Never throws: a server that cannot start still has a loopback URL, so the page's calls fail on this PC.
+     */
+    start(): Promise<{
+        url: string;
+        ready: boolean;
+    }>;
+    /** Settles once: true at the first ready, false when the server gave up or stopped before that. */
+    readonly ready: Promise<boolean>;
+    /** Where the server is now; `ready` only tells the first answer. */
+    readonly state: DesktopServerState;
+    stop(): Promise<void>;
+}
+/** What plugins see of the server (ctx.server) from their setup on: the plugin host starts it only after that. */
+export declare function createServerStatus(): {
+    status: DesktopServerStatus;
+    settle: (value: boolean) => void;
+    setState: (next: DesktopServerState) => void;
+};
+export declare function readServerManifest(resources: string): ServerManifest | null;
+export declare function serverArgv(execPath: string, resources: string, entry: string): string[];
+/**
+ * `key`'s value in `env`. Windows names a variable in any case (`Path`), and the plugin host's copy of process.env
+ * matches a name only in the case it has, where the process's own env ignores case.
+ */
+export declare function envValue(env: Record<string, string | undefined>, key: string, platform?: NodeJS.Platform): string | undefined;
+/** `dir` first on a PATH, once: a relaunched app inherits the PATH its predecessor already extended. */
+export declare function pathWithFirst(dir: string, path: string | undefined, platform?: NodeJS.Platform): string;
+export declare function serverEnv(manifest: ServerManifest, { port, secret, dataDir, env, binDir, platform, }: {
+    port: number;
+    secret: string;
+    dataDir: string;
+    env: Record<string, string | undefined>;
+    binDir?: string | null;
+    platform?: NodeJS.Platform;
+}): Record<string, string>;
+/** One random secret per installation, readable by its owner only: outside operationMode local akanjs derives none. */
+export declare function jwtSecret(dataDir: string): string;
+export declare function restartDelay(failures: number, everReady?: boolean): number;
+/** The port the last session's server was ready on (`<server data>/port`), if any. */
+export declare function lastPort(dataDir: string): number | undefined;
+export declare function createDesktopServer(options: DesktopServerOptions): DesktopServer;

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;

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

@@ -0,0 +1,95 @@
+import { type VetoHandler } from "../../../packages/core/src/index.ts";
+/**
+ * Why the app is about to quit: "user" (Cmd+Q, Dock menu, AppleScript), "session" (logout,
+ * restart, shutdown; preventing it cancels the logout), "lastWindowClosed" (the window was closed).
+ */
+export type QuitReason = "user" | "session" | "lastWindowClosed";
+export interface AppInfoResult {
+    id: string;
+    name: string;
+    version: string;
+    build: number;
+}
+export interface AppApi {
+    getInfo(): Promise<AppInfoResult>;
+    /** The URL that started the app (deep link), or null. */
+    getLaunchUrl(): Promise<{
+        url: string | null;
+    }>;
+    /** Ends the app without asking onBeforeQuit handlers. Android and desktop only (iOS apps must not quit themselves). */
+    exit(): Promise<void>;
+    /**
+     * Ends the app and starts it again in a new process, without asking onBeforeQuit handlers: after a setting
+     * that takes a restart, or to recover an app nobody attends. The web reloads the page; iOS answers UNSUPPORTED.
+     */
+    relaunch(): Promise<void>;
+    /** Sends the app to the background (Android) or minimizes its window (desktop). */
+    minimize(): Promise<void>;
+    /** Internal: the page's answer to a beforeQuit event. Use onBeforeQuit(). */
+    answerBeforeQuit(args: {
+        id: number;
+        allow?: boolean;
+    }): Promise<void>;
+    /**
+     * Android: whether back belongs to the page right now, for a page that listens to backButton. false hands it to
+     * the system, which then shows its own back-to-home animation; each new listener starts at true.
+     */
+    setBackEnabled(args: {
+        enabled: boolean;
+    }): Promise<void>;
+}
+export type BackProgressPhase = "started" | "progressed" | "cancelled";
+export interface AppEvents {
+    /** A deep link arrived while running. URLs that arrive before anyone listens are delivered to the first listener. */
+    urlOpen: {
+        url: string;
+    };
+    /** Android back gesture/button. While anything listens, back no longer walks the WebView history by itself. */
+    backButton: {
+        canGoBack: boolean;
+    };
+    /** Internal: the app is about to quit (desktop). Use onBeforeQuit(). */
+    beforeQuit: {
+        id: number;
+        reason: QuitReason;
+    };
+    /**
+     * Android 14+: a back swipe in progress, for a page that animates it. `progress` runs 0–1; a committed swipe then
+     * arrives as backButton, and one let go early as `cancelled`.
+     */
+    backProgress: {
+        phase: BackProgressPhase;
+        progress: number;
+        swipeEdge: "left" | "right";
+    };
+    /**
+     * Desktop, an app that carries a server (desktop.server): where it is, at every change and when the first page
+     * starts listening. "gaveUp" means it is not started again until the app is.
+     */
+    serverState: {
+        state: "starting" | "up" | "restarting" | "gaveUp" | "stopped";
+    };
+}
+export declare const app: import("../../../packages/core/src/plugin.ts").Plugin<AppApi, AppEvents>;
+/** Calls `handler` for every deep link while mounted. */
+export declare function useUrlOpen(handler: (url: string) => void): void;
+/**
+ * Takes over the Android back button while mounted. The handler decides: e.g. close a dialog,
+ * `history.back()` when `canGoBack`, or `app.exit()` at the root.
+ */
+export declare function useBackButton(handler: (event: {
+    canGoBack: boolean;
+}) => void): void;
+/**
+ * Runs `handler` before the app quits (desktop: Cmd+Q, Dock menu, logout, closing the window).
+ * Call `event.preventDefault()` to keep running, e.g. after asking to save; `event.reason` tells
+ * why. app.exit() does not ask. Elsewhere it never fires (`app.eventImplementation("beforeQuit")`
+ * tells). Returns an unregister function.
+ */
+export declare const onBeforeQuit: (handler: VetoHandler<{
+    reason: QuitReason;
+}>) => () => void;
+/** onBeforeQuit while mounted; always calls the latest handler. */
+export declare function useBeforeQuit(handler: VetoHandler<{
+    reason: QuitReason;
+}>): void;

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

@@ -0,0 +1,2 @@
+import type { AppApi, AppEvents } from "./index.ts";
+export declare const web: import("../../../packages/core/src/plugin.ts").WebPlugin<AppApi, AppEvents>;