@lakutata/builder 3.1.3 → 3.1.6

package/dist/types/lib/mobile/Addons.d.ts

@@ -0,0 +1,154 @@
+import type { NativeFile } from '../Native.js';
+import { type AndroidAbi } from './Node.js';
+/**
+ * The SDKs of iOS the native addons are built for: the architectures built and the slice of the framework of the
+ * Node.js of the application (NodeMobile.xcframework) they link
+ */
+declare const IOS_SDKS: {
+    readonly iphoneos: {
+        readonly archs: "arm64";
+        readonly slice: "ios-arm64";
+        readonly platform: "iPhoneOS";
+    };
+    readonly iphonesimulator: {
+        readonly archs: "arm64";
+        readonly slice: "ios-arm64-simulator";
+        readonly platform: "iPhoneSimulator";
+    };
+};
+/**
+ * A SDK of iOS: iphoneos (the devices) or iphonesimulator (the simulators of the Macs of Apple silicon)
+ */
+export type IosSdk = keyof typeof IOS_SDKS;
+/**
+ * The file of a Node.js project mapping the placeholders of its addons (their paths in the native tree) to the libraries
+ * the system loads instead (the frameworks of the application on iOS, the libraries of the HAP on HarmonyOS):
+ * {directory, files}, the directory relative to the project or absolute
+ */
+export declare const MOBILE_ADDONS_FILE: string;
+/**
+ * What was done to the native addons of a mobile application
+ */
+export type MobileAddons = {
+    /**
+     * The packages built from their sources (now, or before: the cache), with the target built for:
+     * `@lakutata/math (arm64-v8a)`
+     */
+    built: string[];
+    /**
+     * The packages whose prebuilt addons of the system were kept (prebuilds/android-<arch>)
+     */
+    prebuilt: string[];
+    /**
+     * The frameworks made of the addons (iOS), for each SDK: `iphonesimulator/lakutata-math-math.framework`
+     */
+    frameworks: string[];
+    /**
+     * The libraries made of the addons (HarmonyOS), in the libraries of the HAP: `liblakutata-math-math.so`
+     */
+    libraries: string[];
+};
+/**
+ * The options of the native addons of a mobile application
+ */
+export type MobileAddonOptions = {
+    /**
+     * The architectures of Android built for, the ones of libnode by default
+     */
+    abis?: AndroidAbi[];
+    /**
+     * The SDKs of iOS built for, both by default (iphoneos, iphonesimulator)
+     */
+    sdks?: IosSdk[];
+    /**
+     * Called with what is done, the builds taking a while
+     */
+    progress?: (message: string) => void;
+};
+/**
+ * Build the native addons of a mobile application of Android: a native tree per architecture (<directory>-<arch>, the
+ * one of process.arch loaded by the bundle), each package of addons built for it from its sources (node-gyp, the NDK,
+ * the headers and the library of libnode), or keeping its prebuilt addons of the architecture
+ * (prebuilds/android-<arch>, node-gyp-build). The tree of the build is removed once they are made
+ * @param project
+ * @param directory the native tree
+ * @param files the files of the tree
+ * @param node the export of the libnode of Android
+ * @param options
+ * @internal
+ */
+export declare function prepareAndroidAddons(project: string, directory: string, files: NativeFile[], node: string, options?: MobileAddonOptions): Promise<MobileAddons>;
+/**
+ * The name of the framework of an addon: its package and its file, in the characters of the names and of the
+ * identifiers of the bundles (letters, digits and hyphens)
+ * @param name the name of its package
+ * @param file its file
+ * @internal
+ */
+export declare function frameworkName(name: string, file: string): string;
+/**
+ * The Info.plist of the framework of an addon: the keys the frameworks embedded in an application of the App Store
+ * have
+ * @param name
+ * @param version the version of its package
+ * @param sdk
+ * @internal
+ */
+export declare function frameworkInfo(name: string, version: string, sdk: IosSdk): string;
+/**
+ * The headers of a libnode as node-gyp builds the addons against them, linked but for these:
+ * - node_object_wrap.h without the calls of the cleanup hooks of node::ObjectWrap (OBJECT_WRAP_HOOKS), as in the headers
+ *   of Node.js 24.18: an addon built on node::ObjectWrap (better-sqlite3, the addons of NAN) would abort the application
+ *   whenever the garbage collector frees one of its objects. A header without them is copied as it is;
+ * - for iOS, config.gypi with OS "mac": the libnode of iOS is configured with OS "ios", for which the common.gypi of
+ *   Node.js turns the exceptions and the RTTI of C++ off in the projects of Xcode as it does for macOS, while the addons
+ *   (and node-addon-api) give their settings of Xcode (the exceptions, the RTTI, the standard of C++) to OS "mac" only.
+ *   Built as for macOS, an addon keeps them; the SDK, the architectures and the deployment target of iOS are given to
+ *   xcodebuild
+ * @param node the export of the libnode
+ * @param work a directory of the build
+ * @param os "mac" for iOS: the OS given to config.gypi
+ * @returns the directory of the headers (the nodedir of node-gyp)
+ */
+export declare function addonNodeHeaders(node: string, work: string, os?: 'mac'): Promise<string>;
+/**
+ * Build the native addons of a mobile application of iOS: each package of addons built for the SDKs from its sources
+ * (node-gyp, xcodebuild, linking the framework of the Node.js of the application), each addon made a framework, which
+ * the project of iOS embeds in the application; its files in the native tree replaced by placeholders (no library of
+ * the App Store outside of its frameworks), which the entry of the project loads from the frameworks of the application
+ * (MOBILE_ADDONS_FILE: the project is in the application, next to its frameworks). The frameworks of the SDKs made
+ * before are removed
+ * @param project
+ * @param stage the Node.js project
+ * @param directory its native tree
+ * @param files the files of the tree
+ * @param frameworks the directory of the frameworks, a directory per SDK (the NodeAddons of the project of iOS)
+ * @param node the export of the libnode of iOS
+ * @param options
+ * @internal
+ */
+export declare function prepareIosAddons(project: string, stage: string, directory: string, files: NativeFile[], frameworks: string, node: string, options?: MobileAddonOptions): Promise<MobileAddons>;
+/**
+ * The name of the library of an addon in the HAP: libaddon-<package>-<file>.so, in letters, digits, hyphens and
+ * underscores (the libraries made before are the libaddon-*.so of the directory)
+ * @param name the name of its package
+ * @param file its file
+ * @internal
+ */
+export declare function harmonyLibraryName(name: string, file: string): string;
+/**
+ * Build the native addons of a mobile application of HarmonyOS: each package of addons built from its sources (node-gyp,
+ * the LLVM of the native SDK, linking libnode.so), each addon made a library of the HAP (libaddon-<package>-<file>.so in
+ * its libs/arm64-v8a: the addons cannot be loaded from the resources of the HAP); its files in the native tree replaced
+ * by placeholders, which the entry of the project loads from the libraries of the HAP (MOBILE_ADDONS_FILE)
+ * @param project
+ * @param stage the Node.js project
+ * @param directory its native tree
+ * @param files the files of the tree
+ * @param libraries the directory of the libraries of the HAP (the libs/arm64-v8a of its module)
+ * @param node the export of the libnode of HarmonyOS
+ * @param options
+ * @internal
+ */
+export declare function prepareHarmonyAddons(project: string, stage: string, directory: string, files: NativeFile[], libraries: string, node: string, options?: MobileAddonOptions): Promise<MobileAddons>;
+export {};

