akanjs 3.0.0-beta.26 → 3.0.0-beta.28

package/types/vendor/@akanjs/native/packages/cli/src/platforms/macos.d.ts

@@ -3,5 +3,10 @@ import type { Launched, LaunchOptions } from "../lib/launch.ts";
 import type { BuildContext } from "../lib/prepare.ts";
 export declare const MACOS_MIN = "26.0";
 export declare function buildMacos(ctx: BuildContext): Promise<string>;
+/**
+ * Mach-O files the app carries in its server and its `bin`, whatever their names (native addons, executables, a
+ * package's own executable): nested code the bundle's signature does not sign.
+ */
+export declare function carriedNativeCode(resources: string): string[];
 export declare function launchMacos(ctx: BuildContext, appPath: string, opts: LaunchOptions): Promise<Launched>;
 export declare function runMacos(ctx: BuildContext, appPath: string, args: ParsedArgs): Promise<number>;

package/types/vendor/@akanjs/native/packages/cli/src/platforms/windows-installer.d.ts

@@ -0,0 +1,38 @@
+import type { BuildContext } from "../lib/prepare.ts";
+/** Microsoft's permanent link to the Evergreen Bootstrapper (MicrosoftEdgeWebview2Setup.exe). */
+export declare const WEBVIEW2_BOOTSTRAPPER_URL = "https://go.microsoft.com/fwlink/p/?LinkId=2124703";
+/** MAX_PATH less its NUL: what a PC without long paths enabled (the Windows default) can open or unpack. */
+export declare const WINDOWS_MAX_PATH = 259;
+export interface InstallerInput {
+    name: string;
+    id: string;
+    exe: string;
+    version: string;
+    build: number;
+    /** The built app folder, copied whole. */
+    folder: string;
+    /** Its top-level files and folders: what an update or uninstall removes. */
+    entries: {
+        name: string;
+        dir: boolean;
+    }[];
+    icon?: string;
+    bootstrapper: string;
+    stopScript: string;
+    outFile: string;
+}
+export declare function installerScript(input: InstallerInput): string;
+/**
+ * Stops every process running from the install folder, and waits (up to 10 s) until they are gone. Through
+ * WMI: the installer is a 32-bit program, so its PowerShell is too, and a 32-bit process cannot read a
+ * 64-bit one's path (Get-Process's Path comes back empty).
+ */
+export declare const STOP_SCRIPT = "param([string]$Dir)\n$prefix = [IO.Path]::GetFullPath($Dir).TrimEnd('\\') + '\\'\n$running = { Get-CimInstance Win32_Process | Where-Object { $_.ExecutablePath -and $_.ExecutablePath.StartsWith($prefix, [StringComparison]::OrdinalIgnoreCase) } }\n& $running | ForEach-Object { Stop-Process -Id $_.ProcessId -Force -ErrorAction SilentlyContinue }\nfor ($i = 0; $i -lt 50 -and (& $running); $i++) { Start-Sleep -Milliseconds 200 }\n";
+/** The longest path under `folder`, relative and with Windows separators. Links are not followed. */
+export declare function deepestPath(folder: string): string;
+/** How long `relative` gets on a typical PC while an update unpacks, the longest it ever is: root, app, staging, app. */
+export declare function installedPathLength(appName: string, relative: string): number;
+/** makensis: AKAN_NATIVE_MAKENSIS, PATH, then where the NSIS installer puts it. */
+export declare function findMakensis(env?: Record<string, string | undefined>): string | null;
+/** Writes the setup program next to the app folder and answers its path. */
+export declare function buildWindowsInstaller(ctx: BuildContext, folder: string): Promise<string>;

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

@@ -1,7 +1,7 @@
 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";
