akanjs 3.0.2 → 3.1.0-rc.0

package/types/ui/overlayLayer.d.ts

@@ -4,6 +4,8 @@ export declare const overlayZ: {
     readonly dropdown: 100;
     readonly popconfirmScrim: 105;
     readonly popconfirm: 110;
+    readonly tooltip: 115;
+    readonly modal: 120;
 };
 /** Takes the scope from {@link useOverlayScope}. */
 export declare const OverlayOwnerProvider: import("react").Provider<string>;
@@ -15,3 +17,7 @@ export declare const useOverlayLayerProps: () => {
 };
 /** True when the click landed in an overlay `scope`, or a scope nested in it, rendered; any other is outside. */
 export declare const isOwnOverlayClick: (target: EventTarget | null, scope: string) => boolean;
+/** Takes the root a modal draws its panel in; overlays rendered under it portal there instead of `<body>`. */
+export declare const OverlayPortalProvider: import("react").Provider<HTMLElement | null>;
+/** The element an overlay portals into: the enclosing modal's root, else `<body>`. `null` until mounted. */
+export declare const useOverlayPortal: () => HTMLElement | null;

package/types/ui/overlayPosition.d.ts

@@ -14,3 +14,20 @@ export declare const useOverlayPosition: ({ opened, triggerRef, panelRef, align,
     align: "start" | "end";
     gap?: number;
 }) => OverlayPosition | null;
+export type OverlaySide = "top" | "right" | "bottom" | "left";
+export interface AnchoredPosition {
+    top: number;
+    left: number;
+    /** The side the panel landed on: the asked one, or its opposite when that has more room. */
+    side: OverlaySide;
+    /** The trigger's centre along the panel's edge, held clear of its corners, for the pointer. */
+    arrowOffset: number;
+}
+/** Like {@link useOverlayPosition}, for a panel centred on any side of its trigger, as a tooltip is. */
+export declare const useAnchoredPosition: ({ opened, triggerRef, panelRef, side, gap, }: {
+    opened: boolean;
+    triggerRef: RefObject<HTMLElement | null>;
+    panelRef: RefObject<HTMLElement | null>;
+    side: OverlaySide;
+    gap?: number;
+}) => AnchoredPosition | null;

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

@@ -1,5 +1,6 @@
 import { type DoctorCheck } from "./commands/doctor.ts";
 import type { AkanNativeConfig } from "./config.ts";
+import { requestedDistribution } from "./lib/distribution.ts";
 import type { Device, DeviceSelector } from "./lib/launch.ts";
 import { type LogEvent, type LogSink } from "./lib/log.ts";
 import { type MacosBuild, type MacosNotarization, type MacosSigning, macosDistributionFromEnv } from "./lib/macossigning.ts";