package/dist/types/lib/mobile/Node.d.ts

@@ -0,0 +1,89 @@
+/**
+ * The version of Node.js of the mobile applications when their libnode does not tell it: the one of the release of
+ * lakutata/libnode they download (MOBILE_NODE_RELEASE)
+ */
+export declare const MOBILE_NODE_VERSION: string;
+/**
+ * The systems of the mobile applications of React Native
+ */
+export type MobilePlatform = 'android' | 'ios' | 'harmony';
+/**
+ * The architectures of Android of a libnode built for them (the arch of Node.js names the native tree of the
+ * architecture, the target names the compilers of the NDK)
+ */
+export declare const ANDROID_ABIS: {
+    readonly 'arm64-v8a': {
+        readonly arch: "arm64";
+        readonly target: "aarch64-linux-android";
+    };
+    readonly 'armeabi-v7a': {
+        readonly arch: "arm";
+        readonly target: "armv7a-linux-androideabi";
+    };
+    readonly x86_64: {
+        readonly arch: "x64";
+        readonly target: "x86_64-linux-android";
+    };
+};
+/**
+ * An architecture of Android (an ABI): arm64-v8a, armeabi-v7a or x86_64
+ */
+export type AndroidAbi = keyof typeof ANDROID_ABIS;
+/**
+ * The version of Node.js of a libnode: the one of its headers (include/node/node_version.h)
+ * @param directory the export of the libnode
+ * @internal
+ */
+export declare function mobileNodeVersion(directory: string): string;
+/**
+ * The architectures of Android a libnode is built for (libs/<abi>/libnode.so)
+ * @param directory the export of the libnode of Android
+ * @internal
+ */
+export declare function mobileNodeAbis(directory: string): AndroidAbi[];
+/**
+ * Check the export of a libnode of a system: its headers, and its libraries (Android: libs/<abi>/libnode.so, HarmonyOS:
+ * libs/arm64-v8a/libnode.so) or its framework (iOS: NodeMobile.xcframework)
+ * @param platform
+ * @param directory
+ * @internal
+ */
+export declare function checkMobileNode(platform: MobilePlatform, directory: string): void;
+/**
+ * The release of lakutata/libnode the mobile applications download their libnode from: its tag is v<release> (the
+ * version of Node.js, then -<revision> for a release of the same version built again)
+ */
+export declare const MOBILE_NODE_RELEASE: string;
+/**
+ * The options of {@link downloadMobileNode}
+ */
+export type MobileNodeDownloadOptions = {
+    /**
+     * The system downloaded for
+     */
+    platform: MobilePlatform;
+    /**
+     * The architectures of Android downloaded for, arm64-v8a and x86_64 by default (the devices, the emulators of the
+     * computers of Intel)
+     */
+    abis?: AndroidAbi[];
+    /**
+     * Called with what is being downloaded
+     */
+    progress?: (line: string) => void;
+};
+/**
+ * Download the libnode of a mobile system from the releases of lakutata/libnode (LAKUTATA_LIBNODE_MIRROR: a mirror of
+ * them), once: its archives are checked with the SHA256SUMS of the release and kept in the cache
+ * (~/.cache/lakutata/mobile, LAKUTATA_CACHE_DIR). LAKUTATA_MOBILE_NODE_DIR gives exports of a libnode of your own instead
+ * (a directory per system: android, ios, harmony; built with the repository of lakutata/libnode)
+ * @param options
+ * @returns the directory of the export: its headers (include/node) and its libraries (libs/<abi>/libnode.so) or its
+ * framework (NodeMobile.xcframework)
+ * @example
+ * import {downloadMobileNode} from '@lakutata/builder'
+ *
+ * const directory = await downloadMobileNode({platform: 'android', abis: ['arm64-v8a'], progress: console.log})
+ * console.log(directory)
+ */
+export declare function downloadMobileNode(options: MobileNodeDownloadOptions): Promise<string>;

