feat: build-target options

docs: update readme with new usage
fix: don't call next twice
2017-09-01 00:28:10 -05:00 · 2017-08-31 13:59:01 -05:00 · 2017-08-31 10:02:12 -05:00 · 2017-08-31 08:46:50 -05:00 · 2017-08-31 01:15:51 -05:00 · 2017-08-30 15:32:26 -05:00
83 changed files with 5042 additions and 10050 deletions
@@ -4,5 +4,6 @@ end_of_line = lf
 charset = utf-8
 indent_style = space
 indent_size = 2
-trim_trailing_whitespace = true
+#https://github.com/Microsoft/vscode/issues/23983#event-1087502108
+#trim_trailing_whitespace = true
 insert_final_newline = true
@@ -1,33 +0,0 @@
-{
-  "parser": "@typescript-eslint/parser",
-  "parserOptions": {
-    "ecmaVersion": 2020,
-    "sourceType": "module"
-  },
-  "extends": [
-    "eslint:recommended",
-    "plugin:@typescript-eslint/recommended",
-    "prettier"
-  ],
-  "plugins": ["@typescript-eslint", "prettier"],
-  "rules": {
-    "prettier/prettier": "warn",
-    "@typescript-eslint/no-explicit-any": "off",
-    "@typescript-eslint/no-unused-vars": ["warn", { "argsIgnorePattern": "^_" }],
-    "@typescript-eslint/ban-ts-comment": "off",
-    "@typescript-eslint/explicit-module-boundary-types": "off",
-    "@typescript-eslint/no-var-requires": "off",
-    "@typescript-eslint/ban-types": "off",
-    "@typescript-eslint/no-non-null-assertion": "warn",
-    "@typescript-eslint/no-empty-function": "warn",
-    "no-useless-escape": "warn",
-    "no-empty": "warn",
-    "no-constant-condition": "warn",
-    "prefer-const": "warn"
-  },
-  "env": {
-    "node": true,
-    "es6": true
-  },
-  "ignorePatterns": ["lib/", "node_modules/", "*.js", "webpack.config.ts"]
-}
@@ -1 +0,0 @@
-custom: https://www.paypal.me/calebsboyd
@@ -1,23 +0,0 @@
---
-name: Bug Report
-about: Report a bug encountered while running Nexe
-labels: bug
-
---
-<!-- Please use this template while reporting a bug and provide as much info as possible. Not doing so may result in your bug not being addressed in a timely manner. Thanks!
-->
-
-**What happened**:
-
-**What you expected to happen**:
-
-**How to reproduce it (as minimally and precisely as possible)**:
-
-**Anything else we need to know?**:
-
-**Environment**:
- Platform(OS/Version):
- Host Node Version:
- Target Node Version:
- Nexe version:
- Python Version:
@@ -1,11 +0,0 @@
---
-name: Feature Request
-about: Suggest an feature request
-labels: feature
-
---
-<!-- Please only use this template for submitting feature requests -->
-
-**What would you like to be added**:
-
-**Why is this needed**:
@@ -1,11 +0,0 @@
-**What this PR does / why we need it**:
-
-**Which issue(s) this PR fixes**:
-<!--
-*Automatically closes linked issue when PR is merged.
-Usage: `Fixes #<issue number>`, or `Fixes (paste link of issue)`.
-_If PR is about `failing-tests or flakes`, please post the related issues/tests in a comment and do not use `Fixes`_*
-->
-Fixes #
-
-**Special notes for your reviewer**:
@@ -1,21 +0,0 @@
-name: No Response
-
-# Both `issue_comment` and `scheduled` event types are required for this Action
-# to work properly.
-on:
-  issue_comment:
-    types: [created]
-  schedule:
-    # 9AM Central
-    - cron: '0 14 * * *'
-
-jobs:
-  noResponse:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: lee-dohm/no-response@v0.5.0
-        with:
-          token: ${{ github.token }}
-          closeComment: 'Closed awaiting response from OP, please open a new issue with the requested information and/or examples'
-          daysUntilClose: 21
-          responseRequiredLabel: more-information-needed
@@ -1,160 +0,0 @@
-name: Build and test asset
-
-on:
-  schedule:
-    - cron: '0 10 * * 1'          # every Monday at 10:00 UTC
-  workflow_dispatch:
-    inputs:
-      versions:
-        description: 'Node.js version(s) as JSON array'
-        required: true
-        default: '[ "lts/*", "22", "24" ]'
-  pull_request:
-    branches: [ master ]
-  push:
-    tags: [ '*' ]
-
-jobs:
-  build:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ windows-latest, macos-latest, ubuntu-latest ]
-        # Use the input versions if provided, otherwise fall back to default
-        version: ${{ fromJSON(inputs.versions || '[ "lts/*", "22", "24" ]') }}
-    env:
-      NEXE_ASSET: ${{ github.workspace }}/nexe-asset
-      NEXE_TMP_CACHE_PATH: ${{ github.workspace }}/nexe-tmp
-      NEXE_TMP: ${{ github.workspace }}/nexe-tmp/standard
-      CCACHE_COMPRESS: '1'
-      ErrorView: NormalView
-    steps:
-      # Checkout repository
-      - uses: actions/checkout@v4
-
-      # Set up Node.js (using matrix version)
-      - uses: actions/setup-node@v4
-        with:
-          node-version: ${{ matrix.version }}
-
-      # Record the exact Node.js version for later use (cross‑platform)
-      - name: Record exact Node.js version
-        shell: bash
-        run: echo "NODEJS_VERSION=$(node -p process.versions.node)" >> $GITHUB_ENV
-
-      # Install Node dependencies
-      - run: npm ci
-
-      # Python may be needed for native addons
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.9'
-
-      # Windows: install NASM (required for some native modules)
-      - if: matrix.os == 'windows-latest'
-        run: choco install nasm
-
-      # Ubuntu: update package lists (kept for safety, can be removed if not needed)
-      - if: matrix.os == 'ubuntu-latest'
-        run: sudo apt-get update
-
-      # Linux/macOS: enable compiler caching with ccache
-      - if: matrix.os != 'windows-latest'
-        uses: hendrikmuhs/ccache-action@v1.2
-        with:
-          create-symlink: true
-          key: ${{ github.job }}-${{ matrix.os }}-${{ matrix.version }}
-
-      # Windows: adjust asset name and suffix
-      - if: matrix.os == 'windows-latest'
-        shell: bash
-        run: |
-          echo "NEXE_ASSET=${NEXE_ASSET}.exe" >> $GITHUB_ENV
-          echo "EXECUTABLE_SUFFIX=.exe" >> $GITHUB_ENV
-
-      # Main build & test (asset + integration)
-      - name: Build and test asset
-        run: node tasks/asset-build && node tasks/asset-test-build && npm run test:integration:run
-
-      # Rename the built asset to include target platform info
-      - name: Update release artifact name
-        shell: bash
-        run: |
-          nexe_target="$(node -p 'require("./lib/target").getTarget().toString()')"
-          echo "NEXE_TARGET=${nexe_target}" >> $GITHUB_ENV
-          artefact_name="nexe-asset-${nexe_target}"
-          mv "${NEXE_ASSET}" "${artefact_name}"
-          echo "NEXE_ASSET=${artefact_name}" >> $GITHUB_ENV
-
-      # Upload main asset
-      - name: Upload asset artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: ${{ env.NEXE_ASSET }}
-          path: ${{ env.NEXE_ASSET }}
-          if-no-files-found: error
-
-      # Upload integration test binary
-      - name: Upload integration test artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: integration-tests-${{ env.NEXE_TARGET }}${{ env.EXECUTABLE_SUFFIX }}
-          path: integration-tests${{ env.EXECUTABLE_SUFFIX }}
-          if-no-files-found: error
-
-      # If this is a tag push, attach the asset to the release
-      - if: startsWith(github.ref, 'refs/tags/')
-        uses: softprops/action-gh-release@v2
-        with:
-          fail_on_unmatched_files: true
-          prerelease: true
-          files: ${{ env.NEXE_ASSET }}
-
-      # Extra step for Ubuntu: build static (musl) version
-      - if: matrix.os == 'ubuntu-latest'
-        name: musl static build
-        shell: bash
-        run: |
-          # Determine musl target and set up environment
-          nexe_target="$(node -p 'require("./lib/target").getTarget({ platform: "static" }).toString()')"
-          echo "NEXE_TARGET=${nexe_target}" >> $GITHUB_ENV
-          artefact_name="nexe-asset-${nexe_target}"
-          export NEXE_ASSET="${artefact_name}"
-          echo "NEXE_ASSET=${NEXE_ASSET}" >> $GITHUB_ENV
-          export MUSL_BUILD=yes NEXE_TMP="${NEXE_TMP_CACHE_PATH}/musl"
-
-          # Set up cross‑compiler with ccache
-          eval $(npx -p node-musl musl-exports)
-          export CC="ccache ${CC}" CXX="ccache ${CXX}" LD="ccache ${LD}"
-
-          # Build and test musl version
-          node tasks/asset-build
-          node tasks/asset-test-build
-          npm run test:integration:run
-
-      # Upload musl asset
-      - if: matrix.os == 'ubuntu-latest'
-        name: Upload musl asset
-        uses: actions/upload-artifact@v4
-        with:
-          name: ${{ env.NEXE_ASSET }}
-          path: ${{ env.NEXE_ASSET }}
-          if-no-files-found: error
-
-      # Upload musl integration test binary
-      - if: matrix.os == 'ubuntu-latest'
-        name: Upload musl integration test
-        uses: actions/upload-artifact@v4
-        with:
-          name: integration-tests-${{ env.NEXE_TARGET }}${{ env.EXECUTABLE_SUFFIX }}
-          path: integration-tests
-          if-no-files-found: error
-
-      # If this is a tag push, also attach the musl asset to the release
-      - if: startsWith(github.ref, 'refs/tags/') && matrix.os == 'ubuntu-latest'
-        uses: softprops/action-gh-release@v2
-        with:
-          fail_on_unmatched_files: true
-          prerelease: true
-          files: ${{ env.NEXE_ASSET }}
@@ -1,12 +1,9 @@
 .DS_Store
 temp/
 coverage
-nexe
 node_modules
 *.log
 *.exe
-*.bin
-!winsw.exe
 .idea
 .nexe
 lib
@@ -0,0 +1,7 @@
+language: node_js
+node_js:
+- '6'
+script: npm run nexe-build
+env:
+  global:
+    secure: LyC6djYqPfPKz5gHILES9JmSRxQ+ntKOcoaZNM5WID0+gogUoXZBhcmmtvq9RnMpFZN3pYujY6LB5iy7QS2seGjg+feyewNKI30yIK6N9ulJyZZKmrJVDdRx4wvl8YVTkttjcJFkanDGa6zRvFfFDKx/iIdcWLEpnqR/WO1ppf8=
@@ -1,3 +1,5 @@
 {
-    "recommendations": [ "ms-vscode.vscode-typescript-tslint-plugin" ]
+    "recommendations": [
+      "esbenp.prettier-vscode"
+    ]
 }
@@ -1,7 +1,8 @@
 {
-  "tslint.enable": true,
-  "tslint.run": "onType",
-  "tslint.autoFixOnSave": true,
+  "typescript.tsdk": "./node_modules/typescript/lib",
+  "prettier.semi": false,
+  "prettier.singleQuote": true,
+  "prettier.typescriptEnable": ["typescript"],
  "files.exclude": {
    "**/.git": true,
    "**/.svn": true,
@@ -13,6 +14,5 @@
    "lib/**/*": true,
    "**/node_modules": true,
    "**/bower_components": true
-  },
-  "typescript.tsdk": "node_modules\\typescript\\lib"
+  }
 }
@@ -1,4 +1,4 @@
-Copyright (c) 2013-2018 Nexe Contributors
+Copyright (c) 2013-2017 Nexe Contributors

 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
@@ -1,23 +1,22 @@
-
 <p align="center"><img src="https://cloud.githubusercontent.com/assets/2391349/23598327/a17bb68a-01ee-11e7-8f55-88a5fc96e997.png" /></p>

 <p align="center">
-  <a href="https://dev.azure.com/nexe-ci/Nexe/_build?definitionId=1"><img src="https://img.shields.io/azure-devops/build/nexe-ci/nexe/1/master.svg" alt="Build Status"></a>
+  <a href="https://circleci.com/gh/nexe/nexe"><img src="https://img.shields.io/circleci/project/nexe/nexe.svg" alt="Build Status"></a>
  <a href="https://www.npmjs.com/package/nexe"><img src="https://img.shields.io/npm/dt/nexe.svg" alt="Downloads"></a>
  <a href="https://www.npmjs.com/package/nexe"><img src="https://img.shields.io/npm/v/nexe.svg" alt="Version"></a>
  <a href="https://www.npmjs.com/package/nexe"><img src="https://img.shields.io/npm/l/nexe.svg" alt="License"></a>
-  <a href="https://discord.gg/2qTH52zNcZ"><img src="https://discordapp.com/api/guilds/814334925049561168/widget.png?style=shield"></a>
 </p>

-<p align="center">Install:&nbsp<code>npm i nexe -g</code></p>
+<p align="center"><code>npm i nexe@beta -g</code></p>
 <p align="center">Nexe is a command-line utility that compiles your Node.js application into a single executable file.</p>

 <p align="center">
-  <img src="https://user-images.githubusercontent.com/5818726/30999006-df7e0ae0-a497-11e7-96db-9ce87ae67b34.gif"/>
+  <img src="https://cloud.githubusercontent.com/assets/5818726/26533446/ce19ee5a-43de-11e7-9540-caf7ebd93370.gif"/>
 </p>

 ## Motivation and Features

+- Supports production ready builds
 - Self contained applications
 - Ability to run multiple applications with *different* node.js runtimes.
 - Distribute binaries without needing node / npm.
@@ -29,70 +28,40 @@

 ## Usage

- Application entrypoint:
+- Existing application bundle:

-  `nexe my-app.js`
+  `nexe my-app-bundle.js -o my-app`

 - stdin interface

-  `rollup -c | nexe --resource "./public/**/*" -o my-app.exe`
+  `rollup -c | nexe --resource ./public/**/* -o my-app.exe`

 For more CLI options see: `nexe --help`

-### Examples
+## Including Additional Resources

- `nexe server.js -r "public/**/*.html"`
- `nexe --build`
- `nexe -t x86-8.0.0`
+Additional resources can be added to the binary by passing `-r glob/pattern/**/*`. These included files can be read in the application by using `fs.readFile` or `fs.readFileSync`

-## Resources
+## Compiling Node

-Additional files or resources can be added to the binary by passing `-r "glob/pattern/**/*"`. These included files can be read in the application by using `fs.readFile` or `fs.readFileSync`.
+By default `nexe` will attempt to download a pre-built executable. However, some users may want to customize the way node is built, either by changing the flags, providing a different icon, or different executable details. To build node, use the `build` option/flag

