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

package/vendor/@akanjs/native/native/desktop/src/win/volume.rs

@@ -0,0 +1,71 @@
+//! The system output volume on Windows (volume plugin), with the ops and JSON of volume.rs: the default
+//! render endpoint's IAudioEndpointVolume, which is what the taskbar's volume slider moves.
+//!
+//! - volume.watch is not an op here: the plugin host polls volume.get. Hearing changes would take an
+//!   IAudioEndpointVolumeCallback per endpoint and an IMMNotificationClient for a new default endpoint,
+//!   two COM objects kept alive for one event.
+//! - Every endpoint has a software volume, so it is always settable.
+
+use windows::Win32::Media::Audio::Endpoints::IAudioEndpointVolume;
+use windows::Win32::Media::Audio::{eConsole, eRender, IMMDeviceEnumerator, MMDeviceEnumerator};
+use windows::Win32::System::Com::{CoCreateInstance, CLSCTX_ALL, CLSCTX_INPROC_SERVER};
+
+use crate::json;
+
+fn endpoint() -> Result<IAudioEndpointVolume, String> {
+  // COM is initialized on this thread (tao's OleInitialize, wry's CoInitializeEx).
+  unsafe {
+    let devices: IMMDeviceEnumerator =
+      CoCreateInstance(&MMDeviceEnumerator, None, CLSCTX_INPROC_SERVER).map_err(|e| format!("INTERNAL: cannot list the audio devices: {e}"))?;
+    let device = devices.GetDefaultAudioEndpoint(eRender, eConsole).map_err(|_| "NOT_FOUND: there is no audio output".to_string())?;
+    device.Activate::<IAudioEndpointVolume>(CLSCTX_ALL, None).map_err(|e| format!("UNSUPPORTED: the audio output has no volume control: {e}"))
+  }
+}
+
+pub fn state_json(level: f32, muted: bool) -> String {
+  format!(r#"{{"level":{},"muted":{},"settable":true}}"#, (f64::from(level) * 1000.0).round() / 1000.0, muted)
+}
+
+fn state(volume: &IAudioEndpointVolume) -> Result<String, String> {
+  unsafe {
+    let level = volume.GetMasterVolumeLevelScalar().map_err(|e| format!("INTERNAL: cannot read the volume: {e}"))?;
+    let muted = volume.GetMute().map_err(|e| format!("INTERNAL: cannot read the mute: {e}"))?.as_bool();
+    Ok(state_json(level, muted))
+  }
+}
+
+fn set(cmd: &json::V) -> Result<String, String> {
+  let level = cmd.get("level").and_then(|v| v.as_f64()).filter(|v| (0.0..=1.0).contains(v)).ok_or("level must be a number from 0 to 1")?;
+  let volume = endpoint()?;
+  unsafe { volume.SetMasterVolumeLevelScalar(level as f32, std::ptr::null()) }.map_err(|e| format!("INTERNAL: cannot set the volume: {e}"))?;
+  state(&volume)
+}
+
+fn mute(cmd: &json::V) -> Result<String, String> {
+  let muted = cmd.get("muted").and_then(|v| v.as_bool()).ok_or("muted must be a boolean")?;
+  let volume = endpoint()?;
+  unsafe { volume.SetMute(muted, std::ptr::null()) }.map_err(|e| format!("INTERNAL: cannot set the mute: {e}"))?;
+  state(&volume)
+}
+
+/// volume.* shell ops; None for other ops.
+pub fn shell_op(op: &str, cmd: &json::V) -> Option<Result<String, String>> {
+  let result = match op {
+    "volume.get" => endpoint().and_then(|volume| state(&volume)),
+    "volume.set" => set(cmd),
+    "volume.mute" => mute(cmd),
+    _ if op.starts_with("volume.") => Err(format!("unknown op {op}")),
+    _ => return None,
+  };
+  Some(result)
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  #[test]
+  fn state_shape() {
+    assert_eq!(state_json(0.49999997, true), r#"{"level":0.5,"muted":true,"settable":true}"#);
+  }
+}

package/vendor/@akanjs/native/native/ios/Sources/AkanNativeShell.swift

@@ -13,10 +13,20 @@ enum AkanNativeLog {
         logger.info("\(text, privacy: .public)")
     }
 
+    /// One `[page<+> <level>]` tag per line, the desktop host's grammar, which the akan CLI reads the level back from;
+    /// os_log takes the page's level too, so `log stream` and Console.app filter on it.
     static func page(_ level: String, _ text: String) {
-        print("[page \(level)] \(text)")
+        let lines = text.replacingOccurrences(of: "\\n+$", with: "", options: .regularExpression)
+            .components(separatedBy: "\n")
+        print(lines.enumerated().map { "[page\($0.offset == 0 ? "" : "+") \(level)] \($0.element)" }.joined(separator: "\n"))
         fflush(stdout)
-        logger.info("[page \(level, privacy: .public)] \(text, privacy: .public)")
+        let message = lines.joined(separator: "\n")
+        switch level {
+        case "error": logger.error("\(message, privacy: .public)")
+        case "warn": logger.warning("\(message, privacy: .public)")
+        case "trace", "verbose", "debug": logger.debug("\(message, privacy: .public)")
+        default: logger.info("\(message, privacy: .public)")
+        }
     }
 }
 

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

@@ -1,8 +1,11 @@
 
 
-import { resolve } from "node:path";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
 import { type DoctorCheck, doctorChecks, hostPlatforms, runFixes } from "./commands/doctor.ts";
 import type { AkanNativeConfig } from "./config.ts";
+import { makeNativeBoot } from "./lib/boot.ts";
+import { BUNDLE_FILE, compatProblems, readBundleInfo } from "./lib/compat.ts";
 import { CancelledError, withSignal } from "./lib/exec.ts";
 import { type HmrContext, lanAddress, resolveDevEntry, startHmrServer } from "./lib/hmr.ts";
 import type { Device, DeviceSelector, Launched } from "./lib/launch.ts";
@@ -19,8 +22,18 @@ import {
   SigningError,
   WebBuildError,
   WebInputError,
+  type WindowsBuild,
 } from "./lib/prepare.ts";
 import { ConfigError, type Project, projectFromConfig } from "./lib/project.ts";
+import { assertSigningKey, publishRelease } from "./lib/publish.ts";
+import {
+  assertChannel,
+  generateUpdateKey,
+  type UpdateManifest,
+  updateKeyPath,
+  webManifest,
+  writeWebBundle,
+} from "./lib/updates.ts";
 import { androidDevices, launchAndroid } from "./platforms/android.ts";
 import { PLATFORM_TARGETS, type TargetPlatform } from "./platforms/index.ts";
 import { iosDevices, physicalIosDevice } from "./platforms/ios.ts";
@@ -36,10 +49,11 @@ export type {
   IosSigningResult,
   LogEvent,
   TargetPlatform,
+  WindowsBuild,
 };
 
 /** semver of this API. A caller checks the major before it relies on anything here. */
-export const API_VERSION = "0.1.0";
+export const API_VERSION = "0.8.0";
 
 export type AkanNativeErrorCode =
   | "CONFIG_INVALID"
@@ -97,7 +111,7 @@ export interface TaskOptions {
 }
 
 export interface Artifact {
-  kind: "app" | "apk" | "aab" | "ipa" | "folder" | "web";
+  kind: "app" | "apk" | "aab" | "ipa" | "folder" | "web" | "installer";
   path: string;
   signing: "none" | "adhoc" | "debug" | "development" | "distribution";
   device?: "simulator" | "device";
@@ -141,18 +155,17 @@ export function validateConfig(config: AkanNativeConfig, options: { appDir: stri
 }
 
 /** Builds the app. Default profile release (like `akan-native build`). `ios.device`: an iPhone build (signed; release adds an .ipa). */
-export function build(options: TaskOptions & { profile?: BuildProfile; ios?: IosBuild }): Promise<BuildResult> {
+export function build(
+  options: TaskOptions & { profile?: BuildProfile; ios?: IosBuild; windows?: WindowsBuild },
+): Promise<BuildResult> {
   return task(
     options,
     async (warnings) =>
       (
-        await buildIn(
-          options,
-          options.profile ?? "release",
-          options.mode ?? "production",
-          warnings,
-          options.ios ? { ios: options.ios } : {},
-        )
+        await buildIn(options, options.profile ?? "release", options.mode ?? "production", warnings, {
+          ...(options.ios ? { ios: options.ios } : {}),
+          ...(options.windows ? { windows: options.windows } : {}),
+        })
       ).result,
   );
 }
@@ -184,6 +197,123 @@ export function release(
   });
 }
 
+/**
+ * An unsigned web bundle update (UP-2), for a signer that keeps the key off the build machine. Writes
+ * `<out>/files/<sha256>`, `<out>/manifest.template.json` (the manifest with `channel`, `sequence` and `bundle` left
+ * empty for the signer) and `<out>/bundle.json` (the native API the bundle needs, UP-3). Prepares the web bundle as a
+ * release build does, without building the native app.
+ */
+export function packUpdate(
+  options: TaskOptions & { platform: "ios" | "android"; out: string },
+): Promise<{ manifest: UpdateManifest; out: string }> {
+  return task(options, async () => {
+    const appDir = resolve(options.appDir);
+    let project: Project;
+    try {
+      project = projectFromConfig(options.config, appDir, { resolveFrom: options.resolveFrom });
+    } catch (error) {
+      throw toAkanNativeError(error, "CONFIG_INVALID");
+    }
+    
+    const out = resolve(options.out);
+    mkdirSync(out, { recursive: true });
+    const ctx = await prepare(project, options.platform, {
+      mode: options.mode ?? "production",
+      profile: "release",
+      skipWebBuild: options.skipWebBuild ?? false,
+      outDir: out,
+      envFiles: options.envFiles,
+      env: options.env,
+      api: true,
+    }).catch((error) => {
+      throw toAkanNativeError(error, "CONFIG_INVALID");
+    });
+    makeNativeBoot(ctx, options.platform);
+    const info = readBundleInfo(join(out, BUNDLE_FILE));
+    const manifest = webManifest({
+      app: project.config.app,
+      platform: options.platform,
+      channel: "",
+      nativeApi: info.nativeApi.hash,
+      sequence: 0,
+      bundle: "",
+      files: writeWebBundle(out, ctx.webDir, ctx.html, ctx.env),
+    });
+    writeFileSync(join(out, "manifest.template.json"), `${JSON.stringify(manifest, null, 2)}\n`);
+    return { manifest, out };
+  });
+}
+
+export interface PublishResult {
+  build: BuildResult;
+  /** `<out>/<os>-<arch>` (desktop) or `<out>/<platform>` (a phone's web bundle): what to upload under updates.url. */
+  dir: string;
+  bundle: string;
+  channel: string;
+  files: number;
+  /** Bytes of the files the manifest names. */
+  size: number;
+}
+
+/**
+ * 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.
+ */
+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 { 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");
+    });
+    return {
+      build: result,
+      dir,
+      bundle: manifest.bundle,
+      channel,
+      files: manifest.files.length,
+      size: manifest.files.reduce((n, f) => n + f.size, 0),
+    };
+  });
+}
+
+/**
+ * Whether a web bundle can run in the binary a store release shipped (UP-3): `shipped` is that build's bundle.json,
+ * `bundle` the one `packUpdate` wrote. Anything in `problems` means a new binary.
+ */
+export function compareBundles(shipped: string, bundle: string): { compatible: boolean; problems: string[] } {
+  const [before, now] = [readBundleInfo(resolve(shipped)), readBundleInfo(resolve(bundle))];
+  const problems =
+    before.app.id !== now.app.id
+      ? [`${shipped} is for ${before.app.id}, the bundle for ${now.app.id}`]
+      : compatProblems(before.nativeApi.inputs, now.nativeApi.inputs);
+  return { compatible: problems.length === 0, problems };
+}
+
+/**
+ * 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.
+ */
+export function updateKeygen(options: { config: AkanNativeConfig }): {
+  publicKey: string;
+  keyPath: string;
+  created: boolean;
+} {
+  const keyPath = updateKeyPath(options.config.app.id);
+  return { ...generateUpdateKey(keyPath), keyPath };
+}
+
 /** Builds (default profile debug) and launches the app on a simulator, emulator, desktop or browser. */
 export function run(
   options: TaskOptions & {
@@ -483,7 +613,7 @@ async function buildIn(
   profile: BuildProfile,
   mode: string,
   warnings: string[],
-  extra: Pick<BuildOptions, "android" | "ios" | "devServer" | "startPath"> = {},
+  extra: Pick<BuildOptions, "android" | "ios" | "windows" | "devServer" | "startPath"> = {},
 ): Promise<{ ctx: BuildContext; artifact: string; result: BuildResult }> {
   const started = performance.now();
   const appDir = resolve(options.appDir);

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

@@ -8,14 +8,14 @@ import { findAppDir, loadProject } from "../lib/project.ts";
 import { PLATFORM_TARGETS, TARGETS, type TargetPlatform } from "../platforms/index.ts";
 import { physicalIosDevice } from "../platforms/ios.ts";
 
-export const BOOLEAN_FLAGS = ["skip-web-build", "open", "release", "debug", "headless", "aab"];
+export const BOOLEAN_FLAGS = ["skip-web-build", "open", "release", "debug", "headless", "aab", "installer"];
 
 /** Flags of every build: the app, the env mode (.env.<mode>), the profile, the web build. */
-export const BUILD_FLAGS = ["app", "mode", "release", "debug", "skip-web-build", "aab", "device", "build"];
+export const BUILD_FLAGS = ["app", "mode", "release", "debug", "skip-web-build", "aab", "installer", "device", "build"];
 /** Flags of launching a build (web server, simulators, emulators). */
 export const LAUNCH_FLAGS = ["port", "host", "open", "headless", "device", "avd"];
 
-export const BUILD_USAGE = `akan-native build <${TARGETS.join("|")}> [--app <dir>] [--mode <mode>] [--debug] [--skip-web-build] [--aab] [--device] [--build <n>]`;
+export const BUILD_USAGE = `akan-native build <${TARGETS.join("|")}> [--app <dir>] [--mode <mode>] [--debug] [--skip-web-build] [--aab] [--installer] [--device] [--build <n>]`;
 export const RUN_USAGE = `akan-native run <${TARGETS.join("|")}> [--app <dir>] [--mode <mode>] [--release] [--skip-web-build] [--port <n>] [--open] [--headless] [--device <name>] [--avd <name>] [--start <path>]`;
 
 export interface BuildDefaults {
@@ -57,6 +57,7 @@ export async function buildFromArgs(
   if (project.plugins.length) log.info(dim(`plugins: ${project.plugins.map((p) => p.manifest.id).join(", ")}`));
 
   if (args.flags.aab === true && platform !== "android") throw new CliError("--aab is for android", 2);
+  if (args.flags.installer === true && platform !== "windows") throw new CliError("--installer is for windows", 2);
   
   const device = args.flags.device;
   const iphone = platform === "ios" && typeof device === "string" ? await physicalIosDevice(device) : null;
@@ -69,6 +70,7 @@ export async function buildFromArgs(
     startPath: extra.startPath,
     
     ...(args.flags.aab === true ? { android: { bundle: true } } : {}),
+    ...(args.flags.installer === true ? { windows: { installer: true } } : {}),
 
     ...(iosDevice
       ? { ios: { device: true, ...(iphone ? { target: { udid: iphone.udid, name: iphone.name } } : {}) } }

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

@@ -1,22 +1,12 @@
 
 
-import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { existsSync, statSync } from "node:fs";
 import { join, relative, resolve, sep } from "node:path";
 import { checkFlags, type ParsedArgs, parseArgs, stringFlag } from "../lib/args.ts";
-import { runtimeVersion } from "../lib/boot.ts";
-import { BUNDLE_FILE, readBundleInfo } from "../lib/compat.ts";
 import { bold, CliError, dim, log } from "../lib/log.ts";
 import { findAppDir, loadProject } from "../lib/project.ts";
-import {
-  generateUpdateKey,
-  hostArch,
-  sha256,
-  signManifest,
-  type UpdateFile,
-  type UpdateManifest,
-  updateKeyPath,
-} from "../lib/updates.ts";
-import { publishAppUpdate } from "../platforms/desktop-update.ts";
+import { assertSigningKey, publishRelease } from "../lib/publish.ts";
+import { assertChannel, generateUpdateKey, updateKeyPath } from "../lib/updates.ts";
 import { BOOLEAN_FLAGS, buildFromArgs } from "./build.ts";
 
 export const UPDATE_USAGE =
@@ -42,80 +32,29 @@ async function keygen(args: ParsedArgs): Promise<number> {
   return 0;
 }
 
-/** Every file of a web bundle as the app serves it: index.html with the init script and CSP, public/, env.runtime.json. */
-function webFiles(webDir: string, html: string, env: Record<string, string>): { path: string; data: Uint8Array }[] {
-  const files: { path: string; data: Uint8Array }[] = [];
-  const walk = (dir: string) => {
-    for (const name of readdirSync(dir).sort()) {
-      const path = join(dir, name);
-      if (statSync(path).isDirectory()) walk(path);
-      else {
-        const rel = relative(webDir, path);
-        files.push({ path: rel, data: rel === "index.html" ? new TextEncoder().encode(html) : readFileSync(path) });
-      }
-    }
-  };
-  walk(webDir);
-  files.push({ path: "env.runtime.json", data: new TextEncoder().encode(JSON.stringify(env, null, 2)) });
-  return files;
-}
-
 async function publish(args: ParsedArgs): Promise<number> {
   const arg = args.positional[1];
   const desktop = arg === "macos" || arg === "windows" || arg === "linux" ? arg : null;
   if (!desktop && arg !== "ios" && arg !== "android") throw new CliError(`usage: ${UPDATE_USAGE}`, 2);
   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 { ctx, artifact } = await buildFromArgs(
     { positional: [platform], flags: args.flags },
     { mode: "production", profile: "release" },
     platform,
   );
   const { config, appDir } = ctx.project;
-  if (!config.updates)
-    throw new CliError("akan-native.config.ts has no updates: { url, publicKey } (run `akan-native update keygen`)");
-  const channel = stringFlag(args, "channel") ?? config.updates.channel;
-  
-  const out = join(outDir(args, appDir), desktop ? `${desktop}-${hostArch()}` : platform);
-  const keyPath = updateKeyPath(config.app.id);
-  const sequence = Math.floor(Date.now() / 1000);
-
-  let manifest: UpdateManifest;
-  if (desktop) {
-    manifest = await publishAppUpdate(ctx, desktop, artifact, out, channel, sequence);
-  } else {
-    const info = readBundleInfo(join(ctx.outDir, BUNDLE_FILE));
-    mkdirSync(join(out, "files"), { recursive: true });
-    const files: UpdateFile[] = webFiles(ctx.webDir, ctx.html, ctx.env).map(({ path, data }) => {
-      const hash = sha256(data);
-      const target = join(out, "files", hash);
-      if (!existsSync(target)) writeFileSync(target, data);
-      return { path, sha256: hash, size: data.length };
-    });
-    manifest = {
-      schema: 1,
-      kind: "web",
-      app: config.app.id,
-      platform,
-      channel,
-      nativeApi: info.nativeApi.hash,
-      sequence,
-      bundle: `${sequence}-${info.web.hash.slice(0, 8)}`,
-      runtimeVersion: runtimeVersion(),
-      version: config.app.version,
-      files,
-    };
-  }
-  const bytes = new TextEncoder().encode(`${JSON.stringify(manifest, null, 2)}\n`);
-  mkdirSync(out, { recursive: true });
-  writeFileSync(join(out, `${channel}.json`), bytes);
-  writeFileSync(join(out, `${channel}.json.sig`), `${signManifest(bytes, keyPath, config.updates.publicKey)}\n`);
+  const channel = requested ?? config.updates?.channel ?? "production";
+  const { dir, manifest } = await publishRelease(ctx, platform, artifact, outDir(args, appDir), channel);
   const size = manifest.files.reduce((n, f) => n + f.size, 0);
   log.ok(
-    `published ${bold(manifest.bundle)} to ${relative(process.cwd(), out) || out}/${channel}.json ${dim(`(${manifest.files.length} files, ${(size / 1024).toFixed(0)} KiB${manifest.nativeApi ? `, native API ${manifest.nativeApi}` : ""})`)}`,
+    `published ${bold(manifest.bundle)} to ${relative(process.cwd(), dir) || dir}/${channel}.json ${dim(`(${manifest.files.length} files, ${(size / 1024).toFixed(0)} KiB${manifest.nativeApi ? `, native API ${manifest.nativeApi}` : ""})`)}`,
   );
   log.info(
     dim(
-      `Upload ${relative(process.cwd(), join(out, ".."))} to ${config.updates.url} (or try it with \`akan-native update serve\`).`,
+      `Upload ${relative(process.cwd(), join(dir, ".."))} to ${config.updates?.url} (or try it with \`akan-native update serve\`).`,
     ),
   );
   return 0;

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

@@ -181,6 +181,11 @@ export interface AkanNativeConfig {
      * or APIs the bundle uses. Android 10+ devices with Google Play update WebView themselves.
      */
     minWebViewVersion?: number;
+    /**
+     * Media plays with sound without a tap first, as it does on iOS and the desktop (WebView's
+     * mediaPlaybackRequiresUserGesture off): an app nobody taps, such as a signage screen. Default false.
+     */
+    autoplay?: boolean;
     /**
      * Appended to app.id in debug builds (e.g. ".debug"), so a debug build installs next to the
      * release app. Deep links and app links must list the suffixed id for debug builds.
@@ -227,6 +232,42 @@ export interface AkanNativeConfig {
      * hides the window: the app keeps running, a Dock click shows it again, Cmd+Q quits. Default true.
      */
     quitOnLastWindowClosed?: boolean;
+    /**
+     * What a window does when its page's web process ends: a crash, a hang, out of memory. "errorPage"
+     * (default) loads the page again once and shows an error page when it ends again within a minute, so a
+     * page that crashes on load does not loop; the app quits when the webview's browser process ends
+     * (Windows). "reload" loads it again every time, waiting longer after each end in a row (1 s, doubling
+     * to a minute), and relaunches the app when the browser process ends: an app nobody attends, such as a
+     * kiosk or a signage screen. iOS and Android always start the page over.
+     */
+    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.
+     */
+    window?: { fullscreen?: boolean; skipTaskbar?: boolean };
+    /**
+     * Windows: "auto" answers the page's getDisplayMedia() with the first screen at once, without the picker or a
+     * user gesture: a remote-support session on an unattended screen. It is Chromium's switch for automated media
+     * tests (--use-fake-ui-for-media-stream), made for every media request, so keep it to an app whose pages ask
+     * for no camera or microphone. Default "picker". WebView2's choice by title follows the UI language, so none is
+     * offered. macOS and Linux ignore it.
+     */
+    screenCapture?: "picker" | "auto";
+    /**
+     * 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.
+     */
+    server?: { dir: string; entry: string; env?: Record<string, string> };
+    /**
+     * A folder of executables the app carries (akanjs `bin`): copied to the app's resources (`bin/`) and put
+     * first on the app's PATH at launch, so its plugins and its server find them by name before the computer's.
+     * macOS builds sign every Mach-O file in it.
+     */
+    bin?: string;
   };
   /**
    * App icon for every platform, generated from one square PNG, ideally 1024×1024 (CLI-8).

package/vendor/@akanjs/native/packages/cli/src/lib/configkeys.ts

@@ -28,8 +28,15 @@ const KNOWN: Shape = {
     resources: { "[]": { from: true, to: true } },
   },
   security: { csp: true, shell: { externalSchemes: true } },
-  android: { minWebViewVersion: true, debugAppIdSuffix: true, googleServices: true },
-  desktop: { quitOnLastWindowClosed: true },
+  android: { minWebViewVersion: true, debugAppIdSuffix: true, googleServices: true, autoplay: true },
+  desktop: {
+    quitOnLastWindowClosed: true,
+    recovery: true,
+    window: { fullscreen: true, skipTaskbar: true },
+    screenCapture: true,
+    server: { dir: true, entry: true, env: true },
+    bin: true,
+  },
   keyboard: { resize: true },
   push: {
     android: { channel: { id: true, name: true, importance: true, description: true }, smallIcon: true, color: true },

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

@@ -0,0 +1,58 @@
+
+
+import { existsSync, statSync } from "node:fs";
+import { isAbsolute, join, resolve } from "node:path";
+import { LAUNCHER_ENV_KEYS } from "../../../desktop/src/server.ts";
+import type { AkanNativeConfig } from "../config.ts";
+
+export interface DesktopServerConfig {
+  /** Absolute. */
+  dir: string;
+  entry: string;
+  env: Record<string, string>;
+}
+
+const ENV_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const LAUNCHER_KEYS = new Set<string>(LAUNCHER_ENV_KEYS);
+
+export function validateDesktopServer(
+  desktop: AkanNativeConfig["desktop"],
+  appDir: string,
+  problems: string[],
+): DesktopServerConfig | null {
+  const server = desktop?.server;
+  if (server === undefined) return null;
+  if (!server || typeof server !== "object") {
+    problems.push("desktop.server must be an object with dir and entry");
+    return null;
+  }
+  const before = problems.length;
+  const dir = typeof server.dir === "string" && server.dir ? resolve(appDir, server.dir) : null;
+  if (!dir) problems.push("desktop.server.dir is required: the folder the server runs from");
+  else if (!existsSync(dir) || !statSync(dir).isDirectory())
+    problems.push(`desktop.server.dir: ${dir} is not a folder`);
+  const entry = typeof server.entry === "string" ? server.entry : "";
+  if (!entry || isAbsolute(entry) || entry.split(/[\\/]/).includes(".."))
+    problems.push(
+      `desktop.server.entry must be a file inside desktop.server.dir (got ${JSON.stringify(server.entry)})`,
+    );
+  else if (dir && existsSync(dir) && !existsSync(join(dir, entry)))
+    problems.push(`desktop.server.entry: ${join(dir, entry)} not found`);
+  const env: Record<string, string> = {};
+  if (server.env !== undefined && (!server.env || typeof server.env !== "object" || Array.isArray(server.env)))
+    problems.push("desktop.server.env must be an object of strings");
+  else
+    for (const [key, value] of Object.entries(server.env ?? {})) {
+
+      const upper = key.toUpperCase();
+      if (!ENV_NAME.test(key)) problems.push(`desktop.server.env: ${JSON.stringify(key)} is not a variable name`);
+      else if (LAUNCHER_KEYS.has(upper))
+        problems.push(`desktop.server.env.${key}: the launcher sets it at every start`);
+      else if (upper === "PATH" && key !== "PATH") problems.push(`desktop.server.env.${key}: write it as PATH`);
+      else if (Object.keys(env).some((kept) => kept.toUpperCase() === upper))
+        problems.push(`desktop.server.env.${key}: Windows reads it as the same variable as another one here`);
+      else if (typeof value !== "string") problems.push(`desktop.server.env.${key} must be a string`);
+      else env[key] = value;
+    }
+  return problems.length === before && dir ? { dir, entry, env } : null;
+}

package/vendor/@akanjs/native/packages/cli/src/lib/hmr.ts

@@ -413,6 +413,8 @@ export async function startHmrServer(opts: HmrOptions): Promise<HmrServer> {
     Bun.serve({
       hostname: opts.hostname,
       port: opts.port,
+
+      idleTimeout: 0,
       async fetch(req, srv) {
         const url = new URL(req.url);
         if (relayed.has(url.pathname) && req.headers.get("upgrade")?.toLowerCase() === "websocket") {

package/vendor/@akanjs/native/packages/cli/src/lib/prepare.ts

@@ -26,6 +26,10 @@ const DEV_SERVER_PAGE = `<!doctype html>
 </html>
 `;
 
+export interface WindowsBuild {
+  installer?: boolean;
+}
+
 export interface BuildOptions {
   mode: string;
   profile: BuildProfile;
@@ -57,6 +61,8 @@ export interface BuildOptions {
   android?: AndroidRelease;
   /** iOS devices (akanjs readiness O1-2, O1-3). */
   ios?: IosBuild;
+  /** Windows: an NSIS setup program next to the app folder (platforms/windows-installer.ts). */
+  windows?: WindowsBuild;
 }
 
 /** Which identity and profile an iOS device build signs with; unset: found in the keychain and Xcode's profiles. */
@@ -138,8 +144,9 @@ export interface BuildContext {
   startPath?: string;
   android?: AndroidRelease;
   ios?: IosBuild;
-  /** Artifacts besides the one the builder returns (an .aab next to the .apk). */
-  artifacts: { kind: "aab" | "ipa"; path: string }[];
+  windows?: WindowsBuild;
+  /** Artifacts besides the one the builder returns (an .aab next to the .apk, a Windows setup program). */
+  artifacts: { kind: "aab" | "ipa" | "installer"; path: string }[];
   /** What the builder signed with, when it signs (Android: the app's release key or the debug key). */
   signedAs?: "debug" | "development" | "distribution";
   /** Called through the API (BuildOptions.api). */
@@ -271,6 +278,7 @@ export async function prepare(project: Project, platform: Platform, options: Bui
     ...(options.profile === "debug" && options.startPath ? { startPath: checkStartPath(options.startPath) } : {}),
     ...(options.android ? { android: options.android } : {}),
     ...(options.ios ? { ios: options.ios } : {}),
+    ...(options.windows ? { windows: options.windows } : {}),
     artifacts: [],
   };
 }