package/dist/types/lib/mobile/Stage.d.ts

@@ -0,0 +1,111 @@
+import { type BundleResult } from '../Bundle.js';
+import { type IosSdk, type MobileAddons } from './Addons.js';
+import { type AndroidAbi, type MobilePlatform } from './Node.js';
+/**
+ * The options of {@link stageMobileApp}
+ */
+export type MobileStageOptions = {
+    /**
+     * The system the project is made for: Android (copied from the assets of the application into its files at its
+     * first launch), iOS (in the bundle of the application) or HarmonyOS (in the resources of the HAP)
+     */
+    platform: MobilePlatform;
+    /**
+     * The directory of the application (its package.json), the current one by default
+     */
+    project?: string;
+    /**
+     * The directory of the Node.js project made, which the native project of the system packs into the application
+     * (android/app/src/main/assets/nodejs, ios/nodejs, harmony/entry/src/main/resources/resfile/nodejs in the projects
+     * of the mobile-react template); made again at each stage
+     */
+    outdir: string;
+    /**
+     * The compiled entry of the application (the "main" of the package.json by default)
+     */
+    entry?: string;
+    /**
+     * Minify the bundle (true by default)
+     */
+    minify?: boolean;
+    /**
+     * The modules left out of the bundle, besides `@lakutata/netif` (the listening on network interfaces, which the
+     * mobile systems do not have)
+     */
+    external?: string[];
+    /**
+     * The libnode of the system: the directory it is put into (packages/ipc/native/node/out/<platform> in the projects
+     * of the mobile-react template), its headers (include/node) and its libraries. The bundle targets its version of
+     * Node.js (24.20.0 without it); the native addons are built against it, and need it
+     */
+    node?: string;
+    /**
+     * The architectures of Android the native addons are built for, the ones of the libnode by default
+     */
+    abis?: AndroidAbi[];
+    /**
+     * The SDKs of iOS the native addons are built for: iphoneos and iphonesimulator by default
+     */
+    sdks?: IosSdk[];
+    /**
+     * The directory of the frameworks of the native addons of iOS, a directory per SDK, which the project of iOS embeds
+     * in the application (`ios/NodeAddons` in the projects of the template); required by the native addons of iOS, the
+     * frameworks of the SDKs built made again at each stage
+     */
+    frameworks?: string;
+    /**
+     * The directory of the libraries of the HAP the native addons of HarmonyOS are put in
+     * (`harmony/entry/libs/arm64-v8a` in the projects of the template); required by the native addons of HarmonyOS, the
+     * libraries of the addons made before (libaddon-*.so) removed at each stage
+     */
+    libraries?: string;
+    /**
+     * Called with what is done (the native addons built, which takes a while)
+     */
+    progress?: (message: string) => void;
+};
+/**
+ * The Node.js project made by {@link stageMobileApp}
+ */
+export type MobileStage = {
+    /**
+     * Its directory: its manifest (package.json), its entry (main.js), the bundle of the application (app.cjs) and its
+     * resources (resources)
+     */
+    directory: string;
+    /**
+     * The system it is made for
+     */
+    platform: MobilePlatform;
+    /**
+     * The version of Node.js it is made for
+     */
+    node: string;
+    bundle: BundleResult;
+    /**
+     * What was done to the native addons of the application, undefined without addon
+     */
+    addons?: MobileAddons;
+};
+/**
+ * Make the Node.js project of a mobile application of React Native (Android, iOS, HarmonyOS), which the native module
+ * of the application runs in its libnode: the bundle of the application (CommonJS, for the version of Node.js of the
+ * libnode) and its resources (lakutata.resources), its manifest and its entry. The bundle holds the dependencies: the
+ * project is packed into the application as it is. The native addons are built for the system from the sources of their
+ * packages, against the headers and the libraries of the libnode: on Android, a native tree per architecture (node-gyp
+ * and the NDK of Android); on iOS, a framework per addon for each SDK (node-gyp and Xcode), in the directory of the
+ * frameworks the project of iOS embeds; on HarmonyOS, a library per addon (node-gyp and the native SDK of HarmonyOS),
+ * in the libraries of the HAP
+ * @param options
+ * @example
+ * import {stageMobileApp} from '@lakutata/builder'
+ *
+ * //In packages/app of a project of the mobile-react template, before the application of Android is built
+ * const stage = await stageMobileApp({
+ *     platform: 'android',
+ *     outdir: '../../android/app/src/main/assets/nodejs',
+ *     node: '../ipc/native/node/out/android'
+ * })
+ * console.log(stage.directory, stage.node)
+ */
+export declare function stageMobileApp(options: MobileStageOptions): Promise<MobileStage>;