+import type { DesktopPlugin, DesktopServerStatus, Launch, NativeEvent } from "./plugin.ts";
 /** How long the window waits for one plugin's setup. */
 export declare const SETUP_TIMEOUT_MS = 3000;
 /**
@@ -11,7 +11,14 @@ export declare const SETUP_TIMEOUT_MS = 3000;
 export declare const SETUP_WAIT_MS = 5000;
 export interface HostServices {
     app: AppInfo;
+    dev?: boolean;
     appDataDir: string;
+    /** paths.ts appLocalDataDir; appDataDir when not given. */
+    appLocalDataDir?: string;
+    /** desktop.bin in the app's resources, or null. */
+    binDir?: string | null;
+    /** The carried server (resources/server.json), or null. */
+    server?: DesktopServerStatus | null;
     /** Sends an event (numbered for its document) to a window's page. */
     emit(window: number, message: BridgeEvent): void;
     /**

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

@@ -0,0 +1,11 @@
+export type GrantMode = "read" | "write" | "folder";
+export interface FileGrant {
+    path: string;
+    mode: GrantMode;
+}
+export declare function devGrantKeyFile(home?: string): string;
+export declare function grantFile(path: string, mode: GrantMode, { dev }?: {
+    dev?: boolean;
+}): string;
+export declare function resolveGrant(id: unknown): FileGrant | null;
+export declare function devGrantKey(file?: string): Buffer;

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

@@ -1,4 +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/paths.d.ts

@@ -6,16 +6,27 @@ type Env = Record<string, string | undefined>;
  *   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   (large and machine-specific: not Roaming)
+ *   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). Only
+ * (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): {

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

@@ -12,6 +12,8 @@ export type EmitTarget = {
 } | "focused";
 export interface DesktopContext {
     app: AppInfo;
+    /** A dev build (boot.json `dev`): its pages come from a dev server the shell did not start. */
+    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.
@@ -36,6 +38,22 @@ export interface DesktopContext {
     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.
+     */
+    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). */
@@ -100,6 +118,9 @@ export interface DesktopContext {
         exit(code?: number): void;
     };
 }
