code2app 0.1.45 → 0.1.47

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code2app",
-  "version": "0.1.45",
+  "version": "0.1.47",
   "description": "Tauri scaffold that packages a website or a bundled CLI as a native desktop + mobile app, configured from a single JSON profile",
   "type": "module",
   "author": "vtempest",

package/test/cli.test.mjs

@@ -0,0 +1,159 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+/**
+ * `bin/cli.js` runs on import, reading `process.argv`. Only the subcommands that
+ * write somewhere other than the package itself are exercised in-process: `init`
+ * scaffolds into a temp directory, while `configure` and `icons` would rewrite
+ * this package's own tracked `src-tauri/` files.
+ */
+let tmp;
+let out;
+let errs;
+let exits;
+let origArgv;
+let origCwd;
+
+class Exit extends Error {}
+
+async function cli(...args) {
+  vi.resetModules();
+  process.argv = ["node", "cli.js", ...args];
+  await import("../bin/cli.js");
+}
+
+const read = (...p) => fs.readFileSync(path.join(tmp, ...p), "utf8");
+
+beforeEach(() => {
+  tmp = fs.mkdtempSync(path.join(os.tmpdir(), "naw-cli-"));
+  out = [];
+  errs = [];
+  exits = [];
+  origArgv = process.argv;
+  origCwd = process.cwd();
+  process.chdir(tmp);
+  vi.spyOn(console, "log").mockImplementation((...a) => void out.push(a.join(" ")));
+  vi.spyOn(console, "error").mockImplementation((...a) => void errs.push(a.join(" ")));
+  vi.spyOn(process, "exit").mockImplementation((code) => {
+    exits.push(code);
+    throw new Exit(`exit ${code}`);
+  });
+});
+
+afterEach(() => {
+  process.chdir(origCwd);
+  process.argv = origArgv;
+  vi.restoreAllMocks();
+  fs.rmSync(tmp, { recursive: true, force: true });
+});
+
+describe("help", () => {
+  it("prints usage and exits 0 with no command", async () => {
+    await cli().catch(() => {});
+    expect(out.join("\n")).toContain("init <dir>");
+    expect(out.join("\n")).toContain("configure [--profile <name>]");
+    expect(out.join("\n")).toContain("icons [--profile <name>]");
+    expect(exits[0]).toBe(0);
+  });
+
+  it("prints usage and exits 1 for an unknown command", async () => {
+    await cli("bogus").catch(() => {});
+    expect(out.join("\n")).toContain("native-app-wrapper");
+    expect(exits[0]).toBe(1);
+  });
+});
+
+describe("init", () => {
+  it("requires a target directory", async () => {
+    await cli("init").catch(() => {});
+    expect(errs.join("\n")).toContain("init needs a target directory");
+    expect(exits[0]).toBe(1);
+  });
+
+  it("rejects an unknown profile name", async () => {
+    await cli("init", "app", "--profile", "nope").catch(() => {});
+    expect(errs.join("\n")).toContain('no profile named "nope"');
+    expect(exits[0]).toBe(1);
+  });
+
+  it("rejects a flag with no value", async () => {
+    await cli("init", "app", "--profile").catch(() => {});
+    expect(errs.join("\n")).toContain("--profile needs a value");
+  });
+
+  it("refuses a non-empty target without --force", async () => {
+    fs.mkdirSync("busy");
+    fs.writeFileSync(path.join("busy", "keep.txt"), "x");
+    await cli("init", "busy").catch(() => {});
+    expect(errs.join("\n")).toContain("already exists and is not empty");
+    expect(exits[0]).toBe(1);
+  });
+
+  it("scaffolds a standalone wrapper from the example profile", { timeout: 120_000 }, async () => {
+    await cli("init", "myapp");
+
+    expect(exits).toEqual([]);
+    const pkg = JSON.parse(read("myapp", "package.json"));
+    expect(pkg.name).toBe("example-app-native");
+    expect(pkg.private).toBe(true);
+    expect(pkg.version).toBe("0.1.0");
+    expect(pkg.bin).toBeUndefined();
+    expect(pkg.scripts.init).toBeUndefined();
+    expect(pkg.scripts["android:dev"]).toBeDefined(); // example profile enables mobile
+
+    const conf = JSON.parse(read("myapp", "src-tauri", "tauri.conf.json"));
+    expect(conf.productName).toBe("Example App");
+    expect(read("myapp", "src-tauri", "Cargo.toml")).toContain('name = "example-app-native"');
+    expect(read("myapp", "src-tauri", "Cargo.toml")).toContain('name = "example_app_native_lib"');
+    expect(read("myapp", "src-tauri", "src", "main.rs")).toContain("example_app_native_lib::run()");
+
+    expect(fs.existsSync(path.join(tmp, "myapp", "profiles", "example.json"))).toBe(true);
+    expect(fs.existsSync(path.join(tmp, "myapp", "bin", "cli.js"))).toBe(true);
+    expect(fs.existsSync(path.join(tmp, "myapp", "src-tauri", "icons", "icon.ico"))).toBe(true);
+    expect(fs.existsSync(path.join(tmp, "myapp", "docs", "BUILDING.md"))).toBe(true);
+    expect(fs.existsSync(path.join(tmp, "myapp", "docs", "MOBILE.md"))).toBe(true);
+    expect(fs.existsSync(path.join(tmp, "myapp", "docs", "OAUTH.md"))).toBe(true);
+
+    const log = out.join("\n");
+    expect(log).toContain("scaffolded Example App into myapp/");
+    expect(log).toContain("wrote src-tauri/tauri.conf.json");
+    expect(log).toContain("Next: cd myapp && npm install && npm run dev");
+  });
+
+  it("scaffolds from a custom --profile-file (local mode with a sidecar, no mobile)", { timeout: 120_000 }, async () => {
+    fs.writeFileSync(
+      "tool.json",
+      JSON.stringify({
+        appName: "Local Tool",
+        identifier: "com.local.tool",
+        version: "3.1.4",
+        mode: "local",
+        sidecar: { name: "tool", build: "make {out}" },
+        placeholderIcon: { accent: "#ff0000" },
+      }),
+    );
+    fs.mkdirSync("dest");
+
+    await cli("init", "dest", "--profile-file", "tool.json", "--force");
+
+    const pkg = JSON.parse(read("dest", "package.json"));
+    expect(pkg.name).toBe("local-tool-native");
+    expect(pkg.version).toBe("3.1.4");
+    expect(pkg.scripts["build:sidecar"]).toBe("node scripts/build-sidecar.mjs");
+    expect(pkg.scripts.predev).toContain("build-sidecar");
+    expect(Object.keys(pkg.scripts).some((k) => /^(pre)?(android|ios):/.test(k))).toBe(false);
+    expect(fs.existsSync(path.join(tmp, "dest", "docs", "LOCAL_APPS.md"))).toBe(true);
+    expect(fs.existsSync(path.join(tmp, "dest", "docs", "MOBILE.md"))).toBe(false);
+    expect(fs.existsSync(path.join(tmp, "dest", "docs", "OAUTH.md"))).toBe(false);
+    expect(fs.existsSync(path.join(tmp, "dest", "profiles", "tool.json"))).toBe(true);
+    expect(read("dest", "src-tauri", "src", "generated_config.rs")).toContain('SIDECAR_NAME: &str = "tool"');
+  });
+
+  it("allows an existing empty target directory", { timeout: 120_000 }, async () => {
+    fs.mkdirSync("empty");
+    await cli("init", "empty");
+    expect(fs.existsSync(path.join(tmp, "empty", "package.json"))).toBe(true);
+  });
+});