package/dist/types/lib/nwjs/Addons.d.ts

@@ -0,0 +1,69 @@
+import type { NativeFile } from '../Native.js';
+import { type NwjsRelease } from './Runtime.js';
+/**
+ * Make an addon of Windows load in NW.js: the libraries it imports (imported or delay-loaded) named node.exe are named
+ * node.dll, the library of NW.js holding the functions of Node.js (Node-API). The delay-load hook of node-gyp gives an
+ * addon the executable when it loads node.exe, which in NW.js does not export them: the addon fails to load ("A dynamic
+ * link library (DLL) initialization routine failed"), or blocks NW.js. Named node.dll, the library is the one NW.js
+ * loaded. The addon is changed in place (its other bytes are kept); it then loads in NW.js only, not in Node.js.
+ * @param file the content of the addon (a .node file of Windows)
+ * @returns the names changed: 0 when it imports no node.exe (an addon built for NW.js, or loading Node.js otherwise)
+ * @internal
+ */
+export declare function nameNwjsNode(file: Buffer): number;
+/**
+ * The architectures of a native binary (Mach-O, possibly universal; ELF; PE) as node names them: x64, ia32, arm64, arm
+ * @param file
+ * @internal
+ */
+export declare function binaryArchitectures(file: Buffer): string[];
+/**
+ * Whether an addon uses the C++ API of V8 (NAN, v8.h) rather than Node-API: the names of the functions of V8 it imports
+ * (mangled by the Itanium ABI or by MSVC). Built for the V8 of Node.js, it does not run in the one of NW.js (Chromium)
+ * @param file
+ * @internal
+ */
+export declare function usesV8Api(file: Buffer): boolean;
+/**
+ * What {@link prepareNwjsAddons} did to the addons of the native tree
+ */
+export type NwjsAddons = {
+    /**
+     * The addons whose node.exe was named node.dll (Windows)
+     */
+    renamed: string[];
+    /**
+     * The packages built again from their sources: for the architecture of the runtime, or with the headers of NW.js
+     */
+    rebuilt: string[];
+};
+/**
+ * node-gyp: the one of the project, of the builder, else the one of npm
+ * @param project
+ * @internal
+ */
+export declare function nodeGyp(project: string): string;
+/**
+ * The directory of the package of a file (the one holding its package.json)
+ * @param file
+ * @internal
+ */
+export declare function packageOf(file: string): string | undefined;
+/**
+ * The .node files under a directory
+ * @param directory
+ * @internal
+ */
+export declare function nodeFiles(directory: string): Promise<string[]>;
+/**
+ * Make the addons of the native tree of an application of NW.js load in its runtime: the packages whose addons are not
+ * for the architecture of the runtime (built with the headers of its Node.js), or use V8 (NW.js 0.111.3 and later: the
+ * headers of NW.js), built again from their sources; on Windows, the node.exe they import named node.dll
+ * @param project
+ * @param directory the native tree
+ * @param files the files of the tree (their sources)
+ * @param release
+ * @param platform the build of NW.js (win-x64, osx-arm64…)
+ * @internal
+ */
+export declare function prepareNwjsAddons(project: string, directory: string, files: NativeFile[], release: NwjsRelease, platform: string): Promise<NwjsAddons>;