@@ -7,15 +8,21 @@ import { type AndroidSigning, type BuildProfile, type IosBuild, type IosSigning,
 import { type DesktopArch, type UpdateManifest } from "./lib/updates.ts";
 import { type WindowsSigning, windowsSigningFromEnv } from "./lib/windowssigning.ts";
 import { type TargetPlatform } from "./platforms/index.ts";
+export { type UpdateDecision, type UpdateDecisionInput, updateDecision } from "../../core/src/kernel.ts";
+/**
+ * A phone's update protocol as the apps run it, for a signer or a server that checks what it publishes or registers:
+ * the envelope's verification, the keyId of a public key, and what a verified manifest means to a binary.
+ */
+export { keyIdOf, openEnvelope } from "./lib/updates.ts";
 export type { AkanNativeConfig, AndroidSigning, DesktopArch, Device, DeviceSelector, DoctorCheck, IosBuild, IosSigning, IosSigningResult, LinuxBuild, LogEvent, MacosBuild, MacosNotarization, MacosSigning, TargetPlatform, WindowsBuild, WindowsSigning, };
 /**
  * The macOS signing and notarization the AKAN_NATIVE_MACOS_* variables name, for a caller that keeps them in its
  * environment (the API itself reads no variable): pass the result as `macos`.
  */
 /** The Authenticode settings the AKAN_NATIVE_WINDOWS_* variables name: pass the result as `windows.signing`. */
-export { macosDistributionFromEnv, windowsSigningFromEnv };
+export { macosDistributionFromEnv, requestedDistribution, windowsSigningFromEnv };
 /** semver of this API. A caller checks the major before it relies on anything here. */
-export declare const API_VERSION = "0.10.0";
+export declare const API_VERSION = "0.11.0";
 export type AkanNativeErrorCode = "CONFIG_INVALID" | "TOOLCHAIN_MISSING" | "WEB_INPUT_INVALID" | "WEB_BUILD_FAILED" | "NATIVE_BUILD_FAILED" | "SIGNING_FAILED" | "DEVICE_FAILED" | "CANCELLED" | "INTERNAL";
 export declare class AkanNativeError extends Error {
     readonly code: AkanNativeErrorCode;
@@ -144,6 +151,8 @@ export interface PublishCheckOptions extends Pick<TaskOptions, "appDir" | "confi
     out?: string;
     /** Whether the release will carry a server; the config's `desktop.server` by default. */
     server?: boolean;
+    /** A desktop release's CPU, which names its feed folder: this computer's by default. */
+    arch?: DesktopArch;
 }
 /**
  * What publishUpdate() refuses before it builds, without building (CONFIG_INVALID): no updates settings, a channel no
@@ -166,6 +175,8 @@ export declare function publishUpdate(options: TaskOptions & {
     macos?: Pick<MacosBuild, "signing" | "notarize">;
     /** Authenticode for a Windows release's files. No setup program is made. */
     windows?: Pick<WindowsBuild, "signing">;
+    /** A desktop release's CPU, of the same OS: an x64 release from an arm64 machine. Default this computer's. */
+    arch?: DesktopArch;
 }): Promise<PublishResult>;
 /**
  * Whether a web bundle can run in the binary a store release shipped (UP-3): `shipped` is that build's bundle.json,
@@ -177,7 +188,7 @@ export declare function compareBundles(shipped: string, bundle: string): {
 };
 /**
  * The app's update signing key: made once (AKAN_NATIVE_UPDATE_KEY, else ~/.akan/native/keys/<app id>.update.key),
- * then read. `publicKey` goes into the config's `updates.publicKey`; the key file never leaves the machine.
+ * then read. `publicKey` goes into the config's `updates.publicKeys`; the key file never leaves the machine.
  */
 export declare function updateKeygen(options: {
     config: AkanNativeConfig;

package/types/vendor/@akanjs/native/packages/cli/src/commands/update.d.ts

@@ -1,2 +1,2 @@
-export declare const UPDATE_USAGE = "akan-native update keygen [--app <dir>] | akan-native update publish <ios|android|macos|windows|linux> [--app <dir>] [--mode <mode>] [--debug] [--channel <name>] [--out <dir>] | akan-native update serve [--app <dir>] [--out <dir>] [--port <n>]";
+export declare const UPDATE_USAGE = "akan-native update keygen [--app <dir>] | akan-native update publish <ios|android|macos|windows|linux> [--app <dir>] [--mode <mode>] [--debug] [--channel <name>] [--out <dir>] [--arch <arm64|x64>] [--sign] [--notarize] | akan-native update serve [--app <dir>] [--out <dir>] [--port <n>]";
 export declare function update(argv: string[]): Promise<number>;

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

@@ -82,6 +82,8 @@ export interface AkanNativeConfig {
         /** Painted before the page loads, to avoid a white flash (SH-3). */
         backgroundColor?: string;
         backgroundColorDark?: string;
+        /** The web inspector in a release build too (a debug build always has it): internal test builds only. */
+        devtools?: boolean;
     };
     /** Overrides for permission usage texts, e.g. { NSCameraUsageDescription: "..." }. */
     usageDescriptions?: Record<string, string>;
@@ -112,14 +114,21 @@ export interface AkanNativeConfig {
     };
     /**
      * Over-the-air updates (UP-2 web bundles on iOS / Android, UP-1 app updates on macOS), used by
-     * @akanjs/native/plugins/updates. `akan-native update keygen` makes the signing key and prints `publicKey`;
-     * `akan-native update publish <platform>` writes signed releases for `url`.
+     * @akanjs/native/plugins/updates. `akan-native update keygen` makes the signing key and prints its public key;
+     * `akan-native update publish <platform>` writes signed releases for `url`. `publicKeys` lists the keys a phone
+     * trusts, the online signing key first and offline spares after (a key revokes only keys before it); `publicKey` is
+     * the one-key form, and a desktop app trusts the first. `report.url` is where a phone posts what became of each
+     * release, at its next launch or return to the foreground.
      */
     updates?: {
         url: string;
-        publicKey: string;
+        publicKey?: string;
+        publicKeys?: string[];
         channel?: string;
         readyTimeout?: number;
+        report?: {
+            url: string;
+        };
     };
     /** Links that open the app, delivered through the app plugin's urlOpen (and getLaunchUrl). */
     deepLinks?: {
@@ -268,12 +277,13 @@ export interface AkanNativeConfig {
         recovery?: "errorPage" | "reload";
         /**
          * The main window from its first frame: `fullscreen` (borderless, on the display the window opens on)
-         * and `skipTaskbar` (no taskbar button; Windows and Linux). A plugin's launch phase may still decide
-         * otherwise (DesktopContext.launch.setWindow). Default false for both.
+         * `skipTaskbar` (no taskbar button; Windows and Linux) and `frameless` (no title bar or border). A plugin's
+         * launch phase may still decide otherwise (DesktopContext.launch.setWindow). Default false for all three.
          */
         window?: {
             fullscreen?: boolean;
             skipTaskbar?: boolean;
+            frameless?: boolean;
         };
         /**
          * Windows: "auto" answers the page's getDisplayMedia() with the first screen at once, without the picker or a
@@ -283,16 +293,31 @@ export interface AkanNativeConfig {
          * offered. macOS and Linux ignore it.
          */
         screenCapture?: "picker" | "auto";
+        /**
+         * Windows installer: "bootstrapper" (default) carries Microsoft's 2 MB setup that downloads the WebView2
+         * Runtime when the PC has none; "standalone" carries the whole runtime (~200 MB), for a PC that is offline or
+         * behind a proxy at install. Either runs only where no runtime is installed.
+         */
+        webview2?: "bootstrapper" | "standalone";
+        /** Windows: the installed app's Publisher (Apps & features) and its executable's company name (default: the app name). */
+        publisher?: string;
         /**
          * A server the app starts beside its window (akanjs `native.desktop.server`). `dir` is copied to
          * the app's resources (`server/`), and `entry` there runs on the app's own Bun with `env`, bound to
          * a loopback port picked at launch; the page reads its URL as PUBLIC_AKAN_SERVER_URL. The launcher
          * sets PORT, JWT_SECRET, the data folders (`<app local data>/server`) and the listen host itself.
+         * `restart`: crashes in a row before it gives up (5), or "forever"; `watchdog`: its health route asked every
+         * `intervalMs`, `failures` missed in a row restarting it.
          */
         server?: {
             dir: string;
             entry: string;
             env?: Record<string, string>;
+            restart?: number | "forever";
+            watchdog?: {
+                intervalMs: number;
+                failures: number;
+            };
         };
         /**
          * A folder of executables the app carries (akanjs `bin`): copied to the app's resources (`bin/`) and put

package/types/vendor/@akanjs/native/packages/cli/src/lib/compat.d.ts

@@ -37,6 +37,14 @@ export interface BundleInfo {
         hash: string;
         files: number;
     };
+    /** A phone build with updates: what its binary reads (updates.json), the floor of every release's sequence included. */
+    updates?: {
+        protocol: 2;
+        url: string;
+        channel: string;
+        keyIds: string[];
+        embeddedSequence: number;
+    };
 }
 /** "0.1.4" → "0.1", "1.2.0" → "1". */
 export declare function runtimeLine(version: string): string;

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

@@ -4,5 +4,10 @@ export interface DesktopServerConfig {
     dir: string;
     entry: string;
     env: Record<string, string>;
+    restart?: number | "forever";
+    watchdog?: {
+        intervalMs: number;
+        failures: number;
+    };
 }
 export declare function validateDesktopServer(desktop: AkanNativeConfig["desktop"], appDir: string, problems: string[]): DesktopServerConfig | null;

package/types/vendor/@akanjs/native/packages/cli/src/lib/distribution.d.ts

@@ -0,0 +1,22 @@
+import { type MacosNotarization, type MacosSigning } from "./macossigning.ts";
+import { type WindowsSigning } from "./windowssigning.ts";
+export interface DistributionRequest {
+    /** Sign the app with the identity the env names (Developer ID on macOS, Authenticode on Windows). */
+    sign?: boolean;
+    /** macOS: upload the signed app to Apple's notary service. */
+    notarize?: boolean;
+}
+export interface Distribution {
+    macos?: {
+        signing?: MacosSigning;
+        notarize?: MacosNotarization;
+    };
+    windows?: {
+        signing?: WindowsSigning;
+    };
+    /** One line saying who signs and where the app goes, for before the build; null when nothing is signed. */
+    notice: string | null;
+    /** The env names that configure a signature this build was not asked to make. */
+    unused: string[];
+}
+export declare function requestedDistribution(platform: string, profile: "debug" | "release", { sign, notarize }: DistributionRequest, env?: Record<string, string | undefined>): Distribution;

package/types/vendor/@akanjs/native/packages/cli/src/lib/project.d.ts

@@ -18,6 +18,7 @@ export interface ResolvedConfig extends Omit<AkanNativeConfig, "icon" | "splash"
     shell: {
         backgroundColor: string;
         backgroundColorDark: string;
+        devtools: boolean;
     };
     usageDescriptions: Record<string, string>;
     permissions: PermissionsConfig;
@@ -34,8 +35,11 @@ export interface ResolvedConfig extends Omit<AkanNativeConfig, "icon" | "splash"
         window: {
             fullscreen: boolean;
             skipTaskbar: boolean;
+            frameless: boolean;
         };
         screenCapture: "picker" | "auto";
+        webview2: "bootstrapper" | "standalone";
+        publisher?: string;
         server?: DesktopServerConfig;
         /** Absolute. */
         bin?: string;

package/types/vendor/@akanjs/native/packages/cli/src/lib/publish.d.ts

@@ -1,32 +1,38 @@
 import type { BuildContext } from "./prepare.ts";
-import { type UpdateManifest } from "./updates.ts";
+import { type DesktopArch, type UpdateManifest } from "./updates.ts";
 export type ReleasePlatform = "macos" | "windows" | "linux" | "ios" | "android";
 export interface PublishedRelease {
     /** `<out>/<os>-<arch>` for a desktop app, `<out>/<platform>` for a phone's web bundle. */
     dir: string;
     manifest: UpdateManifest;
+    /** The file installed apps read: `<dir>/<channel>.json`, or a phone's `<dir>/<channel>/<nativeApi>.json`. */
+    file: string;
 }
 /**
- * The publish time in seconds, and past the release `<channel>.json` in `dir` already names: apps take only a larger
- * sequence, so a clock behind the last publisher's would make this release look older to every one of them.
+ * The publish time in seconds, and past every release of the channel in `dir`: apps take only a larger sequence, so a
+ * clock behind the last publisher's would make this release look older to every one of them. A phone's native APIs
+ * share one count, so a binary moving to the next generation never meets a smaller number.
  */
 export declare function nextSequence(dir: string, channel: string, now?: number): number;
-/** `<out>/<os>-<arch>` for a desktop release, `<out>/<platform>` for a phone's web bundle. */
-export declare function releaseDir(out: string, platform: ReleasePlatform): string;
+/** `<out>/<os>-<arch>` for a desktop release (the arch it was built for), `<out>/<platform>` for a phone's web bundle. */
+export declare function releaseDir(out: string, platform: ReleasePlatform, arch?: DesktopArch): string;
 /** Refuses before the build a desktop release the apps of its channel would refuse for its server (assertSameServer). */
 export declare function assertServerOfChannel(config: {
     desktop?: {
         server?: unknown;
     };
-}, platform: ReleasePlatform, out: string, channel: string): void;
-/** Refuses before the build a release that could not be signed: no key on this machine, or another app's. */
+}, platform: ReleasePlatform, out: string, channel: string, arch?: DesktopArch): void;
+/**
+ * Refuses before the build a release that could not be signed: no key on this machine, another app's, or for a desktop
+ * app one the app does not trust (it trusts the first of updates.publicKeys).
+ */
 export declare function assertSigningKey(config: {
     app: {
         id: string;
     };
     updates?: {
-        publicKey: string;
+        publicKeys: string[];
     } | null;
-}): void;
-/** Writes the release of `artifact` (the app a release build made) and its signed `<channel>.json` under `out`. */
+}, platform?: ReleasePlatform): void;
+/** Writes the release of `artifact` (the app a release build made) and its signed manifest under `out`. */
 export declare function publishRelease(ctx: BuildContext, platform: ReleasePlatform, artifact: string, out: string, channel: string): Promise<PublishedRelease>;

