akanjs 3.0.0-beta.28 → 3.0.0-beta.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akanjs",
-  "version": "3.0.0-beta.28",
+  "version": "3.0.0-beta.29",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {

package/server/akanApp.ts

@@ -242,7 +242,7 @@ export class AkanApp {
     if (this.#solo) return await this.#startSolo();
     if (SelfExec.carried)
       throw new Error(
-        "A desktop app's server runs in one process, and this main.ts asks for replicas (replica, solo: false or AKAN_SOLO=false), which would start with the `bun` on the user's PATH. Leave them out of the app the desktop build carries.",
+        "A desktop app's server runs in one process, and this one was asked for a gateway and replicas, which would start with the `bun` on the user's PATH: by `replica` or `solo: false` in main.ts, or by AKAN_SOLO=false, an AKAN_REPLICA other than one traffic replica, or AKAN_COMMAND_TYPE=start in its env. Leave them out of the app the desktop build carries.",
       );
     Logger.role = "gateway";
     await this.#prepareRuntimeDir();
@@ -943,8 +943,10 @@ export class AkanApp {
   async #proxyResponse(req: Request, upstreamRes: Response): Promise<Response> {
     const headers = new Headers(upstreamRes.headers);
     
-    headers.delete("content-encoding");
-    headers.delete("content-length");
+    if (headers.has("content-encoding")) {
+      headers.delete("content-encoding");
+      headers.delete("content-length");
+    }
     this.#rewriteInternalLocation(headers);
     const proxied = new Response(upstreamRes.body, {
       status: upstreamRes.status,

package/server/akanServer.ts

@@ -170,6 +170,7 @@ export class AkanServer {
   #ops: OpsRoute | null | undefined;
   #lastMetrics: AkanMetricsReport = {};
   #stopping: Promise<void> | null = null;
+  #parentGone: boolean = false;
   #orphanExiting = false;
   constructor(
     name = "AkanServer",
@@ -472,7 +473,7 @@ export class AkanServer {
     this.#di.registerSchedule(this.serverMode);
     this.logger.verbose(`🚀 ${this.name} is running on ${unix ? `unix://${unix}` : `port ${port}`}`);
     const wsPort = this.#wsServer?.port;
-    process.send?.({
+    this.#sendReady({
       type: "ready",
       pid: process.pid,
       replicaIdx: Number(process.env.AKAN_REPLICA_IDX ?? 0),
@@ -481,7 +482,7 @@ export class AkanServer {
       wsUpstream: typeof wsPort === "number" ? { type: "tcp", host: "127.0.0.1", port: wsPort } : undefined,
       healthPath: "/_akan/app/child-health",
       crossSite: CrossSiteGuard.option(),
-    } satisfies AkanIpcMessage);
+    });
     await this.#di.runSchedulerInit();
     ShutdownManager.register(this.logger, () => this.stop());
     return this;
@@ -490,7 +491,10 @@ export class AkanServer {
   async start({ listen, web }: { listen?: boolean; web?: AkanWebOption } = {}) {
     const isNoListenCommand = process.env.AKAN_COMMAND_TYPE === "script" || process.env.AKAN_COMMAND_TYPE === "console";
     const shouldListen = (listen ?? !isNoListenCommand) && this.serverMode !== "batch";
+    
+    if (shouldListen || !isNoListenCommand) this.#registerParentIpc();
     await this.init({ routes: shouldListen, web });
+    if (this.#parentGone) return this;
     if (!shouldListen) {
       const websocket = this.#di.getWebsocketAdaptor();
       if (websocket)
@@ -500,20 +504,18 @@ export class AkanServer {
         Logger.role = this.serverMode;
         this.#metricsTimer ??= ProcessMetricsCollector.startReporting(() => this.#reportMetrics());
         this.#di.registerSchedule(this.serverMode);
-        this.#registerParentIpc();
         await this.#startLogTransport();
-        process.send?.({
+        this.#sendReady({
           type: "ready",
           pid: process.pid,
           replicaIdx: Number(process.env.AKAN_REPLICA_IDX ?? 0),
           role: this.serverMode,
-        } satisfies AkanIpcMessage);
+        });
         await this.#di.runSchedulerInit();
         ShutdownManager.register(this.logger, () => this.stop());
       }
       return this;
     }
-    this.#registerParentIpc();
     return this.listen();
   }
   stop(): Promise<void> {
@@ -560,9 +562,17 @@ export class AkanServer {
   #registerParentIpc() {
     process.on("message", (message) => this.#handleIpcMessage(message as AkanIpcMessage));
     process.on("disconnect", () => this.#handleParentDisconnect());
+    
+    if (process.send && !process.connected) this.#handleParentDisconnect();
+  }
+
+  #sendReady(message: AkanIpcMessage) {
+    if (process.send?.(message) === false) this.#handleParentDisconnect();
   }
 
   #handleParentDisconnect() {
+    if (this.#parentGone) return;
+    this.#parentGone = true;
     this.logger.warn("Parent IPC channel closed; shutting down to avoid an orphaned replica");
     setTimeout(() => this.#exitOrphaned(1), this.shutdownTimeoutMs + 1_000);
     void this.stop()

package/server/contentEncoding.ts

@@ -32,6 +32,8 @@ const GZIP_LEVEL = 6;
 /** Under a KB the framing bytes and the call cost more than the repetition they remove. */
 const MIN_COMPRESS_BYTES = 1024;
 
+const MAX_COMPRESS_BYTES = 4 * 1024 * 1024;
+
 const compressBody = (bytes: Uint8Array, encoding: ContentEncoding) =>
   encoding === "br"
     ? brotliCompressSync(bytes, {
@@ -42,8 +44,17 @@ const compressBody = (bytes: Uint8Array, encoding: ContentEncoding) =>
       })
     : gzipSync(bytes, { level: GZIP_LEVEL });
 
+const isWholeBody = (req: Request, response: Response) =>
+  !req.headers.has("range") &&
+  !response.headers.has("content-range") &&
+  response.status >= 200 &&
+  response.status < 300 &&
+  response.status !== 206;
+
 export const compressResponse = async (req: Request, response: Response): Promise<Response> => {
   if (response.headers.has("content-encoding") || !response.body) return response;
+  if (!isWholeBody(req, response)) return response;
+  if (Number(response.headers.get("content-length")) > MAX_COMPRESS_BYTES) return response;
   if (!isCompressibleContentType(response.headers.get("content-type") ?? "")) return response;
   if (process.env.AKAN_HTTP_COMPRESS === "false" || process.env.AKAN_HTTP_COMPRESS === "0") return response;
   const acceptEncoding = req.headers.get("accept-encoding") ?? "";

package/server/ops/appInfo.ts

@@ -7,6 +7,7 @@ export interface AppPublicInfo {
   repoName: string;
   environment: string;
   operationMode: string;
+  workspaceRoot?: string;
 }
 
 export interface AppDetailInfo extends AppPublicInfo {
@@ -39,7 +40,8 @@ export class AppInfo {
 
   static public(): AppPublicInfo {
     const { appName, repoName, environment, operationMode } = getEnv();
-    return { appName, repoName, environment, operationMode };
+    const workspaceRoot = operationMode === "local" ? process.env.AKAN_WORKSPACE_ROOT : undefined;
+    return { appName, repoName, environment, operationMode, ...(workspaceRoot ? { workspaceRoot } : {}) };
   }
 
   static detail(proc: AppProcessInfo): AppDetailInfo {

package/server/selfExec.ts

@@ -1,12 +1,19 @@
-
+interface SelfExecGlobal {
+  [key: symbol]: string | undefined;
+}
 
 export class SelfExec {
-  static #beBun: string | undefined;
+  
+  static readonly #key = Symbol.for("akan.selfExec.beBun");
+
+  static get #beBun(): string | undefined {
+    return (globalThis as unknown as SelfExecGlobal)[SelfExec.#key];
+  }
 
   static adopt() {
     const value = process.env.BUN_BE_BUN;
     if (value === undefined) return;
-    SelfExec.#beBun = value;
+    (globalThis as unknown as SelfExecGlobal)[SelfExec.#key] = value;
     delete process.env.BUN_BE_BUN;
   }
 
@@ -16,7 +23,8 @@ export class SelfExec {
   }
 
   static env(env: NodeJS.ProcessEnv = process.env): NodeJS.ProcessEnv {
-    return SelfExec.#beBun === undefined ? env : { ...env, BUN_BE_BUN: SelfExec.#beBun };
+    const beBun = SelfExec.#beBun;
+    return beBun === undefined ? env : { ...env, BUN_BE_BUN: beBun };
   }
 
   static command(script: string, ...args: string[]): string[] {

package/types/server/ops/appInfo.d.ts

@@ -4,6 +4,7 @@ export interface AppPublicInfo {
     repoName: string;
     environment: string;
     operationMode: string;
+    workspaceRoot?: string;
 }
 export interface AppDetailInfo extends AppPublicInfo {
     akanVersion: string | null;

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

@@ -7,7 +7,7 @@ import { type UpdateManifest } from "./lib/updates.ts";
 import { type TargetPlatform } from "./platforms/index.ts";
 export type { AkanNativeConfig, AndroidSigning, Device, DeviceSelector, DoctorCheck, IosBuild, IosSigning, IosSigningResult, LogEvent, TargetPlatform, WindowsBuild, };
 /** semver of this API. A caller checks the major before it relies on anything here. */
-export declare const API_VERSION = "0.8.0";
+export declare const API_VERSION = "0.9.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;
@@ -126,6 +126,22 @@ export interface PublishResult {
     /** Bytes of the files the manifest names. */
     size: number;
 }
+export interface PublishCheckOptions extends Pick<TaskOptions, "appDir" | "config"> {
+    platform: Exclude<TargetPlatform, "web">;
+    channel?: string;
+    out?: string;
+    /** Whether the release will carry a server; the config's `desktop.server` by default. */
+    server?: boolean;
+}
+/**
+ * What publishUpdate() refuses before it builds, without building (CONFIG_INVALID): no updates settings, a channel no
+ * app could be configured for, no signing key on this machine or another app's, and a desktop release whose server
+ * presence is not the channel's previous release's. For a caller with a long build of its own before publishUpdate.
+ */
+export declare function checkPublishUpdate(options: PublishCheckOptions): {
+    channel: string;
+    out: string;
+};
 /**
  * A signed release for the updates plugin (UP-1, UP-2): a release build, then `<channel>.json`, its signature and
  * its files under `out` (default <appDir>/.akan/native/updates), signed with the key updateKeygen() made.

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

@@ -11,6 +11,14 @@ export interface PublishedRelease {
  * sequence, so a clock behind the last publisher's would make this release look older to every one of them.
  */
 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;
+/** 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. */
 export declare function assertSigningKey(config: {
     app: {

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

@@ -52,6 +52,8 @@ export interface UpdateManifest {
         sha256: string;
         size: number;
     }[];
+    /** App updates: whether the app carries a server; an installed app refuses a release that differs from itself. */
+    server?: boolean;
 }
 /** 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>): {

package/types/vendor/@akanjs/native/packages/cli/src/platforms/desktop-update.d.ts

@@ -1,7 +1,13 @@
 import type { BuildContext } from "../lib/prepare.ts";
 import { type UpdateManifest } from "../lib/updates.ts";
 import { type DesktopOs } from "./desktop.ts";
+/**
+ * An installed app refuses a release whose server presence is not its own (plugins/updates): published, this one would
+ * be refused by every app the channel reached, and so would every release after it. A manifest from before the field
+ * says nothing and is not compared.
+ */
+export declare function assertSameServer(dir: string, channel: string, server: boolean): void;
 export declare function publishAppUpdate(ctx: BuildContext, os: DesktopOs, app: string, out: string, channel: string, sequence: number): Promise<{
     manifest: UpdateManifest;
-    superseded: string | null;
+    leftovers: string[];
 }>;

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

@@ -16,6 +16,13 @@ export interface InstallerInput {
         name: string;
         dir: boolean;
     }[];
+    /** Bytes the app folder takes on disk, and bytes the setup unpacks in all (the folder and the WebView2 bootstrapper). */
+    space: {
+        install: number;
+        unpack: number;
+    };
+    /** deepLinks.schemes: the uninstaller removes those the app registered for its own executable. */
+    schemes: string[];
     icon?: string;
     bootstrapper: string;
     stopScript: string;
@@ -23,15 +30,23 @@ export interface InstallerInput {
 }
 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).
+ * Stops every process running from the install folder, waits (up to 10 s) until they are gone, and exits 1 when
+ * one is left or cannot be seen. 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";
+export declare const STOP_SCRIPT = "param([string]$Dir)\n$ErrorActionPreference = 'Stop'\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 }\nif (& $running) { exit 1 }\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;
+/** The bytes of the files under `folder`, and what they take on disk. Links are not followed. */
+export declare function folderSize(folder: string): {
+    bytes: number;
+    disk: number;
+};
+/**
+ * How long `relative` gets on a typical PC while an update unpacks, the longest it ever is: root, app, then
+ * `.update-<bundle>\` and the app again.
+ */
+export declare function installedPathLength(appName: string, version: 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. */

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

@@ -12,7 +12,10 @@ 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. */
+    /**
+     * A debug build (boot.json `dev`: `--debug`, and every dev build, whose pages come from a dev server the shell did not
+     * start). It has the release app's id, so what it keeps apart goes in folders of its own.
+     */
     readonly dev: boolean;
     /**
      * The window whose page made this call (SH-6; 1 = the window the app opened). Only in method
@@ -51,7 +54,7 @@ export interface DesktopContext {
     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.
+     * first answered ready, false when it could not start or gave up before that; `state` and `onState` follow it after.
      */
     readonly server: DesktopServerStatus | null;
     /** Pushes an event of this plugin to the pages that listen. Returns the windows reached. */
@@ -108,18 +111,29 @@ export interface DesktopContext {
     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.
+     * plugin's setup (async allowed, at most 3 s each) before it creates the window. setWindow after
+     * that is ignored with a warning.
      */
     readonly launch: {
         /** Creates the window at these bounds (logical points) instead of the configured size (window-state). */
         setWindow(bounds: LaunchWindow): void;
-        /** Ends the app before a window is created; onQuit hooks do not run (single-instance). */
+        /**
+         * Ends the app before a window is created; onQuit hooks do not run (single-instance). A setup that ran past its
+         * time quits the app instead, since its window exists by then.
+         */
         exit(code?: number): void;
     };
 }
+/**
+ * "starting" until the server answers ready (again after a crash before that), "up" while it answers, "restarting"
+ * after a crash once it had been up, "gaveUp" when it is not started again this session, "stopped" as the app quits.
+ */
+export type DesktopServerState = "starting" | "up" | "restarting" | "gaveUp" | "stopped";
 export interface DesktopServerStatus {
     readonly ready: Promise<boolean>;
+    readonly state: DesktopServerState;
+    /** Every later change of `state`. Returns an unsubscribe function. */
+    onState(listener: (state: DesktopServerState) => void): () => void;
 }
 /** Which page load ended. `id` is "" for a page that sends no document id (v1 callers, tests). */
 export interface DocumentInfo {

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

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

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

@@ -1,3 +1,4 @@
+import type { DesktopServerState, DesktopServerStatus } from "./plugin.ts";
 export interface ServerManifest {
     /** The file in resources/server that starts the server. */
     entry: string;
@@ -14,6 +15,8 @@ export declare const MAX_FAILURES = 5;
 export declare const BOOT_RESTART_DELAY = 250;
 /** A run that stayed up this long was healthy: its crash starts the count again. */
 export declare const HEALTHY_RUN = 60000;
+/** server-output.log moves to server-output.log.1 past this size. */
+export declare const OUTPUT_LOG_LIMIT: number;
 export interface ServerProcess {
     readonly exited: Promise<number | null>;
     send(message: unknown): void;
@@ -41,6 +44,8 @@ export interface DesktopServerOptions {
     freePort?(preferred?: number): Promise<number>;
     /** The server gave up: MAX_FAILURES crashes in a row, or it could not start at all. */
     onGiveUp?(message: string): void;
+    /** Every change of `state`. */
+    onState?(state: DesktopServerState): void;
     readyTimeout?: number;
     stopGrace?: number;
     restartDelay?(failures: number, everReady: boolean): number;
@@ -57,10 +62,23 @@ export interface DesktopServer {
     }>;
     /** Settles once: true at the first ready, false when the server gave up or stopped before that. */
     readonly ready: Promise<boolean>;
+    /** Where the server is now; `ready` only tells the first answer. */
+    readonly state: DesktopServerState;
     stop(): Promise<void>;
 }
+/** What plugins see of the server (ctx.server) from their setup on: the plugin host starts it only after that. */
+export declare function createServerStatus(): {
+    status: DesktopServerStatus;
+    settle: (value: boolean) => void;
+    setState: (next: DesktopServerState) => void;
+};
 export declare function readServerManifest(resources: string): ServerManifest | null;
 export declare function serverArgv(execPath: string, resources: string, entry: string): string[];
+/**
+ * `key`'s value in `env`. Windows names a variable in any case (`Path`), and the plugin host's copy of process.env
+ * matches a name only in the case it has, where the process's own env ignores case.
+ */
+export declare function envValue(env: Record<string, string | undefined>, key: string, platform?: NodeJS.Platform): string | undefined;
 /** `dir` first on a PATH, once: a relaunched app inherits the PATH its predecessor already extended. */
 export declare function pathWithFirst(dir: string, path: string | undefined, platform?: NodeJS.Platform): string;
 export declare function serverEnv(manifest: ServerManifest, { port, secret, dataDir, env, binDir, platform, }: {

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

@@ -62,6 +62,13 @@ export interface AppEvents {
         progress: number;
         swipeEdge: "left" | "right";
     };
+    /**
+     * Desktop, an app that carries a server (desktop.server): where it is, at every change and when the first page
+     * starts listening. "gaveUp" means it is not started again until the app is.
+     */
+    serverState: {
+        state: "starting" | "up" | "restarting" | "gaveUp" | "stopped";
+    };
 }
 export declare const app: import("../../../packages/core/src/plugin.ts").Plugin<AppApi, AppEvents>;
 /** Calls `handler` for every deep link while mounted. */

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

@@ -1,4 +1,5 @@
 import { type DesktopPlugin } from "../../../packages/desktop/src/plugin.ts";
+import { type RelaunchOptions } from "../../../packages/desktop/src/relaunch.ts";
 import type { UpdatesApi, UpdatesEvents } from "./index.ts";
 export interface UpdatesConfig {
     app: string;
@@ -16,6 +17,10 @@ export interface UpdatesConfig {
  * launcher's own wait (READY_TIMEOUT, 8 s) only decides when the window opens.
  */
 export declare const SERVER_BOOT_ALLOWANCE = 120000;
+/** A server whose init throws answered ready first: its release is confirmed only once it stayed up this long. */
+export declare const SERVER_SETTLE = 5000;
+/** Tries of a release whose server did not come up, or whose Windows swap did not happen, before it is failed. */
+export declare const MAX_STRIKES = 3;
 export interface DesktopUpdatesOptions {
     platform?: NodeJS.Platform;
     /** The installed app; the running one by default. */
@@ -24,8 +29,9 @@ export interface DesktopUpdatesOptions {
     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>;
+    relaunch?(exe: string, moves: [string, string][], recover?: RelaunchOptions["recover"]): Promise<void>;
     serverBootAllowance?: number;
+    serverSettle?: number;
 }
 export declare function createDesktopUpdates(options?: DesktopUpdatesOptions): DesktopPlugin<UpdatesApi, UpdatesEvents>;
 declare const _default: DesktopPlugin<UpdatesApi, UpdatesEvents>;

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

@@ -1,11 +1,13 @@
 /**
  * Over-the-air updates. On iOS and Android they replace the web bundle (UP-2); the native code
- * stays, so a bundle only runs in a binary with the same native API (UP-3, `nativeApi`). Releases
- * are made with `akan-native update publish <platform>` and signed with the key of `akan-native update keygen`.
+ * stays, so a bundle only runs in a binary with the same native API (UP-3, `nativeApi`). On macOS,
+ * Windows and Linux they replace the whole app (UP-1). Releases are made with
+ * `akan-native update publish <platform>` and signed with the key of `akan-native update keygen`.
  *
  * A new bundle first runs on trial: the app calls notifyReady() once it works. A trial that does
  * not confirm within `updates.readyTimeout` (akan-native.config.ts, default 10 s), or that crashes and is
- * launched again, is rolled back to the previous bundle.
+ * launched again, is rolled back to the previous bundle. On a desktop app that carries a server, the
+ * trial also waits for that server to answer and stay up.
  */
 export interface UpdateState {
     /** The downloaded bundle running now; null = the one inside the app. */
@@ -24,7 +26,10 @@ export interface UpdateState {
     nativeApi: string | null;
 }
 export interface UpdateCheck {
-    /** A newer bundle for this binary exists (not rolled back before). */
+    /**
+     * A newer bundle for this binary exists (not rolled back before). Desktop: never the release on trial, nor one whose
+     * server presence differs from this app's.
+     */
     available: boolean;
     bundle: string | null;
     /** The app version it was published with. */
@@ -45,11 +50,18 @@ export interface UpdatesApi {
     download(): Promise<{
         bundle: string;
     }>;
-    /** Reloads the page into the downloaded bundle now (on trial). Rejects NOT_FOUND without one. */
+    /**
+     * Phones: reloads the page into the downloaded bundle now (on trial). Desktop: replaces the app with the download and
+     * relaunches it (on trial); rejects NOT_ALLOWED while the running release is still on trial. Rejects NOT_FOUND
+     * without a download.
+     */
     apply(): Promise<void>;
     /** The running bundle works: keep it. Call it once the app has started; harmless otherwise. */
     notifyReady(): Promise<void>;
-    /** Back to the app's own bundle from the next launch on. */
+    /**
+     * Phones: back to the app's own bundle from the next launch on. Desktop: drops the download and forgets the refused
+     * releases; the running app stays, and a trial keeps its record.
+     */
     reset(): Promise<void>;
 }
 export interface UpdatesEvents {

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

@@ -25,7 +25,7 @@ import {
   type WindowsBuild,
 } from "./lib/prepare.ts";
 import { ConfigError, type Project, projectFromConfig } from "./lib/project.ts";
-import { assertSigningKey, publishRelease } from "./lib/publish.ts";
+import { assertServerOfChannel, assertSigningKey, publishRelease } from "./lib/publish.ts";
 import {
   assertChannel,
   generateUpdateKey,
@@ -53,7 +53,7 @@ export type {
 };
 
 /** semver of this API. A caller checks the major before it relies on anything here. */
-export const API_VERSION = "0.8.0";
+export const API_VERSION = "0.9.0";
 
 export type AkanNativeErrorCode =
   | "CONFIG_INVALID"
@@ -255,6 +255,35 @@ export interface PublishResult {
   size: number;
 }
 
+export interface PublishCheckOptions extends Pick<TaskOptions, "appDir" | "config"> {
+  platform: Exclude<TargetPlatform, "web">;
+  channel?: string;
+  out?: string;
+  /** Whether the release will carry a server; the config's `desktop.server` by default. */
+  server?: boolean;
+}
+
+/**
+ * What publishUpdate() refuses before it builds, without building (CONFIG_INVALID): no updates settings, a channel no
+ * app could be configured for, no signing key on this machine or another app's, and a desktop release whose server
+ * presence is not the channel's previous release's. For a caller with a long build of its own before publishUpdate.
+ */
+export function checkPublishUpdate(options: PublishCheckOptions): { channel: string; out: string } {
+  if (!options.config.updates)
+    throw new AkanNativeError("CONFIG_INVALID", "the config has no updates: { url, publicKey } to publish for");
+  const channel = options.channel ?? options.config.updates.channel ?? "production";
+  const out = resolve(options.out ?? resolve(options.appDir, ".akan", "native", "updates"));
+  try {
+    if (options.channel !== undefined) assertChannel(options.channel);
+    assertSigningKey(options.config);
+    const server = options.server ?? !!options.config.desktop?.server;
+    assertServerOfChannel({ desktop: server ? { server } : {} }, options.platform, out, channel);
+  } catch (error) {
+    throw toAkanNativeError(error, "CONFIG_INVALID");
+  }
+  return { channel, out };
+}
+
 /**
  * A signed release for the updates plugin (UP-1, UP-2): a release build, then `<channel>.json`, its signature and
  * its files under `out` (default <appDir>/.akan/native/updates), signed with the key updateKeygen() made.
@@ -263,17 +292,8 @@ export function publishUpdate(
   options: TaskOptions & { platform: Exclude<TargetPlatform, "web">; channel?: string; out?: string },
 ): Promise<PublishResult> {
   return task(options, async (warnings) => {
-    if (!options.config.updates)
-      throw new AkanNativeError("CONFIG_INVALID", "the config has no updates: { url, publicKey } to publish for");
-    try {
-      if (options.channel !== undefined) assertChannel(options.channel);
-      assertSigningKey(options.config);
-    } catch (error) {
-      throw toAkanNativeError(error, "CONFIG_INVALID");
-    }
+    const { channel, out } = checkPublishUpdate(options);
     const { ctx, artifact, result } = await buildIn(options, "release", options.mode ?? "production", warnings);
-    const channel = options.channel ?? ctx.project.config.updates?.channel ?? "production";
-    const out = resolve(options.out ?? resolve(options.appDir, ".akan", "native", "updates"));
     const { dir, manifest } = await publishRelease(ctx, options.platform, artifact, out, channel).catch((error) => {
       throw toAkanNativeError(error, "CONFIG_INVALID");
     });

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

@@ -5,7 +5,7 @@ import { join, relative, resolve, sep } from "node:path";
 import { checkFlags, type ParsedArgs, parseArgs, stringFlag } from "../lib/args.ts";
 import { bold, CliError, dim, log } from "../lib/log.ts";
 import { findAppDir, loadProject } from "../lib/project.ts";
-import { assertSigningKey, publishRelease } from "../lib/publish.ts";
+import { assertServerOfChannel, assertSigningKey, publishRelease } from "../lib/publish.ts";
 import { assertChannel, generateUpdateKey, updateKeyPath } from "../lib/updates.ts";
 import { BOOLEAN_FLAGS, buildFromArgs } from "./build.ts";
 
@@ -39,7 +39,14 @@ async function publish(args: ParsedArgs): Promise<number> {
   const platform = desktop ?? (arg as "ios" | "android");
   const requested = stringFlag(args, "channel");
   if (requested !== undefined) assertChannel(requested);
-  assertSigningKey((await loadProject(findAppDir(stringFlag(args, "app") ?? process.cwd()))).config);
+  const project = await loadProject(findAppDir(stringFlag(args, "app") ?? process.cwd()));
+  assertSigningKey(project.config);
+  assertServerOfChannel(
+    project.config,
+    platform,
+    outDir(args, project.appDir),
+    requested ?? project.config.updates?.channel ?? "production",
+  );
   const { ctx, artifact } = await buildFromArgs(
     { positional: [platform], flags: args.flags },
     { mode: "production", profile: "release" },