package/dist/types/lib/nwjs/Package.d.ts

@@ -0,0 +1,56 @@
+import { type NwjsRuntime } from './Runtime.js';
+import { type NwjsStage, type NwjsStageOptions } from './Stage.js';
+/**
+ * The options of {@link buildNwjsApp}
+ */
+export type NwjsAppOptions = Omit<NwjsStageOptions, 'outdir'> & {
+    /**
+     * The directory of the application made (dist/nwjs by default): <program>-<build of NW.js> in it
+     */
+    outdir?: string;
+    /**
+     * Called with what is being downloaded (the runtime of NW.js)
+     */
+    progress?: (line: string) => void;
+};
+/**
+ * The application of NW.js made by {@link buildNwjsApp}, distributed as it is or by its installers
+ */
+export type NwjsApp = {
+    /**
+     * Its directory: the runtime of NW.js and the application (Windows, Linux), the bundle of macOS (<product>.app)
+     */
+    directory: string;
+    /**
+     * Its executable, named after the program (<program>.exe, <product>.app/Contents/MacOS/nwjs, <program>)
+     */
+    executable: string;
+    /**
+     * The name of its program and of its product
+     */
+    program: string;
+    productName: string;
+    runtime: NwjsRuntime;
+    /**
+     * The application staged (its release, its addons): its directory is removed once copied
+     */
+    stage: NwjsStage;
+};
+/**
+ * Make the application of NW.js of a project for this system: the runtime of NW.js (normal) with the application
+ * (stageNwjsApp: its bundle, its native addons made to load in NW.js, its resources, its manifest), named after it.
+ * On Windows and Linux, the files of the application are next to its executable (nw.exe, nw renamed after its program:
+ * the name of its installers, lakutata.installer.name, else the program of its package; on Windows, its icon and its
+ * version information are the ones of the application); on macOS, they are in the bundle
+ * (<product>.app/Contents/Resources/app.nw), whose Info.plist gives its name, its identifier (the appId of the
+ * installer), its version and its icon, signed again (ad hoc). The icon is lakutata.icon. Its files are readable by
+ * every user, its programs runnable (once installed by root, the application runs for the users)
+ * @param options
+ * @example
+ * import {buildNwjsApp} from '@lakutata/builder'
+ *
+ * //dist/nwjs/desk-osx-arm64/Desk.app on a Mac with Apple silicon
+ * const app = await buildNwjsApp({})
+ * console.log(app.directory, app.runtime.version)
+ */
+export declare function buildNwjsApp(options: NwjsAppOptions): Promise<NwjsApp>;

package/dist/types/lib/nwjs/Runtime.d.ts