package/types/vendor/@akanjs/native/packages/cli/src/lib/updates.d.ts

@@ -2,12 +2,18 @@ import type { Platform } from "../../../core/src/index.ts";
 export interface UpdatesConfig {
     /** Base URL of the update files, e.g. "https://example.com/updates". http:// only for localhost / 10.0.2.2 in dev builds. */
     url: string;
-    /** Raw 32-byte Ed25519 public key, base64 (`akan-native update keygen` prints it). */
-    publicKey: string;
+    /**
+     * Raw 32-byte Ed25519 public keys, base64 (`akan-native update keygen` prints one): the keys a phone binary trusts, the
+     * online signing key first and offline spares after it, since a key may revoke only keys listed before it. A desktop
+     * app trusts the first.
+     */
+    publicKeys: string[];
     /** Manifest name under <platform>/. Default "production". */
     channel: string;
     /** How long a newly applied bundle has to call notifyReady() before it is rolled back, ms. Default 10000. */
     readyTimeout: number;
+    /** Where a phone posts what became of each release (downloaded, applied, confirmed, rolled back, failed); null: no reports. */
+    reportUrl: string | null;
 }
 export interface UpdateFile {
     /** Relative path inside the bundle ("index.html", "icons/a.png", "env.runtime.json"). */
@@ -19,7 +25,8 @@ export type DesktopArch = "arm64" | "x64";
 /** The CPU of the desktop apps this machine builds (cargo and bun build for the host). */
 export declare function hostArch(): DesktopArch;
 export interface UpdateManifest {
-    schema: 1;
+    /** 2 for a phone's web bundle, which travels in an UpdateEnvelope; 1 for a desktop app. */
+    schema: 1 | 2;
     kind: "web" | "app";
     app: string;
     platform: Platform;
@@ -54,6 +61,18 @@ export interface UpdateManifest {
     }[];
     /** App updates: whether the app carries a server; an installed app refuses a release that differs from itself. */
     server?: boolean;
+    /** Web bundles: keyIds the phone stops trusting for good; each listed before the signer's key in its updates.publicKeys. */
+    revokeKeys?: string[];
+    /** Web bundles: with a new revocation, compare this release with the binary's own bundle instead of the running one. */
+    resetSequence?: boolean;
+}
+/** A phone's `<platform>/<channel>/<nativeApi>.json`: one object, so a new manifest never meets an old signature. */
+export interface UpdateEnvelope {
+    /** The manifest's exact bytes, base64. */
+    manifest: string;
+    keyId: string;
+    /** Ed25519 over the manifest bytes, base64. */
+    signature: string;
 }
 /** Every file of a web bundle as the app serves it: index.html with the init script and CSP, public/, env.runtime.json. */
 export declare function webFiles(webDir: string, html: string, env: Record<string, string>): {
@@ -78,6 +97,8 @@ export declare function webManifest(release: {
 /** Refuses a channel no app could be configured for: it would be written but never taken. */
 export declare function assertChannel(channel: string): void;
 export declare function validateUpdates(raw: unknown, problems: string[]): UpdatesConfig | null;
+/** What an envelope names its signer by: the first 8 bytes of the raw public key's SHA-256, in hex. */
+export declare const keyIdOf: (publicKey: string) => string;
 /** Where the signing key of an app lives: AKAN_NATIVE_UPDATE_KEY (a file path), else ~/.akan/native/keys/<app id>.update.key. */
 export declare function updateKeyPath(appId: string, env?: Record<string, string | undefined>): string;
 /** Creates the Ed25519 key pair; returns the public key for akan-native.config.ts. Never overwrites a key. */
@@ -85,9 +106,24 @@ export declare function generateUpdateKey(path: string): {
     publicKey: string;
     created: boolean;
 };
-/** The key at `keyPath`, refused unless it is the one whose public half the apps were built with. */
-export declare function signingKey(keyPath: string, expectedPublicKey: string): import("node:crypto").KeyObject;
-export declare function signManifest(bytes: Uint8Array, keyPath: string, expectedPublicKey: string): string;
+/** The key at `keyPath` and where it sits in `publicKeys`, refused unless the apps were built to trust it. */
+export declare function signingKey(keyPath: string, publicKeys: readonly string[]): {
+    key: import("node:crypto").KeyObject;
+    keyId: string;
+    index: number;
+};
+/** A desktop app's base64 signature (protocol v1), with the key the app trusts: the first of updates.publicKeys. */
+export declare function signManifest(bytes: Uint8Array, keyPath: string, publicKeys: readonly string[]): string;
+/** A phone's envelope (protocol v2) for the manifest's exact bytes, signed with any key of `publicKeys`. */
+export declare function sealManifest(bytes: Uint8Array, keyPath: string, publicKeys: readonly string[]): UpdateEnvelope;
+/**
+ * The manifest bytes of an envelope, verified as a phone verifies it against `publicKeys` (minus `revoked`). What it
+ * then decides (revocation, sequence) is AkanNativeKernel.updateDecision, kernel.ts updateDecision.
+ */
+export declare function openEnvelope(text: string, publicKeys: readonly string[], revoked?: readonly string[]): {
+    manifest: Uint8Array;
+    keyId: string;
+};
 /** Verifies like the apps do: raw public key, base64 signature over the exact manifest bytes. */
 export declare function verifyManifest(bytes: Uint8Array, signature: string, publicKey: string): boolean;
 export declare const sha256: (data: Uint8Array | string) => string;
@@ -100,4 +136,12 @@ export declare const sha256: (data: Uint8Array | string) => string;
 export declare function updatesResource(updates: UpdatesConfig, app: {
     id: string;
     version: string;
-}, platform: Platform, nativeApi: string | undefined, dev: boolean): string;
+}, platform: Platform, nativeApi: string | undefined, dev: boolean, embeddedSequence?: number): string;
+/**
+ * updates.json of a phone build, and the same facts in the build's bundle.json: a signer that registers the store build
+ * checks the binary reads its URL and keys, and takes `embeddedSequence` as the floor every release must pass.
+ */
+export declare function writePhoneUpdates(path: string, outDir: string, updates: UpdatesConfig, app: {
+    id: string;
+    version: string;
+}, platform: "ios" | "android", nativeApi: string | undefined, dev: boolean): void;

package/types/vendor/@akanjs/native/packages/cli/src/lib/vectors.d.ts

@@ -1,4 +1,4 @@
-export declare const VECTOR_FILES: readonly ["scope", "routes", "ranges", "ids", "bridge", "navigation", "acl", "retained", "ed25519"];
+export declare const VECTOR_FILES: readonly ["scope", "routes", "ranges", "ids", "bridge", "navigation", "acl", "retained", "ed25519", "updates"];
 /**
  * How many checks each file holds: the runners fail when a file is missing or ran another number,
  * so an empty or truncated file cannot pass as zero checks.

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

@@ -1,6 +1,11 @@
 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";
+/** The Evergreen Standalone Installer per CPU (MicrosoftEdgeWebView2RuntimeInstaller<X64|ARM64>.exe). */
+export declare const WEBVIEW2_STANDALONE_URLS: {
+    readonly x64: "https://go.microsoft.com/fwlink/?linkid=2124701";
+    readonly arm64: "https://go.microsoft.com/fwlink/?linkid=2099616";
+};
 /** 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 {
@@ -24,6 +29,8 @@ export interface InstallerInput {
     /** deepLinks.schemes: the uninstaller removes those the app registered for its own executable. */
     schemes: string[];
     icon?: string;
+    /** desktop.publisher: the Publisher Apps & features lists, and the setup program's company name. */
+    publisher?: string;
     bootstrapper: string;
     stopScript: string;
     outFile: string;

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

@@ -3,6 +3,11 @@ import type { Launched, LaunchOptions } from "../lib/launch.ts";
 import type { BuildContext } from "../lib/prepare.ts";
 /** The version resource wants four numbers: major.minor.patch.build. */
 export declare function windowsVersion(version: string, build: number): string;
+export declare function windowsVersionInfo(app: {
+    name: string;
+    version: string;
+    build: number;
+}, publisher?: string): string[];
 export declare function buildWindows(ctx: BuildContext): Promise<string>;
 export declare function launchWindows(ctx: BuildContext, dir: string, opts: LaunchOptions): Promise<Launched>;
 export declare function runWindows(ctx: BuildContext, dir: string, args: ParsedArgs): Promise<number>;

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

@@ -110,3 +110,39 @@ export declare function externalSchemes(extra?: readonly string[]): string[];
  * never opens anything.
  */
 export declare function decideNavigation(url: string, topLevel: boolean, origin: string, extra?: readonly string[]): "load" | "open" | "drop";
+export interface UpdateDecisionInput {
+    /** The binary's keyIds, in `updates.publicKeys` order. */
+    ring: readonly string[];
+    /** keyIds state.json has revoked. */
+    revoked: readonly string[];
+    /** The envelope's keyId, whose signature over the manifest verified. */
+    signer: string;
+    revokeKeys: readonly string[];
+    resetSequence: boolean;
+    sequence: number;
+    /** The binary's own bundle (updates.json `embeddedSequence`). */
+    embedded: number;
+    /** The bundle running now, null for the binary's own. */
+    running: {
+        sequence: number;
+        keyId: string;
+    } | null;
+}
+export type UpdateDecision = {
+    kind: "untrusted" | "revoked" | "self-revoke" | "revoke-later";
+} | {
+    kind: "take" | "stale";
+    baseline: number;
+    revoke: string[];
+};
+/**
+ * Whether a web bundle manifest is taken (updates protocol v2, vectors/updates.json). A key may revoke only keys listed
+ * before it, so a leaked online key — listed first — cannot revoke the offline spares that recover from it, and
+ * `resetSequence` counts only on a manifest that newly revokes a key, so replaying it cannot roll anyone back. A bundle a
+ * revoked key signed sets no bar, and revocations apply even when the release itself is not newer.
+ */
+export declare function updateDecision(input: UpdateDecisionInput): UpdateDecision;
+/** One answer of updateDecision as the vectors write it. */
+export declare const updateDecisionWire: (decision: UpdateDecision) => string;
+/** The v2 envelope of a channel for one native API: one file per binary generation, so each takes its own fixes. */
+export declare const updateManifestUrl: (url: string, platform: string, channel: string, nativeApi: string) => string;

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

@@ -165,6 +165,8 @@ export interface LaunchWindow {
     fullscreen?: boolean;
     /** No taskbar button (Windows, Linux; macOS has none). */
     skipTaskbar?: boolean;
+    /** No title bar or border. */
+    frameless?: boolean;
 }
 /** What the launch phase decided; sent to the main thread with "ready". */
 export interface Launch {

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

@@ -3,7 +3,16 @@ export interface ServerManifest {
     /** The file in resources/server that starts the server. */
     entry: string;
     env: Record<string, string>;
+    /** Crashes in a row before the launcher gives up, MAX_FAILURES unless named; "forever" never gives up. */
+    restart?: number | "forever";
+    /** The health route asked every `intervalMs` once the server is ready; `failures` missed in a row restart it. */
+    watchdog?: {
+        intervalMs: number;
+        failures: number;
+    };
 }
+/** Answered by the server's own process, solo or behind its gateway, without a database round trip. */
+export declare const HEALTH_PATH = "/_akan/app/health";
 /** 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. */
@@ -50,6 +59,8 @@ export interface DesktopServerOptions {
     stopGrace?: number;
     restartDelay?(failures: number, everReady: boolean): number;
     now?(): number;
+    /** Whether the server at `url` answers its health route; the watchdog's question. */
+    probe?(url: string, timeoutMs: number): Promise<boolean>;
 }
 export interface DesktopServer {
     /**

package/types/vendor/@akanjs/native/plugins/external-view/src/desktop.d.ts

@@ -0,0 +1,17 @@
+import type { ExternalViewApi, ExternalViewConsoleLevel, ExternalViewEvents } from "./index.ts";
+/** consoleMessage per view: this many in CONSOLE_WINDOW_MS, the rest counted and reported with the next one. */
+export declare const CONSOLE_BURST = 20;
+export declare const CONSOLE_WINDOW_MS = 10000;
+export declare function consoleLevel(value: unknown): ExternalViewConsoleLevel | null;
+/** Chrome's virtual key code for a KeyboardEvent.code, which a trusted key event needs beside `key`. */
+export declare function virtualKey(code: string): number;
+/** One console call or uncaught exception as a message, from the protocol event the shell passed on. */
+export declare function consoleMessageOf(method: string, params: unknown): Omit<ExternalViewEvents["consoleMessage"], "id"> | null;
+/** Lets CONSOLE_BURST messages through per window of time, and counts what it held back for the next one. */
+export declare function createConsoleCap(now?: () => number): (view: string) => {
+    pass: boolean;
+    dropped: number;
+};
+export declare function createDesktopExternalView(): import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<ExternalViewApi, ExternalViewEvents>;
+declare const _default: import("../../../packages/desktop/src/plugin.ts").DesktopPlugin<ExternalViewApi, ExternalViewEvents>;
+export default _default;