@mirinjs/cli 0.1.0-alpha.1 → 0.1.0-alpha.11

package/src/dev.ts

@@ -9,14 +9,22 @@
  */
 
 import { $ } from "bun";
-import { mkdirSync, rmSync, symlinkSync, existsSync } from "node:fs";
+import { mkdirSync, rmSync, symlinkSync, existsSync, writeFileSync } from "node:fs";
 import { createServer } from "node:net";
 import { join } from "node:path";
 import { buildAppBundle } from "./bundle.ts";
 import { buildWindowsBundle } from "./bundle-win.ts";
+import {
+  buildLinuxBundle,
+  resolveLinuxIconPng,
+  resolveLinuxDesktopIconPng,
+  desktopEntry,
+} from "./bundle-linux.ts";
+import { homedir } from "node:os";
 import { resolveArtifacts } from "./artifacts.ts";
 
 const IS_WINDOWS = process.platform === "win32";
+const IS_LINUX = process.platform === "linux";
 import { sweepBuildTemps } from "./temps.ts";
 import { normalizeSidecars, compileWorkers } from "./extras.ts";
 
@@ -36,6 +44,11 @@ export async function dev(projectDir = process.cwd()): Promise<number> {
   const appName: string = config.name ?? "Mirin App";
   const bundleId: string = config.id ?? "dev.mirin.app";
   const mainEntry = join(projectDir, config.main ?? "main/main.ts");
+  const iconSrc = config.icon ? join(projectDir, config.icon) : undefined;
+  // Linux: resolve the app icon to a concrete PNG the core stamps onto the window
+  // as `_NET_WM_ICON` (cosmic dock/taskbar). Passed straight through in dev — no
+  // bundling; the file is read from the project at window-create time.
+  const linuxIconPng = IS_LINUX && iconSrc ? resolveLinuxIconPng(iconSrc) : undefined;
 
   // --- native artifacts ---
   const artifacts = await resolveArtifacts({ release: false });
@@ -61,7 +74,7 @@ export async function dev(projectDir = process.cwd()): Promise<number> {
     else console.warn(`[mirin dev] sidecar "${sc.name}" not found: ${sc.src}`);
   }
 
-  // --- assemble the dev bundle (Windows app folder, or macOS .app) ---
+  // --- assemble the dev bundle (Windows/Linux app folder, or macOS .app) ---
   console.log("[mirin dev] assembling dev bundle…");
   const { app, exe } = IS_WINDOWS
     ? await buildWindowsBundle({
@@ -71,7 +84,17 @@ export async function dev(projectDir = process.cwd()): Promise<number> {
         coreDll: artifacts.coreDylib,
         helperExe: artifacts.helperBin,
         cefPath: artifacts.cefPath,
-        icon: config.icon ? join(projectDir, config.icon) : undefined,
+        icon: iconSrc,
+      })
+    : IS_LINUX
+    ? await buildLinuxBundle({
+        appName,
+        outDir: work,
+        hostExe,
+        coreDll: artifacts.coreDylib,
+        helperExe: artifacts.helperBin,
+        cefPath: artifacts.cefPath,
+        icon: iconSrc,
       })
     : await buildAppBundle({
         appName,
@@ -81,19 +104,41 @@ export async function dev(projectDir = process.cwd()): Promise<number> {
         coreDylib: artifacts.coreDylib,
         helperBin: artifacts.helperBin,
         cefPath: artifacts.cefPath,
-        icon: config.icon ? join(projectDir, config.icon) : undefined,
+        icon: iconSrc,
         urlSchemes: config.urlSchemes,
       });
 
+  // Linux: install a dev `.desktop` entry so cosmic's dock can resolve the app's
+  // icon. cosmic matches a running X11 window's `WM_CLASS` (which the core sets to
+  // the bundle id) against `StartupWMClass`, then shows that entry's `Icon`. Written
+  // to the per-user applications dir; harmless on other DEs.
+  if (IS_LINUX && iconSrc) {
+    const desktopIcon = resolveLinuxDesktopIconPng(iconSrc);
+    if (desktopIcon) {
+      const appsDir = join(homedir(), ".local", "share", "applications");
+      mkdirSync(appsDir, { recursive: true });
+      writeFileSync(
+        join(appsDir, `${bundleId}.desktop`),
+        desktopEntry({ name: appName, exec: exe, iconPng: desktopIcon, wmClass: bundleId }),
+      );
+    }
+  }
+
   // --- start Vite on a free port so concurrent dev sessions don't collide ---
   // `--port <free> --strictPort` pins Vite to the port we probed (overriding any
   // port/strictPort in the app's vite.config) and passes the real URL to the app,
   // so the host and Vite never disagree about which port is in use.
+  //
+  // Bind + address on 127.0.0.1 (IPv4), NOT "localhost": on hosts where Vite binds
+  // IPv6-only (`[::1]`) while Chromium resolves `localhost` to IPv4 (common on
+  // Linux), the webview's page load is refused and the window stays blank. Pinning
+  // both sides to 127.0.0.1 avoids the family mismatch (and matches the loopback
+  // RPC server). `--host 127.0.0.1` forces Vite's bind.
   const port = await findFreePort(DEV_PORT_BASE);
-  const devUrl = `http://localhost:${port}`;
+  const devUrl = `http://127.0.0.1:${port}`;
   console.log(`[mirin dev] starting Vite dev server on ${devUrl}…`);
   const vite = Bun.spawn(
-    ["bunx", "vite", "--clearScreen", "false", "--port", String(port), "--strictPort"],
+    ["bunx", "vite", "--clearScreen", "false", "--host", "127.0.0.1", "--port", String(port), "--strictPort"],
     {
       cwd: projectDir,
       stdio: ["ignore", "inherit", "inherit"],
@@ -109,13 +154,24 @@ export async function dev(projectDir = process.cwd()): Promise<number> {
       ...process.env,
       MIRIN_CORE: IS_WINDOWS
         ? join(app, "mirin_core.dll")
+        : IS_LINUX
+        ? join(app, "libmirin_core.so")
         : join(app, "Contents", "MacOS", "libmirin_core.dylib"),
+      // Linux: the flat app dir holds libcef.so + libmirin_core.so; put it on the
+      // loader path so the host's dlopen and libmirin_core's NEEDED libcef.so (and
+      // the spawned mirin-helper) all resolve. (macOS uses the framework loader;
+      // Windows the exe-dir search — neither needs this.)
+      ...(IS_LINUX ? { LD_LIBRARY_PATH: `${app}${process.env.LD_LIBRARY_PATH ? ":" + process.env.LD_LIBRARY_PATH : ""}` } : {}),
       MIRIN_WORKER: workerJs,
       MIRIN_DEV_URL: devUrl,
-      MIRIN_MANIFEST_JSON: JSON.stringify({ windows: config.windows }),
+      MIRIN_MANIFEST_JSON: JSON.stringify({ id: bundleId, windows: config.windows }),
       // dev: true → enables inspect-element AND gives this run its own `-dev`
       // CEF cache dir, so `mirin dev` can run alongside the installed app.
-      MIRIN_CONFIG_JSON: JSON.stringify({ dev: true }),
+      // `icon_path` (Linux) → the window's `_NET_WM_ICON` (cosmic dock/taskbar).
+      MIRIN_CONFIG_JSON: JSON.stringify({
+        dev: true,
+        ...(linuxIconPng ? { icon_path: linuxIconPng } : {}),
+      }),
       MIRIN_SIDECAR_DIR: sidecarsDir,
       MIRIN_WORKERS_DIR: workersDir,
     },

package/src/dmg.ts

@@ -93,6 +93,34 @@ export async function notarizeAndStaple(target: string): Promise<boolean> {
   return true;
 }
 
+/**
+ * `hdiutil create` with retries. "Resource busy" is a transient CI flake — a
+ * Spotlight/antivirus/`fseventsd` process touches the staging folder (or a prior
+ * image hasn't fully detached) while hdiutil tries to read it. A short backoff
+ * clears it; only a non-busy error fails immediately.
+ */
+async function hdiutilCreate(
+  vol: string,
+  staging: string,
+  format: string,
+  dmgPath: string,
+): Promise<void> {
+  let stderr = "";
+  for (let attempt = 1; attempt <= 4; attempt++) {
+    const res =
+      await $`hdiutil create -volname ${vol} -srcfolder ${staging} -ov -format ${format} ${dmgPath}`
+        .quiet()
+        .nothrow();
+    if (res.exitCode === 0) return;
+    stderr = res.stderr.toString().trim();
+    if (!/busy/i.test(stderr)) break; // not the transient flake — fail now
+    console.warn(`[mirin release] hdiutil create busy (attempt ${attempt}/4); retrying…`);
+    rmSync(dmgPath, { force: true });
+    await Bun.sleep(3000 * attempt);
+  }
+  throw new Error(`hdiutil create failed: ${stderr}`);
+}
+
 /** Does this config ask for a styled Finder window (vs. a plain DMG)? */
 function wantsLayout(o: DmgOptions): boolean {
   return !!(o.background || o.appPosition || o.applicationsPosition || o.windowSize || o.iconSize);
@@ -131,7 +159,7 @@ export async function buildDmg(input: BuildDmgInput): Promise<string> {
       }
     }
     if (!built) {
-      await $`hdiutil create -volname ${vol} -srcfolder ${staging} -ov -format ${format} ${dmgPath}`.quiet();
+      await hdiutilCreate(vol, staging, format, dmgPath);
     }
   } finally {
     rmSync(staging, { recursive: true, force: true });

package/src/icon-win.ts

@@ -1,58 +1,210 @@
 /**
  * Produce a Windows `.ico` from the app's icon source (mirrors the macOS `.icns`
- * path in `bundle.ts`). mirin loads it at runtime and sets it as the window icon
- * (taskbar / Alt-Tab / title). Accepts a `.ico` (copied), a `.iconset` directory
- * (its `icon_NxN.png` renditions packed as multi-size PNG entries — Vista+ icons
- * embed PNGs directly, so no rescaling is needed), or a single `.png`.
+ * path in `bundle.ts`). Emits **classic DIB/BMP icon entries** (32bpp BGRA + AND
+ * mask), NOT PNG-compressed entries: Bun's `--windows-icon` embedder silently
+ * ignores PNG-format ICOs (the exe keeps Bun's default icon), and some shells
+ * mis-scale them. Accepts a `.ico` (copied), a `.iconset` directory (its
+ * `icon_NxN.png` renditions), or a single square `.png`.
  */
 
 import { copyFileSync, existsSync, readFileSync, writeFileSync } from "node:fs";
+import { inflateSync } from "node:zlib";
 import { join } from "node:path";
 
-/** The iconset renditions worth packing (small sizes render crisper than scaling 256). */
+/** Standard Windows icon sizes; intermediate sizes are downscaled from these by
+ *  the shell, so the 256 entry keeps large views crisp. */
 const ICO_SIZES = [16, 32, 48, 64, 128, 256];
 
-interface IconEntry {
+interface IcoEntry {
   size: number;
-  png: Uint8Array;
+  /** DIB image (small sizes) or raw PNG bytes (256) — see {@link rendition}. */
+  data: Buffer;
+  /** True when `data` is a PNG blob (the 256 convention) rather than a DIB. */
+  png: boolean;
 }
 
-/** Pack PNG renditions into a multi-image `.ico` (each entry is a PNG blob). */
-function packIco(entries: IconEntry[]): Uint8Array {
-  const headerSize = 6 + entries.length * 16;
-  const header = new Uint8Array(headerSize);
-  const dv = new DataView(header.buffer);
-  dv.setUint16(0, 0, true); // reserved
-  dv.setUint16(2, 1, true); // type 1 = icon
-  dv.setUint16(4, entries.length, true);
+/**
+ * Minimal PNG decoder → top-down RGBA. Handles 8-bit, non-interlaced, color
+ * types 0/2/4/6 (the renditions macOS `iconutil`/`sips` and design tools emit).
+ * Throws on anything else so the caller skips just that rendition.
+ */
+function decodePng(buf: Buffer): { width: number; height: number; rgba: Buffer } {
+  if (buf.readUInt32BE(0) !== 0x89504e47) throw new Error("not a PNG");
+  let width = 0;
+  let height = 0;
+  let bitDepth = 0;
+  let colorType = 0;
+  let interlace = 0;
+  const idat: Buffer[] = [];
+  let pos = 8;
+  while (pos + 8 <= buf.length) {
+    const len = buf.readUInt32BE(pos);
+    const type = buf.toString("latin1", pos + 4, pos + 8);
+    const data = buf.subarray(pos + 8, pos + 8 + len);
+    if (type === "IHDR") {
+      width = data.readUInt32BE(0);
+      height = data.readUInt32BE(4);
+      bitDepth = data[8]!;
+      colorType = data[9]!;
+      interlace = data[12]!;
+    } else if (type === "IDAT") {
+      idat.push(data);
+    } else if (type === "IEND") {
+      break;
+    }
+    pos += 12 + len;
+  }
+  if (bitDepth !== 8 || interlace !== 0) {
+    throw new Error(`unsupported PNG (depth ${bitDepth}, interlace ${interlace})`);
+  }
+  const channels = colorType === 6 ? 4 : colorType === 2 ? 3 : colorType === 4 ? 2 : colorType === 0 ? 1 : 0;
+  if (!channels) throw new Error(`unsupported color type ${colorType}`);
+
+  const raw = inflateSync(Buffer.concat(idat));
+  const stride = width * channels;
+  const rgba = Buffer.alloc(width * height * 4);
+  let prev = Buffer.alloc(stride);
+  let rp = 0;
+  for (let y = 0; y < height; y++) {
+    const filter = raw[rp++]!;
+    const cur = Buffer.from(raw.subarray(rp, rp + stride));
+    rp += stride;
+    unfilter(filter, cur, prev, channels);
+    for (let x = 0; x < width; x++) {
+      const s = x * channels;
+      let r: number;
+      let g: number;
+      let b: number;
+      let a: number;
+      if (channels === 4) {
+        r = cur[s]!;
+        g = cur[s + 1]!;
+        b = cur[s + 2]!;
+        a = cur[s + 3]!;
+      } else if (channels === 3) {
+        r = cur[s]!;
+        g = cur[s + 1]!;
+        b = cur[s + 2]!;
+        a = 255;
+      } else if (channels === 2) {
+        r = g = b = cur[s]!;
+        a = cur[s + 1]!;
+      } else {
+        r = g = b = cur[s]!;
+        a = 255;
+      }
+      const d = (y * width + x) * 4;
+      rgba[d] = r;
+      rgba[d + 1] = g;
+      rgba[d + 2] = b;
+      rgba[d + 3] = a;
+    }
+    prev = cur;
+  }
+  return { width, height, rgba };
+}
+
+/** Reverse a PNG scanline filter in place (None/Sub/Up/Average/Paeth). */
+function unfilter(filter: number, cur: Buffer, prev: Buffer, bpp: number): void {
+  for (let i = 0; i < cur.length; i++) {
+    const a = i >= bpp ? cur[i - bpp]! : 0;
+    const b = prev[i]!;
+    const c = i >= bpp ? prev[i - bpp]! : 0;
+    let v = cur[i]!;
+    if (filter === 1) v += a;
+    else if (filter === 2) v += b;
+    else if (filter === 3) v += (a + b) >> 1;
+    else if (filter === 4) {
+      const p = a + b - c;
+      const pa = Math.abs(p - a);
+      const pb = Math.abs(p - b);
+      const pc = Math.abs(p - c);
+      v += pa <= pb && pa <= pc ? a : pb <= pc ? b : c;
+    }
+    cur[i] = v & 0xff;
+  }
+}
+
+/** Encode one icon image as a DIB: BITMAPINFOHEADER + bottom-up 32bpp BGRA + a
+ *  (zeroed) 1bpp AND mask — the alpha channel drives transparency. */
+function dibEntry(size: number, rgba: Buffer): Buffer {
+  const xor = Buffer.alloc(size * size * 4);
+  for (let dy = 0; dy < size; dy++) {
+    const sy = size - 1 - dy; // DIB rows run bottom-to-top
+    for (let x = 0; x < size; x++) {
+      const s = (sy * size + x) * 4;
+      const d = (dy * size + x) * 4;
+      xor[d] = rgba[s + 2]!; // B
+      xor[d + 1] = rgba[s + 1]!; // G
+      xor[d + 2] = rgba[s]!; // R
+      xor[d + 3] = rgba[s + 3]!; // A
+    }
+  }
+  const andStride = Math.ceil(size / 32) * 4; // 1bpp, rows padded to 4 bytes
+  const andMask = Buffer.alloc(andStride * size, 0);
+  const hdr = Buffer.alloc(40);
+  hdr.writeUInt32LE(40, 0); // biSize
+  hdr.writeInt32LE(size, 4); // biWidth
+  hdr.writeInt32LE(size * 2, 8); // biHeight = XOR rows + AND rows
+  hdr.writeUInt16LE(1, 12); // biPlanes
+  hdr.writeUInt16LE(32, 14); // biBitCount
+  hdr.writeUInt32LE(0, 16); // BI_RGB
+  hdr.writeUInt32LE(xor.length + andMask.length, 20);
+  return Buffer.concat([hdr, xor, andMask]);
+}
 
-  let offset = headerSize;
+/** Assemble the ICONDIR + entries into a `.ico`. */
+function packIco(entries: IcoEntry[]): Buffer {
+  const dirSize = 6 + entries.length * 16;
+  const dir = Buffer.alloc(dirSize);
+  dir.writeUInt16LE(0, 0); // reserved
+  dir.writeUInt16LE(1, 2); // type 1 = icon
+  dir.writeUInt16LE(entries.length, 4);
+  let offset = dirSize;
   entries.forEach((e, i) => {
     const base = 6 + i * 16;
-    header[base] = e.size >= 256 ? 0 : e.size; // width (0 = 256)
-    header[base + 1] = e.size >= 256 ? 0 : e.size; // height
-    header[base + 2] = 0; // palette
-    header[base + 3] = 0; // reserved
-    dv.setUint16(base + 4, 1, true); // planes
-    dv.setUint16(base + 6, 32, true); // bits per pixel
-    dv.setUint32(base + 8, e.png.length, true); // bytes in resource
-    dv.setUint32(base + 12, offset, true); // image offset
-    offset += e.png.length;
+    dir[base] = e.size >= 256 ? 0 : e.size; // width (0 = 256)
+    dir[base + 1] = e.size >= 256 ? 0 : e.size; // height
+    dir.writeUInt16LE(1, base + 4); // planes
+    dir.writeUInt16LE(32, base + 6); // bits per pixel
+    dir.writeUInt32LE(e.data.length, base + 8); // bytes in resource
+    dir.writeUInt32LE(offset, base + 12); // image offset
+    offset += e.data.length;
   });
+  return Buffer.concat([dir, ...entries.map((e) => e.data)]);
+}
 
-  const out = new Uint8Array(offset);
-  out.set(header, 0);
-  let pos = headerSize;
-  for (const e of entries) {
-    out.set(e.png, pos);
-    pos += e.png.length;
+/**
+ * Build one icon entry from a square PNG rendition. Sizes ≥256 are stored as the
+ * raw PNG blob (the Windows convention — a 256×256 DIB is non-standard and is
+ * rejected by Bun/rcedit/the resource compiler); smaller sizes are decoded to a
+ * DIB. Returns undefined if the file isn't the expected square size.
+ */
+function rendition(file: string, size: number): IcoEntry | undefined {
+  try {
+    const buf = readFileSync(file);
+    if (size >= 256) return { size, data: buf, png: true };
+    const { width, height, rgba } = decodePng(buf);
+    if (width !== size || height !== size) return undefined;
+    return { size, data: dibEntry(size, rgba), png: false };
+  } catch (e) {
+    console.warn(`[mirin] icon: skipping ${file} (${e instanceof Error ? e.message : e})`);
+    return undefined;
   }
-  return out;
 }
 
-/** Write `outPath` (an `.ico`) from `iconSrc`, returning it, or undefined if no
- *  usable source was found. */
-export function makeWindowsIcon(iconSrc: string, outPath: string): string | undefined {
+/**
+ * Write `outPath` (an `.ico`) from `iconSrc`, returning it, or undefined if no
+ * usable source was found. With `onlyLargest`, emits a single (largest) entry —
+ * needed for the **exe** icon, since rcedit's multi-size icon replacement fails on
+ * Bun-compiled exes (single-entry works, and Windows downscales 256 cleanly for
+ * small views). The full multi-size form is fine for `icon.ico` (NSIS + WM_SETICON).
+ */
+export function makeWindowsIcon(
+  iconSrc: string,
+  outPath: string,
+  opts?: { onlyLargest?: boolean },
+): string | undefined {
   if (!existsSync(iconSrc)) {
     console.warn(`[mirin] icon not found, skipping: ${iconSrc}`);
     return undefined;
@@ -62,14 +214,33 @@ export function makeWindowsIcon(iconSrc: string, outPath: string): string | unde
     return outPath;
   }
 
-  const entries: IconEntry[] = [];
+  const entries: IcoEntry[] = [];
   if (iconSrc.endsWith(".iconset")) {
-    for (const size of ICO_SIZES) {
+    const sizes = opts?.onlyLargest ? [...ICO_SIZES].reverse() : ICO_SIZES;
+    for (const size of sizes) {
       const png = join(iconSrc, `icon_${size}x${size}.png`);
-      if (existsSync(png)) entries.push({ size, png: readFileSync(png) });
+      if (existsSync(png)) {
+        const e = rendition(png, size);
+        if (e) {
+          entries.push(e);
+          if (opts?.onlyLargest) break;
+        }
+      }
     }
   } else if (iconSrc.endsWith(".png")) {
-    entries.push({ size: 256, png: readFileSync(iconSrc) });
+    try {
+      const buf = readFileSync(iconSrc);
+      const { width, height, rgba } = decodePng(buf);
+      if (width !== height || width > 256) {
+        console.warn(`[mirin] icon png must be square ≤256px (got ${width}×${height})`);
+      } else if (width === 256) {
+        entries.push({ size: 256, data: buf, png: true });
+      } else {
+        entries.push({ size: width, data: dibEntry(width, rgba), png: false });
+      }
+    } catch (e) {
+      console.warn(`[mirin] icon: cannot decode ${iconSrc} (${e instanceof Error ? e.message : e})`);
+    }
   }
 
   if (!entries.length) {

package/src/index.ts

@@ -8,16 +8,53 @@ import { dev } from "./dev.ts";
 import { build } from "./build.ts";
 import { release } from "./release.ts";
 import { scaffold } from "create-mirinjs";
+import type { LinuxPackageFormat } from "mirinjs";
 
-const [command, arg] = Bun.argv.slice(2);
+/** Minimal flag parser: `--k=v`, `--k v`, and boolean `--k`; the rest are positionals. */
+function parseArgs(argv: string[]): { positionals: string[]; opts: Record<string, string | boolean> } {
+  const opts: Record<string, string | boolean> = {};
+  const positionals: string[] = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === undefined) continue;
+    if (a.startsWith("--")) {
+      const eq = a.indexOf("=");
+      if (eq >= 0) {
+        opts[a.slice(2, eq)] = a.slice(eq + 1);
+      } else {
+        const key = a.slice(2);
+        const next = argv[i + 1];
+        if (next !== undefined && !next.startsWith("--")) {
+          opts[key] = next;
+          i++;
+        } else {
+          opts[key] = true;
+        }
+      }
+    } else {
+      positionals.push(a);
+    }
+  }
+  return { positionals, opts };
+}
+
+const [command, ...rest] = Bun.argv.slice(2);
+const { positionals, opts } = parseArgs(rest);
+const arg = positionals[0];
 
 const USAGE = `mirin — build desktop apps with Bun + Chromium
 
 Usage:
   mirin dev          run the app against the Vite dev server (HMR + typed RPC)
-  mirin build        package a standalone, signed .app (output: ./build)
+  mirin build        package a standalone app (output: ./build)
   mirin release      build + emit update artifacts (output: ./build/release)
   mirin init [dir]   scaffold a new app
+
+Options (build):
+  --version <v>              override the app version (else package.json)
+  --linux                    also emit Linux packages (AppImage + .deb + .rpm)
+  --linux-target <a,b,…>     restrict Linux packaging to these formats
+                             (appimage,deb,rpm) — implies --linux
 `;
 
 switch (command) {
@@ -26,7 +63,13 @@ switch (command) {
     break;
   }
   case "build": {
-    await build();
+    const version = typeof opts.version === "string" ? opts.version : undefined;
+    const target = typeof opts["linux-target"] === "string" ? opts["linux-target"] : undefined;
+    const linuxFormats = target
+      ? (target.split(",").map((s) => s.trim()).filter(Boolean) as LinuxPackageFormat[])
+      : undefined;
+    const packageLinux = opts.linux === true || linuxFormats != null;
+    await build(process.cwd(), { version, packageLinux, linuxFormats });
     process.exit(0);
     break;
   }

package/src/installer-inno.ts

@@ -0,0 +1,130 @@
+/**
+ * Windows installer via **Inno Setup** — a modern, clean wizard (the installer VS
+ * Code ships). Generates an `.iss` script from the app folder + config and compiles
+ * it with `iscc`. Like the NSIS path it installs per-user (`%LOCALAPPDATA%\Programs`,
+ * no elevation) or per-machine (Program Files), creates Start Menu + Desktop
+ * shortcuts, and registers an uninstaller / Add-Remove-Programs entry — but with
+ * Inno's `WizardStyle=modern` flat UI instead of NSIS's dated one.
+ *
+ * Requires `iscc` (Inno Setup 6+) on PATH; the caller checks `hasInno()` and falls
+ * back to NSIS / the portable `.zip` when it's absent.
+ */
+
+import { $ } from "bun";
+import { existsSync, rmSync, writeFileSync } from "node:fs";
+import { join, isAbsolute } from "node:path";
+import type { InnoConfig } from "mirinjs";
+import { makeWindowsIcon } from "./icon-win.ts";
+
+export interface BuildInnoInput {
+  appDir: string; // the assembled app folder (build/<App>)
+  appName: string;
+  exeName: string; // <App>.exe
+  version: string;
+  bundleId: string; // reverse-DNS id → AppId / uninstall key
+  outDir: string; // build/release
+  fileName: string; // e.g. stable-win32-x64-Anko-setup.exe
+  options: InnoConfig;
+  projectDir: string;
+}
+
+/** Whether the Inno Setup compiler `iscc` is on PATH. */
+export function hasInno(): boolean {
+  return Bun.which("iscc") != null;
+}
+
+const resolve = (projectDir: string, p: string) => (isAbsolute(p) ? p : join(projectDir, p));
+/** Escape an Inno directive value: `{` is the constant sigil. */
+const v = (s: string) => s.replace(/\{/g, "{{");
+
+/** Build the installer with `iscc`, returning the setup.exe path. */
+export async function buildInnoInstaller(input: BuildInnoInput): Promise<string> {
+  const { appDir, appName, exeName, version, bundleId, outDir, fileName, options, projectDir } = input;
+  const out = join(outDir, fileName);
+  rmSync(out, { force: true });
+  if (!fileName.endsWith(".exe")) throw new Error("inno: fileName must end with .exe");
+  const baseName = fileName.slice(0, -".exe".length);
+
+  const perMachine = options.perMachine === true;
+  const minimal = options.oneClick === true;
+  const desktop = options.desktopShortcut !== false;
+  const startMenu = options.startMenuShortcut !== false;
+  const runAfter = options.runAfterFinish !== false;
+  const changeDir = options.allowChangeInstallDir !== false && !minimal;
+  const publisher = options.publisher ?? appName;
+  const installDir =
+    options.installDir ?? (perMachine ? "{autopf}\\" + appName : "{localappdata}\\Programs\\" + appName);
+
+  // Setup icon: an explicit .ico, else the app's bundled icon.ico.
+  let icon: string | undefined;
+  if (options.installerIcon) {
+    icon = makeWindowsIcon(resolve(projectDir, options.installerIcon), join(outDir, "_inno.ico"));
+  } else if (existsSync(join(appDir, "icon.ico"))) {
+    icon = join(appDir, "icon.ico");
+  }
+  const license = options.license ? resolve(projectDir, options.license) : undefined;
+  if (license && !existsSync(license)) throw new Error(`inno: license not found: ${license}`);
+
+  const L: string[] = [];
+  L.push("[Setup]");
+  L.push(`AppId={{${bundleId}}`);
+  L.push(`AppName=${v(appName)}`);
+  L.push(`AppVersion=${v(version)}`);
+  // Without this, Inno's display name defaults to "<name> version <x>" (shown in
+  // the wizard title + Add/Remove Programs); pin it to the app name.
+  L.push(`AppVerName=${v(appName)}`);
+  L.push(`AppPublisher=${v(publisher)}`);
+  L.push("WizardStyle=modern");
+  L.push(`DefaultDirName=${installDir}`);
+  L.push(`DefaultGroupName=${v(appName)}`);
+  L.push(`PrivilegesRequired=${perMachine ? "admin" : "lowest"}`);
+  L.push(`OutputDir=${outDir}`);
+  L.push(`OutputBaseFilename=${baseName}`);
+  L.push("Compression=lzma2/max");
+  L.push("SolidCompression=yes");
+  L.push("ArchitecturesAllowed=x64compatible");
+  L.push("ArchitecturesInstallIn64BitMode=x64compatible");
+  L.push(`UninstallDisplayIcon={app}\\${exeName}`);
+  if (icon) L.push(`SetupIconFile=${icon}`);
+  if (license) L.push(`LicenseFile=${license}`);
+  if (minimal) {
+    L.push("DisableWelcomePage=yes");
+    L.push("DisableReadyPage=yes");
+  }
+  if (!changeDir) L.push("DisableDirPage=yes");
+  if (!startMenu) L.push("DisableProgramGroupPage=yes");
+  if (options.include) L.push("", "; --- user include ---", options.include, "");
+
+  L.push("", "[Files]");
+  L.push(`Source: "${appDir}\\*"; DestDir: "{app}"; Flags: ignoreversion recursesubdirs createallsubdirs`);
+
+  if (desktop) {
+    L.push("", "[Tasks]");
+    L.push(`Name: "desktopicon"; Description: "Create a desktop shortcut"; GroupDescription: "Additional:"`);
+  }
+
+  L.push("", "[Icons]");
+  if (startMenu) L.push(`Name: "{group}\\${v(appName)}"; Filename: "{app}\\${exeName}"`);
+  if (desktop) {
+    L.push(`Name: "{autodesktop}\\${v(appName)}"; Filename: "{app}\\${exeName}"; Tasks: desktopicon`);
+  }
+
+  if (runAfter) {
+    L.push("", "[Run]");
+    L.push(
+      `Filename: "{app}\\${exeName}"; Description: "Launch ${v(appName)}"; ` +
+        "Flags: nowait postinstall skipifsilent",
+    );
+  }
+
+  const script = join(outDir, "_installer.iss");
+  writeFileSync(script, L.join("\n") + "\n");
+  console.log(`[mirin release] compiling Inno Setup installer → ${fileName}`);
+  const res = await $`iscc /Q ${script}`.nothrow();
+  rmSync(script, { force: true });
+  rmSync(join(outDir, "_inno.ico"), { force: true });
+  if (res.exitCode !== 0 || !existsSync(out)) {
+    throw new Error(`iscc failed (exit ${res.exitCode})`);
+  }
+  return out;
+}