@lakutata/builder 3.0.0-beta.0

package/dist/esm/lib/Icons.js

@@ -0,0 +1,372 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { deflateSync, inflateSync } from 'node:zlib';
+/**
+ * The signature of the PNG files
+ */
+const PNG_SIGNATURE = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+/**
+ * The table of the CRC-32 of the chunks of PNG
+ */
+const CRC_TABLE = (() => {
+    const table = new Uint32Array(256);
+    for (let n = 0; n < 256; n++) {
+        let c = n;
+        for (let k = 0; k < 8; k++)
+            c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        table[n] = c >>> 0;
+    }
+    return table;
+})();
+/**
+ * The CRC-32 of a chunk of PNG (its type and its data)
+ * @param data
+ */
+function crc32(data) {
+    let crc = 0xffffffff;
+    for (const byte of data)
+        crc = CRC_TABLE[(crc ^ byte) & 0xff] ^ (crc >>> 8);
+    return (crc ^ 0xffffffff) >>> 0;
+}
+/**
+ * The predictor of Paeth (the filter 4 of PNG)
+ * @param a the byte on the left
+ * @param b the byte above
+ * @param c the byte above on the left
+ */
+function paeth(a, b, c) {
+    const p = a + b - c;
+    const pa = Math.abs(p - a), pb = Math.abs(p - b), pc = Math.abs(p - c);
+    return pa <= pb && pa <= pc ? a : pb <= pc ? b : c;
+}
+/**
+ * Decode a PNG file (not interlaced): its pixels in RGBA, whatever its colors (gray, RGB, palette, with alpha) and its
+ * depth (1 to 16 bits)
+ * @param data
+ * @param file its name, in the errors
+ */
+export function decodePng(data, file = 'the image') {
+    if (data.length < 8 || !data.subarray(0, 8).equals(PNG_SIGNATURE))
+        throw new Error(`${file} is not a PNG image`);
+    let offset = 8;
+    let width = 0, height = 0, depth = 0, type = 0, interlace = 0;
+    let palette;
+    let transparency;
+    const compressed = [];
+    while (offset + 8 <= data.length) {
+        const length = data.readUInt32BE(offset);
+        const name = data.toString('latin1', offset + 4, offset + 8);
+        const chunk = data.subarray(offset + 8, offset + 8 + length);
+        offset += 12 + length;
+        if (name === 'IHDR') {
+            width = chunk.readUInt32BE(0);
+            height = chunk.readUInt32BE(4);
+            depth = chunk[8];
+            type = chunk[9];
+            interlace = chunk[12];
+        }
+        else if (name === 'PLTE')
+            palette = chunk;
+        else if (name === 'tRNS')
+            transparency = chunk;
+        else if (name === 'IDAT')
+            compressed.push(chunk);
+        else if (name === 'IEND')
+            break;
+    }
+    if (!width || !height)
+        throw new Error(`${file} has no header (IHDR)`);
+    if (interlace)
+        throw new Error(`${file} is interlaced: save it without interlacing`);
+    const channels = { 0: 1, 2: 3, 3: 1, 4: 2, 6: 4 }[type];
+    if (!channels || ![1, 2, 4, 8, 16].includes(depth))
+        throw new Error(`${file} has colors this tool does not read (type ${type}, ${depth} bits)`);
+    if (type === 3 && !palette)
+        throw new Error(`${file} has no palette (PLTE)`);
+    const raw = inflateSync(Buffer.concat(compressed));
+    const bitsPerPixel = channels * depth;
+    const stride = Math.ceil(width * bitsPerPixel / 8);
+    //The distance of the byte on the left: one pixel, at least one byte
+    const left = Math.max(1, bitsPerPixel >> 3);
+    const rows = Buffer.alloc(stride * height);
+    for (let y = 0; y < height; y++) {
+        const filter = raw[y * (stride + 1)];
+        const source = raw.subarray(y * (stride + 1) + 1, (y + 1) * (stride + 1));
+        const row = rows.subarray(y * stride, (y + 1) * stride);
+        const above = y ? rows.subarray((y - 1) * stride, y * stride) : undefined;
+        for (let x = 0; x < stride; x++) {
+            const a = x >= left ? row[x - left] : 0;
+            const b = above ? above[x] : 0;
+            const c = above && x >= left ? above[x - left] : 0;
+            const predicted = filter === 0 ? 0 : filter === 1 ? a : filter === 2 ? b : filter === 3 ? (a + b) >> 1 : filter === 4 ? paeth(a, b, c) : -1;
+            if (predicted < 0)
+                throw new Error(`${file} has an unknown filter (${filter})`);
+            row[x] = (source[x] + predicted) & 0xff;
+        }
+    }
+    //A sample of a pixel, as it is written, and scaled to 8 bits
+    const value = (row, index) => {
+        if (depth === 8)
+            return row[index];
+        if (depth === 16)
+            return row.readUInt16BE(index * 2);
+        return row[(index * depth) >> 3] >> (8 - depth - ((index * depth) & 7)) & ((1 << depth) - 1);
+    };
+    const sample = (row, index) => {
+        if (depth === 8 || type === 3)
+            return value(row, index);
+        if (depth === 16)
+            return row[index * 2];
+        return Math.round(value(row, index) * 255 / ((1 << depth) - 1));
+    };
+    //The color made transparent by tRNS, of the gray and RGB images
+    const key = (index) => transparency && transparency.length >= (index + 1) * 2 ? transparency.readUInt16BE(index * 2) : -1;
+    const pixels = Buffer.alloc(width * height * 4);
+    for (let y = 0; y < height; y++) {
+        const row = rows.subarray(y * stride, (y + 1) * stride);
+        for (let x = 0; x < width; x++) {
+            const target = (y * width + x) * 4;
+            const raw16 = (channel) => value(row, x * channels + channel);
+            if (type === 3) {
+                const index = sample(row, x);
+                palette.copy(pixels, target, index * 3, index * 3 + 3);
+                pixels[target + 3] = transparency && index < transparency.length ? transparency[index] : 255;
+            }
+            else if (type === 0 || type === 4) {
+                const gray = sample(row, x * channels);
+                pixels[target] = pixels[target + 1] = pixels[target + 2] = gray;
+                pixels[target + 3] = type === 4 ? sample(row, x * channels + 1) : raw16(0) === key(0) ? 0 : 255;
+            }
+            else {
+                for (let channel = 0; channel < 3; channel++)
+                    pixels[target + channel] = sample(row, x * channels + channel);
+                pixels[target + 3] = type === 6 ? sample(row, x * channels + 3) : raw16(0) === key(0) && raw16(1) === key(1) && raw16(2) === key(2) ? 0 : 255;
+            }
+        }
+    }
+    return { width: width, height: height, pixels: pixels };
+}
+/**
+ * Encode an image into a PNG file (RGBA, 8 bits)
+ * @param image
+ */
+export function encodePng(image) {
+    const chunk = (name, data) => {
+        const typed = Buffer.concat([Buffer.from(name, 'latin1'), data]);
+        const length = Buffer.alloc(4);
+        length.writeUInt32BE(data.length);
+        const crc = Buffer.alloc(4);
+        crc.writeUInt32BE(crc32(typed));
+        return Buffer.concat([length, typed, crc]);
+    };
+    const header = Buffer.alloc(13);
+    header.writeUInt32BE(image.width, 0);
+    header.writeUInt32BE(image.height, 4);
+    header[8] = 8;
+    header[9] = 6;
+    const stride = image.width * 4;
+    const raw = Buffer.alloc((stride + 1) * image.height);
+    for (let y = 0; y < image.height; y++) {
+        //The filter Sub (1): the icons compress better
+        raw[y * (stride + 1)] = 1;
+        for (let x = 0; x < stride; x++) {
+            const value = image.pixels[y * stride + x];
+            raw[y * (stride + 1) + 1 + x] = (value - (x >= 4 ? image.pixels[y * stride + x - 4] : 0)) & 0xff;
+        }
+    }
+    return Buffer.concat([PNG_SIGNATURE, chunk('IHDR', header), chunk('IDAT', deflateSync(raw, { level: 9 })), chunk('IEND', Buffer.alloc(0))]);
+}
+/**
+ * Resize an image (a square into a square): each pixel the average of the ones it covers, weighted by their alpha
+ * (premultiplied, the transparent edges keep their colors)
+ * @param image
+ * @param size
+ */
+export function resize(image, size) {
+    if (image.width === size && image.height === size)
+        return image;
+    //Separable: the columns, then the rows
+    const pass = (source, width, height, target, horizontal) => {
+        const length = horizontal ? width : height;
+        const scale = length / target;
+        const output = new Float64Array((horizontal ? target * height : width * target) * 4);
+        for (let i = 0; i < target; i++) {
+            const start = i * scale, end = (i + 1) * scale;
+            //The weights of the source pixels the target pixel covers
+            const weights = [];
+            for (let j = Math.floor(start); j < Math.min(length, Math.ceil(end)); j++) {
+                const weight = Math.min(end, j + 1) - Math.max(start, j);
+                if (weight > 0)
+                    weights.push([j, weight]);
+            }
+            const total = weights.reduce((sum, [, weight]) => sum + weight, 0);
+            for (let k = 0; k < (horizontal ? height : width); k++) {
+                for (let channel = 0; channel < 4; channel++) {
+                    let sum = 0;
+                    for (const [j, weight] of weights)
+                        sum += source[((horizontal ? k * width + j : j * width + k) * 4) + channel] * weight;
+                    output[((horizontal ? k * target + i : i * width + k) * 4) + channel] = sum / total;
+                }
+            }
+        }
+        return output;
+    };
+    const premultiplied = new Float64Array(image.width * image.height * 4);
+    for (let i = 0; i < image.width * image.height; i++) {
+        const alpha = image.pixels[i * 4 + 3] / 255;
+        for (let channel = 0; channel < 3; channel++)
+            premultiplied[i * 4 + channel] = image.pixels[i * 4 + channel] * alpha;
+        premultiplied[i * 4 + 3] = image.pixels[i * 4 + 3];
+    }
+    const resized = pass(pass(premultiplied, image.width, image.height, size, true), size, image.height, size, false);
+    const pixels = Buffer.alloc(size * size * 4);
+    for (let i = 0; i < size * size; i++) {
+        const alpha = resized[i * 4 + 3];
+        for (let channel = 0; channel < 3; channel++)
+            pixels[i * 4 + channel] = alpha > 0 ? Math.min(255, Math.round(resized[i * 4 + channel] * 255 / alpha)) : 0;
+        pixels[i * 4 + 3] = Math.min(255, Math.round(alpha));
+    }
+    return { width: size, height: size, pixels: pixels };
+}
+/**
+ * The sizes of the icons of Windows (ico)
+ */
+export const ICO_SIZES = [16, 20, 24, 32, 40, 48, 64, 128, 256];
+/**
+ * The icon of Windows (ico) of an image, in its sizes: the bitmaps of the ones smaller than 256 (the format every tool
+ * reads: the resources of the executables, NSIS, Windows Installer), the PNG of 256
+ * @param image
+ */
+export function icoFile(image) {
+    const images = ICO_SIZES.map((size) => {
+        const resized = resize(image, size);
+        if (size >= 256)
+            return encodePng(resized);
+        //BITMAPINFOHEADER, its height the one of the colors and of the mask; the rows from the bottom, BGRA, then the mask
+        const header = Buffer.alloc(40);
+        header.writeUInt32LE(40, 0);
+        header.writeInt32LE(size, 4);
+        header.writeInt32LE(size * 2, 8);
+        header.writeUInt16LE(1, 12);
+        header.writeUInt16LE(32, 14);
+        const colors = Buffer.alloc(size * size * 4);
+        const maskStride = Math.ceil(size / 32) * 4;
+        const mask = Buffer.alloc(maskStride * size);
+        for (let y = 0; y < size; y++) {
+            for (let x = 0; x < size; x++) {
+                const from = (y * size + x) * 4;
+                const to = ((size - 1 - y) * size + x) * 4;
+                colors[to] = resized.pixels[from + 2];
+                colors[to + 1] = resized.pixels[from + 1];
+                colors[to + 2] = resized.pixels[from];
+                colors[to + 3] = resized.pixels[from + 3];
+                if (!resized.pixels[from + 3])
+                    mask[(size - 1 - y) * maskStride + (x >> 3)] |= 0x80 >> (x & 7);
+            }
+        }
+        return Buffer.concat([header, colors, mask]);
+    });
+    const directory = Buffer.alloc(6 + 16 * images.length);
+    directory.writeUInt16LE(1, 2);
+    directory.writeUInt16LE(images.length, 4);
+    let offset = directory.length;
+    images.forEach((data, index) => {
+        const entry = 6 + index * 16;
+        const size = ICO_SIZES[index];
+        directory[entry] = size >= 256 ? 0 : size;
+        directory[entry + 1] = size >= 256 ? 0 : size;
+        directory.writeUInt16LE(1, entry + 4);
+        directory.writeUInt16LE(32, entry + 6);
+        directory.writeUInt32LE(data.length, entry + 8);
+        directory.writeUInt32LE(offset, entry + 12);
+        offset += data.length;
+    });
+    return Buffer.concat([directory, ...images]);
+}
+/**
+ * The types of the icons of macOS (icns) of PNG, by their sizes in pixels (the Retina ones are the doubles of the others)
+ */
+const ICNS_TYPES = [['icp4', 16], ['icp5', 32], ['ic11', 32], ['icp6', 64], ['ic12', 64], ['ic07', 128], ['ic08', 256], ['ic13', 256], ['ic09', 512], ['ic14', 512], ['ic10', 1024]];
+/**
+ * The icon of macOS (icns) of an image: its PNG in the sizes of macOS, but the ones larger than it
+ * @param image
+ */
+export function icnsFile(image) {
+    const encoded = new Map();
+    const entries = [];
+    for (const [type, size] of ICNS_TYPES) {
+        if (size > image.width)
+            continue;
+        if (!encoded.has(size))
+            encoded.set(size, encodePng(resize(image, size)));
+        const data = encoded.get(size);
+        const header = Buffer.alloc(8);
+        header.write(type, 0, 'latin1');
+        header.writeUInt32BE(data.length + 8, 4);
+        entries.push(header, data);
+    }
+    const header = Buffer.alloc(8);
+    header.write('icns', 0, 'latin1');
+    header.writeUInt32BE(8 + entries.reduce((sum, entry) => sum + entry.length, 0), 4);
+    return Buffer.concat([header, ...entries]);
+}
+/**
+ * The sizes of the icons of Linux (the hicolor theme)
+ */
+export const LINUX_SIZES = [16, 24, 32, 48, 64, 128, 256, 512];
+/**
+ * Write the icons of Linux of an image into a directory: its PNG in the sizes of the hicolor theme (<size>x<size>.png),
+ * but the ones larger than it
+ * @param image
+ * @param directory
+ */
+export async function writeLinuxIcons(image, directory) {
+    await mkdir(directory, { recursive: true });
+    const files = [];
+    for (const size of LINUX_SIZES.filter((size) => size <= image.width)) {
+        const file = path.join(directory, `${size}x${size}.png`);
+        await writeFile(file, encodePng(resize(image, size)));
+        files.push(file);
+    }
+    return files;
+}
+/**
+ * Give an executable of Windows the icon (ico), as its icon groups (the one of node.exe), its signature removed (it does
+ * not match it anymore)
+ * @param file
+ * @param ico
+ */
+export async function setExecutableIcon(file, ico) {
+    const { NtExecutable, NtExecutableResource, Data, Resource } = await import('resedit');
+    const executable = NtExecutable.from(await readFile(file), { ignoreCert: true });
+    const resource = NtExecutableResource.from(executable);
+    const icons = Data.IconFile.from(ico).icons.map((item) => item.data);
+    const groups = Resource.IconGroupEntry.fromEntries(resource.entries);
+    for (const { id, lang } of groups.length ? groups : [{ id: 1, lang: 1033 }])
+        Resource.IconGroupEntry.replaceIconsForResource(resource.entries, id, lang, icons);
+    resource.outputResource(executable);
+    await writeFile(file, Buffer.from(executable.generate()));
+}
+/**
+ * The icon of the application (lakutata.icon of its package.json): a square PNG image, 256 pixels at least (1024 for
+ * the Retina screens of macOS), undefined without icon
+ * @param project
+ * @param manifest
+ */
+export function applicationIcon(project, manifest) {
+    const declared = manifest.lakutata?.icon;
+    if (declared === undefined)
+        return undefined;
+    if (typeof declared !== 'string' || !declared)
+        throw new Error('The icon of the application (lakutata.icon of its package.json) must be a PNG image of the project');
+    const file = path.resolve(project, declared);
+    if (!existsSync(file))
+        throw new Error(`The icon of the application ${declared} (lakutata.icon) does not exist`);
+    const image = decodePng(readFileSync(file), declared);
+    if (image.width !== image.height)
+        throw new Error(`The icon of the application ${declared} must be square (it is ${image.width}x${image.height})`);
+    if (image.width < 256)
+        throw new Error(`The icon of the application ${declared} must be 256 pixels at least (it is ${image.width}): its icons are made from it`);
+    return { file: file, image: image };
+}