@@ -0,0 +1,120 @@
+/**
+ * A release of NW.js: its version and the ones of the Node.js and the Chromium it embeds, the systems it is built for
+ */
+export type NwjsRelease = {
+    /**
+     * The version of NW.js (0.119.2)
+     */
+    version: string;
+    /**
+     * The day it was released (2026/10/22)
+     */
+    date: string;
+    /**
+     * The version of the Node.js it embeds (26.12.1)
+     */
+    node: string;
+    /**
+     * The version of the Chromium it embeds (156.0.8078.48)
+     */
+    chromium: string;
+    /**
+     * The systems it is built for: win-x64, win-ia32, win-arm64, osx-x64, osx-arm64, linux-x64, linux-ia32, linux-arm64
+     */
+    platforms: string[];
+};
+/**
+ * The flavors of NW.js: normal (the one shipped), sdk (with the developer tools, for the development)
+ */
+export type NwjsFlavor = 'normal' | 'sdk';
+/**
+ * The options of {@link downloadNwjs}
+ */
+export type NwjsRuntimeOptions = {
+    /**
+     * The version of NW.js: a version (0.72.0), latest (the latest release) or win7 (0.72.0, the last one running on
+     * Windows 7, 8 and 8.1)
+     */
+    version: string;
+    /**
+     * normal (by default) or sdk
+     */
+    flavor?: NwjsFlavor;
+    /**
+     * The system (process.platform: win32, darwin, linux), the one of the machine by default
+     */
+    platform?: NodeJS.Platform;
+    /**
+     * The architecture (process.arch: x64, ia32, arm64), the one of the machine by default. On a Mac with Apple silicon,
+     * a release without osx-arm64 (before 0.77) is the x64 one, run by Rosetta
+     */
+    arch?: string;
+    /**
+     * Called with what is being downloaded
+     */
+    progress?: (line: string) => void;
+};
+/**
+ * A runtime of NW.js, downloaded into the cache
+ */
+export type NwjsRuntime = NwjsRelease & {
+    flavor: NwjsFlavor;
+    /**
+     * Its system and its architecture as NW.js names them (osx-arm64)
+     */
+    platform: string;
+    /**
+     * The directory of the runtime: nw.exe and its libraries, nwjs.app, nw and its libraries
+     */
+    directory: string;
+    /**
+     * Its executable: nw.exe, nwjs.app/Contents/MacOS/nwjs, nw
+     */
+    executable: string;
+};
+/**
+ * Compare two versions (1.2.3)
+ * @param left
+ * @param right
+ */
+export declare function compareVersions(left: string, right: string): number;
+/**
+ * The releases of NW.js, newest first: the list of nwjs.io (LAKUTATA_NWJS_VERSIONS), kept a day in the cache; the
+ * cached one when it cannot be read
+ * @example
+ * import {nwjsReleases} from '@lakutata/builder'
+ *
+ * for (const release of (await nwjsReleases()).slice(0, 3)) console.log(release.version, release.node, release.chromium)
+ */
+export declare function nwjsReleases(): Promise<NwjsRelease[]>;
+/**
+ * A release of NW.js: a version, latest (the latest release) or win7 (0.72.0, the last one running on Windows 7, 8
+ * and 8.1). Refused when it embeds a Node.js older than the one lakutata runs on (18.10)
+ * @param version
+ * @example
+ * import {nwjsRelease} from '@lakutata/builder'
+ *
+ * const release = await nwjsRelease('win7')
+ * console.log(release.version, release.node, release.chromium) //0.72.0 19.3.0 109.0.5414.87
+ */
+export declare function nwjsRelease(version: string): Promise<NwjsRelease>;
+/**
+ * The system and the architecture of a release as NW.js names them (osx-arm64), the x64 build on a Mac with Apple
+ * silicon when the release has no arm64 one
+ * @param release
+ * @param platform
+ * @param arch
+ */
+export declare function nwjsPlatform(release: NwjsRelease, platform?: NodeJS.Platform, arch?: string): string;
+/**
+ * A runtime of NW.js for a system, downloaded once into the cache (~/.cache/lakutata/nwjs, LAKUTATA_CACHE_DIR) from
+ * dl.nwjs.io (LAKUTATA_NWJS_MIRROR: a mirror of it) and checked with the SHASUMS256.txt of its release
+ * @param options
+ * @example
+ * import {downloadNwjs} from '@lakutata/builder'
+ *
+ * //The NW.js of the development (its developer tools), for the machine
+ * const runtime = await downloadNwjs({version: 'latest', flavor: 'sdk'})
+ * console.log(runtime.executable, runtime.node)
+ */
+export declare function downloadNwjs(options: NwjsRuntimeOptions): Promise<NwjsRuntime>;