+export interface DesktopServerStatus {
+    readonly ready: Promise<boolean>;
+}
 /** Which page load ended. `id` is "" for a page that sends no document id (v1 callers, tests). */
 export interface DocumentInfo {
     window: number;
@@ -126,11 +147,17 @@ export interface LaunchWindow {
     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;

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

@@ -0,0 +1,21 @@
+export interface RelaunchOptions {
+    /** How long the helper waits after this process exited before it starts the app. */
+    delayMs?: number;
+}
+/**
+ * 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 }?: 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,79 @@
+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;
+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;
+    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>;
+    stop(): Promise<void>;
+}
+export declare function readServerManifest(resources: string): ServerManifest | null;
+export declare function serverArgv(execPath: string, resources: string, entry: string): string[];
+/** `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/plugins/app/src/index.d.ts

@@ -18,6 +18,11 @@ export interface AppApi {
     }>;
     /** 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(). */

package/types/vendor/@akanjs/native/plugins/file-picker/src/index.d.ts

@@ -3,6 +3,8 @@ import { AkanNativeError, type FileRef, type Plugin } from "../../../packages/co
 export interface PickedFile extends FileRef {
     /** The file's name as the user saw it, e.g. "Invoice.pdf". Never a path. */
     name: string;
+    /** With forServer: what the app's server exchanges for the file's path (akanjs `NativeFile`). */
+    grant?: string;
 }
 export interface DirectoryFile extends PickedFile {
     /** Relative to the picked folder, "/"-separated, e.g. "2026/March/receipt.pdf". */
@@ -17,6 +19,11 @@ export interface PickFilesOptions {
     types?: string[];
     /** Let the user pick more than one file. Default false. */
     multiple?: boolean;
+    /**
+     * Desktop only: hand the files to the app's server instead of copying them. The FileRefs serve the
+     * originals and each result carries a `grant`; nothing is copied, whatever the file's size.
+     */
+    forServer?: boolean;
 }
 export interface SaveFileOptions {
     /** Suggested file name; the user can change it (the result says what was chosen, where known). */
@@ -29,16 +36,25 @@ export interface SaveFileOptions {
     url?: string;
     /** MIME type of the content (Android files the document under it). Default: from the name's extension. */
     mime?: string;
+    /**
+     * Desktop only: ask where to save and write nothing. The result's `grant` lets the app's server write
+     * the file there; data and url are refused.
+     */
+    forServer?: boolean;
 }
 export interface SaveFileResult {
     /** False when the user closed the dialog. On the web without showSaveFilePicker this is true once the download started. */
     saved: boolean;
     /** The name the file was saved under, when the platform tells (it may differ from the suggestion). */
     name?: string;
+    /** With forServer: what the app's server exchanges for the path to write. */
+    grant?: string;
 }
 export interface PickDirectoryOptions {
     /** Most files to return (1–10000, default 1000); `truncated` tells whether there were more. */
     limit?: number;
+    /** Desktop only: grant the folder to the app's server and copy nothing (FileRefs serve the originals). */
+    forServer?: boolean;
 }
 export interface PickDirectoryResult {
     /** The folder's name; null when the user closed the dialog. */
@@ -46,6 +62,8 @@ export interface PickDirectoryResult {
     /** Every file inside, recursively, as copies; hidden files and folders (".*") are left out. */
     files: DirectoryFile[];
     truncated: boolean;
+    /** With forServer: what the app's server exchanges for the folder's path. */
+    grant?: string;
 }
 /**
  * System file dialogs.
@@ -54,7 +72,8 @@ export interface PickDirectoryResult {
  * - saveFile: the export picker (iOS), ACTION_CREATE_DOCUMENT (Android), an NSSavePanel sheet
  *   (macOS), showSaveFilePicker or a download (web).
  * - pickDirectory: a read-only snapshot of a folder the user picks: its files, copied like pickFiles.
- * Results are copies registered as FileRefs; no absolute path reaches the page. Closing a dialog
+ * Results are copies registered as FileRefs; no absolute path reaches the page. forServer (desktop)
+ * copies nothing and grants the originals to the app's server instead. Closing a dialog
  * resolves (`files: []`, `saved: false`, `name: null`); a second dialog while one is open rejects
  * CANCELLED. On the web call these from a click handler, before any await (user activation).
  */

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

@@ -26,6 +26,15 @@ export interface PushPresentation {
     list?: boolean;
     sound?: boolean;
     badge?: boolean;
+    /**
+     * Not shown when its `data[key]` is one of `values`, e.g. the chat room on screen: `{ key: "url", values: [path] }`.
+     * It still arrives as "received".
+     */
+    except?: PushPresentationExcept;
+}
+export interface PushPresentationExcept {
+    key: string;
+    values: string[];
 }
 export interface PushApi {
     checkPermission(): Promise<{

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

@@ -1,4 +1,32 @@
 import { type DesktopPlugin } from "../../../packages/desktop/src/plugin.ts";
 import type { UpdatesApi, UpdatesEvents } from "./index.ts";
+export interface UpdatesConfig {
+    app: string;
+    platform: string;
+    nativeApi: string | null;
+    embeddedSequence: number;
+    url: string;
+    publicKey: string;
+    channel: string;
+    readyTimeout: number;
+}
+/**
+ * How long a new release's carried server may take to answer ready before its trial clock starts anyway: a first
+ * run scans every file with a cold transpiler cache and migrates the databases, on a PC that may be slow. The
+ * launcher's own wait (READY_TIMEOUT, 8 s) only decides when the window opens.
+ */
+export declare const SERVER_BOOT_ALLOWANCE = 120000;
+export interface DesktopUpdatesOptions {
+    platform?: NodeJS.Platform;
+    /** The installed app; the running one by default. */
+    app?: string | null;
+    /** Its updates.json; read from `app` by default. */
+    config?: UpdatesConfig | null;
+    /** The executable's file name inside an app; the running one's by default. */
+    exeName?: string;
+    relaunch?(exe: string, moves: [string, string][]): Promise<void>;
+    serverBootAllowance?: number;
+}
+export declare function createDesktopUpdates(options?: DesktopUpdatesOptions): DesktopPlugin<UpdatesApi, UpdatesEvents>;
 declare const _default: DesktopPlugin<UpdatesApi, UpdatesEvents>;
 export default _default;

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

@@ -0,0 +1,10 @@
+import type { VolumeState } from "./index.ts";
+export declare function checkLevel(value: unknown): number;
+export declare function checkMuted(value: unknown): boolean;
+export declare const sameVolume: (a: VolumeState, b: VolumeState) => boolean;
+/**
+ * `pactl get-sink-volume @DEFAULT_SINK@` ("Volume: front-left: 32768 /  50% / -18.06 dB, front-right: …"):
+ * the channels' mean. PulseAudio can boost past 100%, which reads as 1.
+ */
+export declare function pactlLevel(output: string): number | null;
+export declare const pactlMuted: (output: string) => boolean;

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

@@ -0,0 +1,18 @@
+import type { VolumeApi, VolumeEvents } from "./index.ts";
+/** Runs pactl and answers its stdout. */
+export type Pactl = (...args: string[]) => Promise<string>;
+/** Answers stdout lines of `pactl subscribe` until the returned function stops it. */
+export type PactlSubscribe = (onLine: (line: string) => void) => () => void;
+export declare const resubscribeDelay: (ends: number) => number;
+export declare const runPactl: Pactl;
+/** One `pactl subscribe`: its lines until it ends; `stop` ends it. */
+export type PactlSubscription = (onLine: (line: string) => void) => {
+    ended: Promise<void>;
+    stop(): void;
+} | null;
+/** `pactl subscribe`, started again (resubscribeDelay) whenever it ends until stopped: a restarted audio server ends it. */
+export declare function resubscribing(subscription?: PactlSubscription, delay?: (ends: number) => number): PactlSubscribe;
+export declare const subscribePactl: PactlSubscribe;
+export declare function createDesktopVolume(platform?: NodeJS.Platform, pactl?: Pactl, subscribe?: PactlSubscribe): import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<VolumeApi, VolumeEvents>;
+declare const _default: import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<VolumeApi, VolumeEvents>;
+export default _default;

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

@@ -0,0 +1,28 @@
+/** The default output's volume, as the system's own volume control shows it. */
+export interface VolumeState {
+    /** 0 (silent) to 1 (full); null when the output takes no volume from the computer (HDMI audio on macOS). */
+    level: number | null;
+    muted: boolean;
+    /** False when setVolume is refused for this output. */
+    settable: boolean;
+}
+export interface VolumeApi {
+    getVolume(): Promise<VolumeState>;
+    /** `level` from 0 to 1. */
+    setVolume(args: {
+        level: number;
+    }): Promise<VolumeState>;
+    setMuted(args: {
+        muted: boolean;
+    }): Promise<VolumeState>;
+}
+export interface VolumeEvents {
+    /** The default output, its volume or its mute changed, whoever changed it. */
+    change: VolumeState;
+}
+/**
+ * The system's output volume: CoreAudio's default output device (macOS), the default render endpoint the taskbar
+ * slider moves (Windows), the default sink of PulseAudio or PipeWire through pactl (Linux), and on Android the
+ * media volume the volume keys move while the app plays. iOS and the web answer UNSUPPORTED.
+ */
+export declare const volume: import("../../../packages/core/src/plugin.ts").Plugin<VolumeApi, VolumeEvents>;

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

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

package/types/webkit/csrFrameDump.d.ts

@@ -0,0 +1,42 @@
+interface LayerRecord {
+    layer: string;
+    status: "pending" | "settled" | "failed";
+    startedAt: number;
+    settledAt: number | null;
+    /** A mounted layer is waiting on this render's promise; false once it unmounts or its Activity hides. */
+    subscribed: boolean;
+    /** The layer has drawn this render's value. */
+    delivered: boolean;
+}
+interface FrameState {
+    phase: string;
+    location: string;
+    prevLocation: string | null;
+    pendingLocation: string | null;
+    stack: {
+        key: string;
+        path: string;
+        pageType: string;
+    }[];
+}
+export declare class CsrFrameDump {
+    #private;
+    static readonly limit = 300;
+    static track(layer: string, result: Promise<unknown>): LayerRecord;
+    static watchFrame(read: () => FrameState): void;
+    static dump(): {
+        now: number;
+        frame: FrameState | null;
+        layers: {
+            layer: string;
+            status: "pending" | "settled" | "failed";
+            startedAt: number;
+            settledAt: number | null;
+            /** A mounted layer is waiting on this render's promise; false once it unmounts or its Activity hides. */
+            subscribed: boolean;
+            /** The layer has drawn this render's value. */
+            delivered: boolean;
+        }[];
+    };
+}
+export {};

package/types/webkit/nativeNavigation.d.ts

@@ -24,6 +24,7 @@ export declare class NativeNavigation {
     #private;
     readonly options: NativeNavigationOptions;
     constructor(options: NativeNavigationOptions);
+    showPushesExcept(pathname: string): void;
     listen(): () => void;
     /**
      * Tells an Android shell whether back is the page's right now: the keyboard is up, there is history, or the

package/types/webkit/nativePurchase.d.ts

@@ -12,10 +12,14 @@ export interface BillingVerification {
     transactionId: string;
 }
 export type PurchaseCallback = (transaction: IapTransaction, verified: unknown) => void | Promise<void>;
+/** The app's own check; the store's raw proof is also on `transaction.verification`. */
+export type BillingVerifier = (data: BillingVerification, transaction: IapTransaction) => Promise<unknown>;
 export interface NativePurchaseOptions {
     productInfo: PurchaseProductInfo[];
-    /** The verification server's origin; it answers `POST <url>/billing/verifyBilling`. */
-    url: string;
+    /** The verification server's origin; it answers `POST <url>/billing/verifyBilling`. Unused with `verify`. */
+    url?: string;
+    /** Verifies instead of the POST: what it resolves reaches onPay/onSubscribe, and `null`, `undefined` or `false` refuses. */
+    verify?: BillingVerifier;
     onPay?: PurchaseCallback;
     onSubscribe?: PurchaseCallback;
 }

package/types/webkit/nativeUpdates.d.ts

@@ -0,0 +1,8 @@
+export declare class NativeUpdates {
+    #private;
+    static readonly recheckAfterMs: number;
+    static get enabled(): boolean;
+    static confirm(): void;
+    listen(): () => void;
+    check(): Promise<void>;
+}

package/ui/Agent/Attach.tsx

@@ -1,5 +1,5 @@
 "use client";
-import { cn } from "akanjs/client";
+import { cn, resolveServerUrl } from "akanjs/client";
 import { useRef } from "react";
 import { AiOutlineClose, AiOutlinePaperClip } from "react-icons/ai";
 import type { MessageAttachment } from "../../vendor/use-agentic";
@@ -61,7 +61,11 @@ export const Chips = ({ className, attachments, onRemove, removeLabel, pending =
           <img
             alt={attachment.name}
             className="size-6 rounded-field object-cover"
-            src={attachment.data ? `data:${attachment.mimeType};base64,${attachment.data}` : attachment.url}
+            src={
+              attachment.data
+                ? `data:${attachment.mimeType};base64,${attachment.data}`
+                : resolveServerUrl(attachment.url ?? "")
+            }
           />
         ) : null}
         <span className="max-w-32 truncate">{attachment.name}</span>

package/ui/CsrImage.tsx

@@ -1,5 +1,5 @@
 "use client";
-import { cn } from "akanjs/client";
+import { cn, resolveServerUrl } from "akanjs/client";
 import type { ProtoLightFile } from "akanjs/constant";
 import type { ImgHTMLAttributes } from "react";
 
@@ -18,7 +18,8 @@ type CsrImageProps = Omit<ImgHTMLAttributes<HTMLImageElement>, "alt" | "src"> &
 const EMPTY_IMAGE = "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7";
 
 export const CsrImage = ({ src, alt, file, className, abstractData, ...props }: CsrImageProps) => {
-  const url = src || file?.url || null;
+  const stored = src || file?.url || null;
+  const url = stored ? resolveServerUrl(stored) : null;
   const [width, height] = [props.width ?? file?.imageSize[0], props.height ?? file?.imageSize[1]];
   const defaultAbstractData =
     "data:image/gif;base64,iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAAFklEQVR42mN8//HLfwYiAOOoQvoqBABbWyZJf74GZgAAAABJRU5ErkJggg==";

package/ui/System/CSR.tsx

@@ -17,6 +17,7 @@ import { st } from "akanjs/store";
 import { animated } from "akanjs/ui";
 import { Activity, type ComponentProps, type ReactNode, type RefObject, useEffect, useMemo } from "react";
 import { createPortal } from "react-dom";
+import { NativeUpdates } from "../../webkit/nativeUpdates";
 import { RenderLayer } from "../../webkit/RenderLayer";
 
 import { FontFace } from "../FontFace";
@@ -394,6 +395,9 @@ const CSRPageContainer = ({ entry, prefix, layoutStyle }: CSRPageContainerProps)
     () => [...pathRoute.renderLayouts, pathRoute.renderPage],
     [pathRoute.renderLayouts, pathRoute.renderPage],
   );
+  useEffect(() => {
+    if (pageType === "current") NativeUpdates.confirm();
+  }, [pageType]);
   const pageContainers = document.getElementById("pageContainers");
   if (!pageContainers) return null;
   const { page, pageContentRef, pageClassName, pageBind } =