package/dist/esm/lib/Installer.js

@@ -0,0 +1,158 @@
+import { readFile, mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { programName } from './Bundle.js';
+import { buildElectronInstaller } from './electron/Electron.js';
+import { buildExecutable } from './Executable.js';
+import { applicationIcon, icoFile } from './Icons.js';
+import { detectLibc } from './Platform.js';
+import { resolveScripts } from './Scripts.js';
+import { buildLinuxPackages, LINUX_TARGETS } from './linux/Linux.js';
+import { buildMacPackages, MAC_TARGETS } from './mac/Mac.js';
+import { buildWindowsPackages, WINDOWS_TARGETS } from './win/Windows.js';
+/**
+ * The maintainer of the package.json: its author
+ * @param author
+ */
+function packageAuthor(author) {
+    if (typeof author === 'string' && author.trim())
+        return author.trim();
+    if (author && typeof author === 'object' && typeof author.name === 'string') {
+        const { name, email } = author;
+        return email ? `${name} <${email}>` : name;
+    }
+    return undefined;
+}
+/**
+ * The configuration of the installers of a project, checked
+ * @param manifest
+ */
+function installerConfig(manifest) {
+    const config = manifest.lakutata?.installer ?? {};
+    if (!config || typeof config !== 'object' || Array.isArray(config))
+        throw new Error('The installers of the application (lakutata.installer of its package.json) must be an object');
+    return config;
+}
+/**
+ * Make the installers of the application for the platform it is made on (the installers of the other platforms are
+ * made on them, as its executables): its executable in a directory, with its native addons and its resources, installed
+ * in /opt/<name> (Linux) or /usr/local/lib/<name> (macOS), its program in the PATH, its service registered (systemd,
+ * OpenRC, launchd)
+ * @param options
+ */
+export async function buildInstaller(options) {
+    const project = path.resolve(options.project);
+    const manifest = JSON.parse(await readFile(path.join(project, 'package.json'), 'utf8'));
+    const config = installerConfig(manifest);
+    if (config.runtime === 'electron')
+        return buildElectronInstaller(project, manifest, config, options);
+    const mac = process.platform === 'darwin';
+    const windows = process.platform === 'win32';
+    if (process.platform !== 'linux' && !mac && !windows)
+        throw new Error(`The installers of ${process.platform} are not supported: the ones of Linux are made on Linux, the ones of macOS on macOS, the ones of Windows on Windows`);
+    const libc = detectLibc();
+    const targets = options.targets?.length ? options.targets
+        : mac ? config.mac?.targets ?? ['pkg', 'tar.gz']
+            : windows ? config.win?.targets ?? ['nsis', 'msi', 'zip']
+                : config.linux?.targets ?? (libc === 'glibc' ? ['deb', 'rpm', 'tar.gz'] : ['apk', 'tar.gz']);
+    for (const target of targets) {
+        if (mac) {
+            if (!MAC_TARGETS.includes(target))
+                throw new Error(`The installer ${target} is not one of macOS (${MAC_TARGETS.join(', ')})`);
+            continue;
+        }
+        if (windows) {
+            if (!WINDOWS_TARGETS.includes(target))
+                throw new Error(`The installer ${target} is not one of Windows (${WINDOWS_TARGETS.join(', ')})`);
+            continue;
+        }
+        if (!LINUX_TARGETS.includes(target))
+            throw new Error(`The installer ${target} is not one of Linux (${LINUX_TARGETS.join(', ')})`);
+        //The executable links the C library of the system it is made on
+        if (target === 'apk' && libc !== 'musl')
+            throw new Error('The apk packages are made on Alpine (musl): the executables made on the systems of the glibc do not run there');
+        if (['deb', 'rpm', 'archlinux'].includes(target) && libc !== 'glibc')
+            throw new Error(`The ${target} packages are made on a system of the glibc: the executables made on Alpine (musl) do not run there`);
+    }
+    const program = programName(manifest);
+    const name = config.name ?? program.toLowerCase();
+    if (!/^[a-z0-9][a-z0-9+.-]*$/.test(name))
+        throw new Error(`The name of the package "${name}" must be lower case letters, digits, "+", "-" and "." (lakutata.installer.name)`);
+    const version = String(manifest.version ?? '');
+    if (!/^\d+\.\d+\.\d+/.test(version))
+        throw new Error(`The version of the package "${version}" must be a version (1.2.3) of the package.json`);
+    const warnings = [];
+    let maintainer = config.maintainer ?? packageAuthor(manifest.author);
+    if (!maintainer) {
+        maintainer = name;
+        warnings.push(`The packages have no maintainer: give it (the author of the package.json, or lakutata.installer.maintainer)`);
+    }
+    const appId = config.appId ?? name;
+    if (!/^[A-Za-z0-9][A-Za-z0-9.-]*$/.test(appId))
+        throw new Error(`The identifier of the application "${appId}" must be letters, digits, "." and "-" (lakutata.installer.appId)`);
+    const service = config.service === true ? {} : config.service || undefined;
+    if (service?.name !== undefined && !/^[A-Za-z0-9_.@-]+$/.test(service.name))
+        throw new Error(`The name of the service "${service.name}" must be letters, digits, "_", ".", "@" and "-"`);
+    const platform = mac ? 'mac' : windows ? 'win' : 'linux';
+    const scripts = resolveScripts(project, platform, config[platform], targets, warnings);
+    const application = applicationIcon(project, manifest);
+    const work = await mkdtemp(path.join(os.tmpdir(), 'lakutata-installer-'));
+    try {
+        //The icon of the installers of Windows (the executable has it too)
+        let icon;
+        if (windows && application) {
+            icon = path.join(work, 'icon.ico');
+            await writeFile(icon, icoFile(application.image));
+        }
+        const executable = await buildExecutable({
+            project: project,
+            entry: options.entry,
+            minify: options.minify,
+            external: options.external,
+            runtime: config.runtime,
+            layout: 'directory',
+            outdir: path.join(work, 'stage')
+        });
+        warnings.push(...executable.warnings);
+        const plan = {
+            name: name,
+            appId: appId,
+            productName: config.productName ?? (typeof manifest.productName === 'string' ? manifest.productName : name),
+            program: program,
+            version: version,
+            description: config.description ?? manifest.description ?? name,
+            maintainer: maintainer,
+            homepage: config.homepage ?? (typeof manifest.homepage === 'string' ? manifest.homepage : undefined),
+            license: config.license ?? (typeof manifest.license === 'string' ? manifest.license : undefined),
+            vendor: config.vendor,
+            addToPath: config.addToPath ?? true,
+            depends: config.linux?.depends ?? [],
+            recommends: config.linux?.recommends ?? [],
+            section: config.linux?.section,
+            priority: config.linux?.priority,
+            service: service && {
+                name: service.name ?? name,
+                description: service.description ?? config.description ?? manifest.description ?? name,
+                args: service.args ?? [],
+                env: { MODE: 'production', ...service.env },
+                //The users of the services of macOS are hidden by their names (_www), the ones of Windows are virtual
+                user: service.user ?? (mac ? `_${name}` : windows ? `NT SERVICE\\${service.name ?? name}` : name),
+                restart: service.restart ?? 'on-failure',
+                autoStart: service.autoStart ?? true
+            },
+            directory: executable.directory,
+            prefix: mac ? `/usr/local/lib/${name}` : windows ? `C:\\Program Files\\${name}` : `/opt/${name}`,
+            scripts: scripts,
+            icon: icon
+        };
+        const outdir = path.resolve(project, options.outdir ?? path.join('dist', 'installer'));
+        await mkdir(outdir, { recursive: true });
+        const files = mac ? await buildMacPackages(plan, targets, path.join(work, 'mac'), outdir)
+            : windows ? await buildWindowsPackages(plan, targets, path.join(work, 'win'), outdir)
+                : await buildLinuxPackages(plan, targets, path.join(work, 'linux'), outdir);
+        return { name: name, version: version, files: files, executable: executable, warnings: warnings };
+    }
+    finally {
+        await rm(work, { recursive: true, force: true });
+    }
+}