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

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;

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

@@ -0,0 +1,66 @@
+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>;
+    /** 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>;
+}
+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;
+    };
+}
+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>;

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

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

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

@@ -0,0 +1,19 @@
+/**
+ * - active: visible and receiving input
+ * - inactive: visible but not focused (another window, system overlay, app switcher)
+ * - background: not visible
+ */
+export type AppStateValue = "active" | "inactive" | "background";
+export interface AppStateApi {
+    getState(): Promise<{
+        state: AppStateValue;
+    }>;
+}
+export interface AppStateEvents {
+    change: {
+        state: AppStateValue;
+    };
+}
+export declare const appState: import("../../../packages/core/src/plugin.ts").Plugin<AppStateApi, AppStateEvents>;
+/** The current app state. Re-renders on every change (SH-1). */
+export declare function useAppState(): AppStateValue;

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

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

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

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

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

@@ -0,0 +1,9 @@
+import type { AppearanceApi, AppearanceEvents } from "./index.ts";
+export type Runner = (argv: string[]) => Promise<{
+    code: number;
+    stdout: string;
+}>;
+/** `run` is replaceable so tests can check the commands and shell ops, `platform` to test the other OSes' fallback. */
+export declare function createDesktopAppearance(run?: Runner, platform?: NodeJS.Platform): import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<AppearanceApi, AppearanceEvents>;
+declare const _default: import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<AppearanceApi, AppearanceEvents>;
+export default _default;

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

@@ -0,0 +1,32 @@
+import type { AppearanceSetting, ColorScheme } from "./setting.ts";
+export { APPEARANCE_SETTINGS, type AppearanceSetting, type ColorScheme, checkSetting } from "./setting.ts";
+export interface AppearanceState {
+    /** The scheme the app is drawn in right now; the page's `prefers-color-scheme` matches it. */
+    mode: ColorScheme;
+    /** The app's setting. Always "system" on the web and until set() was called. */
+    setting: AppearanceSetting;
+}
+/**
+ * Light/dark appearance of the app (plugins.md §4.1). To only follow the OS, CSS
+ * `prefers-color-scheme` is enough; this plugin is for apps with their own theme switch.
+ */
+export interface AppearanceApi {
+    get(): Promise<AppearanceState>;
+    /**
+     * Forces light or dark for the whole app (WebView, system UI such as dialogs, keyboards and
+     * status bar icons), or goes back to the OS setting with "system". The setting is kept across
+     * launches and applied at start (on iOS and Android before the first paint), so call it when the
+     * user picks a theme, not at every start. The change event follows once the app redrew. Not
+     * available on the web (UNSUPPORTED): a page cannot change `prefers-color-scheme`.
+     */
+    set(args: {
+        mode: AppearanceSetting;
+    }): Promise<void>;
+}
+export interface AppearanceEvents {
+    /** `mode` or `setting` changed: an OS switch while following the system, or set(). */
+    change: AppearanceState;
+}
+export declare const appearance: import("../../../packages/core/src/plugin.ts").Plugin<AppearanceApi, AppearanceEvents>;
+/** The current appearance. Re-renders on every change. */
+export declare function useAppearance(): AppearanceState;

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

@@ -0,0 +1,6 @@
+export type ColorScheme = "light" | "dark";
+/** What the app asked for: a fixed scheme, or "system" to follow the OS setting. */
+export type AppearanceSetting = ColorScheme | "system";
+export declare const APPEARANCE_SETTINGS: readonly AppearanceSetting[];
+/** Checks set()'s argument; the native implementations check the same list. */
+export declare function checkSetting(mode: unknown): AppearanceSetting;

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

@@ -0,0 +1,3 @@
+import type { AppearanceApi, AppearanceEvents, AppearanceState } from "./index.ts";
+export declare function readWebState(): AppearanceState;
+export declare const web: import("../../../packages/core/src/plugin.ts").WebPlugin<AppearanceApi, AppearanceEvents>;

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

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

package/types/vendor/@akanjs/native/plugins/auth-session/src/args.d.ts

@@ -0,0 +1,18 @@
+export interface StartArgs {
+    url: URL;
+    callbackScheme: string;
+    ephemeral: boolean;
+}
+/** Checks start()'s arguments; the native implementations check the same rules. */
+export declare function checkStart(args: unknown): StartArgs;
+/** Whether `url` is a callback for `scheme` (schemes compare case-insensitively). */
+export declare function isCallback(url: string, scheme: string): boolean;
+/** The `state` parameter of a URL's query, or of its fragment (implicit flows), or null. */
+export declare function stateOf(url: string): string | null;
+/**
+ * Whether a link is the answer to this sign-in. Any app, or a web page linking to the scheme, can
+ * send a link of the callback scheme while start() waits; when the start URL carries OAuth's
+ * `state`, only a callback with the same `state` is taken (RFC 6749 §10.12) and others are left
+ * to the app plugin. PKCE is still the app's (RFC 8252 §8.1).
+ */
+export declare function isAnswer(url: string, scheme: string, state: string | null): boolean;

package/types/vendor/@akanjs/native/plugins/auth-session/src/desktop.d.ts

@@ -0,0 +1,17 @@
+import type { AuthSessionApi } from "./index.ts";
+export declare const TIMEOUT_MS: number;
+export type Runner = (argv: string[]) => Promise<{
+    code: number;
+    stderr: string;
+}>;
+/** CFBundleURLSchemes of an XML Info.plist (the CLI writes XML), or null if there is none to read. */
+export declare function registeredSchemes(plist: string | null): string[] | null;
+/** Replaceable parts for tests: the command runner, the Info.plist text, the OS and the timeout. */
+export declare function createDesktopAuthSession(options?: {
+    run?: Runner;
+    plist?: () => string | null;
+    timeoutMs?: number;
+    platform?: NodeJS.Platform;
+}): import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<AuthSessionApi, {}>;
+declare const _default: import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<AuthSessionApi, {}>;
+export default _default;