package/test/configure.test.mjs

@@ -0,0 +1,163 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { configure } from "../scripts/configure.mjs";
+
+let root;
+
+const profile = (name, data) => {
+  fs.mkdirSync(path.join(root, "profiles"), { recursive: true });
+  fs.writeFileSync(path.join(root, "profiles", `${name}.json`), JSON.stringify(data));
+};
+const read = (rel) => fs.readFileSync(path.join(root, rel), "utf8");
+const conf = () => JSON.parse(read("src-tauri/tauri.conf.json"));
+
+const remote = {
+  appName: "Remote App",
+  identifier: "com.remote.app",
+  version: "2.0.0",
+  url: "https://remote.example",
+};
+
+beforeEach(() => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), "naw-configure-"));
+});
+
+afterEach(() => {
+  fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe("configure — remote profile", () => {
+  it("writes tauri.conf.json pointing the window at the url", () => {
+    profile("r", remote);
+    const { profile: p, written } = configure(root, "r");
+
+    expect(p.name).toBe("r");
+    expect(written).toEqual(["src-tauri/tauri.conf.json", "src-tauri/src/generated_config.rs"]);
+    const c = conf();
+    expect(c).toMatchObject({
+      productName: "Remote App",
+      version: "2.0.0",
+      identifier: "com.remote.app",
+      build: { frontendDist: "../dist" },
+    });
+    expect(c.app.windows[0]).toMatchObject({ label: "main", url: "https://remote.example", center: true });
+    expect(c.app.security.capabilities).toEqual(["default"]);
+    expect(c.bundle).toMatchObject({
+      publisher: "Remote App",
+      copyright: "",
+      category: "Productivity",
+      shortDescription: "",
+      longDescription: "",
+    });
+    expect(c.bundle.macOS.minimumSystemVersion).toBe("10.15");
+    expect(c.bundle.icon).toHaveLength(5);
+    expect(c.bundle.externalBin).toBeUndefined();
+    expect(c.plugins).toEqual({});
+  });
+
+  it("generates the Rust constants", () => {
+    profile("r", { ...remote, deepLinkScheme: "remoteapp" });
+    configure(root, "r");
+    const rs = read("src-tauri/src/generated_config.rs");
+    expect(rs).toContain('pub const DEEP_LINK_SCHEME: &str = "remoteapp";');
+    expect(rs).toContain('pub const APP_URL: &str = "https://remote.example";');
+    expect(rs).toContain('pub const SIDECAR_NAME: &str = "";');
+    expect(rs).toContain("pub const SIDECAR_ARGS: &[&str] = &[];");
+    expect(rs).toContain("pub const UPDATER_ENABLED: bool = false;");
+    expect(rs).toContain("profiles/r.json");
+  });
+
+  it("includes updater, deep-link, android and ios settings when configured", () => {
+    profile("full", {
+      ...remote,
+      publisher: "Pub",
+      copyright: "© Me",
+      category: "Utilities",
+      shortDescription: "short",
+      longDescription: "long",
+      macos: { minimumSystemVersion: "12.0" },
+      updater: { pubkey: "PK", endpoints: ["https://u.example/latest.json"] },
+      deepLinkScheme: "fullapp",
+      android: { minSdkVersion: 26 },
+      ios: { minimumSystemVersion: "16.0" },
+    });
+    configure(root, "full");
+    const c = conf();
+    expect(c.bundle).toMatchObject({
+      publisher: "Pub",
+      copyright: "© Me",
+      category: "Utilities",
+      shortDescription: "short",
+      longDescription: "long",
+      macOS: { minimumSystemVersion: "12.0" },
+      android: { minSdkVersion: 26 },
+      iOS: { minimumSystemVersion: "16.0" },
+    });
+    expect(c.plugins.updater).toEqual({ active: true, pubkey: "PK", endpoints: ["https://u.example/latest.json"] });
+    expect(c.plugins["deep-link"]).toEqual({
+      desktop: { schemes: ["fullapp"] },
+      mobile: [{ scheme: ["fullapp"], appLink: false }],
+    });
+    expect(read("src-tauri/src/generated_config.rs")).toContain("UPDATER_ENABLED: bool = true;");
+  });
+
+  it("defaults android/ios minimums and falls back publisher → copyright → app name", () => {
+    profile("d", { ...remote, copyright: "C", android: {}, ios: {} });
+    configure(root, "d");
+    const c = conf();
+    expect(c.bundle.publisher).toBe("C");
+    expect(c.bundle.android.minSdkVersion).toBe(24);
+    expect(c.bundle.iOS.minimumSystemVersion).toBe("14.0");
+  });
+
+  it("writes a remote capability scoped to the trusted origins", () => {
+    profile("t", { ...remote, trustedOrigins: ["https://remote.example/", "https://*.remote.example"] });
+    const { written } = configure(root, "t");
+    expect(written).toContain("src-tauri/capabilities/remote.json");
+    expect(conf().app.security.capabilities).toEqual(["default", "remote"]);
+    const cap = JSON.parse(read("src-tauri/capabilities/remote.json"));
+    expect(cap).toMatchObject({
+      identifier: "remote",
+      windows: ["main"],
+      permissions: ["opener:allow-open-url"],
+    });
+    expect(cap.remote.urls).toEqual(["https://remote.example/*", "https://*.remote.example/*"]);
+  });
+
+  it("removes a stale remote capability when no origins are trusted", () => {
+    profile("t", { ...remote, trustedOrigins: ["https://remote.example"] });
+    configure(root, "t");
+    expect(fs.existsSync(path.join(root, "src-tauri/capabilities/remote.json"))).toBe(true);
+
+    profile("t", remote);
+    const { written } = configure(root, "t");
+    expect(fs.existsSync(path.join(root, "src-tauri/capabilities/remote.json"))).toBe(false);
+    expect(written).toContain("src-tauri/capabilities/remote.json (removed — no trustedOrigins)");
+  });
+});
+
+describe("configure — local profile with a sidecar", () => {
+  it("loads index.html, bundles the binary and passes fixed args to Rust", () => {
+    profile("l", {
+      appName: "Local App",
+      identifier: "com.local.app",
+      version: "1.0.0",
+      mode: "local",
+      sidecar: { name: "mytool", args: ["--json", "a b"], build: "make {out}" },
+    });
+    configure(root, "l");
+    const c = conf();
+    expect(c.app.windows[0].url).toBe("index.html");
+    expect(c.bundle.externalBin).toEqual(["binaries/mytool"]);
+    const rs = read("src-tauri/src/generated_config.rs");
+    expect(rs).toContain('pub const SIDECAR_NAME: &str = "mytool";');
+    expect(rs).toContain('pub const SIDECAR_ARGS: &[&str] = &["--json", "a b"];');
+    expect(rs).toContain('pub const APP_URL: &str = "";');
+  });
+
+  it("propagates profile errors", () => {
+    expect(() => configure(root, "missing")).toThrow("no such profile");
+  });
+});

package/test/icons-and-sidecar.test.mjs

@@ -0,0 +1,128 @@
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import zlib from "node:zlib";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { generatePlaceholderIcons } from "../scripts/generate-placeholder-icons.mjs";
+import { buildSidecar, hostTargetTriple } from "../scripts/build-sidecar.mjs";
+
+let root;
+
+beforeEach(() => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), "naw-icons-"));
+});
+
+afterEach(() => {
+  fs.rmSync(root, { recursive: true, force: true });
+});
+
+const hasRustc = (() => {
+  try {
+    execFileSync("rustc", ["--version"], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+})();
+
+describe("generatePlaceholderIcons", () => {
+  const theme = { background: ["#1e293b", "#0b1220"], accent: "#f8fafc" };
+
+  it("draws the full Tauri icon set plus a 1024px master", { timeout: 60_000 }, () => {
+    const written = generatePlaceholderIcons(root, theme);
+    const icons = path.join(root, "src-tauri", "icons");
+
+    for (const file of [
+      "32x32.png", "64x64.png", "128x128.png", "128x128@2x.png", "icon.png",
+      "Square30x30Logo.png", "Square310x310Logo.png", "StoreLogo.png",
+      "icon.ico", "icon.icns",
+    ]) {
+      expect(written).toContain(file);
+      expect(fs.statSync(path.join(icons, file)).size).toBeGreaterThan(0);
+    }
+    expect(written).toHaveLength(17);
+    expect(fs.existsSync(path.join(root, "assets", "icon-source.png"))).toBe(true);
+
+    const png = fs.readFileSync(path.join(icons, "128x128.png"));
+    expect(png.readUInt32BE(16)).toBe(128);
+    expect(png.readUInt32BE(20)).toBe(128);
+
+    const ico = fs.readFileSync(path.join(icons, "icon.ico"));
+    expect(ico.readUInt16LE(4)).toBe(6);
+    const icns = fs.readFileSync(path.join(icons, "icon.icns"));
+    expect(icns.toString("ascii", 0, 4)).toBe("icns");
+  });
+
+  it("paints a rounded, gradient-filled tile with transparent corners", { timeout: 60_000 }, () => {
+    generatePlaceholderIcons(root, theme);
+    const png = fs.readFileSync(path.join(root, "src-tauri", "icons", "128x128.png"));
+    // Locate IDAT and inflate it.
+    let at = 8;
+    let idat;
+    while (at < png.length) {
+      const len = png.readUInt32BE(at);
+      if (png.toString("ascii", at + 4, at + 8) === "IDAT") idat = png.subarray(at + 8, at + 8 + len);
+      at += 12 + len;
+    }
+    const raw = zlib.inflateSync(idat);
+    const px = (x, y) => [...raw.subarray(y * (128 * 4 + 1) + 1 + x * 4).subarray(0, 4)];
+    expect(px(0, 0)[3]).toBe(0); // rounded corner is transparent
+    expect(px(64, 4)[3]).toBe(255); // top edge of the tile is opaque
+    const top = px(64, 4);
+    const bottom = px(64, 123);
+    expect(top[0]).toBeGreaterThan(bottom[0]); // background gradient darkens downward
+  });
+});
+
+describe("buildSidecar", () => {
+  const profile = (sidecar) => ({ name: "p", sidecar });
+
+  it("is skipped when the profile has no sidecar", () => {
+    expect(buildSidecar(root, profile(null))).toEqual({ skipped: "the profile bundles no sidecar" });
+  });
+
+  it("requires a build command", () => {
+    expect(() => buildSidecar(root, profile({ name: "x" }))).toThrow('has no "build" command');
+  });
+
+  it.skipIf(!hasRustc)("reports the host target triple", () => {
+    expect(hostTargetTriple()).toMatch(/^[\w.-]+-[\w.-]+-[\w.-]+/);
+  });
+
+  it.skipIf(!hasRustc)("runs the build command with {out} substituted and marks it executable", () => {
+    const result = buildSidecar(
+      root,
+      profile({ name: "tool", build: `node -e "require('fs').writeFileSync(process.argv[1], 'bin')" "{out}"` }),
+    );
+    expect(result.triple).toBe(hostTargetTriple());
+    const out = path.join(root, result.outPath);
+    expect(fs.readFileSync(out, "utf8")).toBe("bin");
+    expect(result.outPath.startsWith(path.join("src-tauri", "binaries", "tool-"))).toBe(true);
+    if (process.platform !== "win32") expect(fs.statSync(out).mode & 0o111).not.toBe(0);
+  });
+
+  it.skipIf(!hasRustc)("runs the build in buildCwd", () => {
+    fs.mkdirSync(path.join(root, "sub"));
+    const result = buildSidecar(
+      root,
+      profile({
+        name: "tool",
+        buildCwd: "sub",
+        build: `node -e "require('fs').writeFileSync(process.argv[1], process.cwd())" "{out}"`,
+      }),
+    );
+    expect(fs.realpathSync(fs.readFileSync(path.join(root, result.outPath), "utf8"))).toBe(
+      fs.realpathSync(path.join(root, "sub")),
+    );
+  });
+
+  it.skipIf(!hasRustc)("fails when the command fails or forgets to write {out}", () => {
+    expect(() => buildSidecar(root, profile({ name: "t", build: "exit 3 # {out}" }))).toThrow(
+      "sidecar build command failed with exit code 3",
+    );
+    expect(() => buildSidecar(root, profile({ name: "t", build: "true # {out}" }))).toThrow(
+      "wrote nothing",
+    );
+  });
+});

package/test/png.test.mjs

@@ -0,0 +1,186 @@
+import zlib from "node:zlib";
+import { describe, expect, it } from "vitest";
+import {
+  blend,
+  coverage,
+  encodeIcns,
+  encodeIco,
+  encodePng,
+  hexToRgb,
+  roundedRectDistance,
+} from "../scripts/lib/png.mjs";
+
+const solid = (size, [r, g, b, a]) => {
+  const buf = Buffer.alloc(size * size * 4);
+  for (let i = 0; i < size * size; i++) buf.set([r, g, b, a], i * 4);
+  return buf;
+};
+
+/** Parse a PNG's chunks, checking each CRC. */
+function chunks(png) {
+  const out = [];
+  let at = 8;
+  while (at < png.length) {
+    const len = png.readUInt32BE(at);
+    const type = png.toString("ascii", at + 4, at + 8);
+    const data = png.subarray(at + 8, at + 8 + len);
+    out.push({ type, data });
+    at += 12 + len;
+  }
+  return out;
+}
+
+describe("encodePng", () => {
+  it("writes a valid PNG that decodes back to the same pixels", () => {
+    const rgba = solid(4, [10, 20, 30, 255]);
+    rgba.set([255, 0, 0, 128], 0);
+    const png = encodePng(rgba, 4);
+
+    expect([...png.subarray(0, 8)]).toEqual([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+    const parts = chunks(png);
+    expect(parts.map((c) => c.type)).toEqual(["IHDR", "IDAT", "IEND"]);
+
+    const ihdr = parts[0].data;
+    expect(ihdr.readUInt32BE(0)).toBe(4);
+    expect(ihdr.readUInt32BE(4)).toBe(4);
+    expect(ihdr[8]).toBe(8);
+    expect(ihdr[9]).toBe(6);
+
+    const raw = zlib.inflateSync(parts[1].data);
+    expect(raw.length).toBe(4 * (4 * 4 + 1));
+    // Each scanline starts with filter byte 0, followed by its RGBA pixels.
+    expect(raw[0]).toBe(0);
+    expect([...raw.subarray(1, 5)]).toEqual([255, 0, 0, 128]);
+    expect([...raw.subarray(5, 9)]).toEqual([10, 20, 30, 255]);
+    expect(raw[17]).toBe(0);
+  });
+
+  it("checksums each chunk with CRC-32", () => {
+    const png = encodePng(solid(2, [1, 2, 3, 4]), 2);
+    let at = 8;
+    while (at < png.length) {
+      const len = png.readUInt32BE(at);
+      const body = png.subarray(at + 4, at + 8 + len);
+      const stored = png.readUInt32BE(at + 8 + len);
+      expect(stored).toBe(zlib.crc32(body));
+      at += 12 + len;
+    }
+  });
+});
+
+describe("encodeIco", () => {
+  it("writes a directory entry per image and stores the PNGs verbatim", () => {
+    const small = encodePng(solid(16, [0, 0, 0, 255]), 16);
+    const big = encodePng(solid(2, [0, 0, 0, 255]), 2);
+    const ico = encodeIco([
+      { size: 16, png: small },
+      { size: 256, png: big },
+    ]);
+
+    expect(ico.readUInt16LE(0)).toBe(0);
+    expect(ico.readUInt16LE(2)).toBe(1);
+    expect(ico.readUInt16LE(4)).toBe(2);
+
+    const entry = (i) => 6 + i * 16;
+    expect(ico[entry(0)]).toBe(16);
+    expect(ico[entry(1)]).toBe(0); // 256 is encoded as 0
+    expect(ico[entry(1) + 1]).toBe(0);
+    expect(ico.readUInt16LE(entry(0) + 4)).toBe(1);
+    expect(ico.readUInt16LE(entry(0) + 6)).toBe(32);
+    expect(ico.readUInt32LE(entry(0) + 8)).toBe(small.length);
+
+    const firstOffset = ico.readUInt32LE(entry(0) + 12);
+    expect(firstOffset).toBe(6 + 32);
+    expect(ico.subarray(firstOffset, firstOffset + small.length).equals(small)).toBe(true);
+    const secondOffset = ico.readUInt32LE(entry(1) + 12);
+    expect(secondOffset).toBe(firstOffset + small.length);
+    expect(ico.subarray(secondOffset).equals(big)).toBe(true);
+  });
+});
+
+describe("encodeIcns", () => {
+  it("wraps each PNG in a typed block under an icns header", () => {
+    const a = Buffer.from("AAAA");
+    const b = Buffer.from("BBBBBB");
+    const icns = encodeIcns([
+      { type: "icp4", png: a },
+      { type: "ic07", png: b },
+    ]);
+    expect(icns.toString("ascii", 0, 4)).toBe("icns");
+    expect(icns.readUInt32BE(4)).toBe(icns.length);
+
+    expect(icns.toString("ascii", 8, 12)).toBe("icp4");
+    expect(icns.readUInt32BE(12)).toBe(a.length + 8);
+    expect(icns.subarray(16, 20).equals(a)).toBe(true);
+    expect(icns.toString("ascii", 20, 24)).toBe("ic07");
+    expect(icns.readUInt32BE(24)).toBe(b.length + 8);
+  });
+});
+
+describe("rasterization helpers", () => {
+  it("roundedRectDistance is negative inside, zero on the edge, positive outside", () => {
+    expect(roundedRectDistance(50, 50, 50, 50, 40, 40, 10)).toBeLessThan(0);
+    expect(roundedRectDistance(90, 50, 50, 50, 40, 40, 10)).toBeCloseTo(0, 5);
+    expect(roundedRectDistance(100, 50, 50, 50, 40, 40, 10)).toBeGreaterThan(0);
+  });
+
+  it("rounds the corners: the corner point is farther out than the straight edge", () => {
+    const edge = roundedRectDistance(90, 50, 50, 50, 40, 40, 10);
+    const corner = roundedRectDistance(90, 90, 50, 50, 40, 40, 10);
+    expect(corner).toBeGreaterThan(edge);
+  });
+
+  it("coverage maps signed distance to a clamped 0..1 alpha", () => {
+    expect(coverage(-5)).toBe(1);
+    expect(coverage(-0.5)).toBe(1);
+    expect(coverage(0)).toBe(0.5);
+    expect(coverage(0.5)).toBe(0);
+    expect(coverage(9)).toBe(0);
+  });
+
+  it("hexToRgb parses with or without #, any case", () => {
+    expect(hexToRgb("#ff8000")).toEqual([255, 128, 0]);
+    expect(hexToRgb("0B1220")).toEqual([11, 18, 32]);
+  });
+
+  it.each(["#fff", "red", "#12345", "#gggggg", ""])("hexToRgb rejects %j", (bad) => {
+    expect(() => hexToRgb(bad)).toThrow(/not a #rrggbb color/);
+  });
+});
+
+describe("blend", () => {
+  it("ignores non-positive alpha", () => {
+    const px = Buffer.from([1, 2, 3, 4]);
+    blend(px, 0, [255, 255, 255], 0);
+    blend(px, 0, [255, 255, 255], -1);
+    expect([...px]).toEqual([1, 2, 3, 4]);
+  });
+
+  it("writes the source color over a transparent pixel", () => {
+    const px = Buffer.alloc(4);
+    blend(px, 0, [200, 100, 50], 1);
+    expect([...px]).toEqual([200, 100, 50, 255]);
+  });
+
+  it("mixes with what is underneath, weighted by alpha", () => {
+    const px = Buffer.from([0, 0, 0, 255]);
+    blend(px, 0, [200, 100, 50], 0.5);
+    expect([...px]).toEqual([100, 50, 25, 255]);
+  });
+
+  it("caps alpha at 1 and tracks resulting opacity over a partly transparent pixel", () => {
+    const px = Buffer.from([0, 0, 0, 0]);
+    blend(px, 0, [255, 0, 0], 5);
+    expect(px[3]).toBe(255);
+    const half = Buffer.from([0, 0, 0, 0]);
+    blend(half, 0, [255, 0, 0], 0.5);
+    expect(half[3]).toBe(128);
+    expect(half[0]).toBe(255);
+  });
+
+  it("respects the pixel index offset", () => {
+    const px = Buffer.alloc(8);
+    blend(px, 4, [9, 8, 7], 1);
+    expect([...px]).toEqual([0, 0, 0, 0, 9, 8, 7, 255]);
+  });
+});

package/test/profile.test.mjs

@@ -0,0 +1,170 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { loadProfile, resolveProfileName } from "../scripts/profile.mjs";
+
+let root;
+let origEnv;
+
+const write = (name, profile) => {
+  fs.mkdirSync(path.join(root, "profiles"), { recursive: true });
+  fs.writeFileSync(
+    path.join(root, "profiles", `${name}.json`),
+    typeof profile === "string" ? profile : JSON.stringify(profile),
+  );
+};
+
+const base = { appName: "My App", identifier: "com.my.app", version: "1.2.3", url: "https://my.app" };
+
+beforeEach(() => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), "naw-profile-"));
+  origEnv = process.env.WRAPPER_PROFILE;
+  delete process.env.WRAPPER_PROFILE;
+});
+
+afterEach(() => {
+  if (origEnv === undefined) delete process.env.WRAPPER_PROFILE;
+  else process.env.WRAPPER_PROFILE = origEnv;
+  fs.rmSync(root, { recursive: true, force: true });
+});
+
+describe("resolveProfileName", () => {
+  it("takes --profile <name>", () => {
+    expect(resolveProfileName(root, ["--profile", "foo"])).toBe("foo");
+  });
+
+  it("rejects --profile without a value", () => {
+    expect(() => resolveProfileName(root, ["--profile"])).toThrow("--profile needs a profile name");
+    expect(() => resolveProfileName(root, ["--profile", "--other"])).toThrow("--profile needs a profile name");
+  });
+
+  it("falls back to WRAPPER_PROFILE", () => {
+    process.env.WRAPPER_PROFILE = "from-env";
+    expect(resolveProfileName(root, [])).toBe("from-env");
+  });
+
+  it("uses the only non-example profile", () => {
+    write("example", base);
+    write("solo", base);
+    expect(resolveProfileName(root, [])).toBe("solo");
+  });
+
+  it("uses example.json when it is the only one", () => {
+    write("example", base);
+    expect(resolveProfileName(root, [])).toBe("example");
+  });
+
+  it("explains an empty or missing profiles directory", () => {
+    expect(() => resolveProfileName(root, [])).toThrow("no profile to use");
+    fs.mkdirSync(path.join(root, "profiles"));
+    expect(() => resolveProfileName(root, [])).toThrow("no profile to use");
+  });
+
+  it("asks for a choice when several profiles exist", () => {
+    write("a", base);
+    write("b", base);
+    expect(() => resolveProfileName(root, [])).toThrow(/2 profiles \(a, b\)/);
+  });
+});
+
+describe("loadProfile", () => {
+  it("fills in defaults for a minimal remote profile", () => {
+    write("min", base);
+    const p = loadProfile(root, "min");
+    expect(p).toMatchObject({
+      name: "min",
+      mode: "remote",
+      productName: "My App",
+      trustedOrigins: [],
+      sidecar: null,
+    });
+    expect(p.path).toBe(path.join(root, "profiles", "min.json"));
+    expect(p.window).toEqual({
+      width: 1280,
+      height: 800,
+      minWidth: 480,
+      minHeight: 480,
+      fullscreen: false,
+      resizable: true,
+      title: "My App",
+    });
+  });
+
+  it("lets the profile override window and product name", () => {
+    write("custom", { ...base, productName: "Pretty", window: { width: 900, title: "Hello" } });
+    const p = loadProfile(root, "custom");
+    expect(p.productName).toBe("Pretty");
+    expect(p.window.width).toBe(900);
+    expect(p.window.title).toBe("Hello");
+    expect(p.window.height).toBe(800);
+  });
+
+  it("accepts http://localhost for remote dev", () => {
+    write("dev", { ...base, url: "http://localhost:3000" });
+    expect(loadProfile(root, "dev").url).toBe("http://localhost:3000");
+  });
+
+  it("accepts a local profile with a sidecar", () => {
+    write("local", {
+      appName: "L",
+      identifier: "com.l",
+      version: "1",
+      mode: "local",
+      sidecar: { name: "tool", build: "make OUT={out}" },
+    });
+    const p = loadProfile(root, "local");
+    expect(p.mode).toBe("local");
+    expect(p.sidecar).toEqual({ args: [], name: "tool", build: "make OUT={out}" });
+  });
+
+  it("reports a missing profile", () => {
+    expect(() => loadProfile(root, "ghost")).toThrow("no such profile: profiles/ghost.json");
+  });
+
+  it("reports invalid JSON", () => {
+    write("bad", "{not json");
+    expect(() => loadProfile(root, "bad")).toThrow(/bad.json is not valid JSON/);
+  });
+
+  it.each(["appName", "identifier", "version"])("requires %s", (field) => {
+    write("p", { ...base, [field]: undefined });
+    expect(() => loadProfile(root, "p")).toThrow(`missing required field "${field}"`);
+  });
+
+  it("rejects an unknown mode", () => {
+    write("p", { ...base, mode: "hybrid" });
+    expect(() => loadProfile(root, "p")).toThrow('unknown mode "hybrid"');
+  });
+
+  it("remote mode needs a url, and it must be https or localhost", () => {
+    write("p", { ...base, url: undefined });
+    expect(() => loadProfile(root, "p")).toThrow('needs a "url"');
+    write("p", { ...base, url: "http://example.com" });
+    expect(() => loadProfile(root, "p")).toThrow("must be https://");
+  });
+
+  it("local mode must not set a url", () => {
+    write("p", { appName: "A", identifier: "i", version: "1", mode: "local", url: "https://x" });
+    expect(() => loadProfile(root, "p")).toThrow('mode "local" but also sets "url"');
+  });
+
+  it("validates the sidecar block", () => {
+    const local = { appName: "A", identifier: "i", version: "1", mode: "local" };
+    write("p", { ...local, sidecar: {} });
+    expect(() => loadProfile(root, "p")).toThrow('no "name"');
+    write("p", { ...local, sidecar: { name: "x", build: "make" } });
+    expect(() => loadProfile(root, "p")).toThrow('must contain "{out}"');
+    write("p", { ...base, sidecar: { name: "x" } });
+    expect(() => loadProfile(root, "p")).toThrow('pairs a "sidecar" with mode "remote"');
+  });
+
+  it("validates the updater block", () => {
+    write("p", { ...base, updater: { pubkey: "k" } });
+    expect(() => loadProfile(root, "p")).toThrow('"updater" needs both a "pubkey"');
+    write("p", { ...base, updater: { pubkey: "k", endpoints: [] } });
+    expect(() => loadProfile(root, "p")).toThrow('"updater" needs both');
+    write("p", { ...base, updater: { pubkey: "k", endpoints: ["https://u"] } });
+    expect(loadProfile(root, "p").updater.endpoints).toEqual(["https://u"]);
+  });
+});