@mirinjs/cli 0.1.0-alpha.2 → 0.1.0-alpha.20

package/src/bundle/linux/app.ts

@@ -0,0 +1,275 @@
+/**
+ * Assemble a Linux app folder for a mirin app. Like Windows, Linux has no `.app`
+ * bundle — just a flat directory the dynamic loader can resolve libcef.so + the
+ * CEF runtime from, next to the host binary:
+ *
+ *   <App>/
+ *     <App>                    compiled Bun host (process.execPath)
+ *     libmirin_core.so         loaded by the host via bun:ffi
+ *     mirin-helper             CEF subprocess (browser_subprocess_path)
+ *     libcef.so, libEGL.so, libGLESv2.so, *.pak, icudtl.dat,
+ *     v8_context_snapshot.bin, locales/, chrome-sandbox, …  (CEF runtime)
+ *     resources/               (production only — dev serves from the Vite URL)
+ *       ui/, worker.js, mirin.manifest.json, version.json, sidecars/, workers/
+ *
+ * Wayland-only (docs/linux-port.md); the CEF subprocess name (`mirin-helper`) and
+ * the `resources/` layout match what mirin-core derives at runtime
+ * (engine::derive_subprocess_path, host.ts). libcef.so is resolved via
+ * LD_LIBRARY_PATH set on the host (dev.ts) or an rpath at build time.
+ */
+
+import {
+  chmodSync,
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { basename, extname, join } from "node:path";
+import { copyFlatCefLocales } from "../shared/cef-locales.ts";
+
+/** Source dir (vendor/cef on Linux) must contain libcef.so. */
+const CEF_MARKER = "libcef.so";
+
+/** CEF runtime files copied next to the host binary. Everything else in the Linux
+ *  distribution (include/, cmake/, CMakeLists.txt, archive.json, libcef_dll/) is
+ *  build-time only and intentionally left out. `.so` covers libcef/libEGL/
+ *  libGLESv2/libvk_swiftshader; the extras list catches the non-extension names. */
+const CEF_RUNTIME_EXTS = new Set([".so", ".bin", ".pak", ".dat"]);
+const CEF_RUNTIME_EXTRAS = ["vk_swiftshader_icd.json", "libvulkan.so.1", "chrome-sandbox"];
+
+export interface LinuxBundleOptions {
+  appName: string; // also the host binary stem → <appName>
+  outDir: string;
+  hostExe: string; // compiled Bun host (no extension)
+  coreDll: string; // libmirin_core.so
+  helperExe: string; // mirin-helper
+  cefPath: string; // dir containing the Linux CEF runtime (vendor/cef)
+  /** Production CEF locale allowlist. Undefined keeps every locale. */
+  cefLocales?: string[];
+  /** App icon source (.png / .iconset); resolved to a PNG at resources/icon.png for
+   *  the window's `_NET_WM_ICON` (taskbar/dock). */
+  icon?: string;
+  /** Production-only resources placed under <App>/resources. */
+  resources?: {
+    uiDir?: string; // Vite dist/ → resources/ui (served via app://ui)
+    workerJs?: string; // bundled main-process Worker → resources/worker.js
+    manifestJson?: string; // serialized manifest → resources/mirin.manifest.json
+    versionJson?: string; // serialized version.json → resources/version.json (updater)
+    sidecars?: { name: string; src: string }[]; // → resources/sidecars/<name>
+    workers?: Record<string, string>; // name → abs path → resources/workers/<name>.js
+  };
+}
+
+/**
+ * Resolve the app config's `icon` to a concrete square PNG usable on Linux (for
+ * the window's `_NET_WM_ICON`). Accepts a `.png` (used as-is) or a `.iconset`
+ * directory (pick a good mid/large size). Returns undefined for `.icns` (which the
+ * Linux core can't decode) or a missing/empty source.
+ *
+ * @param icon absolute path to the icon source (`config.icon` joined with the project root).
+ */
+export function resolveLinuxIconPng(icon: string): string | undefined {
+  if (!existsSync(icon)) return undefined;
+  if (statSync(icon).isDirectory()) {
+    const pngs = readdirSync(icon).filter((f) => extname(f).toLowerCase() === ".png");
+    if (!pngs.length) return undefined;
+    // Prefer 128×128: crisp in the dock, and small enough that its `_NET_WM_ICON`
+    // (a 128²+2 CARDINAL array ≈ 64 KB) stays under X11's ~256 KB max request size —
+    // a 256×256 icon (≈ 256 KB) can exceed it and get dropped. Fall back to the
+    // largest available under that ceiling (by pixels parsed from the iconset name).
+    const preferred = ["icon_128x128.png", "icon_64x64.png", "icon_256x256.png"];
+    const MaxSide = 128;
+    const pick =
+      preferred.find((p) => pngs.includes(p)) ??
+      pngs
+        .slice()
+        .sort((a, b) => iconsetPixels(b) - iconsetPixels(a))
+        .find((p) => iconsetPixels(p) <= MaxSide * MaxSide) ??
+      pngs.sort((a, b) => iconsetPixels(a) - iconsetPixels(b))[0];
+    return pick ? join(icon, pick) : undefined;
+  }
+  return extname(icon).toLowerCase() === ".png" ? icon : undefined;
+}
+
+/**
+ * Resolve the app config's `icon` to the *largest* concrete PNG (for a `.desktop`
+ * `Icon=`, which is a file path with no X11 request-size limit — so we want it
+ * crisp, unlike the window `_NET_WM_ICON`). `.png` used as-is; `.iconset` → biggest
+ * PNG inside. Undefined for `.icns` or a missing source.
+ */
+export function resolveLinuxDesktopIconPng(icon: string): string | undefined {
+  if (!existsSync(icon)) return undefined;
+  if (statSync(icon).isDirectory()) {
+    const pngs = readdirSync(icon).filter((f) => extname(f).toLowerCase() === ".png");
+    if (!pngs.length) return undefined;
+    const biggest = pngs.sort((a, b) => iconsetPixels(b) - iconsetPixels(a))[0];
+    return biggest ? join(icon, biggest) : undefined;
+  }
+  return extname(icon).toLowerCase() === ".png" ? icon : undefined;
+}
+
+/**
+ * A freedesktop `.desktop` entry body for a mirin app. cosmic's dock resolves an
+ * X11 window's icon by matching its `WM_CLASS` (which the core sets to the app id)
+ * against a desktop entry's `StartupWMClass`, then uses that entry's `Icon` — the
+ * reliable path on cosmic (its `_NET_WM_ICON` fallback is unreliable). `wmClass`
+ * MUST equal the core's `res_class` (the bundle id).
+ */
+export function desktopEntry(opts: {
+  name: string;
+  exec: string;
+  iconPng: string;
+  wmClass: string;
+  /** Freedesktop main category (e.g. "Utility", "Development"). A trailing `;` is
+   *  added if missing (the spec requires list values to end with one). Omitted → no
+   *  Categories line. Used by the .deb/.rpm/AppImage entries (dev needs none). */
+  categories?: string;
+  /** Optional Comment= (tooltip / description) line. */
+  comment?: string;
+}): string {
+  const lines = ["[Desktop Entry]", "Type=Application", `Name=${desktopValue("Name", opts.name)}`];
+  if (opts.comment) lines.push(`Comment=${desktopValue("Comment", opts.comment)}`);
+  lines.push(
+    `Exec=${desktopExec(opts.exec)}`,
+    `Icon=${desktopValue("Icon", opts.iconPng)}`,
+    `StartupWMClass=${desktopValue("StartupWMClass", opts.wmClass)}`,
+    "Terminal=false",
+  );
+  if (opts.categories) {
+    lines.push(`Categories=${desktopCategories(opts.categories)}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+
+function desktopValue(field: string, value: string): string {
+  assertDesktopScalar(field, value);
+  return value.replace(/\\/g, "\\\\").replace(/\t/g, "\\t");
+}
+
+function desktopExec(value: string): string {
+  assertDesktopScalar("Exec", value);
+  if (/^[A-Za-z0-9._/+:-]+$/.test(value)) return value;
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+
+function desktopCategories(value: string): string {
+  const normalized = value.endsWith(";") ? value : `${value};`;
+  assertDesktopScalar("Categories", normalized);
+  if (!/^[A-Za-z0-9][A-Za-z0-9-]*(;[A-Za-z0-9][A-Za-z0-9-]*)*;$/.test(normalized)) {
+    throw new Error(
+      `[mirin] invalid Linux desktop category "${value}" — use freedesktop category names separated by semicolons.`,
+    );
+  }
+  return normalized;
+}
+
+function assertDesktopScalar(field: string, value: string): void {
+  if (value.length === 0 || /[\0\r\n]/.test(value)) {
+    throw new Error(`[mirin] invalid Linux desktop ${field} value.`);
+  }
+}
+
+/** Effective pixel count encoded in an iconset filename (`icon_256x256@2x.png` → 512²). */
+function iconsetPixels(name: string): number {
+  const m = basename(name).match(/(\d+)x(\d+)(@(\d+)x)?/);
+  if (!m) return 0;
+  const scale = m[4] ? Number(m[4]) : 1;
+  return Number(m[1]) * Number(m[2]) * scale * scale;
+}
+
+/** Build the Linux app folder and return its path + the host binary to launch. */
+export async function buildLinuxBundle(
+  opts: LinuxBundleOptions,
+): Promise<{ app: string; exe: string }> {
+  const { appName, cefPath } = opts;
+  if (!existsSync(join(cefPath, CEF_MARKER))) {
+    throw new Error(`CEF runtime not found at ${cefPath} — run: bun scripts/fetch-cef.ts`);
+  }
+
+  const app = join(opts.outDir, appName);
+  rmSync(app, { recursive: true, force: true });
+  mkdirSync(app, { recursive: true });
+
+  const exe = join(app, appName);
+  cpSync(opts.hostExe, exe);
+  chmodSync(exe, 0o755);
+  cpSync(opts.coreDll, join(app, "libmirin_core.so"));
+  const helper = join(app, "mirin-helper");
+  cpSync(opts.helperExe, helper);
+  chmodSync(helper, 0o755);
+
+  copyCefRuntime(cefPath, app, opts.cefLocales);
+
+  // The window taskbar/dock icon (`_NET_WM_ICON`) is set by the core from a PNG at
+  // `resources/icon.png`; host.ts points the init config's `icon_path` there in prod.
+  // (Dev serves it directly from the project via MIRIN_CONFIG_JSON, not the bundle.)
+  const iconPng = opts.icon ? resolveLinuxIconPng(opts.icon) : undefined;
+  if (iconPng) {
+    const res = join(app, "resources");
+    mkdirSync(res, { recursive: true });
+    cpSync(iconPng, join(res, "icon.png"));
+  }
+
+  // Production resources (dev passes none — paths come from env + the Vite URL).
+  if (opts.resources) {
+    const res = join(app, "resources");
+    mkdirSync(res, { recursive: true });
+    if (opts.resources.uiDir) cpSync(opts.resources.uiDir, join(res, "ui"), { recursive: true });
+    if (opts.resources.workerJs) cpSync(opts.resources.workerJs, join(res, "worker.js"));
+    if (opts.resources.manifestJson != null) {
+      writeFileSync(join(res, "mirin.manifest.json"), opts.resources.manifestJson);
+    }
+    if (opts.resources.versionJson != null) {
+      writeFileSync(join(res, "version.json"), opts.resources.versionJson);
+    }
+    if (opts.resources.workers && Object.keys(opts.resources.workers).length) {
+      const workersDir = join(res, "workers");
+      mkdirSync(workersDir, { recursive: true });
+      for (const [name, src] of Object.entries(opts.resources.workers)) {
+        cpSync(src, join(workersDir, `${name}.js`));
+      }
+    }
+    if (opts.resources.sidecars?.length) {
+      const sidecarsDir = join(res, "sidecars");
+      mkdirSync(sidecarsDir, { recursive: true });
+      for (const sc of opts.resources.sidecars) {
+        if (!existsSync(sc.src)) throw new Error(`sidecar "${sc.name}" not found: ${sc.src}`);
+        const dst = join(sidecarsDir, sc.name);
+        cpSync(sc.src, dst);
+        chmodSync(dst, 0o755);
+      }
+    }
+  }
+
+  return { app, exe };
+}
+
+/** Copy the CEF runtime (shared libs, paks, snapshot, icu data, locales) into `dest`. */
+function copyCefRuntime(cefPath: string, dest: string, locales: string[] | undefined): void {
+  for (const entry of readdirSync(cefPath)) {
+    if (CEF_RUNTIME_EXTS.has(extname(entry).toLowerCase())) {
+      cpSync(join(cefPath, entry), join(dest, entry));
+    }
+  }
+  for (const extra of CEF_RUNTIME_EXTRAS) {
+    const src = join(cefPath, extra);
+    if (existsSync(src)) cpSync(src, join(dest, extra), { recursive: true });
+  }
+  copyFlatCefLocales(join(cefPath, "locales"), join(dest, "locales"), locales);
+  // chrome-sandbox works setuid-root (mode 4755) or, on kernels with unprivileged
+  // user namespaces, via the namespace sandbox with no special perms. We can't
+  // setuid without root here; leave it executable and let CEF pick the userns path.
+  const sandbox = join(dest, "chrome-sandbox");
+  if (existsSync(sandbox)) {
+    try {
+      require("node:fs").chmodSync(sandbox, 0o755);
+    } catch {
+      /* best-effort */
+    }
+  }
+}

package/src/bundle/linux/index.ts

@@ -0,0 +1 @@
+export * from "./app.ts";

package/src/{bundle.ts → bundle/macos/app.ts}

@@ -11,9 +11,19 @@
  * "<exe> Helper (Renderer).app/Contents/MacOS/<exe> Helper (Renderer)".
  */
 
-import { $ } from "bun";
-import { cpSync, mkdirSync, rmSync, writeFileSync, existsSync, readdirSync, chmodSync } from "node:fs";
+import {
+  chmodSync,
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
 import { join } from "node:path";
+import { $ } from "bun";
+import { isIconComposerDoc, writeAppearanceCatalog } from "../../icons/macos/index.ts";
+import { pruneMacCefLocales } from "../shared/cef-locales.ts";
 
 const FRAMEWORK = "Chromium Embedded Framework.framework";
 
@@ -33,9 +43,14 @@ export interface BundleOptions {
   coreDylib: string; // libmirin_core.dylib
   helperBin: string; // compiled mirin-helper binary
   cefPath: string; // dir containing the CEF framework (vendor/cef)
+  /** Production CEF locale allowlist. Undefined keeps every locale. */
+  cefLocales?: string[];
   /** App version → Info.plist CFBundleShortVersionString/CFBundleVersion. */
   version?: string;
-  /** App icon source: a .icns, a .iconset dir, or a square .png. Optional. */
+  /**
+   * App icon source: a .icns, a .iconset dir, a square .png, or an Icon Composer
+   * .icon document (the only form carrying appearance variants). Optional.
+   */
   icon?: string;
   /** Codesign identity; "-" (default) is ad-hoc. Set to a Developer ID to ship. */
   signIdentity?: string;
@@ -98,19 +113,8 @@ const ICONSET_RENDITIONS = [
   { name: "icon_512x512@2x.png", px: 1024 },
 ];
 
-/**
- * Render the app icon to `Resources/icon.icns` and return the CFBundleIconFile
- * stem ("icon"), or undefined if there's no usable source. Accepts a `.icns`
- * (copied), a `.iconset` directory (iconutil), or a square `.png` (rendered to
- * a full iconset via sips, then iconutil).
- */
-async function writeIcon(iconSrc: string, resources: string): Promise<string | undefined> {
-  if (!existsSync(iconSrc)) {
-    console.warn(`[mirin] icon not found, skipping: ${iconSrc}`);
-    return undefined;
-  }
-  const icns = join(resources, "icon.icns");
-
+/** Render one icon source to `Resources/icon.icns`. */
+async function writeIcns(iconSrc: string, icns: string, resources: string): Promise<void> {
   if (iconSrc.endsWith(".icns")) {
     cpSync(iconSrc, icns);
   } else if (iconSrc.endsWith(".iconset")) {
@@ -125,7 +129,38 @@ async function writeIcon(iconSrc: string, resources: string): Promise<string | u
     await $`iconutil -c icns ${iconset} -o ${icns}`.quiet();
     rmSync(iconset, { recursive: true, force: true });
   }
-  return "icon";
+}
+
+/** The Info.plist keys an icon contributes, empty when there's no usable source. */
+interface IconKeys {
+  /** CFBundleIconFile — `Resources/icon.icns`, read by macOS 25 and earlier. */
+  iconFile?: string;
+  /** CFBundleIconName — `Resources/Assets.car`, preferred on macOS 26+. */
+  iconName?: string;
+}
+
+/**
+ * Render the app icon into Resources. An `.icon` document compiles to an
+ * `Assets.car` (macOS 26+ light/dark/tinted) and contributes the `.icns` actool
+ * derives from it; every other source takes the plain iconutil path.
+ */
+async function writeIcon(iconSrc: string, resources: string, work: string): Promise<IconKeys> {
+  if (!existsSync(iconSrc)) {
+    console.warn(`[mirin] icon not found, skipping: ${iconSrc}`);
+    return {};
+  }
+
+  const icns = join(resources, "icon.icns");
+  if (isIconComposerDoc(iconSrc)) {
+    // An Icon Composer document can't go through iconutil, so the only .icns
+    // available for it is the one actool derives.
+    const catalog = await writeAppearanceCatalog(iconSrc, resources, work);
+    if (catalog?.icns) cpSync(catalog.icns, icns);
+    return { iconFile: existsSync(icns) ? "icon" : undefined, iconName: catalog?.name };
+  }
+
+  await writeIcns(iconSrc, icns, resources);
+  return { iconFile: "icon" };
 }
 
 type PlistValue = string | boolean | PlistValue[] | { [k: string]: PlistValue };
@@ -177,8 +212,12 @@ export async function buildAppBundle(opts: BundleOptions): Promise<{ app: string
   cpSync(opts.coreDylib, join(macos, "libmirin_core.dylib"));
 
   // Render the icon (if any) into Resources before writing the plist, so we
-  // only set CFBundleIconFile when an icon was actually produced.
-  const iconFile = opts.icon ? await writeIcon(opts.icon, join(contents, "Resources")) : undefined;
+  // only set the icon keys when an icon was actually produced.
+  const iconWork = join(opts.outDir, ".mirin-icon");
+  const { iconFile, iconName } = opts.icon
+    ? await writeIcon(opts.icon, join(contents, "Resources"), iconWork)
+    : ({} as IconKeys);
+  rmSync(iconWork, { recursive: true, force: true });
   const version = opts.version ?? "0.0.1";
 
   const info: Record<string, PlistValue> = {
@@ -198,20 +237,23 @@ export async function buildAppBundle(opts: BundleOptions): Promise<{ app: string
     LSEnvironment: { MallocNanoZone: "0" },
   };
   if (iconFile) info.CFBundleIconFile = iconFile;
+  // macOS 26+ resolves the appearance-aware icon out of Assets.car via this key
+  // and falls back to CFBundleIconFile when the catalog has no match.
+  if (iconName) info.CFBundleIconName = iconName;
   // Deep-link schemes: register this app as the macOS handler for app://-style
   // URLs (e.g. anko://…). Delivered at runtime via app.on("open-url").
   if (opts.urlSchemes?.length) {
-    info.CFBundleURLTypes = [
-      { CFBundleURLName: bundleId, CFBundleURLSchemes: opts.urlSchemes },
-    ];
+    info.CFBundleURLTypes = [{ CFBundleURLName: bundleId, CFBundleURLSchemes: opts.urlSchemes }];
   }
 
   writeFileSync(join(contents, "Info.plist"), plist(info));
 
-  cpSync(join(cefPath, FRAMEWORK), join(frameworks, FRAMEWORK), {
+  const bundledFramework = join(frameworks, FRAMEWORK);
+  cpSync(join(cefPath, FRAMEWORK), bundledFramework, {
     recursive: true,
     verbatimSymlinks: true,
   });
+  pruneMacCefLocales(bundledFramework, opts.cefLocales);
 
   // Production resources: the served UI, the Worker bundle, and the manifest.
   const resources = join(contents, "Resources");

package/src/bundle/macos/index.ts

@@ -0,0 +1 @@
+export * from "./app.ts";

package/src/bundle/shared/cef-locales.ts

@@ -0,0 +1,91 @@
+import { cpSync, mkdirSync, readdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+
+const CEF_LOCALE = /^[A-Za-z]{2,3}(?:[-_][A-Za-z0-9]{2,8})*$/;
+const MAC_VARIANTS = new Set(["FEMININE", "MASCULINE", "NEUTER"]);
+
+/** Validate and normalize an optional CEF locale allowlist. */
+export function normalizeCefLocales(locales: unknown): string[] | undefined {
+  if (locales == null) return undefined;
+  if (!Array.isArray(locales) || locales.length === 0) {
+    throw new Error("[mirin] cef.locales must contain at least one locale.");
+  }
+
+  const seen = new Set<string>();
+  const normalized: string[] = [];
+  for (const value of locales) {
+    if (typeof value !== "string" || !CEF_LOCALE.test(value)) {
+      throw new Error(`[mirin] invalid CEF locale ${JSON.stringify(value)}.`);
+    }
+    const locale = value.replaceAll("_", "-");
+    const key = locale.toLowerCase();
+    if (!seen.has(key)) {
+      seen.add(key);
+      normalized.push(locale);
+    }
+  }
+  return normalized;
+}
+
+/** Copy selected Windows/Linux `locales/<locale>.pak` files, or every locale when unset. */
+export function copyFlatCefLocales(
+  source: string,
+  destination: string,
+  locales: string[] | undefined,
+): void {
+  if (!locales) {
+    cpSync(source, destination, { recursive: true });
+    return;
+  }
+
+  const entries = readdirSync(source, { withFileTypes: true }).filter(
+    (entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".pak"),
+  );
+  const byLocale = new Map(
+    entries.map((entry) => [localeKey(entry.name.slice(0, -".pak".length)), entry.name]),
+  );
+
+  mkdirSync(destination, { recursive: true });
+  for (const locale of locales) {
+    const file = byLocale.get(localeKey(locale));
+    if (!file) throw new Error(`[mirin] CEF locale "${locale}" is not available in ${source}.`);
+    cpSync(join(source, file), join(destination, file));
+  }
+}
+
+/** Remove unselected macOS `.lproj` locale directories from a copied CEF framework. */
+export function pruneMacCefLocales(framework: string, locales: string[] | undefined): void {
+  if (!locales) return;
+
+  const resources = join(framework, "Resources");
+  const localeDirs = readdirSync(resources, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && entry.name.endsWith(".lproj"))
+    .map((entry) => entry.name);
+  const available = new Set(localeDirs.map((name) => name.slice(0, -".lproj".length)));
+  const keep = new Set<string>();
+
+  for (const locale of locales) {
+    const requested = locale.replaceAll("-", "_");
+    const language = requested.split("_", 1)[0] ?? requested;
+    const root = available.has(requested)
+      ? requested
+      : available.has(language)
+        ? language
+        : undefined;
+    if (!root) throw new Error(`[mirin] CEF locale "${locale}" is not available in ${resources}.`);
+
+    keep.add(`${root}.lproj`);
+    for (const variant of MAC_VARIANTS) {
+      const name = `${root}_${variant}.lproj`;
+      if (localeDirs.includes(name)) keep.add(name);
+    }
+  }
+
+  for (const directory of localeDirs) {
+    if (!keep.has(directory)) rmSync(join(resources, directory), { recursive: true, force: true });
+  }
+}
+
+function localeKey(locale: string): string {
+  return locale.replaceAll("_", "-").toLowerCase();
+}

package/src/{bundle-win.ts → bundle/windows/app.ts}

@@ -15,9 +15,10 @@
  * what mirin-core derives at runtime (engine::derive_subprocess_path, host.ts).
  */
 
-import { cpSync, mkdirSync, rmSync, writeFileSync, existsSync, readdirSync } from "node:fs";
-import { join, extname } from "node:path";
-import { makeWindowsIcon } from "./icon-win.ts";
+import { cpSync, existsSync, mkdirSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { extname, join } from "node:path";
+import { makeWindowsIcon } from "../../icons/windows/index.ts";
+import { copyFlatCefLocales } from "../shared/cef-locales.ts";
 
 /** Source dir (vendor/cef on Windows) must contain libcef.dll. */
 const CEF_MARKER = "libcef.dll";
@@ -26,7 +27,7 @@ const CEF_MARKER = "libcef.dll";
  *  distribution (libcef.lib, include/, cmake/, archive.json, bootstrap*.exe) is
  *  build-time only and intentionally left out. */
 const CEF_RUNTIME_EXTS = new Set([".dll", ".bin", ".pak", ".dat"]);
-const CEF_RUNTIME_EXTRAS = ["vk_swiftshader_icd.json", "locales"];
+const CEF_RUNTIME_EXTRAS = ["vk_swiftshader_icd.json"];
 
 export interface WinBundleOptions {
   appName: string; // also the host exe stem → <appName>.exe
@@ -35,6 +36,8 @@ export interface WinBundleOptions {
   coreDll: string; // mirin_core.dll
   helperExe: string; // mirin-helper.exe
   cefPath: string; // dir containing the Windows CEF runtime (vendor/cef)
+  /** Production CEF locale allowlist. Undefined keeps every locale. */
+  cefLocales?: string[];
   /** App icon source (.ico / .iconset / .png) → <App>/icon.ico, set as the window icon. */
   icon?: string;
   /** Production-only resources placed under <App>/resources. */
@@ -66,7 +69,7 @@ export async function buildWindowsBundle(
   cpSync(opts.coreDll, join(app, "mirin_core.dll"));
   cpSync(opts.helperExe, join(app, "mirin-helper.exe"));
 
-  copyCefRuntime(cefPath, app);
+  copyCefRuntime(cefPath, app, opts.cefLocales);
 
   // App icon → <App>/icon.ico, loaded at runtime by the core and set as the window
   // icon (taskbar / Alt-Tab / title). Sits beside the exe so the core finds it.
@@ -105,7 +108,7 @@ export async function buildWindowsBundle(
 }
 
 /** Copy the CEF runtime (dlls, paks, snapshot, icu data, locales) into `dest`. */
-function copyCefRuntime(cefPath: string, dest: string): void {
+function copyCefRuntime(cefPath: string, dest: string, locales: string[] | undefined): void {
   for (const entry of readdirSync(cefPath)) {
     if (CEF_RUNTIME_EXTS.has(extname(entry).toLowerCase())) {
       cpSync(join(cefPath, entry), join(dest, entry));
@@ -115,4 +118,5 @@ function copyCefRuntime(cefPath: string, dest: string): void {
     const src = join(cefPath, extra);
     if (existsSync(src)) cpSync(src, join(dest, extra), { recursive: true });
   }
+  copyFlatCefLocales(join(cefPath, "locales"), join(dest, "locales"), locales);
 }

package/src/bundle/windows/index.ts

@@ -0,0 +1 @@
+export * from "./app.ts";