package/types/vendor/@akanjs/native/plugins/auth-session/src/index.d.ts

@@ -0,0 +1,41 @@
+export { checkStart, isCallback } from "./args.ts";
+/**
+ * OAuth / OpenID sign-in in the system browser (plugins.md §4.5, like Expo's
+ * WebBrowser.openAuthSessionAsync): shows the provider's page and returns the redirect to
+ * `callbackScheme` with the result (code, state, error) in its query or fragment. The app then
+ * exchanges the code itself (PKCE); this plugin does not parse or validate the result.
+ *
+ * The callback scheme must be one of the app's deep link schemes (akan-native.config.ts
+ * `deepLinks.schemes`): Android and macOS receive the redirect as a deep link, so the app's
+ * `urlOpen` listeners see it too there. iOS catches it inside the session.
+ *
+ * | host    | how                                              | cancel detection                         |
+ * |---------|--------------------------------------------------|------------------------------------------|
+ * | iOS     | ASWebAuthenticationSession                       | the user closed the sheet                |
+ * | Android | Custom Tab + deep link (plain browser if none)   | back in the app without the redirect     |
+ * | macOS   | default browser + deep link (TAO Event::Opened)  | none: a new start() or 10 minutes        |
+ * | web     | UNSUPPORTED                                      |                                          |
+ *
+ * The web has no custom-scheme callback to catch: web apps register an https redirect on their
+ * own origin and read the result on that route (full-page redirect, or a popup posting to its
+ * opener), which depends on the app's routing and is left to the app.
+ */
+export interface AuthSessionApi {
+    /**
+     * Resolves with the callback URL. Rejects CANCELLED when the user dismissed the page, came back
+     * without finishing (Android), or a newer start() replaced this one; INVALID_ARGS for a bad URL
+     * or scheme (Android also when the app does not handle the scheme). `ephemeral` (iOS) signs in
+     * without the browser's cookies and skips the "wants to use … to sign in" prompt.
+     * The callback that ends a start() is its result only: it does not also reach app.urlOpen, on any
+     * platform. A link of the scheme that arrives with no start() waiting (or with another state) is
+     * an ordinary deep link.
+     */
+    start(args: {
+        url: string;
+        callbackScheme: string;
+        ephemeral?: boolean;
+    }): Promise<{
+        url: string;
+    }>;
+}
+export declare const authSession: import("../../../packages/core/src/plugin.ts").Plugin<AuthSessionApi, {}>;

package/types/vendor/@akanjs/native/plugins/auth-session/src.d.ts

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

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

@@ -0,0 +1,44 @@
+import { AkanNativeError } from "../../../packages/core/src/index.ts";
+import { type DesktopContext } from "../../../packages/desktop/src/plugin.ts";
+import type { AutostartApi, AutostartStatus } from "./index.ts";
+export interface ShellError {
+    reason: "alreadyRegistered" | "notRegistered" | "deniedByUser" | "invalidSignature" | "other";
+    code: number;
+    domain: string;
+    message: string;
+}
+export interface ShellAnswer {
+    status: AutostartStatus;
+    error?: ShellError | null;
+}
+/** The error an enable/disable answer stands for, or null when the app is where it was asked to be. */
+export declare function failure(op: "enable" | "disable", answer: ShellAnswer, platform?: NodeJS.Platform): AkanNativeError | null;
+type Env = Record<string, string | undefined>;
+/** $XDG_CONFIG_HOME/autostart; the base directory must be absolute (XDG Base Directory spec). */
+export declare function autostartDir(env?: Env, home?: string): string;
+/**
+ * The Exec= value that runs `path`: one quoted argument (Desktop Entry spec, "The Exec key").
+ * Inside quotes `"`, `` ` ``, `$` and `\` take a backslash; then the string escaping of values
+ * doubles every backslash, and a literal `%` is `%%` (field codes).
+ */
+export declare function desktopExec(path: string): string;
+export declare function desktopEntry(name: string, exec: string): string;
+/**
+ * The state an entry stands for. Hidden=true (the spec's "deleted") or
+ * X-GNOME-Autostart-enabled=false (GNOME's startup settings) is an entry the user switched off.
+ */
+export declare function entryStatus(text: string | null): AutostartStatus;
+/** `executable`: the file the entry starts; an AppImage's mount point changes at every start, $APPIMAGE does not. */
+export declare function linuxAutostart(dir?: () => string, executable?: () => string): {
+    status: (ctx: DesktopContext) => ShellAnswer;
+    enable(ctx: DesktopContext): ShellAnswer;
+    disable(ctx: DesktopContext): ShellAnswer;
+};
+/** `platform` and `linux` are replaceable so tests can check every OS's path on any OS. */
+export declare function createDesktopAutostart(platform?: NodeJS.Platform, linux?: {
+    status: (ctx: DesktopContext) => ShellAnswer;
+    enable(ctx: DesktopContext): ShellAnswer;
+    disable(ctx: DesktopContext): ShellAnswer;
+}): import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<AutostartApi, {}>;
+declare const _default: import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<AutostartApi, {}>;
+export default _default;

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

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

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

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

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

@@ -0,0 +1,4 @@
+/** The largest count: badges are 32-bit integers on iOS (UNUserNotificationCenter.setBadgeCount takes an NSInteger, tauri clamps to i32). */
+export declare const MAX_BADGE_COUNT = 2147483647;
+/** Checks set()'s count; the native implementation checks the same range. */
+export declare function checkCount(count: unknown): number;

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

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