-## Compiling the nexe Executable
-
-By default `nexe` will attempt to download a pre-built executable. These are listed on the [releases page](https://github.com/nexe/nexe/releases/tag/v3.3.3). The exact version you want may be unavailable or you may want to customize what is built. See `nexe --help` for a list of options available when passing the [`--build`](#build-boolean) option. You will also need to ensure your environment is setup to [build node](https://github.com/nodejs/node/blob/master/BUILDING.md). Note: the `python` binary in your path should be an acceptable version of python 3; you can create a [symlink](https://github.com/nexe/nexe/issues/354#issuecomment-319874486) or use the `--python` parameter (e.g. `nexe --build --python=$(which python3)`).
-
-### Linux and macOS
-[Prerequisites & details](https://github.com/nodejs/node/blob/master/BUILDING.md#unix-and-macos)
-
-### Windows
-
-The fastest and most reliable way to get started is simply to run the commands below. If you'd rather read the details or perform a manual install of the prerequisites, [you can find that here](https://github.com/nodejs/node/blob/master/BUILDING.md#windows).
-
-The instructions below are the fastest and most reliable method.
-Run the following sets of commands with PowerShell (running as Administrator).
-
-**Install all required build tools (and dependencies):**
-```
-Set-ExecutionPolicy Unrestricted -Force
-iex ((New-Object System.Net.WebClient).DownloadString('https://boxstarter.org/bootstrapper.ps1'))
-get-boxstarter -Force
-Install-BoxstarterPackage https://raw.githubusercontent.com/nodejs/node/master/tools/bootstrap/windows_boxstarter -DisableReboots
-```
-
-**Set config:**
-```
-npm config set msvs_version 2019
-npm config set python python3.8
-```
-Where `2019` is the version of Visual Studio you have (if you have it).
-
-**Notes:**
- The above works and has been tested with node.js `14.5.4` and `15.8.0`
- Python 3 and Python 2 can coexist and `nexe` will still work, considering the `set config` area above
- Don't use `npm install windows-build-tools` unless you're having some type of issue, because the above commands configures and installs the latest/preferred too.
+Nexe also exposes its patching pipeline to the user. This allows the application of simple patching of node sources prior to compilation.

 ## Node.js API

+Using Nexe Programatically
+
 #### Example

+
 ```javascript
 const { compile } = require('nexe')

 compile({
  input: './my-app.js',
-  build: true, //required to use patches
+  output: './my-app.exe',
+  build: true, //builds node
  patches: [
    async (compiler, next) => {
      await compiler.setFileContentsAsync(
@@ -106,141 +75,92 @@ compile({
  console.log('success')
 })
 ```
-## NexeOptions

-### `options: object`
+### `options`

+ - #### `build: boolean`
+    - Build node from source (required in beta)
 - #### `input: string`
    - Input bundle file path
    - default: stdin or the current directory's main file (package.json)
 - #### `output: string`
    - Output executable file path
    - default: same as `name` with an OS specific extension.
- - #### `target: string | object`
-    - An object or string describing platform-arch-version. e.g. `'windows-ia32-10.13.0'`
-      - each segment is optional, and will be merged with the current environment
-      - Examples: ([full list](https://github.com/nexe/nexe/releases))
-        - `'win32-x86-10.13.0`
-        - `{ platform: 'alpine' }`
-        - `darwin-10.13.0`
-        - `linux-x64`
-        - `macos-10.13.0`
-
-        See [test/target.spec.ts](test/target.spec.ts)
-    - If the [`build`](#build-boolean) flag is set, the platform portion of the target is ignored.
-    - default: `process`
+ - #### `target: string`
+    - Dash seperated platform-architecture-version. e.g. `'win32-ia32-6.10.3'`
+    - default: `[process.platform, process.arch, process.version.slice(1)].join('-')`
 - #### `bundle: string | boolean`
    - If a string is provided it must be a valid relative module path
    and should provide an export with the following signature:
    ```typescript
-    export function createBundle (options: NexeOptions): Promise<string>
+    export function createBundle (
+      filename: string,
+      options: { name: string, minify: any, cwd: string }
+    ): Promise<string>`
    ```
-    - default: true
- - #### `bundleRules: object`
-    - Configuration for the runtime module resolution inside the snapshot.
-    This controls how bare module specifiers (e.g., `require('lodash')`) are resolved from the embedded `node_modules`.
-    - Properties:
-        - `conditions?: string[]` – The set of [conditions](https://nodejs.org/api/packages.html#conditional-exports) to use when evaluating the exports field of a package.
-    - Example:
-    ```
-    javascript
-    {
-      conditions: ['require', 'node', 'production'],
-      basePath: '/snapshot/packages'
-    }
-    ```
-    - default: `{ conditions: ['require', 'node', 'default'], basePath: '/snapshot/node_modules' }`
+    - default: true, uses the internal fuse-box configuration
 - #### `name: string`
    - Module friendly name of the application
    - default: basename of the input file, or `nexe_${Date.now()}`
 - #### `cwd: string`
    - Directory nexe will operate on as though it is the cwd
    - default: process.cwd()
- - #### `mangle: boolean`
-    - If set to false, nexe will not include the virtual filesystem (your application and resources) on the output.
-    - This will cause the output to error as an "Invalid Binary" unless a userland patch alters the contents of lib/_third_party_main.js in the nodejs source.
-    - default: true
- - #### `build: boolean`
-    - Build node from source, passing this flag tells nexe to download and build from source. Subsequently using this flag will cause nexe to use the previously built binary. To rebuild, first add [`--clean`](#clean-boolean)
- - #### `remote: string`
-    - Provide a custom remote location for fetching pre-built nexe binaries from. This can either be an HTTP or HTTPS URL.
-    - default: `null`
- - #### `asset: string`
-    - Provide a pre-built nexe binary asset, this is a file path is resolved relative to cwd.
+ - #### `version: string`
+    - The Node version you're building for
+    - default: `process.version.slice(1)`
 - #### `python: string`
-    - On Linux this is the path pointing to your python3 executable
+    - On Linux this is the path pointing to your python2 executable
    - On Windows this is the directory where `python` can be accessed
    - default: `null`
- - #### `flags: string[]`
+ - #### `flags: Array<string>`
    - Array of node runtime flags to build node with.
    - Example: `['--expose-gc']`
    - default: `[]`
- - #### `configure: string[]`
+ - #### `configure: Array<string>`
    - Array of arguments for the node build configure step
    - Example: `['--with-dtrace', '--dest-cpu=x64']`
    - default: `[]`
- - #### `make: string[]`
-    - Array of arguments for the node build make step
-    - default: `[]`
- - #### `vcBuild: string[]`
-    - Options for windows build
-    - default: `['nosign', 'release']`
+ - #### `make: Array<string>`
+    - Array of arguments for the node build make step, on windows this step recieves options for vcBuild.bat
+    - default: `[]` or `['nosign', 'release']` for non windows systems
+ - #### `make: Array<string>`
+    - Alias for `make` option
 - #### `snapshot: string`
    - path to a file to be used as the warmup snapshot for the build
    - default: `null`
- - #### `resources: string[]`
+ - #### `resources: Array<string>`
    - Array of globs with files to include in the build
    - Example: `['./public/**/*']`
    - default: `[]`
 - #### `temp: string`
    - Path to use for storing nexe's build files
    - Override in the env with `NEXE_TEMP`
-    - default: `~/.nexe`
+    - default: `./.nexe` in the cwd
 - #### `ico: string`
-    - Path to a user provided icon to be used (Windows only). Requires `--build` to be set.
+    - Path to a user provided icon to be used (Windows only).
 - #### `rc: object`
    - Settings for patching the [node.rc](https://github.com/nodejs/node/blob/master/src/res/node.rc) configuration file (Windows only).
-    - Example (keys may vary depending on the version. Reference the file linked above):
-      ```javascript
-        {
-          CompanyName: "ACME Corp",
-          PRODUCTVERSION: "17,3,0,0",
-          FILEVERSION: "1,2,3,4"
-          ...
-        }
-      ```
+    - Example: `{ CompanyName: "ACME Corp" }`
    - default: `{}`
 - #### `clean: boolean`
-    - If included, nexe will remove temporary files for the accompanying configuration and exit
+    - If included, nexe will remove temporary files for accompanying configuration and exit
 - #### `enableNodeCli: boolean`
-    - Enable the original Node CLI (will prevent application cli from working).
-    - Node CLI arguments passed via the [NODE_OPTIONS](https://nodejs.org/api/cli.html#cli_node_options_options) environment
-      variable will still be processed. NODE_OPTIONS support can be disabled with the `--without-node-options` configure flag.
+    - Enable the original Node CLI (will prevent application cli from working)
    - default: `false`
-  - #### `fakeArgv: boolean`
-    - fake the entry point file name (`process.argv[1]`). If nexe was used with stdin this will be `'[stdin]'`.
- - #### `ghToken: string`
-    - Provide a Github Token for accessing nexe releases
-    - This is usually needed in CI environments
-    - default: `process.env.GITHUB_TOKEN`
 - #### `sourceUrl: string`
-    - Provide an alternate url for the node source code
-    - Note: temporary files will still be created for this under the specified version
+    - Provide an alternate url for the node source. Should be a `.tar.gz`
 - #### `loglevel: string`
    - Set the loglevel, info, silent, or verbose
    - default: `'info'`
- - #### `patches: NexePatch[]`
+ - #### `patches: Array<NexePatch>`
    - Userland patches for patching or modifying node source
    - default: `[]`
- - #### `plugins: NexePatch[]`
-    - Userland plugins for modifying nexe executable behavior
-    - default: `[]`

 ### `NexePatch: (compiler: NexeCompiler, next: () => Promise<void>) => Promise<void>`

-Patches and Plugins are just a middleware functions that take two arguments, the `compiler`, and `next`. The compiler is described below, and `next` ensures that the pipeline continues. Its invocation should always be awaited or returned to ensure correct behavior. Patches also require that [`--build`](#build-boolean) be set, while plugins do not.
+A patch is just a middleware function that takes two arguments, the `compiler`, and `next`. The compiler is described below, and `next` ensures that the pipeline continues. Its invocation should always be awaited or returned to ensure correct behavior.

-For examples, see the built in patches: [src/patches](src/patches).
+For examples, see the built in patches: [src/patches](src/patches)

 ### `NexeCompiler`

@@ -250,9 +170,7 @@ For examples, see the built in patches: [src/patches](src/patches).
    - Quickly perform a replace in a file within the downloaded Node.js source. The rest arguments are passed along to `String.prototype.replace`
 - `readFileAsync(filename: string): Promise<NexeFile>`
    - Access (or create) a file within the downloaded Node.js source.
- - `addResource(filename: string, contents: Buffer): Promise<void>`
-    - Add a resource to the nexe bundle
- - `files: NexeFile[]`
+ - `files: Array<NexeFile>`
    - The cache of the currently read, modified, or created files within the downloaded Node.js source.

 #### `NexeFile`
@@ -262,33 +180,19 @@ For examples, see the built in patches: [src/patches](src/patches).

 Any modifications made to `NexeFile#contents` will be maintained in the cache _without_ the need to explicitly write them back out, e.g. using `NexeCompiler#setFileContentsAsync`.

-## Native Modules
+### Native Modules

-In order to use native modules, the native binaries must be shipped alongside the binary generated by nexe.
+Nexe has a plugin built for use with [fuse-box](http://fuse-box.org) > 2.2.1. This plugin currently supports modules that require `.node` files and those that use the `bindings` module.
+Take a look at the [example](examples/native-build/build.js)

-## Troubleshooting
+- [ ] Implement support `node-pre-gyp#find`.

-`Error: Entry file "" not found!` means you need to provide `nexe` with input. Either use `-i` or pipe data to it.
+## Maintainers

-`Error: https://github.com/nexe/nexe/releases/download/v3.3.3/windows-x64-15.8.0 is not available, create it using the --build flag` or similar message means that it either:
- You are having networking issues such as the download being blocked
- You should specify the target so `nexe` knows what version of the executable to use.
-	- See the [releases page](https://github.com/nexe/nexe/releases) to find the executable's version number
-	- Example
-		- `nexe -i "app.js" -r "public/**/*.html" -o "dist/myApp.exe" -t x64-14.15.3`
-		- where `-i` specifies the input, `-r` specifies resources to embed, `-o` specifies the output, `-t` specifies the target.
-	- Alternatively you can compile the executable yourself, see that section for details
+[![Jared Allard](https://avatars.githubusercontent.com/u/2391349?s=130)](https://jaredallard.me/) | [![Caleb Boyd](https://avatars.githubusercontent.com/u/5818726?s=130)](https://github.com/calebboyd) | [![Christopher Karper](https://avatars.githubusercontent.com/u/653156?s=130)](https://github.com/ckarper) | [![Dustin Greif](https://avatars.githubusercontent.com/u/3026298?s=130)](https://github.com/dgreif) |
+---|---|---|---
+[Jared Allard](https://github.com/jaredallard) | [Caleb Boyd](http://github.com/calebboyd) | [Christopher Karper](https://github.com/ckarper) | [Dustin Greif](https://github.com/dgreif) |

-## Contributing
+### Former

-Building
-```
-$ git clone git@github.com:nexe/nexe.git
-$ cd nexe
-$ npm i && npm run build
-```
-
-Testing
-```
-$ npm test
-```
+- [Craig Condon](http://crcn.codes/)
@@ -0,0 +1,21 @@
+environment:
+  CIRCLE_TOKEN:
+    secure: TQKcepXmTzCNt4+tUBtYpwEQkdSPwFr9A8ugtoMhNbKu/SW1WM1EpjEu6kYXxpQ4
+  TRAVIS_TOKEN:
+    secure: tR7HXYv3x97q90uvPrjUxKZh7R1+uqKct0HdEcqTbsg=
+  GITHUB_TOKEN:
+    secure: 3wuEGJsppSKFvdwhp3jprUA9Zkc3WINlc/9oFXjhAR6J05lYMXP7Fl7lXTKpkGZx
+branches:
+  except:
+    - master
+install:
+  - ps: Install-Product node 6
+  - npm i
+build: off
+test: off
+build_script:
+  - npm run nexe-build
+artifacts:
+  - path: .nexe\**\node.exe
+cache:
+  - node_modules
@@ -1,73 +0,0 @@
-schedules:
- cron: "0 8 * * *"
-  displayName: "Daily Build 1"
-  always: true
-  branches:
-    include:
-      - master
- cron: "0 13 * * *"
-  displayName: "Daily Build 2"
-  always: true
-  branches:
-    include:
-      - master
- cron: "0 19 * * *"
-  displayName: "Daily Build 3"
-  always: true
-  branches:
-    include:
-      - master
-jobs:
- job: BaseBuild
-  timeoutInMinutes: 360
-  strategy:
-    matrix:
-      linux:
-        imageName: 'ubuntu-16.04'
-      mac:
-        imageName: 'macos-10.15'
-      windows_2017:
-        imageName: 'vs2017-win2016'
-      windows_2015:
-        imageName: 'vs2017-win2016'
-      alpine:
-        imageName: 'ubuntu-16.04'
-  pool:
-    vmImage: $(imageName)
-  steps:
-  - task: UsePythonVersion@0
-    displayName: Setup Python
-    inputs:
-      versionSpec: '2.7'
-      architecture: 'x64'
-  - task: NodeTool@0
-    displayName: Install Node
-    inputs:
-      versionSpec: '12.x'
-  - script: sudo apt-get update && sudo apt-get install -y libc6-dev-i386 gcc-multilib g++-multilib
-    condition: contains(variables['Agent.JobName'], 'linux')
-    displayName: Install Linux build dependencies
-  - script: npm config set msvs_version 2015
-    condition: contains(variables['Agent.JobName'], 'windows_2015')
-    displayName: Install Windows build dependencies
-  - script: npm install && npm run ci:build
-    displayName: Build Nexe
-    env:
-      GITHUB_TOKEN: $(PersonalGithubToken)
-      NEXE_VERBOSE: $(NEXE_VERBOSE)
-      msbuild_args: /3G
-    condition: not(contains(variables['Agent.JobName'], 'windows'))
-  - powershell: |
-      choco install nasm
-      npm install
-      npm run ci:build
-    displayName: Build Nexe (Windows)
-    condition: contains(variables['Agent.JobName'], 'windows')
-    env:
-      GITHUB_TOKEN: $(PersonalGithubToken)
-      NEXE_VERBOSE: $(NEXE_VERBOSE)
-  - script: npm run test:integration
-    displayName: Test built artefact
-    env:
-      NEXE_VERBOSE: $(NEXE_VERBOSE)
-      BUILD: ''
@@ -0,0 +1,3 @@
+test:
+  override:
+    - npm run nexe-build
@@ -1,8 +0,0 @@
-const express = require('express')
-const path = require('path')
-const app = express()
-app.use('/', express.static(path.join(__dirname, 'public')))
-
-
-app.listen(8888)
-
@@ -1,373 +0,0 @@
-{
-  "name": "express-app",
-  "version": "1.0.0",
-  "lockfileVersion": 1,
-  "requires": true,
-  "dependencies": {
-    "accepts": {
-      "version": "1.3.5",
-      "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.5.tgz",
-      "integrity": "sha1-63d99gEXI6OxTopywIBcjoZ0a9I=",
-      "requires": {
-        "mime-types": "~2.1.18",
-        "negotiator": "0.6.1"
-      }
-    },
-    "array-flatten": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz",
-      "integrity": "sha1-ml9pkFGx5wczKPKgCJaLZOopVdI="
-    },
-    "body-parser": {
-      "version": "1.18.2",
-      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.18.2.tgz",
-      "integrity": "sha1-h2eKGdhLR9hZuDGZvVm84iKxBFQ=",
-      "requires": {
-        "bytes": "3.0.0",
-        "content-type": "~1.0.4",
-        "debug": "2.6.9",
-        "depd": "~1.1.1",
-        "http-errors": "~1.6.2",
-        "iconv-lite": "0.4.19",
-        "on-finished": "~2.3.0",
-        "qs": "6.5.1",
-        "raw-body": "2.3.2",
-        "type-is": "~1.6.15"
-      }
-    },
-    "bytes": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.0.0.tgz",
-      "integrity": "sha1-0ygVQE1olpn4Wk6k+odV3ROpYEg="
-    },
-    "content-disposition": {
-      "version": "0.5.2",
-      "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.2.tgz",
-      "integrity": "sha1-DPaLud318r55YcOoUXjLhdunjLQ="
-    },
-    "content-type": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.4.tgz",
-      "integrity": "sha512-hIP3EEPs8tB9AT1L+NUqtwOAps4mk2Zob89MWXMHjHWg9milF/j4osnnQLXBCBFBk/tvIG/tUc9mOUJiPBhPXA=="
-    },
-    "cookie": {
-      "version": "0.3.1",
-      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.3.1.tgz",
-      "integrity": "sha1-5+Ch+e9DtMi6klxcWpboBtFoc7s="
-    },
-    "cookie-signature": {
-      "version": "1.0.6",
-      "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.6.tgz",
-      "integrity": "sha1-4wOogrNCzD7oylE6eZmXNNqzriw="
-    },
-    "debug": {
-      "version": "2.6.9",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
-      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
-      "requires": {
-        "ms": "2.0.0"
-      }
-    },
-    "depd": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/depd/-/depd-1.1.2.tgz",
-      "integrity": "sha1-m81S4UwJd2PnSbJ0xDRu0uVgtak="
-    },
-    "destroy": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.0.4.tgz",
-      "integrity": "sha1-l4hXRCxEdJ5CBmE+N5RiBYJqvYA="
-    },
-    "ee-first": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz",
-      "integrity": "sha1-WQxhFWsK4vTwJVcyoViyZrxWsh0="
-    },
-    "encodeurl": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz",
-      "integrity": "sha1-rT/0yG7C0CkyL1oCw6mmBslbP1k="
-    },
-    "escape-html": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz",
-      "integrity": "sha1-Aljq5NPQwJdN4cFpGI7wBR0dGYg="
-    },
-    "etag": {
-      "version": "1.8.1",
-      "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz",
-      "integrity": "sha1-Qa4u62XvpiJorr/qg6x9eSmbCIc="
-    },
-    "express": {
-      "version": "4.16.3",
-      "resolved": "https://registry.npmjs.org/express/-/express-4.16.3.tgz",
-      "integrity": "sha1-avilAjUNsyRuzEvs9rWjTSL37VM=",
-      "requires": {
-        "accepts": "~1.3.5",
-        "array-flatten": "1.1.1",
-        "body-parser": "1.18.2",
-        "content-disposition": "0.5.2",
-        "content-type": "~1.0.4",
-        "cookie": "0.3.1",
-        "cookie-signature": "1.0.6",
-        "debug": "2.6.9",
-        "depd": "~1.1.2",
-        "encodeurl": "~1.0.2",
-        "escape-html": "~1.0.3",
-        "etag": "~1.8.1",
-        "finalhandler": "1.1.1",
-        "fresh": "0.5.2",
-        "merge-descriptors": "1.0.1",
-        "methods": "~1.1.2",
-        "on-finished": "~2.3.0",
-        "parseurl": "~1.3.2",
-        "path-to-regexp": "0.1.7",
-        "proxy-addr": "~2.0.3",
-        "qs": "6.5.1",
-        "range-parser": "~1.2.0",
-        "safe-buffer": "5.1.1",
-        "send": "0.16.2",
-        "serve-static": "1.13.2",
-        "setprototypeof": "1.1.0",
-        "statuses": "~1.4.0",
-        "type-is": "~1.6.16",
-        "utils-merge": "1.0.1",
-        "vary": "~1.1.2"
-      }
-    },
-    "finalhandler": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.1.1.tgz",
-      "integrity": "sha512-Y1GUDo39ez4aHAw7MysnUD5JzYX+WaIj8I57kO3aEPT1fFRL4sr7mjei97FgnwhAyyzRYmQZaTHb2+9uZ1dPtg==",
-      "requires": {
-        "debug": "2.6.9",
-        "encodeurl": "~1.0.2",
-        "escape-html": "~1.0.3",
-        "on-finished": "~2.3.0",
-        "parseurl": "~1.3.2",
-        "statuses": "~1.4.0",
-        "unpipe": "~1.0.0"
-      }
-    },
-    "forwarded": {
-      "version": "0.1.2",
-      "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.1.2.tgz",
-      "integrity": "sha1-mMI9qxF1ZXuMBXPozszZGw/xjIQ="
-    },
-    "fresh": {
-      "version": "0.5.2",
-      "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz",
-      "integrity": "sha1-PYyt2Q2XZWn6g1qx+OSyOhBWBac="
-    },
-    "http-errors": {
-      "version": "1.6.3",
-      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-1.6.3.tgz",
-      "integrity": "sha1-i1VoC7S+KDoLW/TqLjhYC+HZMg0=",
-      "requires": {
-        "depd": "~1.1.2",
-        "inherits": "2.0.3",
-        "setprototypeof": "1.1.0",
-        "statuses": ">= 1.4.0 < 2"
-      }
-    },
-    "iconv-lite": {
-      "version": "0.4.19",
-      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.19.tgz",
-      "integrity": "sha512-oTZqweIP51xaGPI4uPa56/Pri/480R+mo7SeU+YETByQNhDG55ycFyNLIgta9vXhILrxXDmF7ZGhqZIcuN0gJQ=="
-    },
-    "inherits": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz",
-      "integrity": "sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4="
-    },
-    "ipaddr.js": {
-      "version": "1.8.0",
-      "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.8.0.tgz",
-      "integrity": "sha1-6qM9bd16zo9/b+DJygRA5wZzix4="
-    },
-    "media-typer": {
-      "version": "0.3.0",
-      "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz",
-      "integrity": "sha1-hxDXrwqmJvj/+hzgAWhUUmMlV0g="
-    },
-    "merge-descriptors": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.1.tgz",
-      "integrity": "sha1-sAqqVW3YtEVoFQ7J0blT8/kMu2E="
-    },
-    "methods": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz",
-      "integrity": "sha1-VSmk1nZUE07cxSZmVoNbD4Ua/O4="
-    },
-    "mime": {
-      "version": "1.4.1",
-      "resolved": "https://registry.npmjs.org/mime/-/mime-1.4.1.tgz",
-      "integrity": "sha512-KI1+qOZu5DcW6wayYHSzR/tXKCDC5Om4s1z2QJjDULzLcmf3DvzS7oluY4HCTrc+9FiKmWUgeNLg7W3uIQvxtQ=="
-    },
-    "mime-db": {
-      "version": "1.35.0",
-      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.35.0.tgz",
-      "integrity": "sha512-JWT/IcCTsB0Io3AhWUMjRqucrHSPsSf2xKLaRldJVULioggvkJvggZ3VXNNSRkCddE6D+BUI4HEIZIA2OjwIvg=="
-    },
-    "mime-types": {
-      "version": "2.1.19",
-      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.19.tgz",
-      "integrity": "sha512-P1tKYHVSZ6uFo26mtnve4HQFE3koh1UWVkp8YUC+ESBHe945xWSoXuHHiGarDqcEZ+whpCDnlNw5LON0kLo+sw==",
-      "requires": {
-        "mime-db": "~1.35.0"
-      }
-    },
-    "ms": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
-      "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g="
-    },
-    "negotiator": {
-      "version": "0.6.1",
-      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.1.tgz",
-      "integrity": "sha1-KzJxhOiZIQEXeyhWP7XnECrNDKk="
-    },
-    "on-finished": {
-      "version": "2.3.0",
-      "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.3.0.tgz",
-      "integrity": "sha1-IPEzZIGwg811M3mSoWlxqi2QaUc=",
-      "requires": {
-        "ee-first": "1.1.1"
-      }
-    },
-    "parseurl": {
-      "version": "1.3.2",
-      "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.2.tgz",
-      "integrity": "sha1-/CidTtiZMRlGDBViUyYs3I3mW/M="
-    },
-    "path-to-regexp": {
-      "version": "0.1.7",
-      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.7.tgz",
-      "integrity": "sha1-32BBeABfUi8V60SQ5yR6G/qmf4w="
-    },
-    "proxy-addr": {
-      "version": "2.0.4",
-      "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.4.tgz",
-      "integrity": "sha512-5erio2h9jp5CHGwcybmxmVqHmnCBZeewlfJ0pex+UW7Qny7OOZXTtH56TGNyBizkgiOwhJtMKrVzDTeKcySZwA==",
-      "requires": {
-        "forwarded": "~0.1.2",
-        "ipaddr.js": "1.8.0"
-      }
-    },
-    "qs": {
-      "version": "6.5.1",
-      "resolved": "https://registry.npmjs.org/qs/-/qs-6.5.1.tgz",
-      "integrity": "sha512-eRzhrN1WSINYCDCbrz796z37LOe3m5tmW7RQf6oBntukAG1nmovJvhnwHHRMAfeoItc1m2Hk02WER2aQ/iqs+A=="
-    },
-    "range-parser": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.0.tgz",
-      "integrity": "sha1-9JvmtIeJTdxA3MlKMi9hEJLgDV4="
-    },
-    "raw-body": {
-      "version": "2.3.2",
-      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.3.2.tgz",
-      "integrity": "sha1-vNYMd9Prk83gBQKVw/N5OJvIj4k=",
-      "requires": {
-        "bytes": "3.0.0",
-        "http-errors": "1.6.2",
-        "iconv-lite": "0.4.19",
-        "unpipe": "1.0.0"
-      },
-      "dependencies": {
-        "depd": {
-          "version": "1.1.1",
-          "resolved": "https://registry.npmjs.org/depd/-/depd-1.1.1.tgz",
-          "integrity": "sha1-V4O04cRZ8G+lyif5kfPQbnoxA1k="
-        },
-        "http-errors": {
-          "version": "1.6.2",
-          "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-1.6.2.tgz",
-          "integrity": "sha1-CgAsyFcHGSp+eUbO7cERVfYOxzY=",
-          "requires": {
-            "depd": "1.1.1",
-            "inherits": "2.0.3",
-            "setprototypeof": "1.0.3",
-            "statuses": ">= 1.3.1 < 2"
-          }
-        },
-        "setprototypeof": {
-          "version": "1.0.3",
-          "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.0.3.tgz",
-          "integrity": "sha1-ZlZ+NwQ+608E2RvWWMDL77VbjgQ="
-        }
-      }
-    },
-    "safe-buffer": {
-      "version": "5.1.1",
-      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.1.tgz",
-      "integrity": "sha512-kKvNJn6Mm93gAczWVJg7wH+wGYWNrDHdWvpUmHyEsgCtIwwo3bqPtV4tR5tuPaUhTOo/kvhVwd8XwwOllGYkbg=="
-    },
-    "send": {
-      "version": "0.16.2",
-      "resolved": "https://registry.npmjs.org/send/-/send-0.16.2.tgz",
-      "integrity": "sha512-E64YFPUssFHEFBvpbbjr44NCLtI1AohxQ8ZSiJjQLskAdKuriYEP6VyGEsRDH8ScozGpkaX1BGvhanqCwkcEZw==",
-      "requires": {
-        "debug": "2.6.9",
-        "depd": "~1.1.2",
-        "destroy": "~1.0.4",
-        "encodeurl": "~1.0.2",
-        "escape-html": "~1.0.3",
-        "etag": "~1.8.1",
-        "fresh": "0.5.2",
-        "http-errors": "~1.6.2",
-        "mime": "1.4.1",
-        "ms": "2.0.0",
-        "on-finished": "~2.3.0",
-        "range-parser": "~1.2.0",
-        "statuses": "~1.4.0"
-      }
-    },
-    "serve-static": {
-      "version": "1.13.2",
-      "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.13.2.tgz",
-      "integrity": "sha512-p/tdJrO4U387R9oMjb1oj7qSMaMfmOyd4j9hOFoxZe2baQszgHcSWjuya/CiT5kgZZKRudHNOA0pYXOl8rQ5nw==",
-      "requires": {
-        "encodeurl": "~1.0.2",
-        "escape-html": "~1.0.3",
-        "parseurl": "~1.3.2",
-        "send": "0.16.2"
-      }
-    },
-    "setprototypeof": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.1.0.tgz",
-      "integrity": "sha512-BvE/TwpZX4FXExxOxZyRGQQv651MSwmWKZGqvmPcRIjDqWub67kTKuIMx43cZZrS/cBBzwBcNDWoFxt2XEFIpQ=="
-    },
-    "statuses": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/statuses/-/statuses-1.4.0.tgz",
-      "integrity": "sha512-zhSCtt8v2NDrRlPQpCNtw/heZLtfUDqxBM1udqikb/Hbk52LK4nQSwr10u77iopCW5LsyHpuXS0GnEc48mLeew=="
-    },
-    "type-is": {
-      "version": "1.6.16",
-      "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.16.tgz",
-      "integrity": "sha512-HRkVv/5qY2G6I8iab9cI7v1bOIdhm94dVjQCPFElW9W+3GeDOSHmy2EBYe4VTApuzolPcmgFTN3ftVJRKR2J9Q==",
-      "requires": {
-        "media-typer": "0.3.0",
-        "mime-types": "~2.1.18"
-      }
-    },
-    "unpipe": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
-      "integrity": "sha1-sr9O6FFKrmFltIF4KdIbLvSZBOw="
-    },
-    "utils-merge": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz",
-      "integrity": "sha1-n5VxD1CiZ5R7LMwSR0HBAoQn5xM="
-    },
-    "vary": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
-      "integrity": "sha1-IpnwLG3tMNSllhsLn3RSShj2NPw="
-    }
-  }
-}
@@ -1,15 +0,0 @@
-{
-  "name": "express-app",
-  "version": "1.0.0",
-  "description": "",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
-  "dependencies": {
-    "express": "^4.16.3"
-  }
-}
@@ -1 +0,0 @@
-<h1>Hello World!</h1>
@@ -0,0 +1,22 @@
+const { FuseBox } = require('fuse-box')
+const { NativeModulePlugin } = require('../../lib/bundling')
+const fuse = FuseBox.init({
+  homeDir: './',
+  cache: false,
+  log: true,
+  debug: true,
+  output: '$name.js',
+  plugins: [
+    new NativeModulePlugin({
+      zmq: {
+        additionalFiles: [
+          '../../windows/lib/x64/libzmq-v100-mt-4_0_4.dll'
+        ]
+      }
+    })
+  ]
+})
+fuse.bundle('app')
+    .target('server')
+    .instructions(`> index.js`)
+fuse.run()
@@ -0,0 +1,19 @@
+var zmq = require('zmq')
+var pub = zmq.socket('pub')
+
+pub.bindSync('tcp://127.0.0.1:3000')
+console.log('Publisher bound to port 3000')
+
+setInterval(function(){
+  console.log('sending a multipart message envelope')
+  pub.send(['kitty cats', 'meow!'])
+}, 2500)
+console.log('global', global.require.main)
+var sub = zmq.socket('sub')
+sub.connect('tcp://127.0.0.1:3000')
+sub.subscribe('kitty cats')
+console.log('Subscriber connected to port 3000')
+
+sub.on('message', function(topic, message) {
+  console.log('received a message related to:', topic.toString(), 'containing message:', message.toString())
+})
@@ -0,0 +1,18 @@
+{
+  "name": "native-build",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "bundle": "node build",
+    "build-windows": "nexe -i app.js -o app.exe"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "zmq": "^2.15.3"
+  },
+  "devDependencies": {
+    "fuse-box": "^2.2.1-beta.7"
+  }
+}
@@ -1,32 +1,10 @@
 #!/usr/bin/env node
-const options = require('./lib/options')
-if (require.main === module) {
-  //fast path for help/version
-  const argv = options.argv
-  const eol = require('os').EOL
-  const showHelp = argv.help || argv._.some(x => x === 'help')
-  const showVersion = argv.version || argv._.some(x => x === 'version')
-  if (showHelp || showVersion) {    
-    process.stderr.write(showHelp ? options.help : options.version + eol)
-  } else {
-    const nexe = require('./lib/nexe')
-    nexe.compile(argv).catch((error) => {
-      const NexeError = require('./lib/compiler').NexeError
-      const chalk = require('chalk')
-      const isSilent = Boolean(argv.silent === true || argv.loglevel === 'silent')
-      if (!isSilent) {
-        if (error instanceof NexeError) {
-          process.stderr.write(eol + chalk.red('Error: ') + error.message + eol
-            + eol + 'See nexe -h for usage..' + eol + eol
-          )
-        } else {
-          process.stderr.write(error.stack + eol)
-        }
-      }
+const nexe = require('./lib/nexe')

-      process.exit(1)
-    })
-  }
-} else {
-  module.exports = require('./lib/nexe')
+module.exports = nexe
+
+if (require.main === module) {
+  nexe.compile(nexe.argv).catch((e) => {
+    process.stderr.write(e.stack, () => process.exit(1))
+  })
 }
@@ -0,0 +1,21 @@
+This is a
+ - [ ] Bug Report
+ - [ ] Feature Request
+ - [ ] Other
+
+<br/>
+If this is a bug report, What are the steps to reproduce?
+
+```
+//provide configuration here
+```
+
+<br/><br/>
+Please also provide:
+
+- Platform(OS/Version):
+- Host Node Version:
+- Target Node Version:
+- Nexe version:
+- Python Version:
+
@@ -2,94 +2,62 @@
  "name": "nexe",
  "description": "Create a single executable out of your Node.js application",
  "license": "MIT",
-  "version": "5.0.0-beta",
+  "version": "2.0.0-rc.1",
  "contributors": [
    "Craig Condon <craig.j.condon@gmail.com> (http://crcn.io)",
    "Jared Allard <jaredallard@outlook.com>",
-    "Caleb Boyd <caleb.boyd@hotmail.com>",
-    "Seth Olivarez <me@oxmc.me> (http://oxmc.me)"
+    "Caleb Boyd <caleb.boyd@hotmail.com>"
  ],
  "scripts": {
-    "ci:build": "ts-node tasks/build",
-    "test": "mocha",
-    "test:integration": "node index.js --target 14.15.3 -i test/integration/index.js -o integration-tests --verbose -r test/integration -r node_modules/ && npm run test:integration:run",
-    "test:integration:run": "run-script-os",
-    "test:integration:run:win32": "integration-tests.exe",
-    "test:integration:run:default": "./integration-tests",
-    "lint": "eslint \"{src,plugins,tasks}/**/*.ts\" --fix",
-    "prepare": "npm run lint && npm run build && npm test",
-    "prebuild": "rimraf lib",
-    "build": "tsc --declaration && tsc -p tasks && webpack",
-    "postbuild": "ts-node tasks/post-build"
+    "nexe-build": "ts-node tasks/build",
+    "prebuild": "rimraf lib && npm run lint",
+    "prepublish": "npm run build",
+    "lint": "prettier --parser typescript --no-semi --print-width 100 --single-quote --write \"src/**/*.ts\"",
+    "build": "tsc --declaration"
  },
  "repository": {
    "type": "git",
    "url": "git://github.com/nexe/nexe.git"
  },
  "files": [
-    "lib"
+    "lib",
+    "source-map-support.js"
  ],
-  "typings": "lib/nexe.d.ts",
  "main": "index.js",
  "bin": {
    "nexe": "index.js"
  },
  "engines": {
-    "node": ">=10"
-  },
-  "mocha": {
-    "spec": "./test/**/*.spec.ts",
-    "checkLeaks": true,
-    "require": [
-      "ts-node/register"
-    ]
+    "node": ">=6"
  },
  "dependencies": {
-    "@calebboyd/semaphore": "^1.3.1",
-    "@yarnpkg/fslib": "^3.0.0-rc.43",
-    "@yarnpkg/libzip": "^3.0.0-rc.43",
-    "app-builder": "^7.0.4",
-    "archiver": "^5.3.1",
-    "axios": "^1.13.2",
-    "caw": "^2.0.1",
-    "chalk": "^2.4.2",
-    "globby": "^11.0.2",
-    "meriyah": "^4.3.5",
-    "minimatch": "^10.1.2",
-    "minimist": "^1.2.8",
-    "mkdirp": "^1.0.4",
-    "multistream": "^4.1.0",
-    "ora": "^3.4.0",
-    "resolve-dependencies": "^6.0.9",
-    "rimraf": "^3.0.2",
-    "run-script-os": "^1.1.6",
-    "tar": "^7.5.2",
-    "webpack-config-prefabs": "0.0.5"
+    "app-builder": "^5.1.0",
+    "chalk": "^1.1.3",
+    "download": "^6.2.0",
+    "fuse-box": "^2.2.1",
+    "globby": "^6.1.0",
+    "minimist": "^1.2.0",
+    "mkdirp": "^0.5.1",
+    "ora": "^1.2.0",
+    "pifi": "1.0.0",
+    "rimraf": "^2.6.1",
+    "uglify-js": "3.0.28"
  },
  "devDependencies": {
-    "@types/archiver": "^5.3.2",
-    "@types/chai": "^4",
-    "@types/globby": "^9",
-    "@types/lodash": "^4.14.192",
-    "@types/minimist": "^1.2.2",
-    "@types/mkdirp": "^1.0.2",
-    "@types/mocha": "^10.0.1",
-    "@types/multistream": "^4.1.0",
-    "@types/ora": "^3.2.0",
-    "@types/rimraf": "3.0.2",
-    "@types/semver": "^7.3.13",
-    "@typescript-eslint/eslint-plugin": "^5.59.0",
-    "@typescript-eslint/parser": "^5.59.0",
-    "chai": "^4.3.7",
-    "eslint": "^8.40.0",
-    "eslint-config-prettier": "^8.8.0",
-    "eslint-plugin-prettier": "^4.2.1",
-    "execa": "^5.1.1",
-    "lodash": "^4.17.21",
-    "mocha": "^10.2.0",
-    "prettier": "^2.8.7",
-    "ts-node": "^10.9.1",
-    "typescript": "^5.0.3",
-    "webpack-cli": "^5.0.1"
+    "@types/bluebird": "^3.5.8",
+    "@types/chalk": "^0.4.31",
+    "@types/execa": "0.7.0",
+    "@types/globby": "^0.6.0",
+    "@types/minimist": "^1.2.0",
+    "@types/mkdirp": "^0.3.29",
+    "@types/ora": "^0.3.31",
+    "@types/pify": "0.0.28",
+    "@types/rimraf": "0.0.28",
+    "execa": "0.8.0",
+    "got": "^7.1.0",
+    "mocha": "^3.2.0",
+    "prettier": "^1.6.1",
+    "ts-node": "3.3.0",
+    "typescript": "^2.4.1"
  }
 }
@@ -0,0 +1,162 @@
+import * as fs from 'fs'
+import * as path from 'path'
+import * as child from 'child_process'
+import { createHash } from 'crypto'
+
+export interface ExtractNodeModuleOptions {
+  [key: string]: { additionalFiles: string[] } | true
+}
+
+function hashName(name: string | Buffer) {
+  return createHash('md5')
+    .update(name)
+    .digest('hex')
+    .toString()
+    .slice(0, 8)
+}
+
+export function embedDotNode(
+  options: ExtractNodeModuleOptions,
+  file: { contents: string; absPath: string }
+) {
+  const contents = fs.readFileSync(file.absPath)
+  const module = Object.keys(options).find(x =>
+    Boolean(~file.absPath.indexOf(path.join('node_modules', x)))
+  )!
+  const bindingName = path.basename(file.absPath)
+  const settings = options[module]
+  const moduleDir = hashName(contents)
+  file.contents = `
+  var fs=require('fs');var path=require('path');var binding='${contents.toString(
+    'base64'
+  )}';function mkdirp(r,t){t=t||null,r=path.resolve(r);try{fs.mkdirSync(r),t=t||r}catch(c){if("ENOENT"===c.code)t=mkdirp(path.dirname(r),t),mkdirp(r,t);else{var i;try{i=fs.statSync(r)}catch(r){throw c}if(!i.isDirectory())throw c}}return t};`
+
+  if (settings === true) {
+    file.contents += `
+      mkdirp('${moduleDir}');
+      var bindingPath = path.join(process.cwd(), '${moduleDir}', '${bindingName}')
+      require('fs').writeFileSync(bindingPath, Buffer.from(binding, 'base64'))
+      process.dlopen(module, bindingPath)
+    `.trim()
+    return
+  }
+
+  let depth = 0
+  settings.additionalFiles.forEach(file => {
+    let ownDepth = 0
+    file.split('/').forEach(x => x === '..' && ownDepth++)
+    depth = ownDepth > depth ? ownDepth : depth
+  })
+  let segments = [moduleDir]
+  while (depth--) {
+    segments.push(hashName(moduleDir + depth))
+  }
+  segments.push(bindingName)
+
+  file.contents += `
+    var cwd = process.cwd()
+    var bindingFileParts = ${JSON.stringify(segments)};
+    var bindingFile = path.join.apply(path, [cwd].concat(bindingFileParts));
+    mkdirp(path.dirname(bindingFile));
+    fs.writeFileSync(bindingFile, Buffer.from(binding, 'base64'));
+    ${settings.additionalFiles.reduce((code, filename, i) => {
+      const contents = fs.readFileSync(path.join(path.dirname(file.absPath), filename))
+      return (code += `
+        var file${i} = '${contents.toString('base64')}';
+        var filePath${i} = path.join(cwd, bindingFileParts[0], '${filename.split('../').join('')}');
+        mkdirp(path.dirname(filePath${i}));
+        fs.writeFileSync(filePath${i}, Buffer.from(file${i}, 'base64'));
+      `)
+    }, '')};
+    process.dlopen(module, bindingFile)
+  `
+}
+
+function findNativeModulePath(filePath: string, bindingsArg: string) {
+  const dirname = path.dirname(filePath)
+  const tempFile = Math.random() * 100 + '.js'
+  const tempFilePath = path.join(dirname, tempFile)
+  fs.writeFileSync(
+    tempFilePath,
+    `
+    var bindings = require('bindings');
+    var Module = require('module');
+    var originalRequire = Module.prototype.require;
+    Module.prototype.require = function(path) {
+      const mod = originalRequire.apply(this, arguments);
+      process.stdout.write(path)
+      return mod
+    };
+    bindings('${bindingsArg}')
+  `
+  )
+  //using exec because it can be done sync
+  const nativeFileName = child.execSync('node ' + tempFile, { cwd: dirname }).toString()
+  fs.unlinkSync(tempFilePath)
+  const relativePath = './' + path.relative(dirname, nativeFileName).replace(/\\/g, '/')
+  return relativePath
+}
+/**
+ * Traverse all nodes in a file and evaluate usages of the bindings module
+ * handles two common cases
+ */
+export class BindingsRewrite {
+  private bindingsIdNodes: any[] = []
+  public nativeModulePaths: string[] = []
+  public rewrite = false
+
+  isRequireBindings(node: any) {
+    return node.callee.name === 'require' && node.arguments[0].value === 'bindings'
+  }
+
+  onNode(absolutePath: string, node: any, parent: any) {
+    if (node.type === 'CallExpression') {
+      if (this.isRequireBindings(node) && parent.type === 'VariableDeclarator') {
+        /**
+         * const loadBindings = require('bindings');
+         *   -> const loadBindings = String('');
+         */
+        this.bindingsIdNodes.push(parent.id)
+        node.callee.name = 'String'
+        node.arguments[0].value = ''
+        this.rewrite = true
+        return
+      }
+
+      if (this.isRequireBindings(node) && parent.type === 'CallExpression') {
+        /**
+         *const bindings = require('bindings')('native-module')....
+         *  -> const bindings = require('./path/to/native/module.node').....
+         */
+        const bindingsArgNode = parent.arguments[0]
+        if (bindingsArgNode.type === 'Literal') {
+          parent.callee = { type: 'Identifier', name: 'require' }
+          bindingsArgNode.value = findNativeModulePath(absolutePath, bindingsArgNode.value)
+          this.nativeModulePaths.push(bindingsArgNode.value)
+          this.rewrite = true
+          return
+        }
+      }
+
+      const bindingsInvocationIdx = this.bindingsIdNodes.findIndex(x => node.callee.name === x.name)
+
+      if (this.bindingsIdNodes[bindingsInvocationIdx]) {
+        /**
+         * const bindings = loadBindings('native-module')
+         *   -> const bindings = require('./path/to/native/module.node')
+         */
+        const bindingsIdNode = this.bindingsIdNodes[bindingsInvocationIdx]
+        const bindingsArgNode = node.arguments[0]
+        this.bindingsIdNodes.splice(bindingsInvocationIdx, 1)
+
+        if (bindingsArgNode.type === 'Literal') {
+          node.callee.name = 'require'
+          bindingsArgNode.value = findNativeModulePath(absolutePath, bindingsArgNode.value)
+          this.nativeModulePaths.push(bindingsArgNode.value)
+          this.rewrite = true
+          return
+        }
+      }
+    }
+  }
+}
@@ -0,0 +1,70 @@
+import { BindingsRewrite, embedDotNode, ExtractNodeModuleOptions } from './bindings-rewrite'
+
+export interface FuseBoxFile {
+  info: { absPath: string }
+  absPath: string
+  contents: string
+  analysis: {
+    dependencies: string[]
+    requiresRegeneration: boolean
+  }
+  loadContents(): void
+  makeAnalysis(
+    parsingOptions?: any,
+    traversalPlugin?: {
+      plugins: Array<{
+        onNode(file: FuseBoxFile, node: any, parent: any): void
+        onEnd(file: FuseBoxFile): void
+      }>
+    }
+  ): void
+}
+
+export default function(options: ExtractNodeModuleOptions) {
+  return new NativeModulePlugin(options)
+}
+
+export class NativeModulePlugin {
+  public test: RegExp
+  public limit2Project = false
+  private modules: (keyof ExtractNodeModuleOptions)[]
+
+  constructor(public options: ExtractNodeModuleOptions) {
+    this.options = options
+    this.test = new RegExp(`node_modules\/(${Object.keys(options).join('|')}).*\.js|\.node$`)
+  }
+
+  init(context: any) {
+    context.allowExtension('.node')
+  }
+
+  transform(file: FuseBoxFile) {
+    file.loadContents()
+
+    if (file.absPath.endsWith('.node')) {
+      embedDotNode(this.options, file)
+      return
+    }
+
+    const bindingsRewrite = new BindingsRewrite()
+    file.makeAnalysis(null, {
+      plugins: [
+        {
+          onNode(file, node, parent) {
+            bindingsRewrite.onNode(file.absPath, node, parent)
+          },
+          onEnd(file) {
+            if (bindingsRewrite.rewrite) {
+              const index = file.analysis.dependencies.indexOf('bindings')
+              if (~index) {
+                file.analysis.dependencies.splice(index, 1)
+              }
+              file.analysis.dependencies.push(...bindingsRewrite.nativeModulePaths)
+              file.analysis.requiresRegeneration = true
+            }
+          }
+        }
+      ]
+    })
+  }
+}
@@ -0,0 +1,57 @@
+import { NexeCompiler } from '../compiler'
+import { FuseBox, JSONPlugin, CSSPlugin, HTMLPlugin, QuantumPlugin } from 'fuse-box'
+import { readFileAsync } from '../util'
+//import NativeModulePlugin from './fuse-native-module-plugin'
+
+function createBundle(filename: string, options: { name: string; minify: any; cwd: string }) {
+  const plugins: any = [JSONPlugin(), CSSPlugin(), HTMLPlugin()]
+  if (options.minify) {
+    plugins.push(
+      QuantumPlugin({
+        target: 'server',
+        uglify: true,
+        bakeApiIntoBundle: options.name
+      })
+    )
+  }
+  const fuse = FuseBox.init({
+    cache: false,
+    log: Boolean(process.env.NEXE_BUNDLE_DEBUG) || false,
+    homeDir: options.cwd,
+    sourceMaps: false,
+    writeBundles: false,
+    output: '$name.js',
+    target: 'server',
+    plugins
+  })
+  fuse.bundle(options.name).instructions(`> ${filename}`)
+  return fuse.run().then(x => {
+    let output = ''
+    x.bundles.forEach(y => (output = y.context.output.lastPrimaryOutput.content!.toString()))
+    return output
+  })
+}
+
+export default async function bundle(compiler: NexeCompiler, next: any) {
+  if (!compiler.options.bundle) {
+    compiler.input = await readFileAsync(compiler.options.input, 'utf-8')
+    return next()
+  }
+
+  if (compiler.options.empty || !compiler.options.input) {
+    compiler.input = ''
+    return next()
+  }
+
+  let producer = createBundle
+  if (typeof compiler.options.bundle === 'string') {
+    producer = require(compiler.options.bundle).createBundle
+  }
+
+  compiler.input = await producer(compiler.options.input, {
+    cwd: compiler.options.cwd,
+    name: compiler.options.name,
+    minify: compiler.options.compress
+  })
+  return next()
+}
@@ -0,0 +1 @@
+export * from './fuse-native-module-plugin'
@@ -1,348 +1,210 @@
-import { delimiter, resolve, normalize, join } from "path";
-import { Buffer } from "buffer";
-import { createReadStream, ReadStream } from "fs";
-import { spawn } from "child_process";
-import { Logger, LogStep } from "./logger";
-import {
-  readFileAsync,
-  writeFileAsync,
-  pathExistsAsync,
-  statAsync,
-  dequote,
-  isWindows,
-  bound,
-  semverGt
-} from "./util";
-import { NexeOptions, version } from "./options";
-import { NexeTarget } from "./target";
-import { Readable, Transform } from "stream";
-import MultiStream = require("multistream");
-import { Bundle, toStream } from "./fs/bundle";
-import { File } from "resolve-dependencies";
+import { dirname, normalize, join } from 'path'
+import { Buffer } from 'buffer'
+import { createHash } from 'crypto'
+import { createReadStream } from 'fs'
+import { Readable } from 'stream'
+import { spawn } from 'child_process'
+import { Logger } from './logger'
+import { readFileAsync, writeFileAsync, pathExistsAsync, dequote, isWindows } from './util'
+import { NexeOptions, nexeVersion } from './options'
+import { NexeTarget } from './target'
+import { getLatestGitRelease, storeAsset } from './releases'

-const isBsd = Boolean(~process.platform.indexOf("bsd"));
-const make = isWindows ? "vcbuild.bat" : isBsd ? "gmake" : "make";
-const configure = isWindows ? "configure" : "./configure";
-
-type StringReplacer = (match: string) => string;
+const isBsd = Boolean(~process.platform.indexOf('bsd'))
+const make = isWindows ? 'vcbuild.bat' : isBsd ? 'gmake' : 'make'
+const configure = isWindows ? 'configure' : './configure'

 export interface NexeFile {
-  filename: string;
-  absPath: string;
-  contents: string | Buffer;
+  filename: string
+  absPath: string
+  contents: string
 }

-export { NexeOptions };
-
-export class NexeError extends Error {
-  constructor(m: string) {
-    super(m);
-    Object.setPrototypeOf(this, NexeError.prototype);
-  }
+interface NexeHeader {
+  resources: { [key: string]: number[] }
+  version: string
 }

 export class NexeCompiler {
-  /**
-   * Epoch of when compilation started
-   */
-  private start = Date.now();
-  private compileStep: LogStep | undefined;
-  public log = new Logger(this.options.loglevel);
-  /**
-   * Copy of process.env
-   */
-  public env = { ...process.env };
-  /**
-   * Virtual FileSystem
-   */
-  public bundle: Bundle;
-  /**
-   * Root directory for the source of the current build
-   */
-  public src: string;
-  /**
-   * In memory files that are being manipulated by the compiler
-   */
-  public files: NexeFile[] = [];
-  /**
-   * Standalone pieces of code run before the application entrypoint
-   */
-  public shims: string[] = [];
-  /**
-   * The last shim (defaults to "require('module').runMain()")
-   */
-  public startup = "";
-  /**
-   * The main entrypoint filename for your application - eg. node mainFile.js
-   */
-  public entrypoint: string | undefined;
-  /**
-   * Not used
-   */
-  public targets: NexeTarget[];
-  /**
-   * Current target of the compiler
-   */
-  public target: NexeTarget;
-  /**
-   * Output filename (-o myapp.exe)
-   */
-  public output = this.options.output;
-  /**
-   * Flag to indicate whether or notstdin was used for input
-   */
-  public stdinUsed = false;
-  /**
-   * Path to the configure script
-   */
-  public configureScript: string;
-  /**
-   * The file path of node binary
-   */
-  public nodeSrcBinPath: string;
-  /**
-   * Remote asset path if available
-   */
-  public remoteAsset: string;
+  private start = Date.now()
+  private env = { ...process.env }
+  private compileStep: { modify: Function; log: Function }
+  public log = new Logger(this.options.loglevel)
+  public src = join(this.options.temp, this.options.version)
+  public files: NexeFile[] = []
+  public input: string
+  public bundledInput?: string
+  public output: string | null
+
+  public resources: { bundle: string; index: { [key: string]: number[] } } = {
+    index: {},
+    bundle: ''
+  }
+  public readFileAsync: (file: string) => Promise<NexeFile>
+  public writeFileAsync: (file: string, contents: Buffer | string) => Promise<void>
+  public replaceInFileAsync: (file: string, replacer: any, replaceValue: string) => Promise<void>
+  public setFileContentsAsync: (file: string, contents: string | Buffer) => Promise<void>
+
+  private nodeSrcBinPath = isWindows
+    ? join(this.src, 'Release', 'node.exe')
+    : join(this.src, 'out', 'Release', 'node')

  constructor(public options: NexeOptions) {
-    const { python } = this.options;
-    //SOMEDAY iterate over multiple targets with `--outDir`
-    this.targets = options.targets as NexeTarget[];
-    this.target = this.targets[0];
-    if (!/https?:\/\//.test(options.remote)) {
-      throw new NexeError(
-        `Invalid remote URI scheme (must be http or https): ${options.remote}`
-      );
+    const { python } = (this.options = options)
+    this.log.step('nexe ' + nexeVersion, 'info')
+    if (python) {
+      if (isWindows) {
+        this.env.PATH = '"' + dequote(normalize(python)) + '";' + this.env.PATH
+      } else {
+        this.env.PYTHON = python
+      }
    }
-    this.remoteAsset = options.remote + "nexe-asset-" + this.target.toString();
-    this.src = join(this.options.temp, this.target.version);
-    this.configureScript =
-      configure + (semverGt(this.target.version, "10.10.0") ? ".py" : "");
-    this.nodeSrcBinPath = isWindows
-      ? join(this.src, "Release", "node.exe")
-      : join(this.src, "out", "Release", "node");
-    this.log.step("nexe " + version, "info");
-    this.bundle = new Bundle(options);
-    if (isWindows) {
-      const originalPath = process.env.PATH;
-      delete process.env.PATH;
-      this.env = { ...process.env };
-      this.env.PATH = python
-        ? (this.env.PATH =
-          dequote(normalize(python)) + delimiter + originalPath)
-        : originalPath;
-      process.env.PATH = originalPath;
-    } else {
-      this.env = { ...process.env };
-      if (python) this.env.PYTHON = python;
+
+    this.readFileAsync = async (file: string) => {
+      let cachedFile = this.files.find(x => normalize(x.filename) === normalize(file))
+      if (!cachedFile) {
+        const absPath = join(this.src, file)
+        cachedFile = {
+          absPath,
+          filename: file,
+          contents: await readFileAsync(absPath, 'utf-8').catch(x => {
+            if (x.code === 'ENOENT') return ''
+            throw x
+          })
+        }
+        this.files.push(cachedFile)
+      }
+      return cachedFile
+    }
+    this.writeFileAsync = (file, contents) => writeFileAsync(join(this.src, file), contents)
+    this.replaceInFileAsync = async (file, replace: string | RegExp, value: string) => {
+      const entry = await this.readFileAsync(file)
+      entry.contents = entry.contents.replace(replace, value)
+    }
+    this.setFileContentsAsync = async (file: string, contents: string) => {
+      const entry = await this.readFileAsync(file)
+      entry.contents = contents
    }
  }

-  @bound
-  addResource(absoluteFileName: string, content?: Buffer | string | File) {
-    return this.bundle.addResource(absoluteFileName, content);
+  quit() {
+    const time = Date.now() - this.start
+    this.log.write(`Finsihed in ${time / 1000}s`)
+    return this.log.flush()
  }

-  @bound
-  async readFileAsync(file: string) {
-    this.assertBuild();
-    let cachedFile = this.files.find(
-      (x) => normalize(x.filename) === normalize(file)
-    );
-    if (!cachedFile) {
-      const absPath = join(this.src, file);
-      cachedFile = {
-        absPath,
-        filename: file,
-        contents: await readFileAsync(absPath, "utf-8").catch((x) => {
-          if (x.code === "ENOENT") return "";
-          throw x;
-        }),
-      };
-      this.files.push(cachedFile);
-    }
-    return cachedFile;
-  }
-
-  @bound
-  writeFileAsync(file: string, contents: string | Buffer) {
-    this.assertBuild();
-    return writeFileAsync(join(this.src, file), contents);
-  }
-
-  @bound
-  async replaceInFileAsync(
-    file: string,
-    replace: string | RegExp,
-    value: string | StringReplacer
-  ) {
-    const entry = await this.readFileAsync(file);
-    entry.contents = entry.contents.toString().replace(replace, value as any);
-  }
-
-  @bound
-  async setFileContentsAsync(file: string, contents: string | Buffer) {
-    const entry = await this.readFileAsync(file);
-    entry.contents = contents;
-  }
-
-  quit(error?: any) {
-    const time = Date.now() - this.start;
-    this.log.write(`Finished in ${time / 1000}s`, error ? "red" : "green");
-    return this.log.flush();
-  }
-
-  assertBuild() {
-    if (!this.options.build) {
-      throw new NexeError("This feature is only available with `--build`");
-    }
-  }
-
-  public getNodeExecutableLocation(target?: NexeTarget) {
-    if (this.options.asset) {
-      return resolve(this.options.cwd, this.options.asset);
-    }
+  private _getNodeExecutableLocation(target?: NexeTarget) {
    if (target) {
-      return join(this.options.temp, target.toString());
+      return join(this.options.temp, target.toString())
    }
-    return this.nodeSrcBinPath;
+    return this.nodeSrcBinPath
  }

  private _runBuildCommandAsync(command: string, args: string[]) {
-    if (this.log.verbose) {
-      this.compileStep!.pause();
-    }
-    return new Promise<void>((resolve, reject) => {
+    return new Promise((resolve, reject) => {
      spawn(command, args, {
        cwd: this.src,
        env: this.env,
-        shell: true,
-        stdio: this.log.verbose ? "inherit" : "ignore",
+        stdio: 'ignore'
      })
-        .once("error", (e: Error) => {
-          if (this.log.verbose) {
-            this.compileStep!.resume();
-          }
-          reject(e);
-        })
-        .once("close", (code: number) => {
-          if (this.log.verbose) {
-            this.compileStep!.resume();
-          }
-          if (code != 0) {
-            const error = `${command} ${args.join(
-              " "
-            )} exited with code: ${code}`;
-            reject(new NexeError(error));
-          }
-          resolve();
-        });
-    });
+        .once('error', reject)
+        .once('close', resolve)
+    })
  }

  private _configureAsync() {
-    if (isWindows && semverGt(this.target.version, "10.15.99")) {
-      return Promise.resolve();
-    }
-    return this._runBuildCommandAsync(this.env.PYTHON || "python", [
-      this.configureScript,
-      ...this.options.configure,
-    ]);
+    return this._runBuildCommandAsync(this.env.PYTHON || 'python', [
+      configure,
+      ...this.options.configure
+    ])
  }

-  public async build(): Promise<ReadStream> {
-    this.compileStep!.log(
-      `Configuring node build${this.options.configure.length ? ": " + this.options.configure : "..."
-      }`
-    );
-    await this._configureAsync();
-    const buildOptions = this.options.make;
-    this.compileStep!.log(
-      `Compiling Node${buildOptions.length ? " with arguments: " + buildOptions : "..."
-      }`
-    );
-    await this._runBuildCommandAsync(make, buildOptions);
-    return createReadStream(this.getNodeExecutableLocation());
+  private async _buildAsync() {
+    this.compileStep.log(
+      `Configuring node build${this.options.configure.length
+        ? ': ' + this.options.configure
+        : '...'}`
+    )
+    await this._configureAsync()
+    const buildOptions = this.options.make
+    this.compileStep.log(
+      `Compiling Node${buildOptions.length ? ' with arguments: ' + buildOptions : '...'}`
+    )
+    await this._runBuildCommandAsync(make, buildOptions)
+    return createReadStream(this._getNodeExecutableLocation())
  }

-  private async _shouldCompileBinaryAsync(
-    binary: NodeJS.ReadableStream | null,
-    location: string
-  ) {
-    //SOMEDAY combine make/configure/vcBuild/and modified times of included files
-    const { snapshot, build } = this.options;
+  private async _fetchPrebuiltBinaryAsync(target: NexeTarget) {
+    const githubRelease = await getLatestGitRelease()
+    const assetName = target.toString()
+    const asset = githubRelease.assets.find(x => x.name === assetName)

-    if (!binary) {
-      return true;
+    if (!asset) {
+      throw new Error(`${assetName} not available, create one using --build`)
    }
+    const filename = this._getNodeExecutableLocation(target)
+    await storeAsset(asset, dirname(filename))
+    return createReadStream(filename)
+  }

-    if (build && snapshot != null && (await pathExistsAsync(snapshot))) {
-      const snapshotLastModified = (await statAsync(snapshot)).mtimeMs;
-      const binaryLastModified = (await statAsync(location)).mtimeMs;
-      return snapshotLastModified > binaryLastModified;
+  private _generateHeader() {
+    const version =
+      ['configure', 'vcBuild', 'make'].reduce((a, c) => {
+        return (a += (this.options as any)[c]
+          .slice()
+          .sort()
+          .join())
+      }, '') + this.options.enableNodeCli
+    const header = {
+      resources: this.resources.index,
+      version: createHash('md5')
+        .update(version)
+        .digest('hex')
    }
+    const serializedHeader = this._serializeHeader(header)
+    return header
+  }

-    return false;
+  private _serializeHeader(header: NexeHeader) {
+    return `process.__nexe=${JSON.stringify(header)};`
  }

  async compileAsync(target: NexeTarget) {
-    const step = (this.compileStep = this.log.step("Compiling result"));
-    const build = this.options.build;
-    const location = this.getNodeExecutableLocation(build ? undefined : target);
-    let binary = (await pathExistsAsync(location))
-      ? createReadStream(location)
-      : null;
+    const step = (this.compileStep = this.log.step('Compiling result'))
+    const build = this.options.build
+    const location = this._getNodeExecutableLocation(target)
+    let binary = (await pathExistsAsync(location)) ? createReadStream(location) : null
+    const header = this._generateHeader()

-    if (await this._shouldCompileBinaryAsync(binary, location)) {
-      binary = await this.build();
-      step.log("Node binary compiled");
+    if (target && !build) {
+      binary = await this._fetchPrebuiltBinaryAsync(target)
    }
-    return this._assembleDeliverable(binary!);
+
+    if (!binary) {
+      binary = await this._buildAsync()
+      step.log('Node binary compiled')
+    }
+    return this._assembleDeliverable(header, binary)
  }

-  code() {
-    return [this.shims.join(""), this.startup].join(";");
-  }
-
-  private async _assembleDeliverable(binary: Readable) {
-    if (!this.options.mangle) {
-      return binary;
+  private _assembleDeliverable(header: NexeHeader, binary: NodeJS.ReadableStream) {
+    if (this.options.empty) {
+      return binary
    }
-    const launchCode = this.code();
-    const codeSize = Buffer.byteLength(launchCode);
-    const sentinel = Buffer.from("<nexe~~sentinel>");
-
-    let vfsSize = 0;
-    // finalize() must be called before any reads — archiver won't emit chunks
-    // until finalized, so calling it inside the Transform's first-chunk callback
-    // creates a deadlock (Transform waits for chunks, archiver waits for finalize).
-    const bundleStream = this.bundle.toStream();
-    this.bundle.finalize();
-    const streams = [
-      binary,
-      toStream(launchCode),
-      bundleStream.pipe(
-        new Transform({
-          transform: (chunk, _, cb) => {
-            if (chunk) vfsSize += chunk.length;
-            cb(null, chunk);
-          },
-        })
-      ),
-    ];
-
-    let done = false;
-    return new MultiStream((cb) => {
-      if (done) cb(null, null);
-      else if (streams.length) cb(null, streams.shift() as Readable);
-      else {
-        done = true;
-        const trailers = Buffer.alloc(16);
-        trailers.writeDoubleLE(codeSize, 0);
-        trailers.writeDoubleLE(vfsSize, 8);
-        cb(null, toStream(Buffer.concat([sentinel, trailers])));
-      }
-    });
+    const artifact = new Readable({ read() {} })
+    binary.on('data', (chunk: Buffer) => {
+      artifact.push(chunk)
+    })
+    binary.on('close', () => {
+      const content = this._serializeHeader(header) + this.input
+      artifact.push(content)
+      artifact.push(this.resources.bundle)
+      const lengths = Buffer.from(Array(16))
+      lengths.writeDoubleLE(Buffer.byteLength(content), 0)
+      lengths.writeDoubleLE(Buffer.byteLength(this.resources.bundle), 8)
+      artifact.push(Buffer.concat([Buffer.from('<nexe~~sentinel>'), lengths]))
+      artifact.push(null)
+    })
+    return artifact
  }
 }
@@ -1,40 +0,0 @@
-# nexe-fs
-
-### Getting Started:
-
-This module contains a set of patches used to create (and use) the Nexe Virtual FileSystem
-
-In order for NVFS to work with node's `require` method. A custom build of node must be used. If using the `nexe` cli this will be handled automatically
-
-The customization should be applied as early as possbile when node is starting up. 
-
-i.e. The contents of `nexe-fs/bootstrap` should be put [here](https://github.com/nodejs/node/blob/0827c80920311fa9d1e6989c8a73aaaeca962eb7/lib/internal/bootstrap/node.js#L27-L28).
-
-### Creating a NVFS:
-
-To create a virtual file system use the `Bundle` Object, in your build process:
-
-```javascript
-const { Bundle } = require('nexe-fs')
-
-const bundle = new Bundle()
-await bundle.addResource(absoluteFileName)
-
-bundle.toStream().pipe(fs.createWriteStream('./myFsBlob'))
-```
-
-In the entrypoint of your application, the fs patch needs to be applied (executed as early as possible)
-For example, In the build process, the application's entrypoint could be prepended with the following:
-
-```javascript
-const codeToPrependToEntrypoint = fs.readFileSync(require.resolve('nexe-fs/patch'), 'utf-8') + `
-shimFs({
-  blobPath: 'location/of/myFsBlob',
-  resources: ${JSON.stringify(bundle)},
-  layout: {
-    resourceStart: 0 // the offset within the blob that is referenced by the bundle index
-  }
-})`
-```
-
-Since a custom node build is being used. A great place for this code would be the node source file: `_third_party_main.js`
@@ -1,482 +0,0 @@
-import { Libzip } from "@yarnpkg/libzip";
-import {
-  FakeFS,
-  PortablePath,
-  RmdirOptions,
-  OpendirOptions,
-  BasePortableFakeFS,
-  Dirent,
-  Dir,
-  MkdirOptions,
-  FSPath,
-  ppath,
-  npath,
-  Filename,
-  CustomDir,
-} from "@yarnpkg/fslib";
-import { ZipFS, ZipOpenFS } from "@yarnpkg/libzip";
-import { resolve, toNamespacedPath } from "path";
-import { constants } from "fs";
-
-export type SnapshotZipFSOptions = {
-  baseFs: FakeFS<PortablePath>;
-  libzip: Libzip | (() => Libzip);
-  zipFs: ZipFS;
-  root: string;
-};
-
-const uniqBy = (
-  arr: Array<string | Dirent<PortablePath>>,
-  pick: (...arg: any[]) => any
-) => {
-  const seen = new Set();
-  return arr.filter((x) => {
-    const key = pick(x);
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
-};
-function uniqReaddir(arr: Array<string | Dirent<PortablePath>>) {
-  return uniqBy(arr, (s: string | Dirent<PortablePath>) =>
-    typeof s === "string" ? s : s.name
-  );
-}
-
-export class SnapshotZipFS extends BasePortableFakeFS {
-  zipFs: ZipFS;
-  baseFs: FakeFS<PortablePath>;
-  root: string;
-  magic: number;
-  constructor(opts: SnapshotZipFSOptions) {
-    super();
-    this.zipFs = opts.zipFs;
-    this.baseFs = opts.baseFs;
-    this.root = opts.root;
-    this.magic = 0x2a << 24;
-  }
-  private readonly fdMap: Map<number, [ZipFS, number]> = new Map();
-  private nextFd = 3;
-
-  async makeCallPromise<T>(
-    p: FSPath<PortablePath>,
-    discard: () => Promise<T>,
-    accept: (zipFS: ZipFS, zipInfo: { subPath: PortablePath }) => Promise<T>,
-    { requireSubpath = true }: { requireSubpath?: boolean } = {}
-  ): Promise<T> {
-    if (typeof p !== "string") return await discard();
-
-    const normalizedP = this.resolve(p);
-
-    const zipInfo = this.findZip(normalizedP);
-    if (!zipInfo) return await discard();
-
-    if (requireSubpath && zipInfo.subPath === "/") return await discard();
-
-    return await accept(this.zipFs, zipInfo);
-  }
-
-  makeCallSync<T>(
-    p: FSPath<PortablePath>,
-    discard: () => T,
-    accept: (
-      zipFS: ZipFS,
-      zipInfo: { subPath: PortablePath; archivePath: string }
-    ) => T,
-    { requireSubpath = true }: { requireSubpath?: boolean } = {}
-  ): T {
-    if (typeof p !== "string") return discard();
-
-    const normalizedP = this.resolve(p);
-
-    const zipInfo = this.findZip(normalizedP);
-    if (!zipInfo) return discard();
-
-    if (requireSubpath && zipInfo.subPath === "/") return discard();
-
-    return accept(this.zipFs, { archivePath: "", ...zipInfo });
-  }
-
-  async realpathPromise(p: PortablePath) {
-    return await this.realpathSync(p);
-  }
-
-  realpathSync(p: PortablePath) {
-    return this.makeCallSync(
-      p,
-      () => this.baseFs.realpathSync(p),
-      (zipFs, { subPath }) => {
-        if (zipFs.lstatSync(subPath).isSymbolicLink()) {
-          return zipFs.realpathSync(subPath);
-        } else {
-          // return the original path in case it wasn't under /snapshot, e.g. if it was for a node module - otherwise the node module parent path is the wrong one (and other things resolve relative to that)
-          return p;
-        }
-      }
-    );
-  }
-
-  findZip(p: PortablePath) {
-    p = this.resolve(p);
-    const snapshotPP = npath.toPortablePath("/snapshot");
-    const pathsToTry = Array.from(
-      new Set([
-        p,
-        resolve("/snapshot", p),
-        ppath.resolve(
-          snapshotPP,
-          npath.toPortablePath(
-            npath.relative(
-              npath.fromPortablePath(this.root),
-              npath.fromPortablePath(p)
-            )
-          )
-        ),
-        ppath.resolve(
-          snapshotPP,
-          npath.toPortablePath(
-            npath.relative(
-              toNamespacedPath(npath.fromPortablePath(this.root)),
-              toNamespacedPath(npath.fromPortablePath(p))
-            )
-          )
-        ),
-        ppath.resolve(
-          snapshotPP,
-          npath.toPortablePath(
-            npath.relative(
-              npath.fromPortablePath(process.cwd()),
-              npath.fromPortablePath(p)
-            )
-          )
-        ),
-        ppath.resolve(
-          snapshotPP,
-          npath.toPortablePath(
-            npath.relative(
-              toNamespacedPath(npath.fromPortablePath(process.cwd())),
-              toNamespacedPath(npath.fromPortablePath(p))
-            )
-          )
-        ),
-      ])
-    );
-    for (const path of pathsToTry) {
-      const portablePath = npath.toPortablePath(path);
-      if (this.zipFs.existsSync(portablePath)) {
-        return {
-          subPath: portablePath,
-        };
-      }
-    }
-    // ESM imports often omit extensions (e.g. `import './lib/array'`).
-    // If the path has no extension, try .js / .mjs / .cjs fallbacks.
-    const basename = ppath.basename(p);
-    if (!ppath.extname(basename)) {
-      for (const path of pathsToTry) {
-        for (const ext of [".js", ".mjs", ".cjs"] as const) {
-          const candidate = npath.toPortablePath(path + ext);
-          if (this.zipFs.existsSync(candidate)) {
-            return { subPath: candidate };
-          }
-        }
-      }
-    }
-  }
-
-  async copyFilePromise(sourceP: PortablePath, destP: PortablePath, flags = 0) {
-    const fallback = async (
-      sourceFs: FakeFS<PortablePath>,
-      sourceP: PortablePath,
-      destFs: FakeFS<PortablePath>,
-      destP: PortablePath
-    ) => {
-      if ((flags & constants.COPYFILE_FICLONE_FORCE) !== 0)
-        throw Object.assign(
-          new Error(
-            `EXDEV: cross-device clone not permitted, copyfile '${sourceP}' -> ${destP}'`
-          ),
-          { code: `EXDEV` }
-        );
-      if (
-        flags & constants.COPYFILE_EXCL &&
-        (await this.existsPromise(sourceP))
-      )
-        throw Object.assign(
-          new Error(
-            `EEXIST: file already exists, copyfile '${sourceP}' -> '${destP}'`
-          ),
-          { code: `EEXIST` }
-        );
-
-      let content;
-      try {
-        content = await sourceFs.readFilePromise(sourceP);
-      } catch (error) {
-        throw Object.assign(
-          new Error(
-            `EINVAL: invalid argument, copyfile '${sourceP}' -> '${destP}'`
-          ),
-          { code: `EINVAL` }
-        );
-      }
-
-      await destFs.writeFilePromise(destP, content);
-    };
-
-    return await this.makeCallPromise(
-      sourceP,
-      async () => {
-        return await this.baseFs.copyFilePromise(sourceP, destP, flags);
-      },
-      async (zipFsS, { subPath: subPathS }) => {
-        return await fallback(zipFsS, subPathS, this.baseFs, destP);
-      }
-    );
-  }
-
-  copyFileSync(sourceP: PortablePath, destP: PortablePath, flags = 0) {
-    const fallback = (
-      sourceFs: FakeFS<PortablePath>,
-      sourceP: PortablePath,
-      destFs: FakeFS<PortablePath>,
-      destP: PortablePath
-    ) => {
-      if ((flags & constants.COPYFILE_FICLONE_FORCE) !== 0)
-        throw Object.assign(
-          new Error(
-            `EXDEV: cross-device clone not permitted, copyfile '${sourceP}' -> ${destP}'`
-          ),
-          { code: `EXDEV` }
-        );
-      if (flags & constants.COPYFILE_EXCL && this.existsSync(sourceP))
-        throw Object.assign(
-          new Error(
-            `EEXIST: file already exists, copyfile '${sourceP}' -> '${destP}'`
-          ),
-          { code: `EEXIST` }
-        );
-
-      let content;
-      try {
-        content = sourceFs.readFileSync(sourceP);
-      } catch (error) {
-        throw Object.assign(
-          new Error(
-            `EINVAL: invalid argument, copyfile '${sourceP}' -> '${destP}'`
-          ),
-          { code: `EINVAL` }
-        );
-      }
-
-      destFs.writeFileSync(destP, content);
-    };
-
-    return this.makeCallSync(
-      sourceP,
-      () => {
-        return this.baseFs.copyFileSync(sourceP, destP, flags);
-      },
-      (zipFsS, { subPath: subPathS }) => {
-        return fallback(zipFsS, subPathS, this.baseFs, destP);
-      }
-    );
-  }
-  async readdirPromise(p: PortablePath): Promise<Array<Filename>>;
-  async readdirPromise(
-    p: PortablePath,
-    opts: { withFileTypes: false } | null
-  ): Promise<Array<Filename>>;
-  async readdirPromise(
-    p: PortablePath,
-    opts: { withFileTypes: true }
-  ): Promise<Array<Dirent<PortablePath>>>;
-  async readdirPromise(
-    p: PortablePath,
-    opts: { withFileTypes: boolean }
-  ): Promise<Array<Filename> | Array<Dirent<PortablePath>>>;
-  async readdirPromise(
-    p: PortablePath,
-    opts?: { withFileTypes?: boolean } | null
-  ): Promise<Array<string | Dirent<PortablePath>>> {
-    const fallback = async () => {
-      return await this.baseFs.readdirPromise(p, opts as any);
-    };
-    return await this.makeCallPromise(
-      p,
-      fallback,
-      async (zipFs, { subPath }) => {
-        const fallbackPaths: Array<string | Dirent<PortablePath>> =
-          await fallback().catch(() => []);
-        return Promise.resolve(
-          uniqReaddir(
-            fallbackPaths.concat(
-              await zipFs.readdirPromise(subPath, opts as any)
-            )
-          )
-        );
-      },
-      {
-        requireSubpath: false,
-      }
-    );
-  }
-
-  readdirSync(p: PortablePath): Array<Filename>;
-  readdirSync(
-    p: PortablePath,
-    opts: { withFileTypes: false } | null
-  ): Array<Filename>;
-  readdirSync(
-    p: PortablePath,
-    opts: { withFileTypes: true }
-  ): Array<Dirent<PortablePath>>;
-  readdirSync(
-    p: PortablePath,
-    opts: { withFileTypes: boolean }
-  ): Array<Filename> | Array<Dirent<PortablePath>>;
-  readdirSync(
-    p: PortablePath,
-    opts?: { withFileTypes?: boolean } | null
-  ): Array<string | Dirent<PortablePath>> {
-    const fallback = () => {
-      return this.baseFs.readdirSync(p, opts as any);
-    };
-    return this.makeCallSync(
-      p,
-      fallback,
-      (zipFs, { subPath }) => {
-        let fallbackPaths: Array<string | Dirent<PortablePath>> = [];
-        try {
-          fallbackPaths = fallback();
-        } catch (e) { }
-        return fallbackPaths.concat(
-          uniqReaddir(zipFs.readdirSync(subPath, opts as any))
-        );
-      },
-      {
-        requireSubpath: false,
-      }
-    );
-  }
-
-  async mkdirPromise(p: PortablePath, opts?: MkdirOptions) {
-    return await this.baseFs.mkdirPromise(p, opts);
-  }
-
-  mkdirSync(p: PortablePath, opts?: MkdirOptions) {
-    return this.baseFs.mkdirSync(p, opts);
-  }
-
-  async rmdirPromise(p: PortablePath, opts?: RmdirOptions) {
-    return await this.baseFs.rmdirPromise(p, opts);
-  }
-
-  rmdirSync(p: PortablePath, opts?: RmdirOptions) {
-    return this.baseFs.rmdirSync(p, opts);
-  }
-
-  async rmPromise(p: PortablePath, opts?: any) {
-    return await this.baseFs.rmPromise(p, opts);
-  }
-
-  rmSync(p: PortablePath, opts?: any) {
-    return this.baseFs.rmSync(p, opts);
-  }
-
-  async opendirPromise(p: PortablePath, opts?: OpendirOptions) {
-    return this.opendirSync(p, opts);
-  }
-
-  opendirSync(p: PortablePath, opts?: OpendirOptions) {
-    const zipInfo = this.findZip(p);
-    let zipFsDir: Dir<PortablePath> | null = null;
-    if (zipInfo) {
-      zipFsDir = this.zipFs.opendirSync(zipInfo.subPath);
-    }
-    let realFsDir: Dir<PortablePath> | null = null;
-    try {
-      realFsDir = this.baseFs.opendirSync(p);
-    } catch (e) {
-      if (!zipFsDir) throw e;
-    }
-    const seen = new Set();
-    const nextDirent = () => {
-      const entry = realFsDir?.readSync() || zipFsDir?.readSync();
-      if (entry && !seen.has(entry.name)) {
-        seen.add(entry.name);
-        return entry;
-      }
-      return null;
-    };
-
-    const onClose = () => {
-      zipFsDir?.closeSync();
-      realFsDir?.closeSync();
-    };
-
-    return new CustomDir(p, nextDirent, { onClose });
-  }
-
-  accessPromise = ZipOpenFS.prototype.accessPromise;
-  accessSync = ZipOpenFS.prototype.accessSync;
-  appendFilePromise = ZipOpenFS.prototype.appendFilePromise;
-  appendFileSync = ZipOpenFS.prototype.appendFileSync;
-  chmodPromise = ZipOpenFS.prototype.chmodPromise;
-  chmodSync = ZipOpenFS.prototype.chmodSync;
-  fchmodPromise = ZipOpenFS.prototype.fchmodPromise;
-  fchmodSync = ZipOpenFS.prototype.fchmodSync;
-  chownPromise = ZipOpenFS.prototype.chownPromise;
-  chownSync = ZipOpenFS.prototype.chownSync;
-  fchownPromise = ZipOpenFS.prototype.fchownPromise;
-  fchownSync = ZipOpenFS.prototype.fchownSync;
-  closePromise = ZipOpenFS.prototype.closePromise;
-  closeSync = ZipOpenFS.prototype.closeSync;
-  createReadStream = ZipOpenFS.prototype.createReadStream;
-  createWriteStream = ZipOpenFS.prototype.createWriteStream;
-  existsPromise = ZipOpenFS.prototype.existsPromise;
-  existsSync = ZipOpenFS.prototype.existsSync;
-  fstatPromise = ZipOpenFS.prototype.fstatPromise;
-  fstatSync = ZipOpenFS.prototype.fstatSync;
-  getExtractHint = ZipOpenFS.prototype.getExtractHint;
-  getRealPath = ZipOpenFS.prototype.getRealPath;
-  linkPromise = ZipOpenFS.prototype.linkPromise;
-  linkSync = ZipOpenFS.prototype.linkSync;
-  lstatPromise = ZipOpenFS.prototype.lstatPromise;
-  lstatSync = ZipOpenFS.prototype.lstatSync;
-  openPromise = ZipOpenFS.prototype.openPromise;
-  openSync = ZipOpenFS.prototype.openSync;
-  readFilePromise = ZipOpenFS.prototype.readFilePromise;
-  readFileSync = ZipOpenFS.prototype.readFileSync;
-  readlinkPromise = ZipOpenFS.prototype.readlinkPromise;
-  readlinkSync = ZipOpenFS.prototype.readlinkSync;
-  readPromise = ZipOpenFS.prototype.readPromise;
-  readSync = ZipOpenFS.prototype.readSync;
-  renamePromise = ZipOpenFS.prototype.renamePromise;
-  renameSync = ZipOpenFS.prototype.renameSync;
-  resolve = ZipOpenFS.prototype.resolve;
-  statPromise = ZipOpenFS.prototype.statPromise;
-  statSync = ZipOpenFS.prototype.statSync;
-  symlinkPromise = ZipOpenFS.prototype.symlinkPromise;
-  symlinkSync = ZipOpenFS.prototype.symlinkSync;
-  truncatePromise = ZipOpenFS.prototype.truncatePromise;
-  truncateSync = ZipOpenFS.prototype.truncateSync;
-  ftruncatePromise = ZipOpenFS.prototype.ftruncatePromise;
-  ftruncateSync = ZipOpenFS.prototype.ftruncateSync;
-  unlinkPromise = ZipOpenFS.prototype.unlinkPromise;
-  unlinkSync = ZipOpenFS.prototype.unlinkSync;
-  unwatchFile = ZipOpenFS.prototype.unwatchFile;
-  utimesPromise = ZipOpenFS.prototype.utimesPromise;
-  utimesSync = ZipOpenFS.prototype.utimesSync;
-  lutimesPromise = ZipOpenFS.prototype.utimesPromise;
-  lutimesSync = ZipOpenFS.prototype.utimesSync;
-  watch = ZipOpenFS.prototype.watch;
-  watchFile = ZipOpenFS.prototype.watchFile;
-  writeFilePromise = ZipOpenFS.prototype.writeFilePromise;
-  writeFileSync = ZipOpenFS.prototype.writeFileSync;
-  writePromise = ZipOpenFS.prototype.writePromise;
-  writeSync = ZipOpenFS.prototype.writeSync;
-
-  // @ts-ignore
-  remapFd = ZipOpenFS.prototype.remapFd;
-}
@@ -1,28 +0,0 @@
-{
-  const __nexe_patches = (process.nexe = { patches: {} }).patches;
-  const slice = [].slice;
-  const __nexe_noop_patch = function (original) {
-    const args = slice.call(arguments, 1);
-    return original.apply(this, args);
-  };
-  const __nexe_patch = function (obj, method, patch) {
-    const original = obj[method];
-    if (!original) return;
-    __nexe_patches[method] = patch;
-    obj[method] = function () {
-      const args = [original].concat(slice.call(arguments));
-      return __nexe_patches[method].apply(this, args);
-    };
-  };
-  __nexe_patch(
-    process.binding("fs"),
-    "internalModuleReadFile",
-    __nexe_noop_patch,
-  );
-  __nexe_patch(
-    process.binding("fs"),
-    "internalModuleReadJSON",
-    __nexe_noop_patch,
-  );
-  __nexe_patch(process.binding("fs"), "internalModuleStat", __nexe_noop_patch);
-}
@@ -1,54 +0,0 @@
-import { relative } from "path";
-import { Readable } from "stream";
-import { File } from "resolve-dependencies";
-import archiver from "archiver";
-
-function makeRelativeToZip(cwd: string, path: string) {
-  return "/snapshot/" + relative(cwd, path);
-}
-
-export function toStream(content: Buffer | string) {
-  const readable = new Readable({
-    read() {
-      this.push(content);
-      this.push(null);
-    },
-  });
-  return readable;
-}
-export class Bundle {
-  cwd: string;
-  files = new Set<string>();
-  zip: any;
-  constructor({ cwd }: { cwd: string } = { cwd: process.cwd() }) {
-    this.cwd = cwd;
-    this.zip = archiver("zip");
-  }
-
-  get list() {
-    return Array.from(this.files);
-  }
-
-  public addResource(
-    absoluteFileName: string,
-    content?: File | Buffer | string
-  ) {
-    const destPath = makeRelativeToZip(this.cwd, absoluteFileName);
-    if (!this.files.has(destPath)) {
-      if (content == null) {
-        this.zip.file(absoluteFileName, { name: destPath });
-      } else {
-        this.zip.append(content, { name: destPath });
-      }
-      this.files.add(destPath);
-    }
-  }
-
-  public finalize() {
-    return this.zip.finalize();
-  }
-
-  public toStream(): Readable {
-    return this.zip;
-  }
-}
@@ -1,15 +0,0 @@
-{
-  "name": "nexe-fs",
-  "version": "1.0.1",
-  "description": "Virtual File System used by nexe",
-  "main": "bundle.js",
-  "files": [
-    "*.d.ts",
-    "*.js"
-  ],
-  "author": "Caleb Boyd",
-  "dependencies": {
-    "multistream": "^2.1.1"
-  },
-  "license": "MIT"
-}
@@ -1,387 +0,0 @@
-import { ZipFS, getLibzipSync } from "@yarnpkg/libzip";
-import { patchFs, PosixFS, NodeFS } from "@yarnpkg/fslib";
-import { SnapshotZipFS } from "./SnapshotZipFS";
-import * as assert from "assert";
-import * as constants from "constants";
-import { dirname, relative, sep } from "path";
-
-export interface NexeHeader {
-  blobPath: string;
-  layout: {
-    resourceStart: number;
-    resourceSize: number;
-    contentSize: number;
-    contentStart: number;
-  };
-}
-
-let originalFsMethods: any = null;
-let lazyRestoreFs = () => {};
-const patches = (process as any).nexe.patches || {};
-const originalPatches = { ...patches };
-delete (process as any).nexe;
-
-function shimFs(binary: NexeHeader, fs: typeof import("fs") = require("fs")) {
-  if (originalFsMethods !== null) {
-    return;
-  }
-
-  originalFsMethods = Object.assign({}, fs);
-
-  const realFs: typeof fs = { ...fs };
-  const nodeFs = new NodeFS(realFs);
-
-  const blob = Buffer.allocUnsafe(binary.layout.resourceSize);
-  const blobFd = realFs.openSync(binary.blobPath, "r");
-  const bytesRead = realFs.readSync(
-    blobFd,
-    blob,
-    0,
-    binary.layout.resourceSize,
-    binary.layout.resourceStart
-  );
-  assert.equal(bytesRead, binary.layout.resourceSize);
-
-  const zipFs = new ZipFS(blob, { readOnly: true });
-  const snapshotZipFS = new SnapshotZipFS({
-    libzip: getLibzipSync(),
-    zipFs,
-    baseFs: nodeFs,
-    root: dirname(process.argv[0]), // executable directory = original project root
-  });
-  const posixSnapshotZipFs = new PosixFS(snapshotZipFS);
-  patchFs(fs, posixSnapshotZipFs); // patches global fs
-
-  // Capture the project root for path mapping
-  const projectRoot = dirname(process.argv[0]);
-  const drive = projectRoot.slice(0, 2); // e.g., "C:"
-
-  // Enable logging with DEBUG=nexe:require
-  let log = (_: string) => true;
-  if ((process.env.DEBUG || "").toLowerCase().includes("nexe:require")) {
-    process.stderr.write(
-      `[nexe] - FILES ${JSON.stringify(
-        // @ts-ignore - accessing private property for debugging
-        Array.from(zipFs.entries.keys()),
-        null,
-        4
-      )}\n`
-    );
-    process.stderr.write(
-      `[nexe] - DIRECTORIES ${JSON.stringify(
-        // @ts-ignore - accessing private property for debugging
-        Array.from(zipFs.listings.keys()),
-        null,
-        4
-      )}\n`
-    );
-    log = (text: string) => process.stderr.write(`[nexe] - ${text}\n`);
-  }
-
-  /**
-   * Convert a Windows path to the snapshot POSIX path.
-   * Handles:
-   *   - Paths under the original project root (e.g., C:\Users\oxmc\Desktop\src\entry.js → /snapshot/src/entry.js)
-   *   - Paths that have been converted to C:\snapshot\... (from _findPath returning /snapshot/...)
-   *   - Already POSIX /snapshot/... paths (return as-is)
-   */
-  function toSnapshotPath(filePath: string): string {
-    // Already a POSIX snapshot path
-    if (filePath.startsWith("/snapshot/")) {
-      return filePath;
-    }
-    // Handle Windows-style snapshot path: e.g., C:\snapshot\src\entry.js
-    if (filePath.startsWith(drive + "\\snapshot\\")) {
-      return "/snapshot/" + filePath.slice(drive.length + 9).replace(/\\/g, "/");
-    }
-    // Path under original project root
-    if (filePath.startsWith(projectRoot)) {
-      const rel = relative(projectRoot, filePath);
-      return "/snapshot/" + rel.replace(/\\/g, "/");
-    }
-    // Not mappable – return unchanged (will likely fail)
-    return filePath;
-  }
-
-  // --- Internal Module Patches (unconditionally assigned) ---
-
-  function internalModuleReadFile(this: any, original: any, ...args: any[]) {
-    // Strip Windows extended-length path prefix if present
-    let filePath = typeof args[0] === "string" ? args[0] : "";
-    if (filePath.startsWith("\\\\?\\")) {
-      filePath = filePath.slice(4);
-    }
-    const mappedPath = toSnapshotPath(filePath);
-    log(`internalModuleReadFile ${filePath} -> ${mappedPath}`);
-    try {
-      // Use the patched fs (which already sees the zip)
-      return fs.readFileSync(mappedPath, "utf-8");
-    } catch (e) {
-      return "";
-    }
-  }
-
-  patches.internalModuleReadFile = internalModuleReadFile;
-
-  // internalModuleReadJSON should return a string (or undefined) in Node 22
-  patches.internalModuleReadJSON = function (this: any, original: any, ...args: any[]) {
-    const content = internalModuleReadFile.call(this, original, ...args);
-    return content === "" ? undefined : content;
-  };
-
-  // Handle Node 22+ signature: first arg is context (non-string), second is path
-  function internalModuleStat(this: any, original: any, ...args: any[]) {
-    const target = args[0];
-    let statPath: string;
-
-    // Node 22+: args[0] is context (often a buffer), args[1] is the path string
-    if (typeof target === "number") {
-      // file descriptor case – unchanged
-      try {
-        originalFsMethods.fstatSync(target);
-        return 0;
-      } catch (e) {
-        return -constants.ENOENT;
-      }
-    }
-
-    if (typeof target === "string") {
-      // Node <22 or when a string is passed directly
-      statPath = target;
-    } else {
-      // Node 22+: path is the second argument
-      statPath = args[1];
-    }
-
-    if (typeof statPath !== "string") {
-      // Unexpected: fallback to original
-      return original.call(this, ...args);
-    }
-
-    // Strip Windows extended-length prefix
-    if (statPath.startsWith("\\\\?\\")) {
-      statPath = statPath.slice(4);
-    }
-
-    const mappedPath = toSnapshotPath(statPath);
-    log(`internalModuleStat ${statPath} -> ${mappedPath}`);
-
-    try {
-      const stat = fs.statSync(mappedPath);
-      return stat.isDirectory() ? 1 : 0;
-    } catch (e) {
-      // VFS has no entry — check the real filesystem at the original path.
-      // This handles dynamically created files (e.g. written via the patched fs)
-      // that don't exist in the zip.
-      try {
-        const realStat = originalFsMethods.statSync(statPath);
-        return realStat.isDirectory() ? 1 : 0;
-      } catch (e2) {
-        return -constants.ENOENT;
-      }
-    }
-  }
-
-  patches.internalModuleStat = internalModuleStat;
-
-  // --- Patch Module._findPath with a correct exports resolver ---
-
-  // Helper to check if a path exists and is a file
-  function isFile(p: string): boolean {
-    try {
-      const stat = fs.statSync(p);
-      return stat.isFile();
-    } catch {
-      return false;
-    }
-  }
-
-  // Recursive exports resolver following Node's conditional exports
-  function resolvePackageExports(exports: any, conditions: string[]): string | null {
-    if (typeof exports === "string") {
-      return exports;
-    }
-    if (!exports || typeof exports !== "object") {
-      return null;
-    }
-    // Handle "." subpath first (for bare module, we always start with ".")
-    const subExports = exports["."] ?? exports;
-    return resolveExportsObject(subExports, conditions);
-  }
-
-  function resolveExportsObject(obj: any, conditions: string[]): string | null {
-    if (typeof obj === "string") {
-      return obj;
-    }
-    if (!obj || typeof obj !== "object") {
-      return null;
-    }
-    // Iterate over keys in order; if a key matches a condition, take that branch
-    for (const key of Object.keys(obj)) {
-      if (conditions.includes(key)) {
-        const value = obj[key];
-        if (typeof value === "string") {
-          return value;
-        }
-        if (value && typeof value === "object") {
-          const nested = resolveExportsObject(value, conditions);
-          if (nested) return nested;
-        }
-      }
-    }
-    // If no matching condition, try "default" if not already tried
-    if (!conditions.includes("default") && obj.default) {
-      const def = obj.default;
-      if (typeof def === "string") return def;
-      if (def && typeof def === "object") {
-        return resolveExportsObject(def, conditions);
-      }
-    }
-    return null;
-  }
-
-  function resolveFromPkg(
-    pkg: any,
-    basePath: string,
-    request: string,
-    nodePath: any,
-    logFn: (s: string) => any,
-    isFileFn: (p: string) => boolean,
-    fsMod: typeof import("fs")
-  ): string | null {
-    // 1. exports field
-    if (pkg.exports) {
-      const conditions = ["require", "node", "default"];
-      const exportTarget = resolvePackageExports(pkg.exports, conditions);
-      if (exportTarget) {
-        const candidate = nodePath.posix.join(basePath, request, exportTarget);
-        logFn(`_findPath exports target: ${candidate}`);
-        if (isFileFn(candidate)) return candidate;
-        for (const ext of [".js", ".json", ".node"]) {
-          const withExt = candidate + ext;
-          if (isFileFn(withExt)) return withExt;
-        }
-      }
-    }
-
-    // 2. main field
-    let main = "index.js";
-    if (typeof pkg.main === "string") main = pkg.main;
-    if (main.startsWith("./")) main = main.slice(2);
-    if (!main || main === ".") main = "index.js";
-    if (main.endsWith("/")) main += "index.js";
-
-    const mainPath = nodePath.posix.join(basePath, request, main);
-    logFn(`_findPath main: ${mainPath}`);
-    try {
-      const st = fsMod.statSync(mainPath);
-      if (st.isFile()) return mainPath;
-      if (st.isDirectory()) {
-        const idxPath = nodePath.posix.join(mainPath, "index.js");
-        if (isFileFn(idxPath)) return idxPath;
-      }
-    } catch (_) {}
-
-    for (const ext of [".js", ".json", ".node"]) {
-      const withExt = mainPath + ext;
-      if (isFileFn(withExt)) return withExt;
-    }
-
-    // 3. index.js fallback only when main not explicitly set
-    if (typeof pkg.main !== "string") {
-      const fallbackIndex = nodePath.posix.join(basePath, request, "index.js");
-      if (isFileFn(fallbackIndex)) return fallbackIndex;
-    }
-
-    // 4. dist subdirectory (axios-style)
-    const distIndex = nodePath.posix.join(basePath, request, "dist", "index.js");
-    if (isFileFn(distIndex)) return distIndex;
-    const distMain = nodePath.posix.join(basePath, request, "dist", request + ".js");
-    if (isFileFn(distMain)) return distMain;
-
-    return null;
-  }
-
-  let _origFindPath: ((...args: any[]) => any) | null = null;
-  try {
-    const Module = require("module");
-    const nodePath = require("path");
-    const capturedOrigFindPath = (Module as any)._findPath;
-    if (typeof capturedOrigFindPath === "function") {
-      _origFindPath = capturedOrigFindPath;
-      (Module as any)._findPath = function nexeFindPath(this: any, ...args: any[]) {
-        const request: string = args[0];
-
-        // For bare module specifiers, try VFS first. Node 22 removed
-        // internalModuleReadJSON from process.binding('fs'), so _findPath can
-        // no longer read package.json from the VFS and falls back to index.js.
-        // Our code reads package.json via the patched fs.readFileSync which works.
-        if (request && request[0] !== "." && !nodePath.isAbsolute(request)) {
-          const basePath = "/snapshot/node_modules";
-          const pkgJsonPath = nodePath.posix.join(basePath, request, "package.json");
-          let pkg: any;
-          try {
-            pkg = JSON.parse(fs.readFileSync(pkgJsonPath, "utf8") as string);
-          } catch (_) {
-            pkg = null;
-          }
-          if (pkg) {
-            const vfsResult = resolveFromPkg(pkg, basePath, request, nodePath, log, isFile, fs);
-            if (vfsResult) {
-              log(`_findPath VFS resolved ${request} -> ${vfsResult}`);
-              return vfsResult;
-            }
-          }
-        }
-
-        // Fall back to original for everything else (real fs, relative, absolute)
-        let result: any;
-        try {
-          result = capturedOrigFindPath.apply(this, args);
-        } catch (_) {
-          result = false;
-        }
-        if (result) return result;
-
-        // Secondary VFS fallback for paths that couldn't be resolved above
-        // (e.g. bare specifier where package.json wasn't found in /snapshot)
-        if (!request || request[0] === "." || nodePath.isAbsolute(request)) {
-          return result;
-        }
-
-        // Use snapshot node_modules as the base for all bare modules
-        const basePath2 = "/snapshot/node_modules";
-        const pkgJsonPath2 = nodePath.posix.join(basePath2, request, "package.json");
-        log(`_findPath secondary snapshot check: ${pkgJsonPath2}`);
-        let pkg2: any;
-        try {
-          pkg2 = JSON.parse(fs.readFileSync(pkgJsonPath2, "utf8") as string);
-        } catch (_) {
-          return result;
-        }
-        return resolveFromPkg(pkg2, basePath2, request, nodePath, log, isFile, fs) ?? result;
-      };
-    }
-  } catch (_) {
-    // Patching _findPath failed, ignore
-  }
-
-  lazyRestoreFs = () => {
-    Object.assign(fs, originalFsMethods);
-    Object.assign(patches, originalPatches);
-    if (_origFindPath !== null) {
-      try {
-        const Module = require("module");
-        (Module as any)._findPath = _origFindPath;
-      } catch (_) {}
-      _origFindPath = null;
-    }
-    lazyRestoreFs = () => {};
-  };
-}
-
-function restoreFs() {
-  lazyRestoreFs();
-}
-
-export { shimFs, restoreFs };
@@ -1,72 +1,68 @@
-import colors from "chalk";
-import ora from "ora";
+import colors = require('chalk')
+import ora = require('ora')

-const frameLength = 120;
+const frameLength = 120

 export interface LogStep {
-  modify(text: string, color?: string): void;
-  log(text: string, color?: string): void;
-  pause(): void;
-  resume(): void;
+  modify(text: string, color?: string): void
+  log(text: string, color?: string): void
 }

 export class Logger {
-  public verbose: boolean;
-  private silent: boolean;
-  private ora: any;
-  private modify: Function;
-  public write: (text: string, color?: string) => void;
+  private verbose: boolean
+  private silent: boolean
+  private ora: any
+  private modify: Function
+  public write: (text: string, color?: string) => void

-  constructor(level: "verbose" | "silent" | "info") {
-    this.verbose = level === "verbose";
-    this.silent = level === "silent";
+  constructor(level: 'verbose' | 'silent' | 'info') {
+    this.verbose = level === 'verbose'
+    this.silent = level === 'silent'
    if (!this.silent) {
      this.ora = ora({
-        text: "Starting...",
-        color: "blue",
-        spinner: "dots",
-      });
-      this.ora.stop();
+        text: 'Starting...',
+        color: 'blue',
+        spinner: 'dots'
+      })
+      this.ora.stop()
    }
-    const noop = () => { };
-    this.modify = this.silent ? noop : this._modify.bind(this);
-    this.write = this.silent ? noop : this._write.bind(this);
+    const noop = () => {}
+    this.modify = this.silent ? noop : this._modify.bind(this)
+    this.write = this.silent ? noop : this._write.bind(this)
  }

  flush() {
-    !this.silent && this.ora.succeed();
-    return new Promise((resolve) => setTimeout(resolve, frameLength));
+    !this.silent && this.ora.succeed()
+    return new Promise(resolve => setTimeout(resolve, frameLength))
  }

-  _write(update: string, color = "green") {
-    this.ora.succeed().text = (colors as any)[color](update);
-    this.ora.start();
+  _write(update: string, color = 'green') {
+    this.ora.succeed().text = (colors as any)[color](update)
+    this.ora.start()
  }

  _modify(update: string, color = this.ora.color) {
-    this.ora.text = update;
-    this.ora.color = color;
+    this.ora.text = update
+    this.ora.color = color
  }

-  step(text: string, method = "succeed"): LogStep {
+  step(text: string, method: string = 'succeed'): LogStep {
    if (this.silent) {
-      return { modify() { }, log() { }, pause() { }, resume() { } };
+      return { modify() {}, log() {} }
    }
    if (!this.ora.id) {
-      this.ora.start().text = text;
-      if (method !== "succeed") {
-        this.ora[method]();
+      this.ora.start().text = text
+      if (method !== 'succeed') {
+        this.ora[method]()
      }
    } else {
-      this.ora[method]().text = text;
-      this.ora.start();
+      this.ora[method]().text = text
+      this.ora.start()
    }

    return {
      modify: this.modify,
-      log: this.verbose ? this.write : this.modify,
-      pause: () => this.ora.stopAndPersist(),
-      resume: () => this.ora.start(),
-    } as LogStep;
+      log: this.verbose ? this.write : this.modify
+    } as LogStep
  }
 }
@@ -1,50 +1,49 @@
-import { compose } from "app-builder";
-import { NexeCompiler } from "./compiler";
-import { normalizeOptions, NexeOptions, NexePatch } from "./options";
-import resource from "./steps/resource";
-import clean from "./steps/clean";
-import cli from "./steps/cli";
-import bundle from "./steps/bundle";
-import download from "./steps/download";
-import shim from "./steps/shim";
-import artifacts from "./steps/artifacts";
-import patches from "./patches";
+import { compose, PromiseConfig, Middleware } from 'app-builder'
+import resource from './steps/resource'
+import { NexeCompiler } from './compiler'
+import {
+  argv,
+  nexeVersion as version,
+  normalizeOptionsAsync,
+  NexeOptions,
+  NexePatch
+} from './options'
+import cli from './steps/cli'
+import bundle from './bundling/fuse'
+import download from './steps/download'
+import artifacts from './steps/artifacts'
+import patches from './patches'
+import { rimrafAsync } from './util'

 async function compile(
  compilerOptions?: Partial<NexeOptions>,
  callback?: (err: Error | null) => void
 ) {
-  let error: Error | null = null,
-    options: NexeOptions | null = null,
-    compiler: NexeCompiler | null = null;
+  const options = await normalizeOptionsAsync(compilerOptions)
+  const compiler = new NexeCompiler(options)
+  const build = compiler.options.build

-  try {
-    options = normalizeOptions(compilerOptions);
-    compiler = new NexeCompiler(options);
-    await compose(
-      clean,
-      resource,
-      cli,
-      bundle,
-      shim,
-      download,
-      options.build
-        ? [artifacts, ...patches, ...(options.patches as NexePatch[])]
-        : [],
-      options.plugins as NexePatch[]
-    )(compiler);
-  } catch (e: any) {
-    error = e;
+  if (options.clean) {
+    const step = compiler.log.step('Cleaning up nexe build artifacts...')
+    step.log(`Deleting directory and contents at: ${compiler.src}`)
+    await rimrafAsync(compiler.src)
+    step.log(`Deleted directory and contents at: ${compiler.src}`)
+    return compiler.quit()
  }

-  if (error) {
-    compiler && compiler.quit(error);
-    if (callback) return callback(error);
-    return Promise.reject(error);
-  }
-
-  if (callback) callback(null);
+  const buildSteps = build
+    ? [download, artifacts, ...patches, ...(options.patches as NexePatch[])]
+    : []
+  const nexe = compose(resource, bundle, cli, buildSteps)
+  return callback
+    ? void nexe(compiler).then(
+        () => callback && callback(null),
+        (e: Error) => {
+          if (callback) callback(e)
+          else throw e
+        }
+      )
+    : nexe(compiler)
 }

-export { compile, NexeCompiler };
-export { argv, version, NexeOptions, help } from "./options";
+export { argv, compile, version }
@@ -1,152 +1,119 @@
-import parseArgv from "minimist";
-import { NexeCompiler, NexeError } from "./compiler";
-import { isWindows, STDIN_FLAG } from "./util";
-import { basename, extname, join, isAbsolute, resolve } from "path";
-import { getTarget, NexeTarget } from "./target";
-import { EOL, homedir } from "os";
-import chalk from "chalk";
-import { resolveSync } from "resolve-dependencies";
-const caw = require("caw");
-const c =
-  process.platform === "win32" ? chalk.constructor({ enabled: false }) : chalk;
+import * as parseArgv from 'minimist'
+import { NexeCompiler } from './compiler'
+import { isWindows } from './util'
+import { basename, extname, join, isAbsolute, relative } from 'path'
+import { getTarget, NexeTarget } from './target'
+import { EOL } from 'os'

-export const version = "{{ version }}";
+export const nexeVersion = '2.0.0-rc.1'

 export interface NexePatch {
-  (compiler: NexeCompiler, next: () => Promise<void>): Promise<void>;
-}
-
-export interface ModuleBundleRule {
-  include?: string[];
-  exclude?: string[];
-}
-
-export interface BundleRules {
-  [moduleName: string]: ModuleBundleRule;
+  (compiler: NexeCompiler, next: () => Promise<void>): Promise<void>
 }

 export interface NexeOptions {
-  build: boolean;
-  input: string;
-  output: string;
-  targets: (string | NexeTarget)[];
-  name: string;
-  remote: string;
-  asset: string;
-  cwd: string;
-  fs: boolean | string[];
-  flags: string[];
-  configure: string[];
-  vcBuild: string[];
-  make: string[];
-  snapshot?: string;
-  resources: string[];
-  temp: string;
-  rc: { [key: string]: string };
-  enableNodeCli: boolean;
-  bundle: boolean | string;
-  bundleRules?: BundleRules;
-  patches: (string | NexePatch)[];
-  plugins: (string | NexePatch)[];
-  native: any;
-  mangle: boolean;
-  ghToken: string;
-  sourceUrl?: string;
-  enableStdIn?: boolean;
-  python?: string;
-  loglevel: "info" | "silent" | "verbose";
-  silent?: boolean;
-  fakeArgv?: boolean;
-  verbose?: boolean;
-  info?: boolean;
-  ico?: string;
-  debugBundle?: boolean;
-  warmup?: string;
-  clean?: boolean;
+  build: boolean
+  input: string
+  output: string
+  targets: (string | NexeTarget)[]
+  name: string
+  cwd: string
+  version: string
+  flags: string[]
+  configure: string[]
+  vcBuild: string[]
+  make: string[]
+  snapshot?: string
+  resources: string[]
+  temp: string
+  rc: { [key: string]: string }
+  enableNodeCli: boolean
+  bundle: boolean | string
+  patches: (string | NexePatch)[]
+  empty: boolean
+  sourceUrl?: string
+  python?: string
+  loglevel: 'info' | 'silent' | 'verbose'
+  silent?: boolean
+  verbose?: boolean
+  info?: boolean
+  ico?: string
+  warmup?: string
+  compress?: boolean
+  clean?: boolean
  /**
   * Api Only
   */
-  downloadOptions: any;
+  downloadOptions: any
+}
+
+function padRight(str: string, l: number) {
+  return (str + ' '.repeat(l)).substr(0, l)
 }

 const defaults = {
+  version: process.version.slice(1),
  flags: [],
  cwd: process.cwd(),
-  fs: true,
  configure: [],
-  mangle: true,
  make: [],
  targets: [],
-  vcBuild: isWindows ? ["nosign", "release"] : [],
+  vcBuild: isWindows ? ['nosign', 'release'] : [],
  enableNodeCli: false,
+  compress: false,
  build: false,
  bundle: true,
-  patches: [],
-  plugins: [],
-  remote: `https://github.com/oxmc/nexe/releases/download/v${require('../package.json').version}/`,
-};
+  patches: []
+}
 const alias = {
-  i: "input",
-  o: "output",
-  v: "version",
-  a: "asset",
-  t: "target",
-  b: "build",
-  n: "name",
-  r: "resource",
-  p: "python",
-  f: "flag",
-  c: "configure",
-  m: "make",
-  h: "help",
-  l: "loglevel",
-  "fake-argv": "fakeArgv",
-  "gh-token": "ghToken",
-};
-const argv = parseArgv(process.argv, { alias, default: { ...defaults } });
-let help = `
-${c.bold("nexe <entry-file> [options]")}
+  i: 'input',
+  o: 'output',
+  t: 'target',
+  n: 'name',
+  v: 'version',
+  r: 'resource',
+  a: 'resource',
+  p: 'python',
+  f: 'flag',
+  c: 'configure',
+  m: 'make',
+  s: 'snapshot',
+  h: 'help',
+  l: 'loglevel'
+}
+const argv = parseArgv(process.argv, { alias, default: defaults })
+const help =
+  `
+nexe --help              CLI OPTIONS

-   ${c.underline.bold("Options:")}
+  -b   --build                              -- build from source
+  -i   --input      =index.js               -- application entry point
+  -o   --output     =my-app.exe             -- path to output file
+  -t   --target     =win32-x64-6.10.3       -- *target a prebuilt binary
+  -n   --name       =my-app                 -- main app module name
+  -v   --version    =${padRight(process.version.slice(1), 23)}-- node version
+  -p   --python     =/path/to/python2       -- python executable
+  -f   --flag       ="--expose-gc"          -- *v8 flags to include during compilation
+  -c   --configure  ="--with-dtrace"        -- *pass arguments to the configure step
+  -m   --make       ="--loglevel"           -- *pass arguments to the make/build step
+  -s   --snapshot   =/path/to/snapshot      -- build with warmup snapshot
+  -r   --resource   =./paths/**/*           -- *embed file bytes within the binary
+       --bundle     =./path/to/config       -- pass a module path that exports nexeBundle
+       --temp       =./path/to/temp         -- nexe temp files (for downloads and source builds)
+       --no-bundle                          -- set when input is already bundled
+       --cwd                                -- set the current working directory for the command
+       --ico                                -- file name for alternate icon file (windows)
+       --rc-*                               -- populate rc file options (windows)
+       --clean                              -- force download of sources
+       --enableNodeCli                      -- enable node cli enforcement (blocks app cli)
+       --sourceUrl                          -- pass an alternate source (node.tar.gz) url
+       --silent                             -- disable logging
+       --verbose                            -- set logging to verbose

-  -i   --input                      -- application entry point
-  -o   --output                     -- path to output file
-  -t   --target                     -- node version description
-  -n   --name                       -- main app module name
-  -r   --resource                   -- *embed files (glob) within the binary
-       --remote                     -- alternate location (URL) to download pre-built base (nexe) binaries from
-       --plugin                     -- extend nexe runtime behavior
+       -* variable key name                 * option can be used more than once`.trim() + EOL

-   ${c.underline.bold("Building from source:")}
-
-  -b   --build                      -- build from source
-  -p   --python                     -- python3 (as python) executable path
-  -f   --flag                       -- *v8 flags to include during compilation
-  -c   --configure                  -- *arguments to the configure step
-  -m   --make                       -- *arguments to the make/build step
-       --patch                      -- module with middleware default export for adding a build patch
-       --no-mangle                  -- used when generating base binaries, or when patching _third_party_main manually
-       --snapshot                   -- path to a warmup snapshot
-       --ico                        -- file name for alternate icon file (windows)
-       --rc-*                       -- populate rc file options (windows)
-       --sourceUrl                  -- pass an alternate source (node.tar.gz) url
-       --enableNodeCli              -- enable node cli enforcement (blocks app cli)
-
-   ${c.underline.bold("Other options:")}
-
-       --bundle                     -- custom bundling module with 'createBundle' export
-       --temp                       -- temp file storage default '~/.nexe'
-       --cwd                        -- set the current working directory for the command
-       --fake-argv                  -- fake argv[1] with entry file
-       --clean                      -- force download of sources
-       --silent                     -- disable logging
-       --verbose                    -- set logging to verbose
-
-       -* variable key name         * option can be used more than once`.trim();
-help = EOL + help + EOL;
-
-function flatten(...args: any[]): string[] {
-  return ([] as string[]).concat(...args).filter((x) => x);
+function flattenFilter(...args: any[]): string[] {
+  return ([] as string[]).concat(...args).filter(x => x)
 }

 /**
@@ -157,169 +124,110 @@ function flatten(...args: any[]): string[] {
 */
 function extractCliMap(match: RegExp, options: any) {
  return Object.keys(options)
-    .filter((x) => match.test(x))
-    .reduce((map: any, option: any) => {
-      const key = option.split("-")[1];
-      map[key] = options[option];
-      delete options[option];
-      return map;
-    }, {} as any);
+    .filter(x => match.test(x))
+    .reduce((map: { [key: string]: string }, option: keyof NexeOptions) => {
+      const key = option.split('-')[1]
+      map[key] = options[option]
+      delete options[option]
+      return map
+    }, {})
+}
+
+function tryResolveMainFileName(cwd: string) {
+  let filename
+  try {
+    const file = require.resolve(cwd)
+    filename = basename(file).replace(extname(file), '')
+  } catch (_) {}
+
+  return !filename || filename === 'index' ? 'nexe_' + Date.now() : filename
 }

 function extractLogLevel(options: NexeOptions) {
-  if (options.loglevel) return options.loglevel;
-  if (options.silent) return "silent";
-  if (options.verbose) return "verbose";
-  return "info";
-}
-
-function isName(name: string) {
-  return name && name !== "index" && name !== STDIN_FLAG;
+  if (options.loglevel) return options.loglevel
+  if (options.silent) return 'silent'
+  if (options.verbose) return 'verbose'
+  return 'info'
 }

 function extractName(options: NexeOptions) {
-  let name = options.name;
-  //try and use the input filename as the output filename if its not index
-  if (!isName(name) && typeof options.input === "string") {
-    name = basename(options.input).replace(extname(options.input), "");
+  let name = options.name
+  if (!name && typeof options.input === 'string') {
+    name = basename(options.input).replace(extname(options.input), '')
  }
-  //try and use the directory as the filename
-  if (!isName(name) && basename(options.cwd)) {
-    name = basename(options.cwd);
-  }
-
-  return name.replace(/\.exe$/, "");
+  name = name || tryResolveMainFileName(options.cwd)
+  return name.replace(/\.exe$/, '')
 }

-function padRelative(input: string) {
-  let prefix = "";
-  if (!input.startsWith(".")) {
-    prefix = "./";
-  }
-  return prefix + input;
+function isEntryFile(filename: string) {
+  return filename && !isAbsolute(filename) && filename !== 'node' && /\.(tsx?|jsx?)$/.test(filename)
 }

-function isEntryFile(filename?: string): filename is string {
-  return Boolean(filename && !isAbsolute(filename));
-}
-
-export function resolveEntry(
-  input: string,
-  cwd: string,
-  maybeEntry: string | undefined,
-  bundle: boolean | string
-) {
-  let result = null;
-  if (input === "-" || maybeEntry === "-") {
-    return STDIN_FLAG;
-  }
-  if (input && isAbsolute(input)) {
-    return input;
-  }
+function findInput(input: string, cwd: string) {
+  const maybeInput = argv._.slice().pop() || ''
  if (input) {
-    const inputPath = padRelative(input);
-    result = resolveSync(cwd, inputPath);
+    return input
  }
-  if (isEntryFile(maybeEntry) && (!result || !result.absPath)) {
-    const inputPath = padRelative(maybeEntry);
-    result = resolveSync(cwd, inputPath);
+  if (isEntryFile(maybeInput)) {
+    return maybeInput
  }
-  if (
-    !process.stdin.isTTY &&
-    (!result || !result.absPath) &&
-    bundle === defaults.bundle
-  ) {
-    return STDIN_FLAG;
+  try {
+    const main = require.resolve(cwd)
+    return './' + relative(cwd, main)
+  } catch (e) {
+    void e
  }
-  if (!result || !result.absPath) {
-    result = resolveSync(cwd, ".");
-  }
-  if (!result.absPath) {
-    throw new NexeError(`Entry file "${input || ""}" not found!`);
-  }
-  return result.absPath;
+
+  return ''
 }

-function isCli(options?: Partial<NexeOptions>) {
-  return argv === options;
-}
-
-function normalizeOptions(input?: Partial<NexeOptions>): NexeOptions {
-  const options = Object.assign({}, defaults, input) as NexeOptions;
-  const opts = options as any;
-  const cwd = (options.cwd = resolve(options.cwd));
-  options.temp = options.temp
-    ? resolve(cwd, options.temp)
-    : process.env.NEXE_TEMP || join(homedir(), ".nexe");
-  const maybeEntry = isCli(input) ? argv._[argv._.length - 1] : undefined;
-  options.input = resolveEntry(options.input, cwd, maybeEntry, options.bundle);
-  options.enableStdIn = isCli(input) && options.input === STDIN_FLAG;
-  options.name = extractName(options);
-  options.loglevel = extractLogLevel(options);
-  options.flags = flatten(opts.flag, options.flags);
-  options.targets = flatten(opts.target, options.targets).map(getTarget);
-  if (!options.targets.length) {
-    options.targets.push(getTarget());
+function normalizeOptionsAsync(input?: Partial<NexeOptions>): Promise<NexeOptions | never> {
+  if (argv.help || argv._.some((x: string) => x === 'version') || argv.version === true) {
+    return new Promise(() => {
+      process.stderr.write(argv.help ? help : nexeVersion + EOL, () => process.exit(0))
+    })
  }
-  options.ghToken = options.ghToken || process.env.GITHUB_TOKEN || "";
-  options.make = flatten(isWindows ? options.vcBuild : options.make);
-  options.configure = flatten(options.configure);
-  options.resources = flatten(opts.resource, options.resources);
+  const options = Object.assign({}, defaults, input) as NexeOptions
+  const opts = options as any

-  if (!options.remote.endsWith("/")) {
-    options.remote += "/";
-  }
+  options.temp = process.env.NEXE_TEMP || join(options.cwd, '.nexe')
+  options.name = extractName(options)
+  options.input = findInput(options.input, options.cwd)
+  options.loglevel = extractLogLevel(options)
+  options.flags = flattenFilter(opts.flag, options.flags)
+  options.targets = flattenFilter(opts.target, options.targets)
+  options.make = flattenFilter(options.vcBuild, options.make)
+  options.configure = flattenFilter(options.configure)
+  options.resources = flattenFilter(opts.resource, options.resources)
+  options.rc = options.rc || extractCliMap(/^rc-.*/, options)

-  options.downloadOptions = options.downloadOptions || {};
-  options.downloadOptions.headers = options.downloadOptions.headers || {};
-  options.downloadOptions.headers["User-Agent"] =
-    "nexe (https://www.npmjs.com/package/nexe)";
-  options.downloadOptions.agent = process.env.HTTPS_PROXY
-    ? caw(process.env.HTTPS_PROXY, { protocol: "https" })
-    : options.downloadOptions.agent || require("https").globalAgent;
-  options.downloadOptions.rejectUnauthorized = process.env
-    .NODE_TLS_REJECT_UNAUTHORIZED
-    ? false
-    : true;
+  options.targets = options.targets.map(getTarget)

-  options.rc = options.rc || extractCliMap(/^rc-.*/, options);
-  options.output =
-    (options.targets[0] as NexeTarget).platform === "windows"
-      ? `${(options.output || options.name).replace(/\.exe$/, "")}.exe`
-      : `${options.output || options.name}`;
-  options.output = resolve(cwd, options.output);
-
-  const requireDefault = (x: string) => {
-    if (typeof x === "string") {
-      return require(x).default;
-    }
-    return x;
-  };
-
-  options.mangle = "mangle" in opts ? opts.mangle : true;
-  options.plugins = flatten(opts.plugin, options.plugins).map(requireDefault);
-  options.patches = flatten(opts.patch, options.patches).map(requireDefault);
-
-  if ((!options.mangle && !options.bundle) || options.patches.length) {
-    options.build = true;
-  }
-
-  if (options.build) {
-    const { arch } = options.targets[0] as NexeTarget;
+  if (options.build && options.targets.length) {
+    const { arch } = options.targets[0] as NexeTarget
    if (isWindows) {
-      options.make = Array.from(new Set(options.make.concat(arch)));
+      options.make = Array.from(new Set(options.make.concat([arch])))
    } else {
-      options.configure = Array.from(
-        new Set(options.configure.concat([`--dest-cpu=${arch}`]))
-      );
+      options.configure = Array.from(new Set(options.configure.concat([`--dest-cpu=${arch}`])))
    }
  }

+  if (!options.targets.length) {
+    options.targets = [getTarget(options.version)]
+  }
+
+  options.patches = options.patches.map(x => {
+    if (typeof x === 'string') {
+      return require(x).default
+    }
+    return x
+  })
+
  Object.keys(alias)
-    .filter((k) => k !== "rc")
-    .forEach((x) => delete opts[x]);
+    .filter(k => k !== 'rc')
+    .forEach(x => delete opts[x])

-  return options;
+  return Promise.resolve(options)
 }

-export { argv, normalizeOptions, help };
+export { argv, normalizeOptionsAsync }
@@ -1,99 +0,0 @@
-const fs = require("fs"),
-  fd = fs.openSync(process.execPath, "r"),
-  stat = fs.fstatSync(fd),
-  tailSize = Math.min(stat.size, 16000),
-  tailWindow = Buffer.alloc(tailSize),
-  match = "<nexe" + "~~sentinel>",
-  matchLength = match.length,
-  lastBuffer = Buffer.alloc(matchLength + 32);
-
-let offset = stat.size,
-  footerPosition = -1,
-  footerPositionOffset = 0,
-  footer: Buffer;
-
-while (true) {
-  const bytesRead = fs.readSync(fd, tailWindow, 0, tailSize, offset - tailSize);
-  if (bytesRead === 0) break;
-
-  const combinedBuffers = Buffer.concat([tailWindow, lastBuffer]);
-  footerPosition = combinedBuffers.indexOf(match);
-
-  if (footerPosition > -1) {
-    footer = combinedBuffers.slice(footerPosition, footerPosition + 32);
-    break;
-  }
-
-  if (offset < 0) break;
-
-  tailWindow.copy(lastBuffer);
-  offset = offset - bytesRead;
-}
-
-if (footerPosition == -1) {
-  throw "Invalid Nexe binary";
-}
-
-const contentSize = footer!.readDoubleLE(16),
-  resourceSize = footer!.readDoubleLE(24),
-  contentStart =
-    offset - tailSize + footerPosition - resourceSize - contentSize,
-  resourceStart = contentStart + contentSize;
-
-Object.defineProperty(
-  process,
-  "__nexe",
-  (function () {
-    let nexeHeader: any = null;
-    return {
-      get: function () {
-        return nexeHeader;
-      },
-      set: function (value: any) {
-        if (nexeHeader) {
-          throw new Error("This property is readonly");
-        }
-        nexeHeader = Object.assign({}, value, {
-          blobPath: process.execPath,
-          layout: {
-            stat,
-            contentSize,
-            contentStart,
-            resourceSize,
-            resourceStart,
-          },
-        });
-        Object.freeze(nexeHeader);
-      },
-      enumerable: false,
-      configurable: false,
-    };
-  })()
-);
-
-const contentBuffer = Buffer.alloc(contentSize),
-  Module = require("module");
-
-fs.readSync(fd, contentBuffer, 0, contentSize, contentStart);
-fs.closeSync(fd);
-
-// Node 24 changed finalizeResolution in the ESM loader to no longer catch ENOENT
-// from realpathSync. VFS paths don't exist on real FS, so binding.lstat (called
-// internally by realpathSync) throws ENOENT and crashes ESM imports.
-// The ESM resolver captures realpathSync via destructuring at load time, so
-// patchFs (which runs later) doesn't reach it. We install an ENOENT-tolerant
-// wrapper here, before any ESM code can load, so the resolver captures our version.
-{
-  const _origRpSync: any = fs.realpathSync;
-  const nexeRpSync = function(p: string, opts?: any): string {
-    try { return _origRpSync(p, opts); }
-    catch (e: any) { if (e?.code === 'ENOENT') return p; throw e; }
-  };
-  (nexeRpSync as any).native = _origRpSync.native;
-  (fs as any).realpathSync = nexeRpSync;
-}
-
-new Module(process.execPath, null)._compile(
-  contentBuffer.slice(1).toString(),
-  process.execPath
-);
@@ -1,18 +1,17 @@
-import { NexeCompiler } from "../compiler";
+import { NexeCompiler } from '../compiler'

-export default async function buildFixes(
-  compiler: NexeCompiler,
-  next: () => Promise<void>
-) {
-  if (!compiler.target.version.startsWith("8.2")) {
-    return next();
+export default async function buildFixes(compiler: NexeCompiler, next: () => Promise<void>) {
+  if (!compiler.options.version.startsWith('8.2')) {
+    return next()
  }

-  await compiler.replaceInFileAsync(
-    "./tools/msvs/find_python.cmd",
-    "%p%python.exe -V 2>&1",
-    '"%p%python.exe" -V 2>&1'
-  );
+  const file = await compiler.readFileAsync('./tools/msvs/find_python.cmd')

-  return next();
+  await compiler.replaceInFileAsync(
+    './tools/msvs/find_python.cmd',
+    '%p%python.exe -V 2>&1',
+    '"%p%python.exe" -V 2>&1'
+  )
+
+  return next()
 }
@@ -1,61 +1,12 @@
-import { NexeCompiler } from "../compiler";
-import { semverGt } from "../util";
+import { NexeCompiler } from '../compiler'

-export default async function disableNodeCli(
-  compiler: NexeCompiler,
-  next: () => Promise<void>
-) {
+export default async function disableNodeCli(compiler: NexeCompiler, next: () => Promise<void>) {
  if (compiler.options.enableNodeCli) {
-    return next();
+    return next()
  }

-  if (semverGt(compiler.target.version, "18.99")) {
-    await compiler.replaceInFileAsync(
-      "src/node.cc",
-      /(?<!static ExitCode )ProcessGlobalArgsInternal\(argv[^;]*;/gm,
-      "ExitCode::kNoFailure;/*$&*/"
-    );
-  } else if (semverGt(compiler.target.version, "11.6.0")) {
-    await compiler.replaceInFileAsync(
-      "src/node.cc",
-      /(?<!int )ProcessGlobalArgs\(argv[^;]*;/gm,
-      "0;/*$&*/"
-    );
-  } else if (semverGt(compiler.target.version, "10.9")) {
-    await compiler.replaceInFileAsync(
-      "src/node.cc",
-      /(?<!void )ProcessArgv\(argv/g,
-      "//$&"
-    );
-  } else if (semverGt(compiler.target.version, "9.999")) {
-    await compiler.replaceInFileAsync(
-      "src/node.cc",
-      "int i = 1; i < v8_argc; i++",
-      "int i = v8_argc; i < v8_argc; i++"
-    );
-    let matches = 0;
-    await compiler.replaceInFileAsync(
-      "src/node.cc",
-      /v8_argc > 1/g,
-      (match) => {
-        if (matches++) {
-          return "false";
-        }
-        return match;
-      }
-    );
-  } else {
-    const nodeccMarker = "argv[index][0] ==";
+  const nodeccMarker = "argv[index][0] == '-'"

-    await compiler.replaceInFileAsync(
-      "src/node.cc",
-      `${nodeccMarker} '-'`,
-      // allow NODE_OPTIONS, introduced in 8.0
-      semverGt(compiler.target.version, "7.99")
-        ? `(${nodeccMarker} (is_env ? '-' : ']'))`
-        : `(${nodeccMarker} ']')`
-    );
-  }
-
-  return next();
+  await compiler.replaceInFileAsync('src/node.cc', nodeccMarker, nodeccMarker.replace('-', ']'))
+  return next()
 }
@@ -1,19 +1,16 @@
-import { NexeCompiler } from "../compiler";
+import { NexeCompiler } from '../compiler'

-export default async function flags(
-  compiler: NexeCompiler,
-  next: () => Promise<void>
-) {
-  const nodeflags = compiler.options.flags;
+export default async function flags(compiler: NexeCompiler, next: () => Promise<void>) {
+  const nodeflags = compiler.options.flags
  if (!nodeflags.length) {
-    return next();
+    return next()
  }

  await compiler.replaceInFileAsync(
-    "node.gyp",
+    'node.gyp',
    "'node_v8_options%': ''",
-    `'node_v8_options%': '${nodeflags.join(" ")}'`
-  );
+    `'node_v8_options%': '${nodeflags.join(' ')}'`
+  )

-  return next();
+  return next()
 }
@@ -1,23 +0,0 @@
-import { NexeCompiler } from '../compiler'
-
-export default async function fsStat(compiler: NexeCompiler, next: () => Promise<void>) {
-  await compiler.replaceInFileAsync(
-    'lib/fs.js',
-    'function statSync(path, options = { bigint: false, throwIfNoEntry: true }) {',
-    `function statSync(path, options = { bigint: false, throwIfNoEntry: true }) {
-  // If Node passes a file descriptor, we must fstat the REAL fs
-  if (typeof path === 'number') {
-    try {
-      return fstatSync(path, options);
-    } catch (e) {
-      if (options.throwIfNoEntry) {
-        throw e;
-      }
-      return options.bigint ? BigInt(-1) : -1;
-    }
-  }
-`
-  )
-
-  return next()
-}
@@ -1,21 +1,21 @@
-import { NexeCompiler } from "../compiler";
+import { NexeCompiler } from '../compiler'

 export default async function nodeGyp(
  { files, replaceInFileAsync }: NexeCompiler,
  next: () => Promise<void>
 ) {
-  await next();
+  await next()

-  const nodeGypMarker = "'lib/fs.js',";
+  const nodeGypMarker = "'lib/fs.js',"
  await replaceInFileAsync(
-    "node.gyp",
+    'node.gyp',
    nodeGypMarker,
    `
    ${nodeGypMarker}
    ${files
-        .filter((x) => x.filename.startsWith("lib"))
-        .map((x) => `'${x.filename}'`)
-        .toString()},
+      .filter(x => x.filename.startsWith('lib'))
+      .map(x => `'${x.filename}'`)
+      .toString()},
  `.trim()
-  );
+  )
 }
@@ -1,18 +1,12 @@
-import { normalize } from "path";
-import { readFileAsync } from "../util";
-import { NexeCompiler } from "../compiler";
+import { normalize } from 'path'
+import { readFileAsync } from '../util'
+import { NexeCompiler } from '../compiler'

-export default async function ico(
-  compiler: NexeCompiler,
-  next: () => Promise<void>
-) {
-  const iconFile = compiler.options.ico;
+export default async function ico(compiler: NexeCompiler, next: () => Promise<void>) {
+  const iconFile = compiler.options.ico
  if (!iconFile) {
-    return next();
+    return next()
  }
-  await compiler.setFileContentsAsync(
-    "src/res/node.ico",
-    await readFileAsync(normalize(iconFile))
-  );
-  return next();
+  await compiler.setFileContentsAsync('src/res/node.ico', await readFileAsync(normalize(iconFile)))
+  return next()
 }
@@ -1,15 +1,12 @@
-import gyp from "./gyp";
-import bootNexe from "./third-party-main";
-import buildFixes from "./build-fixes";
-import cli from "./disable-node-cli";
-import flags from "./flags";
-import ico from "./ico";
-import rc from "./node-rc";
-import snapshot from "./snapshot";
-import fsStat from "./fs-stat-debug";
+import gyp from './gyp'
+import nexePatches from './third-party-main'
+import buildFixes from './build-fixes'
+import cli from './disable-node-cli'
+import flags from './flags'
+import ico from './ico'
+import rc from './node-rc'
+import { NexeCompiler } from '../compiler'

-// Patches are applied in order, so if a patch depends on another patch, it should be listed after the patch it depends on.
-// For example, if a patch modifies the output of gyp, it should be listed after gyp in this array.
-const patches = [gyp, bootNexe, buildFixes, cli, flags, ico, rc, snapshot];
+const patches = [gyp, nexePatches, buildFixes, cli, flags, ico, rc]

-export default patches;
+export default patches
@@ -1,31 +1,19 @@
-import { NexeCompiler } from "../compiler";
+import { NexeCompiler } from '../compiler'

-export default async function nodeRc(
-  compiler: NexeCompiler,
-  next: () => Promise<void>
-) {
-  const options = compiler.options.rc;
+export default async function nodeRc(compiler: NexeCompiler, next: () => Promise<void>) {
+  const options = compiler.options.rc
  if (!options) {
-    return next();
+    return next()
  }

-  const file = await compiler.readFileAsync("src/res/node.rc");
+  const file = await compiler.readFileAsync('src/res/node.rc')

-  Object.keys(options).forEach((key) => {
-    let value = options[key];
-    const isVar = /^[A-Z_]+$/.test(value);
-    value = isVar ? value : `"${value}"`;
-    file.contents = file.contents
-      .toString()
-      .replace(new RegExp(`VALUE "${key}",.*`), `VALUE "${key}", ${value}`);
-  });
-  ["PRODUCTVERSION", "FILEVERSION"].forEach((x) => {
-    if (options[x]) {
-      file.contents = file.contents
-        .toString()
-        .replace(new RegExp(x + " .*$", "m"), `${x} ${options[x]}`);
-    }
-  });
+  Object.keys(options).forEach(key => {
+    let value = options[key]
+    const isVar = /^[A-Z_]+$/.test(value)
+    value = isVar ? value : `"${value}"`
+    file.contents.replace(new RegExp(`VALUE "${key}",*`), `VALUE "${key}", ${value}`)
+  })

-  return next();
+  return next()
 }
@@ -1,32 +1,19 @@
-import { resolve } from "path";
-import { NexeCompiler } from "../compiler";
-import { semverGt } from "../util";
+import { NexeCompiler } from '../compiler'

-export default async function (
-  compiler: NexeCompiler,
-  next: () => Promise<void>
-) {
-  const { snapshot, warmup, cwd } = compiler.options;
+export default async function snapshot(compiler: NexeCompiler, next: () => Promise<void>) {
+  const snapshotFile = compiler.options.snapshot
+  const warmupScript = compiler.options.warmup

-  if (!snapshot) {
-    return next();
+  if (!snapshotFile) {
+    return next()
  }

-  const variablePrefix = semverGt(compiler.target.version, "11.0.0")
-    ? "v8_"
-    : "";
-
  await compiler.replaceInFileAsync(
-    compiler.configureScript,
-    "def configure_v8(o):",
-    `def configure_v8(o):\n  o['variables']['${variablePrefix}embed_script'] = r'${resolve(
-      cwd,
-      snapshot
-    )}'\n  o['variables']['${variablePrefix}warmup_script'] = r'${resolve(
-      cwd,
-      warmup || snapshot
-    )}'`
-  );
+    'configure',
+    'def configure_v8(o):',
+    `def configure_v8(o):\n  o['variables']['embed_script'] = '${snapshotFile}'\n  o['variables']['warmup_script'] = '${warmupScript ||
+      snapshotFile}'`
+  )

-  return next();
+  return next()
 }
@@ -1,131 +1,126 @@
-import { NexeCompiler } from "../compiler";
-import { parse } from "meriyah";
-import { wrap, semverGt } from "../util";
+import { NexeCompiler } from '../compiler'
+import { readFileSync } from 'fs'
+import { join } from 'path'

-function walkSome(node: any, visit: Function) {
-  if (!node || typeof node.type !== "string" || node._visited) {
-    return false;
-  }
-  visit(node);
-  node._visited = true;
-  for (const childNode in node) {
-    const child = node[childNode];
-    if (Array.isArray(child)) {
-      for (let i = 0; i < child.length; i++) {
-        if (walkSome(child[i], visit)) {
-          return true;
-        }
+export default async function main(compiler: NexeCompiler, next: () => Promise<void>) {
+  await compiler.setFileContentsAsync(
+    'lib/_third_party_main.js',
+    `
+const fs = require('fs')
+const path = require('path')
+const Buffer = require('buffer').Buffer
+const isString = x => typeof x === 'string' || x instanceof String
+
+const fd = fs.openSync(process.execPath, 'r')
+const size = fs.statSync(process.execPath).size
+const footer = Buffer.from(Array(32))
+fs.readSync(fd, footer, 0, 32, size - 32)
+
+if (!footer.slice(0, 16).equals(Buffer.from('<nexe~~sentinel>'))) {
+  throw 'Invalid Nexe binary'
+}
+
+const contentSize = footer.readDoubleLE(16)
+const resourceSize = footer.readDoubleLE(24)
+const contentStart = size - 32 - resourceSize - contentSize
+const resourceStart = contentStart + contentSize
+
+Object.defineProperty(process, '__nexe', (function () {
+  let nexeHeader = null
+  return {
+    get: function () {
+      return nexeHeader
+    },
+    set: function (value) {
+      if (nexeHeader) {
+        throw new Error('__nexe cannot be reconfigured')
      }
-    } else if (walkSome(child, visit)) {
-      return true;
-    }
+      nexeHeader = value
+      Object.freeze(nexeHeader)
+    },
+    enumerable: false,
+    configurable: false
+  }
+})());
+
+if (resourceSize) {
+  const originalReadFile = fs.readFile
+  const originalReadFileSync = fs.readFileSync
+  let setupManifest = () => {
+    const manifest = process.__nexe && process.__nexe.resources
+    if (!manifest) {
+      return
+    }
+    Object.keys(manifest).forEach((key) => {
+      const absolutePath = path.resolve(key)
+      if (!manifest[absolutePath]) {
+        manifest[absolutePath] = manifest[key]
+      }
+      const normalizedPath = path.normalize(key)
+      if (!manifest[normalizedPath]) {
+        manifest[normalizedPath] = manifest[key]
+      }
+    })
+    normalizeManifest = () => {}
+  };
+  fs.readFile = function readFile (file, options, callback) {
+    setupManifest()
+    const manifest = process.__nexe
+    const entry = manifest && manifest.resources[file]
+    if (!manifest || !entry || !isString(file)) {
+      return originalReadFile.apply(fs, arguments)
+    }
+    const [offset, length] = entry
+    const resourceOffset = resourceStart + offset
+    const encoding = isString(options) ? options : null
+    callback = typeof options === 'function' ? options : callback
+
+    fs.open(process.execPath, 'r', function (err, fd) {
+      if (err) return callback(err, null)
+      fs.read(fd, Buffer.alloc(length), 0, length, resourceOffset, function (error, bytesRead, buffer) {
+        if (error) {
+          return fs.close(fd, function () {
+            callback(error, null)
+          })
+        }
+        fs.close(fd, function (err) {
+          if (err) {
+            return callback(err, buffer)
+          }
+          const result = Buffer.from(buffer.toString(), 'base64')
+          callback(err, encoding ? result.toString(encoding) : result)
+        })
+      })
+    })
+  }
+
+  fs.readFileSync = function readFileSync (file, options) {
+    setupManifest()
+    const manifest = process.__nexe
+    const entry = manifest && manifest.resources[file]
+    if (!manifest || !entry || !isString(file)) {
+      return originalReadFileSync.apply(fs, arguments)
+    }
+    const [offset, length] = entry
+    const resourceOffset = resourceStart + offset
+    const encoding = isString(options) ? options : null
+    const fd = fs.openSync(process.execPath, 'r')
+    const result = Buffer.alloc(length)
+    fs.readSync(fd, result, 0, length, resourceOffset)
+    fs.closeSync(fd)
+    const contents = Buffer.from(result.toString(), 'base64')
+    return encoding ? contents.toString(encoding) : contents
  }
-  return false;
 }

-export default async function main(
-  compiler: NexeCompiler,
-  next: () => Promise<void>
-) {
-  let bootFile = "lib/internal/bootstrap_node.js";
-  const { version } = compiler.target;
-
-  if (version.startsWith("4.")) {
-    bootFile = "src/node.js";
-  } else if (semverGt(version, "18.11.99")) {
-    bootFile = "lib/internal/process/pre_execution.js";
-  } else if (semverGt(version, "11.99")) {
-    bootFile = "lib/internal/bootstrap/pre_execution.js";
-  } else if (semverGt(version, "9.10.1")) {
-    bootFile = "lib/internal/bootstrap/node.js";
-  }
-
-  const file = await compiler.readFileAsync(bootFile),
-    ast = parse(file.contents.toString(), {
-      next: true,
-      globalReturn: true,
-      loc: true,
-    }),
-    location = { start: { line: 0 } };
-
-  walkSome(ast, (node: any) => {
-    if (!location.start.line && node.type === "BlockStatement") {
-      //Find the first block statement and mark the location
-      Object.assign(location, node.loc);
-      return true;
-    }
-  });
-
-  const fileLines = file.contents.toString().split("\n");
-  if (semverGt(version, "18.16.99")) {
-    await compiler.replaceInFileAsync(
-      "lib/internal/modules/cjs/loader.js",
-      "'use strict';",
-      "'use strict';\n" + '{{ file("lib/fs/bootstrap.js") }}' + "\n"
-    );
-    fileLines.splice(location.start.line, 0, "expandArgv1 = false;");
-  } else {
-    fileLines.splice(
-      location.start.line,
-      0,
-      '{{ file("lib/fs/bootstrap.js") }}' +
-      "\n" +
-      (semverGt(version, "11.99") ? "expandArgv1 = false;\n" : "")
-    );
-  }
-  file.contents = fileLines.join("\n");
-
-  if (semverGt(version, "11.99")) {
-    if (semverGt(version, "12.17.99")) {
-      await compiler.replaceInFileAsync(
-        bootFile,
-        "initializeFrozenIntrinsics();",
-        "initializeFrozenIntrinsics();\n" +
-        wrap('{{ file("lib/patches/boot-nexe.js") }}')
-      );
-    } else {
-      await compiler.replaceInFileAsync(
-        bootFile,
-        "initializePolicy();",
-        "initializePolicy();\n" + wrap('{{ file("lib/patches/boot-nexe.js") }}')
-      );
-    }
-    await compiler.replaceInFileAsync(
-      bootFile,
-      "assert(!CJSLoader.hasLoadedAnyUserCJSModule)",
-      "/*assert(!CJSLoader.hasLoadedAnyUserCJSModule)*/"
-    );
-    // Node 22.22+ / 24 removed the ENOENT catch from finalizeResolution in the
-    // ESM resolver. realpathSync calls binding.lstat which throws ENOENT for VFS
-    // paths (they don't exist on real FS). Restore the catch so VFS imports work.
-    await compiler.replaceInFileAsync(
-      "lib/internal/modules/esm/resolve.js",
-      /const real = realpathSync\(path, \{ encoding: ['"]utf8['"] \}\);/,
-      "let real; try { real = realpathSync(path, { encoding: 'utf8' }); } catch (e) { if (e.code !== 'ENOENT') throw e; real = path; }"
-    );
-    const { contents: nodeccContents } = await compiler.readFileAsync(
-      "src/node.cc"
-    );
-    if (nodeccContents.includes("if (env->worker_context() != nullptr) {")) {
-      await compiler.replaceInFileAsync(
-        "src/node.cc",
-        "if (env->worker_context() != nullptr) {",
-        "if (env->worker_context() == nullptr) {\n" +
-        '  return StartExecution(env, "internal/main/run_main_module"); } else {\n'
-      );
-    } else {
-      await compiler.replaceInFileAsync(
-        "src/node.cc",
-        "MaybeLocal<Value> StartMainThreadExecution(Environment* env) {",
-        "MaybeLocal<Value> StartMainThreadExecution(Environment* env) {\n" +
-        '  return StartExecution(env, "internal/main/run_main_module");\n'
-      );
-    }
-  } else {
-    await compiler.setFileContentsAsync(
-      "lib/_third_party_main.js",
-      '{{ file("lib/patches/boot-nexe.js") }}'
-    );
-  }
-  return next();
+const contentBuffer = Buffer.from(Array(contentSize));
+fs.readSync(fd, contentBuffer, 0, contentSize, contentStart);
+fs.closeSync(fd);
+const Module = require('module');
+process.mainModule = new Module(process.execPath, null);
+process.mainModule.loaded = true;
+process.mainModule._compile(contentBuffer.toString(), process.execPath);
+`.trim()
+  )
+  return next()
 }
@@ -1,76 +1,73 @@
-import axios from "axios";
+import got = require('got')
+import download = require('download')
 import {
+  NodePlatform,
+  NodeArch,
  platforms,
  architectures,
  NexeTarget,
  getTarget,
-  targetsEqual,
-} from "./target";
-export { NexeTarget };
+  targetsEqual
+} from './target'
+export { NexeTarget }

-const versionsToSkip = [
-  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 13, 15, 17, 19, 21, 22,
-];
 export interface GitAsset {
-  name: string;
-  url: string;
-  browser_download_url: string;
+  name: string
+  url: string
+  browser_download_url: string
 }

 export interface GitRelease {
-  tag_name: string;
-  assets_url: string;
-  upload_url: string;
-  assets: GitAsset[];
+  tag_name: string
+  assets_url: string
+  upload_url: string
+  assets: GitAsset[]
 }

 interface NodeRelease {
-  version: string;
+  version: string
 }

-async function getJson<T>(url: string, options?: any): Promise<T> {
-  const response = await axios.get(url, options);
-  return response.data as T;
+async function getJson<T>(url: string, options?: any) {
+  return JSON.parse((await got(url, options)).body) as T
 }

+//TODO only build the latest of each major...?
 function isBuildableVersion(version: string) {
-  if (version === "12.11.0") {
-    return false;
-  }
-  return !versionsToSkip.includes(Number(version.split(".")[0]));
+  const major = +version.split('.')[0]
+  return !~[0, 1, 2, 3, 4, 5, 7].indexOf(major) || version === '4.8.4'
 }

-export function getLatestGitRelease(options?: any): Promise<GitRelease> {
-  return getJson<GitRelease>(
-    "https://api.github.com/repos/nexe/nexe/releases/latest",
-    options
-  );
+export function getLatestGitRelease(options?: any) {
+  return getJson<GitRelease>('https://api.github.com/repos/nexe/nexe/releases/latest', options)
+}
+
+export async function storeAsset(asset: GitAsset, dest: string, headers?: any) {
+  const options = headers ? { headers } : undefined
+  await download(asset.browser_download_url, dest, options as any)
 }

 export async function getUnBuiltReleases(options?: any) {
  const nodeReleases = await getJson<NodeRelease[]>(
-    "https://nodejs.org/download/release/index.json"
-  );
-  const existingVersions = (await getLatestGitRelease(options)).assets.map(
-    (x) => getTarget(x.name)
-  );
+    'https://nodejs.org/download/release/index.json'
+  )
+  const existingVersions = (await getLatestGitRelease(options)).assets.map(x => getTarget(x.name))

-  const versionMap: { [key: string]: true } = {};
+  const versionMap: { [key: string]: true } = {}
  return nodeReleases
    .reduce((versions: NexeTarget[], { version }) => {
-      version = version.replace("v", "").trim();
+      version = version.replace('v', '').trim()
      if (!isBuildableVersion(version) || versionMap[version]) {
-        return versions;
+        return versions
      }
-      versionMap[version] = true;
-      platforms.forEach((platform) => {
-        architectures.forEach((arch) => {
-          if (arch === "x86" && platform === "mac") return;
-          if (arch.includes("arm")) return;
-          versions.push(getTarget({ platform, arch, version }));
-        });
-      });
-      return versions;
+      versionMap[version] = true
+      platforms.forEach(platform => {
+        architectures.forEach(arch => {
+          if (arch === 'x86' && platform === 'mac') return
+          versions.push(getTarget({ platform, arch, version }))
+        })
+      })
+      return versions
    }, [])
-    .filter((x) => !existingVersions.some((t) => targetsEqual(t, x)));
+    .filter(x => !existingVersions.some(t => targetsEqual(t, x)))
 }
@@ -1,35 +1,34 @@
-import { join, dirname } from "path";
-import * as fs from "fs";
-import { promisify } from "util";
-import { readFileAsync, writeFileAsync, isDirectoryAsync } from "../util";
-import mkdirpAsync = require("mkdirp");
-import { NexeCompiler } from "../compiler";
+import { join, dirname } from 'path'
+import { readdir, unlink } from 'fs'
+import { readFileAsync, writeFileAsync, isDirectoryAsync } from '../util'
+import * as mkdirp from 'mkdirp'
+import { NexeCompiler } from '../compiler'
+import pify = require('pify')

-const unlinkAsync = promisify(fs.unlink),
-  readdirAsync = promisify(fs.readdir);
+const mkdirpAsync = pify(mkdirp)
+const unlinkAsync = pify(unlink)
+const readdirAsync = pify(readdir)

 function readDirAsync(dir: string): Promise<string[]> {
-  return readdirAsync(dir).then((paths) => {
+  return readdirAsync(dir).then(paths => {
    return Promise.all(
      paths.map((file: string) => {
-        const path = join(dir, file);
-        return isDirectoryAsync(path).then((x) =>
-          x ? readDirAsync(path) : (path as any)
-        );
+        const path = join(dir, file)
+        return isDirectoryAsync(path).then(x => (x ? readDirAsync(path) : path as any))
      })
-    ).then((result) => {
-      return [].concat(...(result as any));
-    });
-  });
+    ).then(result => {
+      return [].concat(...(result as any))
+    })
+  })
 }

 function maybeReadFileContentsAsync(file: string) {
-  return readFileAsync(file, "utf-8").catch((e) => {
-    if (e.code === "ENOENT") {
-      return "";
+  return readFileAsync(file, 'utf-8').catch(e => {
+    if (e.code === 'ENOENT') {
+      return ''
    }
-    throw e;
-  });
+    throw e
+  })
 }

 /**
@@ -40,37 +39,32 @@ function maybeReadFileContentsAsync(file: string) {
 *  - After the patch functions have run, the temporary directory is emptied
 *  - Original versions of sources to be patched are written to the temporary directory
 *  - Finally, The patched files are written into source.
+ *
 */
-export default async function artifacts(
-  compiler: NexeCompiler,
-  next: () => Promise<void>
-) {
-  const { src } = compiler;
-  const temp = join(src, "nexe");
-  await mkdirpAsync(temp);
-  const tmpFiles = await readDirAsync(temp);
+export default async function artifacts(compiler: NexeCompiler, next: () => Promise<void>) {
+  const { src } = compiler
+  const temp = join(src, 'nexe')
+  await mkdirpAsync(temp)
+  const tmpFiles = await readDirAsync(temp)

  await Promise.all(
-    tmpFiles.map(async (path) => {
-      return compiler.writeFileAsync(
-        path.replace(temp, ""),
-        await readFileAsync(path, "utf-8")
-      );
+    tmpFiles.map(async path => {
+      return compiler.writeFileAsync(path.replace(temp, ''), await readFileAsync(path, 'utf-8'))
    })
-  );
+  )

-  await next();
+  await next()

-  await Promise.all(tmpFiles.map((x) => unlinkAsync(x)));
+  await Promise.all(tmpFiles.map(x => unlinkAsync(x)))
  return Promise.all(
-    compiler.files.map(async (file) => {
-      const sourceFile = join(src, file.filename);
-      const tempFile = join(temp, file.filename);
-      const fileContents = await maybeReadFileContentsAsync(sourceFile);
+    compiler.files.map(async file => {
+      const sourceFile = join(src, file.filename)
+      const tempFile = join(temp, file.filename)
+      const fileContents = await maybeReadFileContentsAsync(sourceFile)

-      await mkdirpAsync(dirname(tempFile));
-      await writeFileAsync(tempFile, fileContents);
-      await compiler.writeFileAsync(file.filename, file.contents);
+      await mkdirpAsync(dirname(tempFile))
+      await writeFileAsync(tempFile, fileContents)
+      await compiler.writeFileAsync(file.filename, file.contents)
    })
-  );
+  )
 }
@@ -1,294 +0,0 @@
-import { NexeCompiler, NexeError } from "../compiler";
-import { resolve, relative, sep, join } from "path";
-import resolveFiles, { resolveSync } from "resolve-dependencies";
-import { dequote, STDIN_FLAG, semverGt } from "../util";
-import { Readable } from "stream";
-import { minimatch } from "minimatch";
-import { readdirSync, statSync } from "fs";
-
-type ModuleRule = {
-  include?: string[];
-  exclude?: string[];
-};
-
-function getModuleName(file: string): string | null {
-  const parts = file.split(/[\\/]/);
-  const idx = parts.lastIndexOf("node_modules");
-  if (idx === -1) return null;
-
-  const name = parts[idx + 1];
-  if (!name) return null;
-
-  return name.startsWith("@")
-    ? parts.slice(idx + 1, idx + 3).join("/")
-    : name;
-}
-
-function getModuleBasePath(file: string, moduleName: string): string | null {
-  const parts = file.split(/[\\/]/);
-  const idx = parts.lastIndexOf("node_modules");
-  if (idx === -1) return null;
-
-  const baseParts = parts.slice(0, idx + 1);
-  if (moduleName.startsWith("@")) {
-    baseParts.push(...moduleName.split("/"));
-  } else {
-    baseParts.push(moduleName);
-  }
-
-  return baseParts.join(sep);
-}
-
-function getModuleRelativePath(file: string, moduleName: string): string {
-  const normalizedFile = file.replace(/\\/g, '/');
-  const normalizedModuleName = moduleName.replace(/\\/g, '/');
-  
-  const marker = `node_modules/${normalizedModuleName}/`;
-  const idx = normalizedFile.indexOf(marker);
-  
-  if (idx === -1) {
-    return "";
-  }
-  
-  return normalizedFile.slice(idx + marker.length);
-}
-
-function getAllFilesInModule(basePath: string): string[] {
-  const files: string[] = [];
-
-  function walk(dir: string) {
-    try {
-      const entries = readdirSync(dir);
-
-      for (const entry of entries) {
-        const fullPath = join(dir, entry);
-        try {
-          const stat = statSync(fullPath);
-
-          if (stat.isDirectory()) {
-            walk(fullPath);
-          } else if (stat.isFile()) {
-            files.push(fullPath);
-          }
-        } catch (err) {
-          // Skip files we can't read
-        }
-      }
-    } catch (err) {
-      // Skip directories we can't read
-    }
-  }
-
-  walk(basePath);
-  return files;
-}
-
-function shouldIncludeFile(
-  file: string,
-  moduleName: string,
-  rule: ModuleRule
-): boolean {
-  const rel = getModuleRelativePath(file, moduleName);
-
-  if (!rel) {
-    return false;
-  }
-
-  // Always include package.json
-  if (rel === "package.json") {
-    return true;
-  }
-
-  // If there's an include list, file MUST match it
-  if (rule.include && rule.include.length > 0) {
-    const matchesInclude = rule.include.some((g) => minimatch(rel, g));
-    if (!matchesInclude) {
-      return false;
-    }
-  }
-
-  // Check exclude patterns
-  if (rule.exclude && rule.exclude.length > 0) {
-    const matchesExclude = rule.exclude.some((g) => minimatch(rel, g));
-    if (matchesExclude) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-function getStdIn(stdin: Readable): Promise<string> {
-  let out = "";
-  return new Promise((resolve) => {
-    stdin
-      .setEncoding("utf8")
-      .on("readable", () => {
-        let current;
-        while ((current = stdin.read())) {
-          out += current;
-        }
-      })
-      .on("end", () => resolve(out.trim()));
-    setTimeout(() => {
-      if (!out.trim()) {
-        resolve(out.trim());
-      }
-    }, 1000);
-  });
-}
-
-export default async function bundle(compiler: NexeCompiler, next: any) {
-  const { bundle: doBundle, cwd, input: inputPath, bundleRules } = compiler.options;
-  
-  const rules: Record<string, ModuleRule> =
-    bundleRules && Object.keys(bundleRules).length ? bundleRules : {};
-
-  let input = inputPath;
-  compiler.entrypoint = "./" + relative(cwd, input);
-
-  if (semverGt(compiler.target.version, "11.99")) {
-    compiler.startup = "";
-  } else {
-    compiler.startup = ';require("module").runMain();';
-  }
-
-  if (!doBundle) {
-    await compiler.addResource(resolve(cwd, input));
-    return next();
-  }
-
-  let code = "";
-  if (typeof doBundle === "string") {
-    code = await require(doBundle).createBundle(compiler.options);
-  }
-
-  if (
-    input === STDIN_FLAG &&
-    (code = code || dequote(await getStdIn(process.stdin)))
-  ) {
-    compiler.stdinUsed = true;
-    compiler.entrypoint = "./__nexe_stdin.js";
-    await compiler.addResource(resolve(cwd, compiler.entrypoint), code);
-    return next();
-  }
-
-  if (input === STDIN_FLAG) {
-    const maybeInput = resolveSync(cwd, ".");
-    if (!maybeInput || !maybeInput.absPath) {
-      throw new NexeError("No valid input detected");
-    }
-    input = maybeInput.absPath;
-    compiler.entrypoint = "./" + relative(cwd, input);
-  }
-
-  const step = compiler.log.step("Resolving dependencies...");
-
-  const { files, warnings } = await resolveFiles(input, {
-    cwd,
-    expand: "variable",
-    loadContent: false,
-  });
-
-  if (
-    warnings.filter(
-      (x) => x.startsWith("Error parsing file") && !x.includes("node_modules")
-    ).length
-  ) {
-    throw new NexeError("Parsing Error:\n" + warnings.join("\n"));
-  }
-
-  // If no bundle rules, use original behavior
-  if (Object.keys(rules).length === 0) {
-    const pkgJsonsToAdd = new Set<string>();
-
-    await Promise.all(
-      Object.entries(files).map(([key]) => {
-        step.log(`Including dependency: ${key}`);
-        // Collect the package.json for each bundled module so Node can
-        // resolve the correct entry point (main/exports) at runtime.
-        const moduleName = getModuleName(key);
-        if (moduleName) {
-          const basePath = getModuleBasePath(key, moduleName);
-          if (basePath) {
-            pkgJsonsToAdd.add(join(basePath, "package.json"));
-          }
-        }
-        return compiler.addResource(key);
-      })
-    );
-
-    await Promise.all(
-      Array.from(pkgJsonsToAdd).map((pkgJson) => {
-        try {
-          statSync(pkgJson);
-          step.log(`Including package.json: ${pkgJson}`);
-          return compiler.addResource(pkgJson);
-        } catch (e) {
-          // package.json doesn't exist on disk, skip
-        }
-      })
-    );
-
-    return next();
-  }
-
-  // Track modules with explicit bundle rules
-  const modulesWithRules = new Map<string, string>();
-
-  for (const file of Object.keys(files)) {
-    const moduleName = getModuleName(file);
-    if (moduleName && rules[moduleName] && !modulesWithRules.has(moduleName)) {
-      const basePath = getModuleBasePath(file, moduleName);
-      if (basePath) {
-        modulesWithRules.set(moduleName, basePath);
-      }
-    }
-  }
-
-  // Collect files to include
-  const filesToInclude = new Set<string>();
-
-  // Add all files that AREN'T from modules with rules (preserve original behavior)
-  for (const file of Object.keys(files)) {
-    const moduleName = getModuleName(file);
-    
-    // If this file is from a module with rules, skip it here
-    if (moduleName && modulesWithRules.has(moduleName)) {
-      continue;
-    }
-    
-    // All other files get included as normal
-    filesToInclude.add(file);
-  }
-
-  // For modules WITH rules: scan and filter
-  for (const [moduleName, basePath] of modulesWithRules) {
-    const rule = rules[moduleName];
-
-    step.log(`Scanning ${moduleName} with bundle rules...`);
-
-    const moduleFiles = getAllFilesInModule(basePath);
-
-    for (const file of moduleFiles) {
-      const rel = getModuleRelativePath(file, moduleName);
-      
-      if (shouldIncludeFile(file, moduleName, rule)) {
-        filesToInclude.add(file);
-        step.log(`Including ${rel} from ${moduleName}`);
-      } else {
-        step.log(`Excluding ${rel} from ${moduleName}`);
-      }
-    }
-  }
-
-  // Add all files
-  await Promise.all(
-    Array.from(filesToInclude).map((file) => {
-      step.log(`Including dependency: ${file}`);
-      return compiler.addResource(file);
-    })
-  );
-
-  return next();
-}
@@ -1,24 +0,0 @@
-import { NexeCompiler } from "../compiler";
-import { rimrafAsync } from "../util";
-import { NexeTarget } from "../target";
-
-export default async function clean(
-  compiler: NexeCompiler,
-  next: () => Promise<any>
-) {
-  const { options } = compiler;
-  if (options.clean) {
-    let path = compiler.src;
-    if (!options.build) {
-      path = compiler.getNodeExecutableLocation(
-        compiler.options.targets[0] as NexeTarget
-      );
-    }
-    const step = compiler.log.step("Cleaning up nexe build artifacts...");
-    step.log(`Deleting contents at: ${path}`);
-    await rimrafAsync(path);
-    step.log(`Deleted contents at: ${path}`);
-    return compiler.quit();
-  }
-  return next();
-}
@@ -1,17 +1,21 @@
-import { platform } from "os";
-import { dirname, normalize, relative, resolve } from "path";
-import {
-  createWriteStream,
-  chmodSync,
-  statSync,
-  readFileSync,
-  writeFileSync,
-} from "fs";
-import { NexeCompiler } from "../compiler";
-import { NexeTarget } from "../target";
-import { STDIN_FLAG } from "../util";
-import { patchMachOExecutable } from "./mach-o";
-import mkdirp = require("mkdirp");
+import { normalize } from 'path'
+import { Readable } from 'stream'
+import { createWriteStream, chmodSync } from 'fs'
+import { readFileAsync, dequote, isWindows } from '../util'
+import { NexeCompiler } from '../compiler'
+import { NexeTarget } from '../target'
+
+function readStreamAsync(stream: NodeJS.ReadableStream): PromiseLike<string> {
+  return new Promise(resolve => {
+    let input = ''
+    stream.setEncoding('utf-8')
+    stream.on('data', (x: string) => {
+      input += x
+    })
+    stream.once('end', () => resolve(dequote(input)))
+    stream.resume && stream.resume()
+  })
+}

 /**
 * The "cli" step detects the appropriate input. If no input options are passed,
@@ -19,57 +23,45 @@ import mkdirp = require("mkdirp");
 * After all the build steps have run, the output (the executable) is written to a file or piped to stdout.
 *
 * Configuration:
+ *   - compiler.options.input - file path to the input bundle.
+ *     - fallbacks: stdin, package.json#main
+ *   - compiler.options.output - file path to the output executable.
+ *     - fallbacks: stdout, nexe_ + epoch + ext
 *
 * @param {*} compiler
 * @param {*} next
 */
-export default async function cli(
-  compiler: NexeCompiler,
-  next: () => Promise<void>
-) {
-  await next();
-  const { log } = compiler,
-    target = compiler.options.targets.shift() as NexeTarget,
-    deliverable = await compiler.compileAsync(target),
-    output = normalize(compiler.output!);
+export default async function cli(compiler: NexeCompiler, next: () => Promise<void>) {
+  const { output } = compiler.options
+  const { log, input: bundledInput } = compiler

-  mkdirp.sync(dirname(output));
+  if (!process.stdin.isTTY) {
+    log.step('Using stdin as input')
+    compiler.input = await readStreamAsync(process.stdin)
+  }

-  return new Promise((res, rej) => {
-    const step = log.step("Writing result to file");
+  await next()
+
+  compiler.output = isWindows
+    ? `${(output || compiler.options.name).replace(/\.exe$/, '')}.exe`
+    : `${output || compiler.options.name}`
+
+  const target = compiler.options.targets.shift() as NexeTarget
+  const deliverable = await compiler.compileAsync(target)
+
+  return new Promise((resolve, reject) => {
+    const step = log.step('Writing result to file')
    deliverable
-      .pipe(createWriteStream(output))
-      .on("error", rej)
-      .once("close", () => {
-        if (compiler.output) {
-          const output = compiler.output,
-            mode = statSync(output).mode | 0o111,
-            inputFileLogOutput = relative(
-              process.cwd(),
-              resolve(
-                compiler.options.cwd,
-                compiler.entrypoint || compiler.options.input
-              )
-            ),
-            outputFileLogOutput = relative(process.cwd(), output);
-
-          if (platform() === "darwin") {
-            step.log("Preparing binary for macOS signing.");
-            writeFileSync(output, patchMachOExecutable(readFileSync(output)));
-          }
-
-          chmodSync(output, mode.toString(8).slice(-3));
-          step.log(
-            `Entry: '${compiler.stdinUsed
-              ? compiler.options.mangle
-                ? STDIN_FLAG
-                : "[none]"
-              : inputFileLogOutput
-            }' written to: ${outputFileLogOutput}`
-          );
-          compiler.quit();
-          res(output);
+      .pipe(createWriteStream(normalize(compiler.output!)))
+      .on('error', reject)
+      .once('close', (e: Error) => {
+        if (e) {
+          reject(e)
+        } else if (compiler.output) {
+          chmodSync(compiler.output, '755')
+          step.log(`Executable written to: ${compiler.output}`)
+          resolve(compiler.quit())
        }
-      });
-  });
+      })
+  })
 }
@@ -1,128 +1,24 @@
-import axios from "axios";
-import { pathExistsAsync } from "../util";
-import { LogStep } from "../logger";
-import { NexeCompiler, NexeError } from "../compiler";
-import { dirname } from "path";
-import { createWriteStream } from "fs";
-import { pipeline } from "stream/promises";
-import { createGunzip } from "zlib";
-import * as tar from 'tar';
-import fs from "fs/promises";
+import download = require('download')
+import { pathExistsAsync } from '../util'
+import { LogStep } from '../logger'
+import { IncomingMessage } from 'http'
+import { NexeCompiler } from '../compiler'

-async function downloadWithProgress(
-  url: string,
-  dest: string,
-  options: any = {},
-  step?: LogStep
-): Promise<void> {
-  // Ensure destination directory exists
-  await fs.mkdir(dirname(dest), { recursive: true });
-
-  const response = await axios({
-    url,
-    method: "GET",
-    responseType: "stream",
-    ...options,
-  });
-
-  const total = parseInt(String(response.headers["content-length"] || "0"), 10);
-  let current = 0;
-
-  // Create write stream
-  const writer = createWriteStream(dest);
-
-  // Handle progress
-  response.data.on("data", (chunk: Buffer) => {
-    current += chunk.length;
-    if (step && total > 0) {
-      step.modify(`Downloading...${((current / total) * 100).toFixed()}%`);
-    }
-  });
-
-  // Pipe the response to file
-  await pipeline(response.data, writer);
-
-  if (step) {
-    step.log(`Download completed: ${dest}`);
-  }
-}
-
-async function fetchNodeSourceAsync(
-  dest: string,
-  url: string,
-  step: LogStep,
-  options = {}
-) {
-  // Ensure destination directory exists
-  await fs.mkdir(dest, { recursive: true });
-
-  const setText = (p: number) =>
-    step.modify(`Downloading Node: ${p.toFixed()}%...`);
-
-  // Download the file first
-  const tempFile = dest + ".tar.gz";
-  const response = await axios({
-    url,
-    method: "GET",
-    responseType: "stream",
-    ...options,
-  });
-
-  const total = parseInt(String(response.headers["content-length"] || "0"), 10);
-  let current = 0;
-
-  // Create write stream for the temp file
-  const writer = createWriteStream(tempFile);
-
-  // Track progress
-  response.data.on("data", (chunk: Buffer) => {
-    current += chunk.length;
-    if (total > 0) {
-      setText((current / total) * 100);
-    }
-  });
-
-  // Wait for download to complete
-  await pipeline(response.data, writer);
-
-  step.log("Extracting Node...");
-
-  // Extract the tar.gz file
-  await pipeline(
-    createReadStream(tempFile),
-    createGunzip(),
-    tar.x({
-      cwd: dest,
-      strip: 1,
+function fetchNodeSourceAsync(dest: string, url: string, step: LogStep, options = {}) {
+  const setText = (p: number) => step.modify(`Downloading Node: ${p.toFixed()}%...`)
+  return download(url, dest, Object.assign(options, { extract: true, strip: 1 }))
+    .on('response', (res: IncomingMessage) => {
+      const total = +res.headers['content-length']!
+      let current = 0
+      res.on('data', data => {
+        current += data.length
+        setText(current / total * 100)
+        if (current === total) {
+          step.log('Extracting Node...')
+        }
+      })
    })
-  );
-
-  // Clean up temp file
-  await fs.unlink(tempFile);
-
-  step.log(`Node source extracted to: ${dest}`);
-}
-
-async function fetchPrebuiltBinary(compiler: NexeCompiler, step: any) {
-  const { target, remoteAsset } = compiler,
-    filename = compiler.getNodeExecutableLocation(target);
-
-  try {
-    await downloadWithProgress(
-      remoteAsset,
-      filename,
-      compiler.options.downloadOptions,
-      step
-    );
-  } catch (e: any) {
-    if (e.response?.status === 404) {
-      throw new NexeError(
-        `${remoteAsset} is not available, create it using the --build flag`
-      );
-    } else {
-      throw new NexeError("Error downloading prebuilt binary: " + e.message);
-    }
-  }
+    .then(() => step.log(`Node source extracted to: ${dest}`))
 }

 /**
@@ -130,40 +26,19 @@ async function fetchPrebuiltBinary(compiler: NexeCompiler, step: any) {
 * @param {*} compiler
 * @param {*} next
 */
-export default async function downloadNode(
-  compiler: NexeCompiler,
-  next: () => Promise<void>
-) {
-  const { src, log, target } = compiler,
-    { version } = target,
-    { sourceUrl, downloadOptions, build } = compiler.options,
-    url =
-      sourceUrl ||
-      `https://nodejs.org/dist/v${version}/node-v${version}.tar.gz`,
-    step = log.step(
-      `Downloading ${build ? "" : "pre-built"} Node.js ${build ? `source from: ${url}` : ""
-      }`
-    ),
-    exeLocation = compiler.getNodeExecutableLocation(
-      build ? undefined : target
-    ),
-    downloadExists = await pathExistsAsync(build ? src : exeLocation);
-
-  if (downloadExists) {
-    step.log("Already downloaded...");
-    return next();
+export default async function downloadNode(compiler: NexeCompiler, next: () => Promise<void>) {
+  const { src, log } = compiler
+  const { version, sourceUrl, downloadOptions } = compiler.options
+  const url = sourceUrl || `https://nodejs.org/dist/v${version}/node-v${version}.tar.gz`
+  const step = log.step(`Downloading Node.js source from: ${url}`)
+  if (await pathExistsAsync(src)) {
+    step.log('Source already downloaded')
+    return next()
  }

-  if (build) {
-    await fetchNodeSourceAsync(src, url, step, downloadOptions);
-  } else {
-    await fetchPrebuiltBinary(compiler, step);
+  if (compiler.options.build) {
+    await fetchNodeSourceAsync(src, url, step, downloadOptions)
  }

-  return next();
-}
-
-// Helper function to create a readable stream
-function createReadStream(path: string) {
-  return require("fs").createReadStream(path);
+  return next()
 }
@@ -1,84 +0,0 @@
-/*
- * The MIT License (MIT)
- *
- * Copyright (c) 2021 Vercel, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- *
- * This code is originally from the [pkg](https://github.com/vercel/pkg).
- */
-
-function parseCStr(buf: Buffer) {
-  for (let i = 0; i < buf.length; i += 1) {
-    if (buf[i] === 0) {
-      return buf.slice(0, i).toString();
-    }
-  }
-}
-
-function patchCommand(type: number, buf: Buffer, file: Buffer) {
-  // segment_64
-  if (type === 0x19) {
-    const name = parseCStr(buf.slice(0, 16));
-
-    if (name === "__LINKEDIT") {
-      const fileoff = buf.readBigUInt64LE(32);
-      const vmsizePatched = BigInt(file.length) - fileoff;
-      const filesizePatched = vmsizePatched;
-
-      buf.writeBigUInt64LE(vmsizePatched, 24);
-      buf.writeBigUInt64LE(filesizePatched, 40);
-    }
-  }
-
-  // symtab
-  if (type === 0x2) {
-    const stroff = buf.readUInt32LE(8);
-    const strsizePatched = file.length - stroff;
-
-    buf.writeUInt32LE(strsizePatched, 12);
-  }
-}
-
-function patchMachOExecutable(file: Buffer) {
-  const align = 8;
-  const hsize = 32;
-
-  const ncmds = file.readUInt32LE(16);
-  const buf = file.slice(hsize);
-
-  for (let offset = 0, i = 0; i < ncmds; i += 1) {
-    const type = buf.readUInt32LE(offset);
-
-    offset += 4;
-    const size = buf.readUInt32LE(offset) - 8;
-
-    offset += 4;
-    patchCommand(type, buf.slice(offset, offset + size), file);
-
-    offset += size;
-    if (offset & align) {
-      offset += align - (offset & align);
-    }
-  }
-
-  return file;
-}
-
-export { patchMachOExecutable };
@@ -1,33 +1,32 @@
-import { each } from "../util";
-import globs from "globby";
-import { resolve } from "path";
-import { NexeCompiler } from "../compiler";
+import { readFileAsync, isDirectoryAsync, each } from '../util'
+import { Buffer } from 'buffer'
+import * as globs from 'globby'
+import { NexeCompiler } from '../compiler'

-export default async function resource(
-  compiler: NexeCompiler,
-  next: () => Promise<any>
-) {
-  const { cwd, resources } = compiler.options;
-  if (!resources.length) {
-    return next();
+export default async function resource(compiler: NexeCompiler, next: () => Promise<void>) {
+  const resources = compiler.resources
+
+  if (!compiler.options.resources.length) {
+    return next()
  }
-  const step = compiler.log.step("Bundling Resources...");
-  let count = 0;
-
-  // workaround for https://github.com/sindresorhus/globby/issues/127
-  // and https://github.com/mrmlnc/fast-glob#pattern-syntax
-  const resourcesWithForwardSlashes = resources.map((r) =>
-    r.replace(/\\/g, "/")
-  );
-
-  await each(
-    globs(resourcesWithForwardSlashes, { cwd, onlyFiles: true }),
-    async (file) => {
-      count++;
-      step.log(`Including file: ${file}`);
-      await compiler.addResource(resolve(cwd, file));
+  const step = compiler.log.step('Bundling Resources...')
+  let count = 0
+  await each(globs(compiler.options.resources), async file => {
+    if (await isDirectoryAsync(file)) {
+      return
    }
-  );
-  step.log(`Included ${count} file(s)`);
-  return next();
+    count++
+    step.log(`Including file: ${file}`)
+    const contents = await readFileAsync(file)
+    const commentSafeContents = contents.toString('base64')
+    resources.index[file] = [
+      Buffer.byteLength(resources.bundle),
+      Buffer.byteLength(commentSafeContents)
+    ]
+    resources.bundle += commentSafeContents
+  })
+  step.log(
+    `Included ${count} file(s). ${(Buffer.byteLength(resources.bundle) / 1e6).toFixed(3)} MB`
+  )
+  return next()
 }
@@ -1,51 +0,0 @@
-import { NexeCompiler } from "../compiler";
-import { wrap } from "../util";
-
-export default async function (
-  compiler: NexeCompiler,
-  next: () => Promise<void>
-) {
-  await next();
-  compiler.shims.push(
-    wrap(
-      [
-        "process.__nexe = {};",
-        "const fsPatcher = (function() {",
-        "const module = {exports: {}};",
-        "const exports = module.exports;",
-        '{{file("lib/fs/patch.bundle.js")}}',
-        "return module.exports;",
-        "})()",
-        "fsPatcher.shimFs(process.__nexe);",
-        // Re-apply ENOENT-tolerant realpathSync after shimFs overwrites boot-nexe's patch.
-        // Node 22.22+ / 24 no longer catches ENOENT in ESM finalizeResolution.
-        // ESM resolver captures fs.realpathSync by destructuring at first ESM load,
-        // which happens after the shim runs — so this wrapper is what it captures.
-        "(function(){var _fs=require('fs'),_o=_fs.realpathSync;_fs.realpathSync=function(p,o){try{return _o.call(this,p,o);}catch(e){if(e&&e.code==='ENOENT')return p;throw e;}};_fs.realpathSync.native=_o.native||_o;})()",
-        compiler.options.fs ? "" : "restoreFs();",
-      ].join("\n")
-      //TODO support only restoring specific methods
-    )
-  );
-  compiler.shims.push(
-    wrap(`
-    if (process.argv[1] && process.env.NODE_UNIQUE_ID) {
-      const cluster = require('cluster')
-      cluster._setupWorker()
-      delete process.env.NODE_UNIQUE_ID
-    }
-  `)
-  );
-
-  compiler.shims.push(
-    wrap(`
-      if (!process.send) {
-        const path = require('path')
-        const entry = path.resolve(path.dirname(process.execPath),${JSON.stringify(
-          compiler.entrypoint
-        )})
-        process.argv.splice(1,0, entry)
-      }
-    `)
-  );
-}
@@ -1,107 +1,89 @@
-export type NodePlatform = "windows" | "mac" | "alpine" | "linux";
-export type NodeArch = "x86" | "x64" | "arm" | "arm64";
+export type NodePlatform = 'windows' | 'mac' | 'alpine' | 'linux'
+export type NodeArch = 'x86' | 'x64'

-const platforms: NodePlatform[] = ["windows", "mac", "alpine", "linux"],
-  architectures: NodeArch[] = ["x86", "x64", "arm", "arm64"];
+const platforms: NodePlatform[] = ['windows', 'mac', 'alpine', 'linux'],
+  architectures: NodeArch[] = ['x86', 'x64']

-export { platforms, architectures };
+export { platforms, architectures }

 export interface NexeTarget {
-  version: string;
-  platform: NodePlatform | string;
-  arch: NodeArch | string;
+  version: string
+  platform: NodePlatform
+  arch: NodeArch
 }

+//TODO bsd
 const prettyPlatform: { [key: string]: NodePlatform } = {
-  win32: "windows",
-  windows: "windows",
-  win: "windows",
-  darwin: "mac",
-  macos: "mac",
-  mac: "mac",
-  linux: "linux",
-  static: "alpine",
-  alpine: "alpine",
-};
+  win32: 'windows',
+  windows: 'windows',
+  darwin: 'mac',
+  macos: 'mac',
+  mac: 'mac',
+  linux: 'linux',
+  static: 'alpine',
+  alpine: 'alpine'
+}

+//TODO arm
 const prettyArch: { [key: string]: NodeArch } = {
-  x86: "x86",
-  arm6: "arm",
-  arm64: "arm64",
-  arm6l: "arm",
-  arm: "arm",
-  arm7: "arm",
-  arm7l: "arm",
-  amd64: "x64",
-  ia32: "x86",
-  x32: "x86",
-  x64: "x64",
-};
+  x86: 'x86',
+  ia32: 'x86',
+  x32: 'x86',
+  x64: 'x64'
+}

 function isVersion(x: string) {
  if (!x) {
-    return false;
+    return false
  }
-  return /^[\d]+$/.test(x.replace(/v|\.|\s+/g, ""));
+  return /\d/.test(x.replace(/v|\./g, ''))
 }

 function isPlatform(x: string): x is NodePlatform {
-  return x in prettyPlatform;
+  return x in prettyPlatform
 }

 function isArch(x: string): x is NodeArch {
-  return x in prettyArch;
+  return x in prettyArch
 }

 class Target implements NexeTarget {
-  constructor(
-    public arch: NodeArch,
-    public platform: NodePlatform,
-    public version: string
-  ) { }
+  constructor(public arch: NodeArch, public platform: NodePlatform, public version: string) {}
  toJSON() {
-    return this.toString();
+    return this.toString()
  }
  toString() {
-    return `${this.platform}-${this.arch}-${this.version}`;
+    return `${this.platform}-${this.arch}-${this.version}`
  }
 }

 export function targetsEqual(a: NexeTarget, b: NexeTarget) {
-  return (
-    a.arch === b.arch && a.platform === b.platform && a.version === b.version
-  );
+  return a.arch === b.arch && a.platform === b.platform && a.version === b.version
 }

-export function getTarget(
-  target: string | Partial<NexeTarget> = ""
-): NexeTarget {
-  const currentArch = process.arch;
-  let arch =
-    currentArch in prettyArch
-      ? prettyArch[process.arch]
-      : (process.arch as NodeArch),
+export function getTarget(target: string | NexeTarget = ''): NexeTarget {
+  let arch = process.arch as NodeArch,
    platform = prettyPlatform[process.platform],
-    version = process.version.slice(1);
+    version = process.version.slice(1)

-  if (typeof target !== "string") {
-    target = `${target.platform}-${target.arch}-${target.version}`;
+  if (typeof target !== 'string') {
+    target = `${target.platform}-${target.arch}-${target.version}`
  }

  target
    .toLowerCase()
-    .split("-")
-    .forEach((x) => {
+    .split('-')
+    .forEach(x => {
      if (isVersion(x)) {
-        version = x.replace(/v/g, "");
+        version = x
      }
      if (isPlatform(x)) {
-        platform = prettyPlatform[x];
+        platform = prettyPlatform[x]
      }
      if (isArch(x)) {
-        arch = prettyArch[x];
+        arch = prettyArch[x]
      }
-    });
+    })

-  return new Target(arch, platform, version);
+  return new Target(arch, platform, version)
 }
@@ -0,0 +1,23 @@
+declare module 'got' {
+  interface GotFn {
+    (url: string, options?: any): Promise<{ body: string }>
+    stream(url: string, optoins?: any): any
+  }
+  function got(url: string, options?: any): Promise<{ body: string }>
+  export = got as GotFn
+}
+declare module 'download' {
+  import { Duplex } from 'stream'
+  interface DownloadOptions {
+    extract?: boolean
+    strip?: number
+    filename?: string
+    proxy?: string
+  }
+  function download(
+    url: string,
+    destination?: string | DownloadOptions,
+    options?: DownloadOptions
+  ): PromiseLike<Buffer> & Duplex
+  export = download
+}
@@ -1,107 +1,62 @@
-import { readFile, writeFile, stat } from "fs";
-import { execFile } from "child_process";
-import { promisify } from "util";
-import rimraf = require("rimraf");
+import { readFile, writeFile, stat } from 'fs'
+import { execFile } from 'child_process'
+import pify = require('pify')
+import rimraf = require('rimraf')

-const rimrafAsync = promisify(rimraf);
-export const STDIN_FLAG = "[stdin]";
+const rimrafAsync = pify(rimraf)

 export async function each<T>(
  list: T[] | Promise<T[]>,
  action: (item: T, index: number, list: T[]) => Promise<any>
 ) {
-  const l = await list;
-  return Promise.all(l.map(action));
-}
-
-export function wrap(code: string) {
-  return "!(function () {" + code + "})();";
+  const l = await list
+  for (let i = 0; i < l.length; i++) {
+    await action(l[i], i, l)
+  }
 }

 function falseOnEnoent(e: any) {
-  if (e.code === "ENOENT") {
-    return false;
+  if (e.code === 'ENOENT') {
+    return false
  }
-  throw e;
+  throw e
 }

-function padRight(str: string, l: number) {
-  return (str + " ".repeat(l)).slice(0, l);
-}
-
-const bound: MethodDecorator = function bound<T>(
-  target: Object,
-  propertyKey: string | symbol,
-  descriptor: TypedPropertyDescriptor<T>
-) {
-  const configurable = true;
-  return {
-    configurable,
-    get(this: T) {
-      const value = (descriptor.value as any).bind(this);
-      Object.defineProperty(this, propertyKey as string, {
-        configurable,
-        value,
-        writable: true,
-      });
-      return value;
-    },
-  };
-};
-
 function dequote(input: string) {
-  input = input.trim();
-  const singleQuote = input.startsWith("'") && input.endsWith("'");
-  const doubleQuote = input.startsWith('"') && input.endsWith('"');
+  input = input.trim()
+  const singleQuote = input.startsWith("'") && input.endsWith("'")
+  const doubleQuote = input.startsWith('"') && input.endsWith('"')
  if (singleQuote || doubleQuote) {
-    return input.slice(1).slice(0, -1);
+    return input.slice(1).slice(0, -1)
  }
-  return input;
+  return input
 }

 export interface ReadFileAsync {
-  (path: string): Promise<Buffer>;
-  (path: string, encoding: string): Promise<string>;
+  (path: string): Promise<Buffer>
+  (path: string, encoding: string): Promise<string>
 }

-const readFileAsync = promisify(readFile);
-const writeFileAsync = promisify(writeFile);
-const statAsync = promisify(stat);
-const execFileAsync = promisify(execFile);
-const isWindows = process.platform === "win32";
+const readFileAsync = pify(readFile)
+const writeFileAsync = pify(writeFile)
+const statAsync = pify(stat)
+const execFileAsync = pify(execFile)
+const isWindows = process.platform === 'win32'

 function pathExistsAsync(path: string) {
  return statAsync(path)
-    .then((x) => true)
-    .catch(falseOnEnoent);
+    .then(x => true)
+    .catch(falseOnEnoent)
 }

 function isDirectoryAsync(path: string) {
  return statAsync(path)
-    .then((x) => x.isDirectory())
-    .catch(falseOnEnoent);
-}
-/**
- * @param version See if this version is greather than the second one
- * @param operand Version to compare against
- */
-function semverGt(version: string, operand: string) {
-  const [cMajor, cMinor, cPatch] = version.split(".").map(Number);
-  let [major, minor, patch] = operand.split(".").map(Number);
-  if (!minor) minor = 0;
-  if (!patch) patch = 0;
-  return (
-    cMajor > major ||
-    (cMajor === major && cMinor > minor) ||
-    (cMajor === major && cMinor === minor && cPatch > patch)
-  );
+    .then(x => x.isDirectory())
+    .catch(falseOnEnoent)
 }

 export {
  dequote,
-  padRight,
-  semverGt,
-  bound,
  isWindows,
  rimrafAsync,
  statAsync,
@@ -109,5 +64,5 @@ export {
  readFileAsync,
  pathExistsAsync,
  isDirectoryAsync,
-  writeFileAsync,
-};
+  writeFileAsync
+}
@@ -1,30 +0,0 @@
-'use strict'
-
-const { resolve } = require('path')
-const resolvePath = (path) => resolve(__dirname, '..', path)
-
-async function compile() {
-  const executableSuffix = require('os').platform().startsWith('win') ? '.exe' : ''
-  const builtExecutablePath = require('path').join(process.env.NEXE_TMP, process.versions.node, `out/Release/node${executableSuffix}`)
-  try {
-    require('fs').unlinkSync(builtExecutablePath)
-  } catch(e) {}
-  const nexe = require('..')
-  console.error('Building asset')
-  return nexe.compile({
-    loglevel: 'verbose',
-    python: process.env.PYTHON || 'python',
-    mangle: false,
-    build: true,
-    output: process.env.NEXE_ASSET || `nexe-asset${executableSuffix}`,
-    input: resolvePath('test/asset-build-input.js'),
-    configure: process.env.MUSL_BUILD ? ['--fully-static'] : [],
-    temp: process.env.NEXE_TMP,
-  })
-}
-
-if (!('MAKEFLAGS' in process.env)) {
-  process.env.MAKEFLAGS = `-j${require('os').cpus().length + 1}`
-}
-
-compile()
@@ -1,25 +0,0 @@
-'use strict'
-
-const { resolve } = require('path')
-const resolvePath = (path) => resolve(__dirname, '..', path)
-
-async function build() {
-  const nexe = require('..')
-  console.error('Doing test build using asset')
-  if (!require('fs').existsSync(process.env.NEXE_ASSET)) {
-    console.error(`Pre-built asset not found at ${process.env.NEXE_ASSET}`)
-    process.exitCode = 1
-    return
-  }
-  return nexe.compile({
-    loglevel: 'verbose',
-    python: process.env.PYTHON || 'python',
-    build: true,
-    output: resolvePath('integration-tests'),
-    input: resolvePath('test/integration/index.js'),
-    resources: [resolvePath('test/integration'), resolvePath('node_modules')],
-    asset: process.env.NEXE_ASSET,
-  })
-}
-
-build()
@@ -1,140 +1,101 @@
-import * as nexe from "../lib/nexe";
-import { getUnBuiltReleases, getLatestGitRelease } from "../lib/releases";
-import { runDockerBuild } from "./docker";
-import { getTarget, targetsEqual, NexeTarget } from "../lib/target";
+import * as nexe from '../src/nexe'
 import {
-  pathExistsAsync,
-  readFileAsync,
-  execFileAsync,
-  semverGt,
-} from "../lib/util";
-import axios from "axios";
-import FormData from "form-data";
-import { cpus } from "os";
+  getUnBuiltReleases,
+  getLatestGitRelease
+} from '../src/releases'
+import * as ci from './ci'
+import { runAlpineBuild } from './docker'
+import { getTarget } from '../src/target'
+import { pathExistsAsync, statAsync, readFileAsync, execFileAsync } from '../src/util'
+import got = require('got')

 const env = process.env,
-  isPullRequest = env.BUILD_REASON === "PullRequest",
-  isWindows = process.platform === "win32",
-  isLinux = process.platform === "linux",
-  buildHost = env.AGENT_JOBNAME || (isWindows && "windows_2017_2015") || "",
-  isMac = process.platform === "darwin",
-  headers = {
-    Authorization: "token " + env.GITHUB_TOKEN,
-    "User-Agent": "nexe (https://www.npmjs.com/package/nexe)",
-  };
+  branchName = env.CIRCLE_BRANCH || env.APPVEYOR_REPO_BRANCH || env.TRAVIS_BRANCH || '',
+  isScheduled = Boolean(env.APPVEYOR_SCHEDULED_BUILD || env.NEXE_TRIGGERED),
+  isLinux = Boolean(env.TRAVIS),
+  isWindows = Boolean(env.APPVEYOR),
+  isMac = Boolean(env.CIRCLECI),
+  isPullRequest = Boolean(env.CIRCLE_PR_NUMBER)
+    || Boolean(env.APPVEYOR_PULL_REQUEST_NUMBER) 
+    || Boolean(env.TRAVIS_PULL_REQUEST_BRANCH),
+  headers = { 'Authorization': 'token ' + env.GITHUB_TOKEN }

 if (require.main === module) {
  if (!isPullRequest) {
-    build().catch((x) => {
-      console.error(x);
-      process.exit(1);
-    });
+    build().catch(x => {
+      console.error(x)
+      process.exit(1)
+    })
  }
 }

-async function build() {
-  const releases = await getUnBuiltReleases({ headers });
-  if (!releases.length) {
-    return;
-  }
-  const windowsBuild = releases.find((x) => x.platform === "windows"),
-    macBuild = releases.find((x) => x.platform === "mac"),
-    linux = releases.find((x) => x.platform === "linux"),
-    alpine = releases.find((x) => x.platform === "alpine");
-
-  let target: NexeTarget | undefined;
-
-  if (env.NEXE_VERSION) target = getTarget(env.NEXE_VERSION);
-  else if (isWindows) target = windowsBuild;
-  else if (isMac) target = macBuild;
-  else if (isLinux) target = linux;
-  if (buildHost.includes("alpine")) target = alpine;
-
-  if (!target) {
-    return console.log("Nothing to build...");
-  }
-
-  if (
-    isWindows &&
-    buildHost.includes("2017") &&
-    !semverGt(target.version, "9.99.99")
-  ) {
-    return console.log(`Not building ${target} on this host...`);
-  }
-  if (
-    isWindows &&
-    buildHost.includes("2015") &&
-    semverGt(target.version, "9.99.99")
-  ) {
-    return console.log(`Not building ${target} on this host...`);
-  }
-
-  const output = isWindows ? "./out.exe" : "./out",
-    options = {
-      mangle: false,
-      build: true,
-      verbose: Boolean(env.NEXE_VERBOSE!),
-      target,
-      make: ["-j" + cpus().length],
-      output,
-    };
-  console.log("Building: " + target + " on " + buildHost);
-  const stop = keepalive();
-
-  if (
-    [/*'arm7l', 'arm6l', 'arm64', */ "alpine"].includes(target.platform) &&
-    buildHost.includes("alpine")
-  ) {
-    await runDockerBuild(target);
-  } else {
-    await nexe.compile(options);
-  }
-  stop();
-  if (await pathExistsAsync(output)) {
-    await assertNexeBinary(output);
-    const gitRelease = await getLatestGitRelease({ headers }),
-      unbuiltReleases = await getUnBuiltReleases({ headers });
-    if (!unbuiltReleases.some((x) => targetsEqual(x, target!))) {
-      console.log(`${target} already uploaded.`);
-      process.exit(0);
-      return;
+async function build () {
+  if (isScheduled) {
+    const releases = await getUnBuiltReleases({ headers })
+    if (!releases.length) {
+      return
    }
+    const windowsBuild = releases.find(x => x.platform === 'windows')
+    const macBuild = releases.find(x => x.platform === 'mac')
+    const linuxOrAlpine = releases.find(x => x.platform === 'linux' || x.platform === 'alpine')

-    // Create form data for file upload
-    const formData = new FormData();
-    formData.append("file", await readFileAsync(output), {
-      filename: target.toString(),
-      contentType: "application/octet-stream",
-    });
+    if (linuxOrAlpine) {
+      await ci.triggerDockerBuild(linuxOrAlpine, branchName)
+    }
+    if (macBuild) {
+      await ci.triggerMacBuild(macBuild, branchName)
+    }
+    if (windowsBuild) {
+      await ci.triggerWindowsBuild(windowsBuild)
+    }
+  }

-    const uploadUrl = gitRelease.upload_url.split("{")[0];
-    await axios
-      .post(uploadUrl, formData, {
-        params: { name: target.toString() },
+  if (env.NEXE_VERSION) {
+    const
+      target = getTarget(env.NEXE_VERSION),
+      output = isWindows ? './out.exe' : './out',
+      options = {
+        empty: true,
+        build: true,
+        target, //FIXME
+        output
+      }
+    
+    const stop = keepalive()
+    if (target.platform === 'alpine') {
+      await runAlpineBuild(target, nexe.version.split('.')[0])
+    } else {
+      await nexe.compile(options)      
+    }
+    stop()
+    
+    
+    if (await pathExistsAsync(output)) {
+      await assertNexeBinary(output)
+      const gitRelease = await getLatestGitRelease({ headers })
+      await got(gitRelease.upload_url.split('{')[0], {
+        query: { name: target.toString() },
+        body: await readFileAsync(output),
        headers: {
-          ...headers,
-          ...formData.getHeaders(),
-        },
+          'Authorization': 'token ' + env.GITHUB_TOKEN,
+          'Content-Type': 'application/octet-stream'
+        }
      })
-      .catch((reason) => {
-        console.log(reason && reason.response && reason.response.data);
-        throw reason;
-      });
-    console.log(target + " uploaded.");
-    process.exit(0);
+      console.log(target + ' uploaded.')
+    }
  }
 }

-function keepalive() {
-  const keepalive = setInterval(() => console.log("Building..."), 300 * 1000);
-  return () => clearInterval(keepalive);
+function keepalive () {
+  const keepalive = setInterval(() => console.log('Building...'), 300 * 1000)
+  return () => clearInterval(keepalive)
 }

-function assertNexeBinary(file: string) {
-  return execFileAsync(file).catch((e) => {
-    if (e && e.stack && e.stack.includes("Invalid Nexe binary")) {
-      return;
+function assertNexeBinary (file: string) {
+  return execFileAsync(file).catch(e => {
+    if (e && e.stack && e.stack.includes('Invalid Nexe binary')) {
+      return
    }
-    throw e;
-  });
+    throw e
+  })
 }
@@ -0,0 +1,48 @@
+import { NexeTarget } from '../src/releases'
+import got = require('got')
+import * as assert from 'assert'
+const { env } = process
+
+export function triggerDockerBuild(release: NexeTarget, branch: string) {
+  assert.ok(env.TRAVIS_TOKEN)
+  const travis = `https://api.travis-ci.org/repo/nexe%2Fnexe/requests`
+  return got(travis, {
+    json: true,
+    body: {
+      request: {
+        branch: branch,
+        config: {
+          merge_mode: 'deep_merge',
+          env: {
+            NEXE_VERSION: release
+          }
+        }
+      }
+    },
+    headers: {
+      'Travis-API-Version': '3',
+      'Authorization': `token ${env.TRAVIS_TOKEN}`
+    }
+  })
+}
+
+export function triggerMacBuild (release: NexeTarget, branch: string) {
+  assert.ok(env.CIRCLE_TOKEN)
+  const circle = `https://circleci.com/api/v1.1/project/github/nexe/nexe/tree/${branch}?circle-token=${env.CIRCLE_TOKEN}`
+  return got(circle, {
+    json: true,
+    body: {
+      build_parameters: {
+        NEXE_VERSION: release.toString()
+      }
+    }
+  })
+}
+
+export function triggerWindowsBuild (release: NexeTarget) {
+  const hasVersion = 'NEXE_VERSION' in env
+  env.NEXE_VERSION = hasVersion 
+    ? env.NEXE_VERSION!.trim() 
+    : release.toString() 
+  return Promise.resolve()
+}
@@ -1,79 +1,32 @@
-import { NexeTarget, architectures } from "../lib/target";
-import { writeFileAsync, readFileAsync } from "../lib/util";
-import axios from "axios";
-import execa = require("execa");
-import { appendFileSync } from "fs";
+import { NexeTarget } from '../src/target'
+import { writeFileAsync } from '../src/util'
+import exec = require('execa')

-function alpine(target: NexeTarget) {
+function alpine (target: NexeTarget, nexeVersion: string) {
+  const version = target.version
  return `
-FROM ${target.arch === "x64" ? "" : "i386/"}alpine:3.12
+FROM i386/alpine:3.6
 RUN apk add --no-cache curl make gcc g++ binutils-gold python linux-headers paxctl libgcc libstdc++ git vim tar gzip wget
-ENV NODE_VERSION=${target.version}
-ENV NEXE_VERSION=latest
 WORKDIR /
-
-RUN curl -sSL https://nodejs.org/dist/v\${NODE_VERSION}/node-v\${NODE_VERSION}.tar.gz | tar -xz && \
-  mkdir /nexe_temp && mv /node-v\${NODE_VERSION} /nexe_temp/\${NODE_VERSION} && \
-  cd /nexe_temp/\${NODE_VERSION} && \
+RUN curl -sSL https://nodejs.org/dist/v${version}/node-v${version}.tar.gz | tar -xz && \
+  cd /node-v${version} && \
  ./configure --prefix=/usr --fully-static && \
-  make && make install && \
+  make -j$(grep -c ^processor /proc/cpuinfo 2>/dev/null || 1) && \
+  make install && \
  paxctl -cm /usr/bin/node

-RUN rm /nexe_temp/\${NODE_VERSION}/out/Release/node && \
-  npm install -g nexe@\${NEXE_VERSION}
-RUN echo "console.log('hello world')" >> index.js && \
-  nexe --build --no-mangle --temp /nexe_temp -c="--fully-static" -o out
-`.trim();
+RUN mkdir nexe_temp && mv node-v${version} nexe_temp/${version}
+RUN npm i nexe@beta -g
+ENV NEXE_TEMP=/nexe_temp
+
+RUN nexe --empty -c="--fully-static" -o /nexe-out`.trim()
 }

-function arm(target: NexeTarget) {
-  return `
-FROM hypriot/rpi-node
-ENV NEXE_VERSION=latest
-WORKDIR /
-
-RUN yarn global add nexe@\${NEXE_VERSION} && \
-  nexe --build --no-mangle -o out -t ${target.version}
-`.trim();
-}
-
-export async function runDockerBuild(target: NexeTarget) {
-  //todo switch on alpine and arm
-  const dockerfile = alpine(target);
-  await writeFileAsync("Dockerfile", dockerfile);
-  const outFilename = "nexe-docker-build-log.txt";
-  await writeFileAsync(outFilename, "");
-  const output: any = [];
-
-  try {
-    output.push(await execa(`docker build -t nexe-docker .`, { shell: true }));
-    output.push(
-      await execa(`docker run -d --name nexe nexe-docker sh`, { shell: true })
-    );
-    output.push(await execa(`docker cp nexe:/out out`, { shell: true }));
-    output.push(await execa(`docker rm nexe`, { shell: true }));
-  } catch (e: any) {
-    console.log("Error running docker");
-    appendFileSync(outFilename, e.message);
-  } finally {
-    output.forEach((x: any) => {
-      appendFileSync(outFilename, x.stderr);
-      appendFileSync(outFilename, x.stdout);
-    });
-
-    try {
-      const response = await axios.put(
-        `https://transfer.sh/${Math.random().toString(36).substring(2)}.txt`,
-        await readFileAsync(outFilename),
-        {
-          headers: {
-            "Content-Type": "application/octet-stream",
-          },
-        }
-      );
-      console.log("Posted docker log: ", response.data);
-    } catch (e: any) {
-      console.log("Error posting log", e);
-    }
-  }
+export async function runAlpineBuild (target: NexeTarget, nexeVersion: string) {
+  await writeFileAsync('Dockerfile', alpine(target, nexeVersion))
+  const option = { stido: 'inherit' } as any
+  await exec('docker', ['build', '-t', 'nexe-alpine', '.'], option)
+  await exec('docker', ['run', '--name', 'nexe', 'nexe-alpine'], option)
+  await exec('docker', ['cp', 'nexe:/nexe-out', 'out'], option)
+  await exec('docker', ['rm', 'nexe'], option)
 }
@@ -1,31 +0,0 @@
-import { writeFileSync, readFileSync } from "fs";
-import { template } from "lodash";
-
-/**
- * post build step to insert code files into code files.
- * And the package.json version.
- */
-cp("src/fs/package.json", "lib/fs/package.json");
-cp("src/fs/bootstrap.js", "lib/fs/bootstrap.js");
-cp("src/fs/README.md", "lib/fs/README.md");
-
-inject("lib/patches/third-party-main.js");
-inject("lib/steps/shim.js");
-inject("lib/options.js", JSON.stringify(require("../package.json").version));
-
-function inject(filename: string, version?: string) {
-  const contents = template(readFileSync(filename, "utf8"), {
-    interpolate: /['"]\{\{([\s\S]*?)\}\}['"]/,
-  })({
-    file: (path: string) => JSON.stringify(readFileSync(path, "utf8")),
-    version,
-  });
-  writeFileSync(filename, contents);
-  console.log(`Wrote: ${filename}`);
-}
-
-function cp(from: string, to: string) {
-  const file = readFileSync(from);
-  writeFileSync(to, file);
-  console.log("Copied: ", from, "To: ", to);
-}
@@ -1,10 +0,0 @@
-{
-  "extends": "../tsconfig.json",
-  "compilerOptions": {
-    "noEmit": true
-  },
-  "include":[
-    "*.ts"
-  ]
-}
-
@@ -1 +0,0 @@
-module.exports = 'abc'
@@ -1 +0,0 @@
-console.log('hello world', require('./dependency'))
@@ -1,3 +0,0 @@
-{
-  "main": "entry.js"
-}
@@ -1,42 +0,0 @@
-const { mkdtemp, copyFile, realpath } = require('fs/promises')
-const os = require('os')
-const path = require('path')
-const rimraf = require('rimraf')
-const cp = require('child_process')
-
-async function runTests() {
-  const tempdir = await realpath(await mkdtemp(path.join(os.tmpdir(), 'nexe-integration-tests-')))
-  const secondTempdir = await mkdtemp(path.join(os.tmpdir(), 'nexe-integration-tests-without-executable-'))
-  const executable = path.join(tempdir, path.basename(process.argv[0]))
-  await copyFile(process.argv[0], executable)
-  process.on('beforeExit', () => {
-    try {
-      rimraf.sync(tempdir)
-      rimraf.sync(secondTempdir)
-    } catch(e) {
-      console.error(`Ignoring error during integration test cleanup of "${tempdir}".`)
-      console.error(`Error: ${e}`)
-    }
-  })
-  console.error('Running integration tests with the binary in the current working directory.')
-  spawnExecutable(tempdir, () => {
-    console.error('Running integration tests with the binary in another directory.')
-    spawnExecutable(secondTempdir)
-  })
-
-  function spawnExecutable(cwd, cb) {
-    cp.spawn(executable,
-      [
-      path.join(tempdir, 'node_modules/mocha/bin/mocha.js'),
-        path.join(tempdir, 'test/integration/tests.integration-spec.js')
-      ],
-      { stdio: ['inherit', 'inherit', 'inherit', 'ipc'], cwd }
-    ).on('exit', (code) => {
-      process.exitCode = process.exitCode || code
-
-      if(cb) cb()
-    })
-  }
-}
-
-runTests()
@@ -1,120 +0,0 @@
-const { expect } = require('chai')
-const fs = require('fs')
-const { dirname, basename } = require('path')
-
-const files = { zipFs: 'test/integration/tests.integration-spec.js', real: 'real', real2: 'real2' }
-describe('SnapshotZipFS', () => {
-  console.error('Note: these tests are order dependant, so subsequent failures are likely a flow on effect.')
-  it('checks existance from the zipFs', () => expect(fs.existsSync(files.zipFs)).to.equal(true))
-  it('checks non-existance from the zipFs', () => expect(fs.existsSync('not found')).to.equal(false))
-  it('reads from the zipFs', () => expect(fs.readFileSync(files.zipFs, 'utf8')).to.include('SnapshotZipFS'))
-  it('copies from the zipFs', () => expect(() => fs.copyFileSync(files.zipFs, files.real)).not.to.throw())
-  it('reads from the real fs', () => expect(fs.readFileSync(files.real, 'utf8')).to.include('SnapshotZipFS'))
-  it('checks non-existance from the real fs', () => expect(fs.existsSync(files.real2)).to.equal(false))
-  it('copies from the real fs', () => expect(() => fs.copyFileSync(files.real, files.real2)).not.to.throw())
-  it('checks existance from the real fs', () => expect(fs.existsSync(files.real2)).to.equal(true))
-  it('unlinks from the real fs', () => expect(() => fs.unlinkSync(files.real2)).not.to.throw())
-  it('symlinks the real fs', () => expect(() => fs.symlinkSync('tmp', files.real2)).not.to.throw())
-  it('readlinks the real fs', () => expect(fs.readlinkSync(files.real2)).to.equal('tmp'))
-  it('truncates the real fs', () => expect(() => fs.truncateSync(files.real)).not.to.throw())
-  it('writeFiles the real fs', () => expect(() => fs.writeFileSync(files.real2, 'testing')).not.to.throw())
-  it('accesses the real fs', () => expect(() => fs.accessSync(files.real)).not.to.throw())
-  it('accesses the zipFs', () => expect(() => fs.accessSync(files.zipFs)).not.to.throw())
-  it('stats the real fs', () => expect(fs.statSync(files.real2).size).to.be.greaterThan(0))
-  it('stats the zipFs', () => expect(fs.statSync(files.zipFs).size).to.be.greaterThan(0))
-  it('readdirs from the zipFs', () => expect(fs.readdirSync(dirname(files.zipFs))).to.include(basename(files.zipFs)))
-  it('readdirs from the real fs', () => expect(fs.readdirSync('.')).to.include(files.real))
-  it('readdirs from both', () => {
-    expect(fs.readdirSync('.')).to.include(files.real),
-    expect(fs.readdirSync('.')).to.include('test')
-  })
-  let dir
-  it('opendirs the zipFs fs', async () => {
-    expect(() => dir = fs.opendirSync(dirname(files.zipFs))).not.to.throw()
-    const names = []
-    for await (const dirent of dir) {
-      names.push(dirent.name)
-    }
-    expect(names).to.include(basename(files.zipFs))
-  })
-  it('opendirs the real fs and zipFs', async () => {
-    expect(() => dir = fs.opendirSync('.')).not.to.throw()
-    const names = []
-    for await (const dirent of dir) {
-      names.push(dirent.name)
-    }
-    expect(names).to.include(files.real)
-    expect(names).to.include('test')
-  })
-  it('createWriteStreams to the real fs', () => expect(() => fs.createWriteStream('createWriteStream')).not.to.throw())
-  it('createReadStreams to the real fs', () => expect(() => fs.createReadStream(files.real)).not.to.throw())
-  it('createReadStreams to the zipFs', () => expect(() => fs.createReadStream(files.zipFs)).not.to.throw())
-  it('renames to the realFs', () => {
-    expect(() => fs.renameSync(files.real2, 'rename')).not.to.throw()
-    expect(fs.existsSync('rename')).to.equal(true)
-  })
-
-  describe('write actions to the zipFs', () => {
-    it(`won't truncate to the zipFs`, () => expect(() => fs.truncateSync(files.zipFs)).to.throw())
-    it(`won't unlink from the zipFs`, () => expect(() => fs.unlinkSync(files.zipFs)).to.throw())
-    it(`won't appendFile to the zipFs`, () => expect(() => fs.appendFileSync(files.zipFs, 'xxx')).to.throw())
-    it(`won't symlink to the zipFs`, () => expect(() => fs.symlinkSync('tmp', files.zipFs)).to.throw())
-    it(`won't chmod to the zipFs`, () => expect(() => fs.chmodSync(files.zipFs, 0o666)).to.throw())
-    it(`won't chown to the zipFs`, () => expect(() => fs.chownSync(files.zipFs, 0, 0)).to.throw())
-    it(`won't writeFile the zipFs`, () => expect(() => fs.writeFileSync(files.zipFs, 'testing')).to.throw())
-    it(`won't createWriteStreams to the zipFs`, () => expect(() => fs.createWriteStream(files.zipFs)).to.throw())
-    it(`won't rename to the zipFs`, () => expect(() => fs.renameSync(files.real, files.zipFs)).to.throw())
-  })
-
-  ;[ 'zipFs', 'real' ].forEach((k) => {
-    it(`watches the ${k} fs`, () => expect(() => fs.watch(files[k], () => null).close()).not.to.throw())
-    it(`watchFiles the ${k} fs`, () => expect(() => fs.watchFile(files[k], () => null)).not.to.throw())
-    it(`unwatchFiles the ${k} fs`, () => expect(() => fs.unwatchFile(files[k])).not.to.throw())
-  })
-  let buffer = Buffer.alloc(8092), fd
-  describe('zipfs file descriptors', () => {
-    it('opens files in the zipFs', () => {
-      expect(() => (fd = fs.openSync(files.zipFs, 'a+'))).not.to.throw()
-      expect(fd).to.not.be.null
-    })
-    it('reads file descriptors from the zipFs', () => {
-      expect(() => fs.readSync(fd, buffer)).not.to.throw()
-      expect(buffer.toString()).to.include('SnapshotZipFS')
-    })
-    it('fstats the zipFs', () => expect(fs.fstatSync(fd).size).to.be.greaterThan(0))
-    it(`won't write to the zipFs`, () => expect(() => fs.writeSync(fd, 'xxx')).to.throw())
-    it(`won't fchmod the zipFs`, () => expect(() => fs.fchmodSync(fd)).to.throw())
-    it(`won't fchown the zipFs`, () => expect(() => fs.fchownSync(fd)).to.throw())
-    it(`won't ftruncate the zipFs`, () => expect(() => fs.ftruncateSync(fd)).to.throw())
-    it('closes file descriptors from the zipFs', () => expect(() => fs.closeSync(fd)).not.to.throw())
-  })
-  fd = null
-  buffer = Buffer.alloc(8092)
-  describe('real file descriptors', () => {
-    it('opens files in the real fs', () => {
-      expect(() => (fd = fs.openSync(files.real2, 'a+'))).not.to.throw()
-      expect(fd).to.not.be.null
-    })
-    it('reads file descriptors from the real fs', () => {
-      expect(() => fs.readSync(fd, buffer)).not.to.throw()
-      expect(buffer.toString()).to.include('SnapshotZipFS')
-    })
-    it('will write to the real fs', () => expect(() => fs.writeSync(fd, 'xxx')).not.to.throw())
-    it('fstats the real fs', () => expect(fs.fstatSync(fd).size).to.be.greaterThan(0))
-    it('closes file descriptors from the real fs', () => expect(() => fs.closeSync(fd)).not.to.throw())
-  })
-  describe('path clashes', () => {
-    it('delegates directory creation to the real fs', () => expect(() => fs.mkdirSync('test')).not.to.throw())
-    it('delegates directory removal to the real fs', () => expect(() => fs.rmdirSync('test')).not.to.throw())
-  })
-  describe('requiring modules', () => {
-    it('resolves modules from the zipFs', () => expect(() => require('resolve-dependencies')).not.to.throw())
-    it('resolves modules from the real fs', () => {
-      fs.mkdirSync('node_modules')
-      fs.mkdirSync('node_modules/fake-package')
-      fs.writeFileSync('node_modules/fake-package/package.json', '{ "name": "fake-package", "main": "some-file.js"}')
-      fs.writeFileSync('node_modules/fake-package/some-file.js', `module.exports = { fake: 'package' }`)
-      expect(require('fake-package')).to.eql({ fake: 'package' })
-    })
-  })
-})
@@ -1,80 +0,0 @@
-import { normalizeOptions } from '../src/options'
-import { expect } from 'chai'
-import * as path from 'path'
-
-const ext = process.platform === 'win32' ? '.exe' : ''
-
-describe('options', () => {
-  describe('cwd', () => {
-    it('should use process.cwd() if nothing is provided', () => {
-      const options = normalizeOptions()
-      expect(options.cwd).to.equal(process.cwd())
-    })
-    it('should use the main module in a package directory (if not in a TTY)', () => {
-      const options = normalizeOptions()
-      if (!process.stdin.isTTY) {
-        expect(options.input).to.equal('[stdin]')
-      } else {
-        expect(options.input).to.equal(path.resolve('./index.js'))
-      }
-    })
-    it('should resolve relative paths for input', () => {
-      const options = normalizeOptions({ input: 'test/fixture/entry.js' })
-      expect(options.input).to.equal(path.resolve('./test/fixture/entry.js'))
-    })
-    it('should accept a module entry as input', () => {
-      const options = normalizeOptions({ input: 'test/fixture' })
-      expect(options.input).to.equal(path.resolve('./test/fixture/entry.js'))
-    })
-    it('should resolve pathed options against cwd', () => {
-      const cwd = path.join(process.cwd(), 'test/fixture')
-      const options = normalizeOptions({
-        cwd,
-        input: 'entry',
-        output: 'abc',
-        temp: './d'
-      })
-      expect(options.temp).to.equal(path.resolve(cwd, './d'))
-      expect(options.input).to.equal(path.resolve(cwd, 'entry.js'))
-      expect(options.output).to.equal(path.resolve(cwd, `abc${ext}`))
-    })
-  })
-
-  describe('remote', () => {
-    it('should use default remote', () => {
-      const options = normalizeOptions({})
-      expect(options.remote).to.equal(`https://github.com/oxmc/nexe/releases/download/v${require('../package.json').version}/`)
-    })
-    it('should append trailing slash to third-party remote if necessary', () => {
-      const options = normalizeOptions({
-        remote: 'https://sitejs.org/nexe'
-      })
-      expect(options.remote).to.equal('https://sitejs.org/nexe/')
-    })
-    it('should not append trailing slash to third-party remote that already has one', () => {
-      const options = normalizeOptions({
-        remote: 'https://sitejs.org/nexe/'
-      })
-      expect(options.remote).to.equal('https://sitejs.org/nexe/')
-    })
-  })
-
-  describe('output', () => {
-    it('should work', () => {
-      const options = normalizeOptions({
-        output: './some-output'
-      })
-      expect(options.output).to.equal(path.resolve(`./some-output${ext}`))
-    })
-    it('should default to the input file name if not index', () => {
-      const options = normalizeOptions({
-        input: './test/fixture'
-      })
-      expect(options.output).to.equal(path.resolve(`./entry${ext}`))
-    })
-    it('should default to the folder/project name if filename is index', () => {
-      const options = normalizeOptions({ cwd: './test/fixture2' })
-      expect(options.output).to.equal(path.resolve(`./test/fixture2/fixture2${ext}`))
-    })
-  })
-})
@@ -1,29 +0,0 @@
-import { padRight, isWindows } from '../src/util'
-import { expect } from 'chai'
-import chalk from 'chalk'
-import { getTarget, NexeTarget } from '../src/target'
-const b = chalk.blue
-const arch = process.arch === 'ia32' ? 'x86' : process.arch
-
-describe('Targets', () => {
-  ;[
-    ['win-ia32-6.11.2', 'windows-x86-6.11.2'],
-    [{ version: '6.11.2', platform: 'win', arch: 'ia32' }, 'windows-x86-6.11.2'],
-    ['win32-x64-6.11.2', 'windows-x64-6.11.2'],
-    ['win-amd64-6.11.2', 'windows-x64-6.11.2'],
-    ['darwin-x64-v8.4.0', 'mac-x64-8.4.0'],
-    ['macos-x64-v8.4.0', 'mac-x64-8.4.0'],
-    ['static-x86-6.10.3', 'alpine-x86-6.10.3'],
-    ['linux-x32', `linux-x86-${process.version.slice(1)}`],
-    ['alpine-notsupported-6.10.3', `alpine-${arch}-6.10.3`],
-    ['not-a-thing', getTarget(process).toString()]
-  ].forEach(([input, expected]) => {
-    it(`should accept: ${padRight(JSON.stringify(input), 53)} ${b('->')}   ${expected}`, () => {
-      expect(getTarget(input).toString()).to.equal(expected)
-    })
-  })
-
-  it('should stringify and toString', () => {
-    expect(JSON.stringify(getTarget(process))).to.equal(`"${getTarget(process)}"`)
-  })
-})
@@ -1,10 +1,7 @@
 {
  "compilerOptions": {
-    "target":"es2015",
-    "skipLibCheck": true,
-    "experimentalDecorators": true,
-    "esModuleInterop": true,
-    "lib": ["es2018"],
+    "target":"es5",
+    "lib": ["es2017"],
    "module": "commonjs",
    "outDir": "./lib",
    "strict": true
@@ -1,7 +0,0 @@
-import * as wcp from 'webpack-config-prefabs'
-export = wcp.nodeLibrary(module, {
-  enableTypescript: true,
-  entry: './src/fs/patch.ts',
-  minimize: false,
-  outputFilepath: './lib/fs/patch.bundle.js',
-});
Author	SHA1	Message	Date
calebboyd	34c51064f4	feat: build-target options	2017-09-01 00:28:10 -05:00
calebboyd	be48e5a2f3	docs: update readme with new usage	2017-08-31 13:59:01 -05:00
calebboyd	0340c01b36	fix: don't call next twice	2017-08-31 10:02:12 -05:00
calebboyd	e62cd19b42	feat: targets	2017-08-31 08:46:50 -05:00
calebboyd	fc99386199	chore: options, and resource normalization	2017-08-31 01:15:51 -05:00
calebboyd	f949bf3040	feat: initial build	2017-08-30 15:32:26 -05:00
calebboyd	0a1e747ca3	chore: inject source-map-support	2017-08-26 23:34:03 -05:00
calebboyd	91aa014b7d	feat: initial fuse-box bundling support	2017-08-25 23:23:57 -05:00
				`@@ -0,0 +1 @@`
				`export * from './fuse-native-module-plugin'`
				`@@ -1 +0,0 @@`
				`console.log('hello world', require('./dependency'))`