bump deps

BREAKING: drop support for node < 14

BREAKING: removed snapshot, ico, and rc options

BREAKING: use python3 as default python binary

.eslintrc.json

@@ -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"]
-}

.github/actions/nexe-alpine/Dockerfile

@@ -0,0 +1,4 @@
+FROM node:fermium-alpine3.10
+RUN apk add --no-cache build-base linux-headers bash clang python3
+SHELL ["/bin/bash", "--login", "-c"]
+CMD ["bash"]

.github/actions/nexe-alpine/action.yml

@@ -0,0 +1,16 @@
+# action.yml
+name: 'Hello World'
+description: 'Greet someone and record the time'
+inputs:
+  who-to-greet:  # id of input
+    description: 'Who to greet'
+    required: true
+    default: 'World'
+outputs:
+  time: # id of output
+    description: 'The time we greeted you'
+runs:
+  using: 'docker'
+  image: 'Dockerfile'
+  args:
+    - ${{ inputs.who-to-greet }}

.github/actions/nexe-linux/Dockerfile

@@ -0,0 +1,23 @@
+FROM centos:7
+
+RUN yum install -y which centos-release-scl && \
+  yum install -y devtoolset-9-gcc \
+    devtoolset-9-gcc-c++ \
+    make \
+    wget \
+    python3 && \
+  echo "source /opt/rh/devtoolset-9/enable" >> /etc/bashrc
+
+SHELL ["/bin/bash", "--login", "-c"]
+
+ADD flags.sh flags.sh
+
+ARG NODE_VERSION=14.20.0
+
+RUN wget https://nodejs.org/dist/v${NODE_VERSION}/node-v${NODE_VERSION}.tar.gz -O node.tar.gz && \
+  mkdir node && tar -zxf node.tar.gz -C node --strip-components=1 && \
+  rm node.tar.gz && \
+  cd node && \
+  . ../flags.sh && \
+  ./configure $(echo $CONFIGURE_FLAGS) && \
+  make $(echo $MAKE_FLAGS) && make install

.github/actions/nexe-linux/action.yml

@@ -0,0 +1,16 @@
+# action.yml
+name: 'Hello World'
+description: 'Greet someone and record the time'
+inputs:
+  who-to-greet:  # id of input
+    description: 'Who to greet'
+    required: true
+    default: 'World'
+outputs:
+  time: # id of output
+    description: 'The time we greeted you'
+runs:
+  using: 'docker'
+  image: 'Dockerfile'
+  args:
+    - ${{ inputs.who-to-greet }}

.github/actions/nexe-linux/flags.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+ARCH=$(uname -m)
+
+case $ARCH in
+  "x86_64")
+    CONFIGURE_FLAGS="--dest-cpu=x64"
+  ;;
+  "aarch64")
+  ;&
+  "armv7l")
+    CONFIGURE_FLAGS="--openssl-no-asm --dest-cpu=arm --with-arm-float-abi=hard"
+  ;;
+  *)
+    CONFIGURE_FLAGS=""
+  ;;
+esac
+
+MAKE_FLAGS="-j$(getconf _NPROCESSORS_ONLN)"

.github/workflows/auto-close-no-response.yml

@@ -6,7 +6,6 @@ on:
   issue_comment:
     types: [created]
   schedule:
-    # 9AM Central
     - cron: '0 14 * * *'
 
 jobs:

.github/workflows/build-asset.yml

@@ -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 }}

.github/workflows/cd.yml

@@ -0,0 +1,52 @@
+name: Base Builds
+on:
+  push:
+    branches:
+      - refactor-old-node
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        version: ['14.20.0', '16.16.0', '18.5.0']
+        arch: [x64, x86]
+        plat: [arm, macos, windows, linux, alpine]
+        exclude:
+          - plat: arm
+            arch: x86
+          - plat: macos
+            arch: x86
+        include:
+          - plat: arm
+            os: ubuntu-20.04
+          - plat: macos
+            os: macos-12
+          - plat: windows
+            os: windows-2022
+          - plat: linux
+            os: ubuntu-20.04
+          - plat: alpine
+            os: ubuntu-20.04
+    name: 'Target: ${{matrix.plat}}-${{ matrix.arch }}-${{ matrix.version }} on ${{ matrix.os }}'
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Setup Python
+        uses: actions/setup-python@v3.1.2
+        with:
+          python-version: '3.10.4'
+      - name: Setup Nasm
+        if: ${{ matrix.plat == 'windows' }}
+        uses: ilammy/setup-nasm@v1.3.0
+      - uses: actions/setup-node@v3
+        with:
+          node-version: ${{ matrix.version }}
+      - uses: actions/checkout@v3
+        with:
+          node-version: 18
+      - name: 'Install Dependencies'
+        run: npm ci
+      - name: 'Build nexe base binary'
+        env:
+          NEXE_TARGET: ${{ matrix.plat }}-${{ matrix.arch }}-${{ matrix.version }}
+        run: npx ts-node tasks/build.ts

.node-version

@@ -0,0 +1 @@
+18.12.1

.swcrc

@@ -0,0 +1,19 @@
+{
+  "module": {
+    "type": "commonjs",
+    "ignoreDynamic": true
+    
+  },
+  "jsc": {
+    "parser": {
+      "syntax": "typescript",
+      "dynamicImport": true,
+      "decorators": true
+    },
+    "transform": {
+      "legacyDecorator": true
+    },
+    "target": "es2019",
+    "externalHelpers": false
+  }
+}

.vscode/extensions.json

@@ -1,3 +1,6 @@
 {
-    "recommendations": [ "ms-vscode.vscode-typescript-tslint-plugin" ]
+  "recommendations": [
+    "esbenp.prettier-vscode",
+    "dbaeumer.vscode-eslint"
+  ]
 }

.vscode/settings.json

@@ -1,7 +1,4 @@
 {
-  "tslint.enable": true,
-  "tslint.run": "onType",
-  "tslint.autoFixOnSave": true,
   "files.exclude": {
     "**/.git": true,
     "**/.svn": true,
@@ -14,5 +11,32 @@
     "**/node_modules": true,
     "**/bower_components": true
   },
-  "typescript.tsdk": "node_modules\\typescript\\lib"
+  "eslint.workingDirectories": [{ "mode": "auto" }],
+  "eslint.format.enable": true,
+  "editor.formatOnSave": true,
+  "eslint.validate": [
+    "javascript",
+    "javascriptreact",
+    "typescript",
+    "typescriptreact"
+  ],
+  "[javascript]": {
+    "editor.formatOnSave": true,
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[javascriptreact]": {
+    "editor.formatOnSave": true,
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[typescript]": {
+    "editor.formatOnSave": true,
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[typescriptreact]": {
+    "editor.formatOnSave": true,
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "editor.codeActionsOnSave": {
+    "source.fixAll.eslint": true
+  }
 }

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2013-2018 Nexe Contributors
+Copyright (c) 2013-2022 Nexe Contributors
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

README.md

@@ -23,7 +23,7 @@
 - Distribute binaries without needing node / npm.
 - Idempotent builds
 - Start and deploy faster.
-- Lockdown specific application versions, and easily rollback.
+- Lock-down specific application versions, and easily rollback.
 - Flexible build pipeline
 - Cross platform builds
 
@@ -79,7 +79,6 @@ 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.
 
@@ -117,14 +116,14 @@ compile({
     - 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'`
+    - An object or string describing platform-arch-version. e.g. `'windows-ia32-18.1.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`
+        - `'win32-x86-18.1.0`
         - `{ platform: 'alpine' }`
-        - `darwin-10.13.0`
+        - `darwin-14.19.1`
         - `linux-x64`
-        - `macos-10.13.0`
+        - `macos-16.15.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.
@@ -136,20 +135,6 @@ compile({
     export function createBundle (options: NexeOptions): 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' }`
  - #### `name: string`
     - Module friendly name of the application
     - default: basename of the input file, or `nexe_${Date.now()}`
@@ -185,9 +170,6 @@ compile({
  - #### `vcBuild: string[]`
     - Options for windows build
     - default: `['nosign', 'release']`
- - #### `snapshot: string`
-    - path to a file to be used as the warmup snapshot for the build
-    - default: `null`
  - #### `resources: string[]`
     - Array of globs with files to include in the build
     - Example: `['./public/**/*']`
@@ -196,20 +178,6 @@ compile({
     - Path to use for storing nexe's build files
     - Override in the env with `NEXE_TEMP`
     - default: `~/.nexe`
- - #### `ico: string`
-    - Path to a user provided icon to be used (Windows only). Requires `--build` to be set.
- - #### `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"
-          ...
-        }
-      ```
-    - default: `{}`
  - #### `clean: boolean`
     - If included, nexe will remove temporary files for the accompanying configuration and exit
  - #### `enableNodeCli: boolean`
@@ -268,14 +236,12 @@ In order to use native modules, the native binaries must be shipped alongside th
 
 ## Troubleshooting
 
-`Error: Entry file "" not found!` means you need to provide `nexe` with input. Either use `-i` or pipe data to it.
-
 `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`
+		- `nexe -i "app.js" -r "public/**/*.html" -o "dist/myApp.exe" -t x64-18.1.0`
 		- 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
 

azure-pipelines.yml

@@ -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: ''

dockerfiles/linux/Dockerfile

@@ -0,0 +1,13 @@
+FROM centos:7
+
+RUN yum install -y which centos-release-scl \
+  && yum install -y devtoolset-9-gcc \
+    devtoolset-9-gcc-c++ \
+    make \
+    python3 \
+    curl \
+  && curl -sL https://rpm.nodesource.com/setup_16.x | bash - \
+  && yum install -y nodejs && npm install nexe -g \
+  && echo "source /opt/rh/devtoolset-9/enable" >> /etc/bashrc
+
+SHELL ["/bin/bash", "--login", "-c"]

dockerfiles/musl/Dockerfile

@@ -0,0 +1,4 @@
+FROM node:16-alpine
+RUN apk add --no-cache build-base linux-headers bash clang python3
+SHELL ["/bin/bash", "--login", "-c"]
+CMD ["bash"]

examples/express-app/index.js

@@ -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)
-

examples/express-app/package-lock.json

@@ -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="
-    }
-  }
-}

examples/express-app/package.json

@@ -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"
-  }
-}

examples/express-app/public/index.html

@@ -1 +0,0 @@
-<h1>Hello World!</h1>

index.js

@@ -1,32 +1,45 @@
 #!/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)
-        }
-      }
 
-      process.exit(1)
+/* eslint-disable no-undef */
-    })
+/* eslint-disable @typescript-eslint/no-var-requires */
+
+const eol = require('os').EOL
+async function main() {
+  const util = require('./lib/cjs/util.js')
+  await util.initEsm()
+  const color = util.color,
+    options = require('./lib/cjs/options.js'),
+    nexe = require('./lib/cjs/nexe.js'),
+    NexeError = require('./lib/cjs/compiler.js').NexeError,
+    del = eol + eol,
+    argv = options.argv,
+    showHelp = argv.help || argv._.some((x) => x === 'help'),
+    showVersion = argv.version || argv._.some((x) => x === 'version')
+
+  try {
+    if (!(showHelp || showVersion)) {
+      await nexe.compile(argv)
+    } else {
+      process.stderr.write(showHelp ? options.help() : options.version + eol)
+    }
+  } catch (error) {
+    if (argv.loglevel !== 'silent') {
+      if (error instanceof NexeError) {
+        process.stderr.write(
+          `${eol}${color('red', 'Error: ')}${error.message}${del}See nexe -h for usage..${del}`
+        )
+      } else {
+        process.stderr.write(error.stack + eol)
+      }
+    }
+    process.exit(1)
   }
-} else {
+  process.exit(0)
-  module.exports = require('./lib/nexe')
+}
+
+if (require.main === module) {
+  main()
+} else {
+  process.stderr.write('Cannot require(..) the nexe cli')
+  process.exit(1)
 }

package.json

@@ -2,94 +2,123 @@
   "name": "nexe",
   "description": "Create a single executable out of your Node.js application",
   "license": "MIT",
-  "version": "5.0.0-beta",
+  "type": "commonjs",
-  "contributors": [
+  "version": "4.0.0-rc.local",
-    "Craig Condon <craig.j.condon@gmail.com> (http://crcn.io)",
+  "bin": {
-    "Jared Allard <jaredallard@outlook.com>",
+    "nexe": "./index.js"
-    "Caleb Boyd <caleb.boyd@hotmail.com>",
+  },
-    "Seth Olivarez <me@oxmc.me> (http://oxmc.me)"
+  "types": "./lib/types/nexe.d.ts",
-  ],
+  "main": "./lib/cjs/nexe.js",
-  "scripts": {
+  "exports": {
-    "ci:build": "ts-node tasks/build",
+    "./package.json": "./package.json",
-    "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",
+      "types": "./lib/types/nexe.d.ts",
-    "test:integration:run": "run-script-os",
+      "node": {
-    "test:integration:run:win32": "integration-tests.exe",
+        "import": "./lib/esm/nexe.js",
-    "test:integration:run:default": "./integration-tests",
+        "require": "./lib/cjs/nexe.js"
-    "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",
+  "engines": {
-    "postbuild": "ts-node tasks/post-build"
+    "node": ">=14"
   },
   "repository": {
     "type": "git",
     "url": "git://github.com/nexe/nexe.git"
   },
   "files": [
-    "lib"
+    "lib",
+    "index.js"
   ],
-  "typings": "lib/nexe.d.ts",
+  "scripts": {
-  "main": "index.js",
+    "lint": "tsc --noEmit && eslint \"{src,tasks,test}/**/*.ts\" --fix",
-  "bin": {
+    "test": "vitest run && node test/exports.mjs",
-    "nexe": "index.js"
+    "prepublishOnly": "npm run lint && npm run build && npm test",
-  },
+    "build": "npm run cjs:build & npm run esm:build",
-  "engines": {
+    "prebuild": "rm -rf lib",
-    "node": ">=10"
+    "cjs:build": "swc src -d lib/cjs --copy-files",
-  },
+    "esm:build": "swc src -d lib/esm --copy-files -C module.type=es6",
-  "mocha": {
+    "postbuild": "node -p \"JSON.stringify({type:'module'})\" > lib/esm/package.json && tsc --emitDeclarationOnly && ts-node tasks/post-build"
-    "spec": "./test/**/*.spec.ts",
-    "checkLeaks": true,
-    "require": [
-      "ts-node/register"
-    ]
   },
+  "contributors": [
+    "Craig Condon <craig.j.condon@gmail.com> (http://crcn.io)",
+    "Jared Allard <jaredallard@outlook.com>",
+    "Caleb Boyd <caleb.boyd@hotmail.com>"
+  ],
   "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",
+    "chalk": "^5.2.0",
-    "globby": "^11.0.2",
+    "download": "^8.0.0",
-    "meriyah": "^4.3.5",
+    "fast-glob": "^3.2.12",
-    "minimatch": "^10.1.2",
+    "got": "^12.5.3",
-    "minimist": "^1.2.8",
+    "meriyah": "^4.3.3",
-    "mkdirp": "^1.0.4",
+    "minimist": "^1.2.7",
     "multistream": "^4.1.0",
-    "ora": "^3.4.0",
+    "ora": "^6.1.2",
-    "resolve-dependencies": "^6.0.9",
+    "resolve-dependencies": "^6.0.8"
-    "rimraf": "^3.0.2",
-    "run-script-os": "^1.1.6",
-    "tar": "^7.5.2",
-    "webpack-config-prefabs": "0.0.5"
   },
   "devDependencies": {
-    "@types/archiver": "^5.3.2",
+    "@swc/cli": "^0.1.57",
-    "@types/chai": "^4",
+    "@swc/core": "^1.3.24",
-    "@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",
+    "@typescript-eslint/eslint-plugin": "^5.47.0",
-    "@types/rimraf": "3.0.2",
+    "@typescript-eslint/parser": "^5.47.0",
-    "@types/semver": "^7.3.13",
+    "eslint": "^8.30.0",
-    "@typescript-eslint/eslint-plugin": "^5.59.0",
+    "eslint-config-prettier": "~8.5.0",
-    "@typescript-eslint/parser": "^5.59.0",
+    "eslint-plugin-import": "^2.26.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",
+    "prettier": "^2.8.1",
-    "lodash": "^4.17.21",
-    "mocha": "^10.2.0",
-    "prettier": "^2.8.7",
     "ts-node": "^10.9.1",
-    "typescript": "^5.0.3",
+    "typescript": "^4.9.4",
-    "webpack-cli": "^5.0.1"
+    "vitest": "^0.26.2"
+  },
+  "prettier": {
+    "parser": "typescript",
+    "semi": false,
+    "singleQuote": true,
+    "printWidth": 100
+  },
+  "eslintConfig": {
+    "parser": "@typescript-eslint/parser",
+    "plugins": [
+      "import",
+      "@typescript-eslint"
+    ],
+    "extends": [
+      "eslint:recommended",
+      "plugin:@typescript-eslint/recommended",
+      "prettier",
+      "plugin:prettier/recommended"
+    ],
+    "rules": {
+      "@typescript-eslint/consistent-type-imports": [
+        2,
+        {
+          "prefer": "type-imports",
+          "disallowTypeAnnotations": false
+        }
+      ],
+      "import/extensions": [
+        2,
+        "ignorePackages"
+      ],
+      "@typescript-eslint/no-unused-vars": [
+        2,
+        {
+          "args": "after-used",
+          "ignoreRestSiblings": true,
+          "argsIgnorePattern": "^_"
+        }
+      ],
+      "@typescript-eslint/no-use-before-define": 0,
+      "@typescript-eslint/no-explicit-any": 0,
+      "@typescript-eslint/explicit-function-return-type": 0,
+      "no-warning-comments": 1,
+      "one-var": [
+        "error",
+        "consecutive"
+      ]
+    }
   }
 }

src/compiler.ts

@@ -1,43 +1,37 @@
-import { delimiter, resolve, normalize, join } from "path";
+import { resolve, normalize, join } from 'node:path'
-import { Buffer } from "buffer";
+import { Buffer } from 'node:buffer'
-import { createReadStream, ReadStream } from "fs";
+import type { ReadStream } from 'node:fs'
-import { spawn } from "child_process";
+import { createReadStream } from 'node:fs'
-import { Logger, LogStep } from "./logger";
+import { spawn } from 'node:child_process'
-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";
 
-const isBsd = Boolean(~process.platform.indexOf("bsd"));
+import type { File } from 'resolve-dependencies'
-const make = isWindows ? "vcbuild.bat" : isBsd ? "gmake" : "make";
+import MultiStream from 'multistream'
-const configure = isWindows ? "configure" : "./configure";
 
-type StringReplacer = (match: string) => string;
+import type { LogStep } from './logger.js'
+import { Logger } from './logger.js'
+import { readFile, writeFile, pathExists, isWindows, bound, wrap } from './util.js'
+import { version } from './options.js'
+import type { NexeOptions } from './options.js'
+import type { NexeTarget } from './target.js'
+import { Bundle, toStream } from './fs/bundle.js'
+
+const isBsd = Boolean(~process.platform.indexOf('bsd')),
+  make = isWindows ? 'vcbuild.bat' : isBsd ? 'gmake' : 'make'
+
+type StringReplacer = (match: string) => string
 
 export interface NexeFile {
-  filename: string;
+  filename: string
-  absPath: string;
+  absPath: string
-  contents: string | Buffer;
+  contents: string | Buffer
 }
 
-export { NexeOptions };
+export { NexeOptions }
 
 export class NexeError extends Error {
   constructor(m: string) {
-    super(m);
+    super(m)
-    Object.setPrototypeOf(this, NexeError.prototype);
+    Object.setPrototypeOf(this, NexeError.prototype)
   }
 }
 
@@ -45,130 +39,112 @@ export class NexeCompiler {
   /**
    * Epoch of when compilation started
    */
-  private start = Date.now();
+  private readonly start = Date.now()
-  private compileStep: LogStep | undefined;
+  private compileStep: LogStep | undefined
-  public log = new Logger(this.options.loglevel);
+  public log = new Logger(this.options.loglevel)
   /**
    * Copy of process.env
    */
-  public env = { ...process.env };
+  public env = { ...process.env }
   /**
    * Virtual FileSystem
    */
-  public bundle: Bundle;
+  public bundle: Bundle
   /**
    * Root directory for the source of the current build
    */
-  public src: string;
+  public src: string
   /**
    * In memory files that are being manipulated by the compiler
    */
-  public files: NexeFile[] = [];
+  public files: NexeFile[] = []
   /**
    * Standalone pieces of code run before the application entrypoint
    */
-  public shims: string[] = [];
+  public shims: string[] = []
   /**
    * The last shim (defaults to "require('module').runMain()")
    */
-  public startup = "";
+  public startup = ''
   /**
    * The main entrypoint filename for your application - eg. node mainFile.js
    */
-  public entrypoint: string | undefined;
+  public entrypoint: string | undefined
   /**
    * Not used
    */
-  public targets: NexeTarget[];
+  public targets: NexeTarget[]
   /**
    * Current target of the compiler
    */
-  public target: NexeTarget;
+  public target: NexeTarget
   /**
    * Output filename (-o myapp.exe)
    */
-  public output = this.options.output;
+  public output = this.options.output
   /**
    * Flag to indicate whether or notstdin was used for input
    */
-  public stdinUsed = false;
+  public stdinUsed = false
-  /**
-   * Path to the configure script
-   */
-  public configureScript: string;
   /**
    * The file path of node binary
    */
-  public nodeSrcBinPath: string;
+  public nodeSrcBinPath: string
   /**
    * Remote asset path if available
    */
-  public remoteAsset: string;
+  public remoteAsset: string
 
   constructor(public options: NexeOptions) {
-    const { python } = this.options;
+    const { python } = (this.options = options)
-    //SOMEDAY iterate over multiple targets with `--outDir`
+    // SOMEDAY iterate over multiple targets with `--outDir`
-    this.targets = options.targets as NexeTarget[];
+    this.targets = options.targets as NexeTarget[]
-    this.target = this.targets[0];
+    this.target = this.targets[0]
     if (!/https?:\/\//.test(options.remote)) {
-      throw new NexeError(
+      throw new NexeError(`Invalid remote URI scheme (must be http or https): ${options.remote}`)
-        `Invalid remote URI scheme (must be http or https): ${options.remote}`
-      );
     }
-    this.remoteAsset = options.remote + "nexe-asset-" + this.target.toString();
+    this.remoteAsset = options.remote + this.target.toString()
-    this.src = join(this.options.temp, this.target.version);
+    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, 'Release', 'node.exe')
-      : join(this.src, "out", "Release", "node");
+      : join(this.src, 'out', 'Release', 'node')
-    this.log.step("nexe " + version, "info");
+    this.log.step('nexe ' + version, 'info')
-    this.bundle = new Bundle(options);
+    this.bundle = new Bundle(options)
-    if (isWindows) {
+
-      const originalPath = process.env.PATH;
+    this.env = { ...process.env }
-      delete process.env.PATH;
+    if (python) {
-      this.env = { ...process.env };
+      this.env.PYTHON = python
-      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;
     }
   }
 
   @bound
-  addResource(absoluteFileName: string, content?: Buffer | string | File) {
+  async addResource(absoluteFileName: string, content?: Buffer | string | File) {
-    return this.bundle.addResource(absoluteFileName, content);
+    return await this.bundle.addResource(absoluteFileName, content)
   }
 
   @bound
   async readFileAsync(file: string) {
-    this.assertBuild();
+    this.assertBuild()
-    let cachedFile = this.files.find(
+    let cachedFile = this.files.find((x) => normalize(x.filename) === normalize(file))
-      (x) => normalize(x.filename) === normalize(file)
-    );
     if (!cachedFile) {
-      const absPath = join(this.src, file);
+      const absPath = join(this.src, file)
       cachedFile = {
         absPath,
         filename: file,
-        contents: await readFileAsync(absPath, "utf-8").catch((x) => {
+        contents: await readFile(absPath, 'utf-8').catch((x) => {
-          if (x.code === "ENOENT") return "";
+          if (x.code === 'ENOENT') return ''
-          throw x;
+          throw x
         }),
-      };
+      }
-      this.files.push(cachedFile);
+      this.files.push(cachedFile)
     }
-    return cachedFile;
+    return cachedFile
   }
 
   @bound
-  writeFileAsync(file: string, contents: string | Buffer) {
+  async writeFileAsync(file: string, contents: string | Buffer) {
-    this.assertBuild();
+    this.assertBuild()
-    return writeFileAsync(join(this.src, file), contents);
+    return await writeFile(join(this.src, file), contents)
   }
 
   @bound
@@ -176,173 +152,135 @@ export class NexeCompiler {
     file: string,
     replace: string | RegExp,
     value: string | StringReplacer
-  ) {
+  ): Promise<boolean> {
-    const entry = await this.readFileAsync(file);
+    const entry = await this.readFileAsync(file)
-    entry.contents = entry.contents.toString().replace(replace, value as any);
+    let replaced = false
+    const replacer = (match: string) => {
+      replaced = true
+      if (typeof value === 'function') return value(match)
+      return value
+    }
+    entry.contents = entry.contents.toString().replace(replace, replacer)
+    return replaced
   }
 
   @bound
   async setFileContentsAsync(file: string, contents: string | Buffer) {
-    const entry = await this.readFileAsync(file);
+    const entry = await this.readFileAsync(file)
-    entry.contents = contents;
+    entry.contents = contents
   }
 
-  quit(error?: any) {
+  async quit(error?: any) {
-    const time = Date.now() - this.start;
+    const time = Date.now() - this.start
-    this.log.write(`Finished in ${time / 1000}s`, error ? "red" : "green");
+    this.log.write(`Finished in ${time / 1000}s`, error ? 'red' : 'green')
-    return this.log.flush();
+    return await this.log.flush()
   }
 
   assertBuild() {
     if (!this.options.build) {
-      throw new NexeError("This feature is only available with `--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);
+      return resolve(this.options.cwd, this.options.asset)
     }
     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[]) {
+  private async _runBuildCommandAsync(command: string, args: string[]) {
     if (this.log.verbose) {
-      this.compileStep!.pause();
+      this.compileStep?.pause()
     }
-    return new Promise<void>((resolve, reject) => {
+    return await new Promise<void>((resolve, reject) => {
       spawn(command, args, {
         cwd: this.src,
         env: this.env,
-        shell: true,
+        stdio: this.log.verbose ? 'inherit' : 'ignore',
-        stdio: this.log.verbose ? "inherit" : "ignore",
       })
-        .once("error", (e: Error) => {
+        .once('error', (e: Error) => {
           if (this.log.verbose) {
-            this.compileStep!.resume();
+            this.compileStep?.resume()
           }
-          reject(e);
+          reject(e)
         })
-        .once("close", (code: number) => {
+        .once('close', (code: number) => {
           if (this.log.verbose) {
-            this.compileStep!.resume();
+            this.compileStep?.resume()
           }
           if (code != 0) {
-            const error = `${command} ${args.join(
+            const error = `${command} ${args.join(' ')} exited with code: ${code}`
-              " "
+            reject(new NexeError(error))
-            )} exited with code: ${code}`;
-            reject(new NexeError(error));
           }
-          resolve();
+          resolve()
-        });
+        })
-    });
+    })
   }
 
-  private _configureAsync() {
+  private async _configureAsync() {
-    if (isWindows && semverGt(this.target.version, "10.15.99")) {
+    if (isWindows) {
-      return Promise.resolve();
+      return await Promise.resolve()
     }
-    return this._runBuildCommandAsync(this.env.PYTHON || "python", [
+    return await this._runBuildCommandAsync(this.env.PYTHON || 'python3', [
-      this.configureScript,
+      './configure.py',
       ...this.options.configure,
-    ]);
+    ])
   }
 
   public async build(): Promise<ReadStream> {
-    this.compileStep!.log(
+    this.compileStep?.log(
-      `Configuring node build${this.options.configure.length ? ": " + this.options.configure : "..."
+      `Configuring node build${
+        this.options.configure.length > 0 ? ': ' + this.options.configure : '...'
       }`
-    );
+    )
-    await this._configureAsync();
+    await this._configureAsync()
-    const buildOptions = this.options.make;
+    const buildOptions = this.options.make
-    this.compileStep!.log(
+    this.compileStep?.log(
-      `Compiling Node${buildOptions.length ? " with arguments: " + buildOptions : "..."
+      `Compiling Node${buildOptions.length > 0 ? ' with arguments: ' + buildOptions : '...'}`
-      }`
+    )
-    );
+    await this._runBuildCommandAsync(make, buildOptions)
-    await this._runBuildCommandAsync(make, buildOptions);
+    return createReadStream(this.getNodeExecutableLocation())
-    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;
-
-    if (!binary) {
-      return true;
-    }
-
-    if (build && snapshot != null && (await pathExistsAsync(snapshot))) {
-      const snapshotLastModified = (await statAsync(snapshot)).mtimeMs;
-      const binaryLastModified = (await statAsync(location)).mtimeMs;
-      return snapshotLastModified > binaryLastModified;
-    }
-
-    return false;
   }
 
   async compileAsync(target: NexeTarget) {
-    const step = (this.compileStep = this.log.step("Compiling result"));
+    const step = (this.compileStep = this.log.step('Compiling result')),
-    const build = this.options.build;
+      build = this.options.build,
-    const location = this.getNodeExecutableLocation(build ? undefined : target);
+      location = this.getNodeExecutableLocation(build ? undefined : target)
-    let binary = (await pathExistsAsync(location))
+    let binary = (await pathExists(location)) ? createReadStream(location) : null
-      ? createReadStream(location)
-      : null;
 
-    if (await this._shouldCompileBinaryAsync(binary, location)) {
+    if (!binary) {
-      binary = await this.build();
+      binary = await this.build()
-      step.log("Node binary compiled");
+      step.log('Node binary compiled')
     }
-    return this._assembleDeliverable(binary!);
+    return await this._assembleDeliverable(binary)
   }
 
   code() {
-    return [this.shims.join(""), this.startup].join(";");
+    return [this.shims.join(''), this.startup].join(';')
   }
 
-  private async _assembleDeliverable(binary: Readable) {
+  private async _assembleDeliverable(binary: NodeJS.ReadableStream) {
     if (!this.options.mangle) {
-      return binary;
+      return binary
     }
-    const launchCode = this.code();
+    const resources = this.bundle.renderIndex()
-    const codeSize = Buffer.byteLength(launchCode);
+    this.shims.unshift(wrap(`process.__nexe = ${JSON.stringify({ resources })};\n`))
-    const sentinel = Buffer.from("<nexe~~sentinel>");
 
-    let vfsSize = 0;
+    const code = this.code(),
-    // finalize() must be called before any reads — archiver won't emit chunks
+      codeSize = Buffer.byteLength(code),
-    // until finalized, so calling it inside the Transform's first-chunk callback
+      lengths = Buffer.from(Array(16))
-    // creates a deadlock (Transform waits for chunks, archiver waits for finalize).
+
-    const bundleStream = this.bundle.toStream();
+    lengths.writeDoubleLE(codeSize, 0)
-    this.bundle.finalize();
+    lengths.writeDoubleLE(this.bundle.size, 8)
-    const streams = [
+    return new (MultiStream as any)([
       binary,
-      toStream(launchCode),
+      toStream(code),
-      bundleStream.pipe(
+      this.bundle.toStream(),
-        new Transform({
+      toStream(Buffer.concat([Buffer.from('<nexe~~sentinel>'), lengths])),
-          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])));
-      }
-    });
   }
 }

src/fs/SnapshotZipFS.ts

@@ -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;
-}

src/fs/bootstrap.js

@@ -1,28 +1,21 @@
-{
+if (true) {
-  const __nexe_patches = (process.nexe = { patches: {} }).patches;
+  const patches = (process.nexe = { patches: {} }).patches
-  const slice = [].slice;
+
-  const __nexe_noop_patch = function (original) {
+  ;["ReadFile", "ReadJSON", "Stat"].forEach((x) => {
-    const args = slice.call(arguments, 1);
+    patch(process.binding("fs"), "internalModule" + x, noop)
-    return original.apply(this, args);
+  })
-  };
+
-  const __nexe_patch = function (obj, method, patch) {
+  function noop(original, ...args) {
+    return original.apply(this, args)
+  }
+
+  function patch(obj, method, patch) {
     const original = obj[method];
-    if (!original) return;
+    if (!original) return
-    __nexe_patches[method] = patch;
+    patches[method] = patch
-    obj[method] = function () {
+    obj[method] = function (...args) {
-      const args = [original].concat(slice.call(arguments));
+      args.unshift(original)
-      return __nexe_patches[method].apply(this, args);
+      return 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);
 }

src/fs/bundle.ts

@@ -1,54 +1,154 @@
-import { relative } from "path";
+import { lstat, realpath, stat } from 'node:fs/promises'
-import { Readable } from "stream";
+import { createReadStream } from 'node:fs'
-import { File } from "resolve-dependencies";
+import { relative } from 'node:path'
-import archiver from "archiver";
+import { Readable } from 'node:stream'
 
-function makeRelativeToZip(cwd: string, path: string) {
+import type { File } from 'resolve-dependencies'
-  return "/snapshot/" + relative(cwd, path);
+import MultiStream from 'multistream'
+
+export type MultiStreams = Array<Readable | (() => Readable)>
+
+function makeRelative(cwd: string, path: string) {
+  return './' + relative(cwd, path)
+}
+
+function sortEntry(a: [string, File], b: [string, File]) {
+  return a[0] > b[0] ? 1 : -1
 }
 
 export function toStream(content: Buffer | string) {
   const readable = new Readable({
     read() {
-      this.push(content);
+      this.push(content)
-      this.push(null);
+      this.push(null)
     },
-  });
+  })
-  return readable;
+  return readable
 }
+
+async function createFile(absoluteFileName: string) {
+  const stats = await lstat(absoluteFileName),
+    file: File = {
+      size: stats.size,
+      moduleType: 'commonjs',
+      contents: '',
+      absPath: absoluteFileName,
+      deps: {},
+    }
+  if (stats.isSymbolicLink()) {
+    file.size = stats.size
+    const [realPath, realStat] = await Promise.all([
+      realpath(absoluteFileName),
+      stat(absoluteFileName),
+    ])
+    file.realPath = realPath
+    file.realSize = realStat.size
+  }
+  return file
+}
+
 export class Bundle {
-  cwd: string;
+  size = 0
-  files = new Set<string>();
+  cwd: string
-  zip: any;
+  rendered = false
+  private offset = 0
+  private index: { [key: string]: [number, number] } = {}
+  private files: { [key: string]: File } = {}
+  streams: MultiStreams = []
   constructor({ cwd }: { cwd: string } = { cwd: process.cwd() }) {
-    this.cwd = cwd;
+    this.cwd = cwd
-    this.zip = archiver("zip");
   }
 
   get list() {
-    return Array.from(this.files);
+    return Object.keys(this.files)
   }
 
-  public addResource(
+  public async addResource(
     absoluteFileName: string,
     content?: File | Buffer | string
-  ) {
+  ): Promise<number> {
-    const destPath = makeRelativeToZip(this.cwd, absoluteFileName);
+    if (this.files[absoluteFileName]) {
-    if (!this.files.has(destPath)) {
+      return this.size
-      if (content == null) {
+    }
-        this.zip.file(absoluteFileName, { name: destPath });
+    if (typeof content === 'string' || Buffer.isBuffer(content)) {
-      } else {
+      this.files[absoluteFileName] = {
-        this.zip.append(content, { name: destPath });
+        size: Buffer.byteLength(content),
+        moduleType: 'commonjs',
+        contents: content.toString(),
+        deps: {},
+        absPath: absoluteFileName,
       }
-      this.files.add(destPath);
+    } else if (content) {
+      this.files[content.absPath] = content
+    } else {
+      this.files[absoluteFileName] = {
+        absPath: absoluteFileName,
+        moduleType: 'commonjs',
+        contents: '',
+        deps: {},
+        size: 0,
+      }
+      this.files[absoluteFileName] = await createFile(absoluteFileName)
+    }
+    return (this.size += this.files[absoluteFileName].size)
+  }
+
+  /**
+   * De-dupe files by absolute path, partition by symlink/real
+   * Iterate over real, add entries
+   * Iterate over symlinks, add symlinks
+   */
+  renderIndex() {
+    if (this.rendered) {
+      throw new Error('Bundle index already rendered')
+    }
+    const files = Object.entries(this.files),
+      realFiles: Array<[string, File]> = [],
+      symLinks: Array<[string, File]> = []
+    for (const entry of files) {
+      if (entry[1].realPath) {
+        symLinks.push(entry)
+      } else {
+        realFiles.push(entry)
+      }
+    }
+    realFiles.sort(sortEntry)
+    symLinks.sort(sortEntry)
+
+    for (const [absPath, file] of realFiles) {
+      this.addEntry(absPath, file)
+    }
+    for (const [absPath, file] of symLinks) {
+      this.addEntry(file.realPath as string, file)
+      this.addEntry(absPath, file, file.realPath)
+    }
+    this.rendered = true
+    return this.index
+  }
+
+  /**
+   * Add a stream if needed and an entry with the required offset and size
+   * Ensure the calling order of this method is idempotent (eg, while iterating a sorted set)
+   * @param entryPath
+   * @param file
+   * @param useEntry
+   */
+  addEntry(entryPath: string, file: File, useEntry?: string) {
+    const existingName = useEntry && makeRelative(this.cwd, useEntry),
+      name = makeRelative(this.cwd, entryPath),
+      size = file.realSize ?? file.size,
+      existingEntry = this.index[existingName ?? name]
+
+    this.index[name] = existingEntry || [this.offset, size]
+    if (!existingEntry) {
+      this.streams.push(() =>
+        file.contents ? toStream(file.contents) : createReadStream(file.absPath)
+      )
+      this.offset += size
     }
   }
 
-  public finalize() {
+  toStream() {
-    return this.zip.finalize();
+    return new MultiStream(this.streams)
-  }
-
-  public toStream(): Readable {
-    return this.zip;
   }
 }

src/fs/package.json

@@ -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"
-}

src/fs/patch.ts

@@ -1,387 +1,437 @@
-import { ZipFS, getLibzipSync } from "@yarnpkg/libzip";
+/* eslint-disable prefer-rest-params */
-import { patchFs, PosixFS, NodeFS } from "@yarnpkg/fslib";
+/* eslint-disable @typescript-eslint/no-var-requires */
-import { SnapshotZipFS } from "./SnapshotZipFS";
+import type { Stats } from 'fs'
-import * as assert from "assert";
+import type { Func } from '../util'
-import * as constants from "constants";
-import { dirname, relative, sep } from "path";
 
-export interface NexeHeader {
+export interface NexeBinary {
-  blobPath: string;
+  blobPath: string
+  resources: { [key: string]: number[] }
   layout: {
-    resourceStart: number;
+    stat: Stats
-    resourceSize: number;
+    resourceStart: number
-    contentSize: number;
+    contentSize?: number
-    contentStart: number;
+    contentStart?: number
-  };
+    resourceSize?: number
+  }
 }
 
-let originalFsMethods: any = null;
+let originalFsMethods: any = null,
-let lazyRestoreFs = () => {};
+  lazyRestoreFs = () => void 0
-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")) {
+// optional Win32 file namespace prefix followed by drive letter and colon
+const windowsFullPathRegex = /^(\\{2}\?\\)?([a-zA-Z]):/,
+  upcaseDriveLetter = (s: string): string =>
+    s.replace(windowsFullPathRegex, (_match, ns, drive) => `${ns || ''}${drive.toUpperCase()}:`)
+
+function shimFs(binary: NexeBinary, fs: any = require('fs')) {
   if (originalFsMethods !== null) {
-    return;
+    return
   }
+  originalFsMethods = Object.assign({}, fs)
+  const { blobPath, resources: manifest } = binary,
+    { resourceStart, stat } = binary.layout,
+    directories: { [key: string]: { [key: string]: boolean } } = {},
+    notAFile = '!@#$%^&*',
+    isWin = process.platform.startsWith('win'),
+    isString = (x: any): x is string => typeof x === 'string' || x instanceof String,
+    noop = () => void 0
+  const path = require('path')
+  const winPath: (key: string) => string = isWin ? upcaseDriveLetter : (s) => s,
+    baseDir = winPath(path.dirname(process.execPath))
 
-  originalFsMethods = Object.assign({}, fs);
+  let log = (_: string) => true,
-
+    loggedManifest = false
-  const realFs: typeof fs = { ...fs };
+  if ((process.env.DEBUG || '').toLowerCase().includes('nexe:require')) {
-  const nodeFs = new NodeFS(realFs);
+    log = (text: string) => {
-
+      setupManifest()
-  const blob = Buffer.allocUnsafe(binary.layout.resourceSize);
+      if (!loggedManifest) {
-  const blobFd = realFs.openSync(binary.blobPath, "r");
+        process.stderr.write('[nexe] - MANIFEST' + JSON.stringify(manifest, null, 4) + '\n')
-  const bytesRead = realFs.readSync(
+        process.stderr.write('[nexe] - DIRECTORIES' + JSON.stringify(directories, null, 4) + '\n')
-    blobFd,
+        loggedManifest = true
-    blob,
+      }
-    0,
+      return process.stderr.write('[nexe] - ' + text + '\n')
-    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;
+  const getKey = function getKey(filepath: string | Buffer | null): string {
+      if (Buffer.isBuffer(filepath)) {
+        filepath = filepath.toString()
+      }
+      if (!isString(filepath)) {
+        return notAFile
+      }
+      const key = path.resolve(baseDir, filepath)
 
-  // internalModuleReadJSON should return a string (or undefined) in Node 22
+      return winPath(key)
-  patches.internalModuleReadJSON = function (this: any, original: any, ...args: any[]) {
+    },
-    const content = internalModuleReadFile.call(this, original, ...args);
+    statTime = function () {
-    return content === "" ? undefined : content;
+      return {
-  };
+        atime: new Date(stat.atime),
-
+        mtime: new Date(stat.mtime),
-  // Handle Node 22+ signature: first arg is context (non-string), second is path
+        ctime: new Date(stat.ctime),
-  function internalModuleStat(this: any, original: any, ...args: any[]) {
+        birthtime: new Date(stat.birthtime),
-    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") {
+  let BigInt: any
-      // 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");
+    BigInt = eval('BigInt')
-    const nodePath = require("path");
+  } catch (ignored) {
-    const capturedOrigFindPath = (Module as any)._findPath;
+    void ignored
-    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
   }
 
+  const minBlocks = Math.max(Math.ceil(stat.blksize / 512), 1),
+    createStat = function (extensions: any, options: any) {
+      const stat = Object.assign(new fs.Stats(), binary.layout.stat, statTime(), extensions)
+      if ('size' in extensions) {
+        // Assume non adjustable allocation size for file system
+        stat.blocks = Math.ceil(stat.size / stat.blksize) * minBlocks
+      }
+      if (options && options.bigint && typeof BigInt !== 'undefined') {
+        for (const k in stat) {
+          if (Object.prototype.hasOwnProperty.call(stat, k) && typeof stat[k] === 'number') {
+            stat[k] = BigInt(stat[k])
+          }
+        }
+      }
+      return stat
+    },
+    ownStat = function (filepath: any, options: any) {
+      setupManifest()
+      const key = getKey(filepath)
+      if (directories[key]) {
+        let mode = binary.layout.stat.mode
+        mode |= fs.constants.S_IFDIR
+        mode &= ~fs.constants.S_IFREG
+        return createStat({ mode, size: 0 }, options)
+      }
+      if (manifest[key]) {
+        return createStat({ size: manifest[key][1] }, options)
+      }
+    },
+    getStat = function (fn: string) {
+      return function stat(filepath: string | Buffer, options: any, callback: any) {
+        let stat: any
+        if (typeof options === 'function') {
+          callback = options
+          stat = ownStat(filepath, null)
+        } else {
+          stat = ownStat(filepath, options)
+        }
+        if (stat) {
+          process.nextTick(() => {
+            callback(null, stat)
+          })
+        } else {
+          return originalFsMethods[fn].apply(fs, arguments)
+        }
+      }
+    }
+
+  function makeLong(filepath: string) {
+    return path._makeLong && path._makeLong(filepath)
+  }
+
+  function fileOpts(options: any) {
+    return !options ? {} : isString(options) ? { encoding: options } : options
+  }
+
+  let setupManifest = () => {
+    Object.keys(manifest).forEach((filepath) => {
+      const entry = manifest[filepath],
+        absolutePath = getKey(filepath),
+        longPath = makeLong(absolutePath),
+        normalizedPath = winPath(path.normalize(filepath))
+
+      if (!manifest[absolutePath]) {
+        manifest[absolutePath] = entry
+      }
+      if (longPath && !manifest[longPath]) {
+        manifest[longPath] = entry
+      }
+      if (!manifest[normalizedPath]) {
+        manifest[normalizedPath] = manifest[filepath]
+      }
+
+      let currentDir = path.dirname(absolutePath),
+        prevDir = absolutePath
+
+      while (currentDir !== prevDir) {
+        directories[currentDir] = directories[currentDir] || {}
+        directories[currentDir][path.basename(prevDir)] = true
+        const longDir = makeLong(currentDir)
+        if (longDir && !directories[longDir]) {
+          directories[longDir] = directories[currentDir]
+        }
+        prevDir = currentDir
+        currentDir = path.dirname(currentDir)
+      }
+    })
+    ;(manifest[notAFile] as any) = false
+    ;(directories[notAFile] as any) = false
+    setupManifest = noop
+  }
+
+  // naive patches intended to work for most use cases
+  const nfs: any = {
+    existsSync: function existsSync(filepath: string) {
+      setupManifest()
+      const key = getKey(filepath)
+      if (manifest[key] || directories[key]) {
+        return true
+      }
+      return originalFsMethods.existsSync.apply(fs, arguments)
+    },
+    realpath: function realpath(filepath: any, options: any, cb: any): void {
+      setupManifest()
+      const key = getKey(filepath)
+      if (isString(filepath) && (manifest[filepath] || manifest[key])) {
+        return process.nextTick(() => cb(null, filepath))
+      }
+      return originalFsMethods.realpath.call(fs, filepath, options, cb)
+    },
+    realpathSync: function realpathSync(filepath: any, options: any) {
+      setupManifest()
+      const key = getKey(filepath)
+      if (manifest[key]) {
+        return filepath
+      }
+      return originalFsMethods.realpathSync.call(fs, filepath, options)
+    },
+    readdir: function readdir(filepath: string | Buffer, options: any, callback: any) {
+      setupManifest()
+      const dir = directories[getKey(filepath)]
+      if (dir) {
+        if (typeof options === 'function') {
+          callback = options
+          options = { encoding: 'utf8' }
+        }
+        process.nextTick(() => callback(null, Object.keys(dir)))
+      } else {
+        return originalFsMethods.readdir.apply(fs, arguments)
+      }
+    },
+    readdirSync: function readdirSync(filepath: string | Buffer) {
+      setupManifest()
+      const dir = directories[getKey(filepath)]
+      if (dir) {
+        return Object.keys(dir)
+      }
+      return originalFsMethods.readdirSync.apply(fs, arguments)
+    },
+
+    readFile: function readFile(filepath: any, options: any, callback: any) {
+      setupManifest()
+      const entry = manifest[getKey(filepath)]
+      if (!entry) {
+        return originalFsMethods.readFile.apply(fs, arguments)
+      }
+      const [offset, length] = entry,
+        resourceOffset = resourceStart + offset,
+        encoding = fileOpts(options).encoding
+      callback = typeof options === 'function' ? options : callback
+
+      originalFsMethods.open(blobPath, 'r', function (err: Error, fd: number) {
+        if (err) return callback(err, null)
+        originalFsMethods.read(
+          fd,
+          Buffer.alloc(length),
+          0,
+          length,
+          resourceOffset,
+          function (error: Error, bytesRead: number, result: Buffer) {
+            if (error) {
+              return originalFsMethods.close(fd, function () {
+                callback(error, null)
+              })
+            }
+            originalFsMethods.close(fd, function (err: Error) {
+              if (err) {
+                return callback(err, result)
+              }
+              callback(err, encoding ? result.toString(encoding) : result)
+            })
+          }
+        )
+      })
+    },
+    createReadStream: function createReadStream(filepath: any, options: any) {
+      setupManifest()
+      const entry = manifest[getKey(filepath)]
+      if (!entry) {
+        return originalFsMethods.createReadStream.apply(fs, arguments)
+      }
+      const [offset, length] = entry,
+        resourceOffset = resourceStart + offset,
+        opts = fileOpts(options)
+
+      return originalFsMethods.createReadStream(
+        blobPath,
+        Object.assign({}, opts, {
+          start: resourceOffset,
+          end: resourceOffset + length - 1,
+        })
+      )
+    },
+    readFileSync: function readFileSync(filepath: any, options: any) {
+      setupManifest()
+      const entry = manifest[getKey(filepath)]
+      if (!entry) {
+        return originalFsMethods.readFileSync.apply(fs, arguments)
+      }
+      const [offset, length] = entry,
+        resourceOffset = resourceStart + offset,
+        encoding = fileOpts(options).encoding,
+        fd = originalFsMethods.openSync(process.execPath, 'r'),
+        result = Buffer.alloc(length)
+      originalFsMethods.readSync(fd, result, 0, length, resourceOffset)
+      originalFsMethods.closeSync(fd)
+      return encoding ? result.toString(encoding) : result
+    },
+    statSync: function statSync(filepath: string | Buffer, options: any) {
+      const stat = ownStat(filepath, options)
+      if (stat) {
+        return stat
+      }
+      return originalFsMethods.statSync.apply(fs, arguments)
+    },
+    stat: getStat('stat'),
+    lstat: getStat('lstat'),
+    lstatSync: function statSync(filepath: string | Buffer, options: any) {
+      const stat = ownStat(filepath, options)
+      if (stat) {
+        return stat
+      }
+      return originalFsMethods.lstatSync.apply(fs, arguments)
+    },
+  }
+  if (typeof fs.exists === 'function') {
+    nfs.exists = function (filepath: string, cb: Func) {
+      cb = cb || noop
+      const exists = nfs.existsSync(filepath)
+      process.nextTick(() => cb(exists))
+    }
+  }
+
+  const patches = (process as any).nexe.patches || {}
+  delete (process as any).nexe
+  patches.internalModuleReadFile = function (this: any, original: any, ...args: any[]) {
+    setupManifest()
+    const filepath = getKey(args[0])
+    if (manifest[filepath]) {
+      log('read     (hit)              ' + filepath)
+      return nfs.readFileSync(filepath, 'utf-8')
+    }
+    log('read          (miss)       ' + filepath)
+    return original.call(this, ...args)
+  }
+  let returningArray: boolean
+  patches.internalModuleReadJSON = function (this: any, original: any, ...args: any[]) {
+    if (!returningArray) returningArray = Array.isArray(original.call(this, ''))
+    const res = patches.internalModuleReadFile.call(this, original, ...args)
+    return returningArray && !Array.isArray(res)
+      ? [res, /"(main|name|type|exports|imports)"/.test(res)]
+      : res
+  }
+  patches.internalModuleStat = function (this: any, original: any, ...args: any[]) {
+    setupManifest()
+    const filepath = getKey(args[0])
+    if (manifest[filepath]) {
+      log('stat     (hit)              ' + filepath + '   ' + 0)
+      return 0
+    }
+    if (directories[filepath]) {
+      log('stat dir (hit)              ' + filepath + '   ' + 1)
+      return 1
+    }
+    const res = original.call(this, ...args)
+    if (res === 0) {
+      log('stat          (miss)        ' + filepath + '   ' + res)
+    } else if (res === 1) {
+      log('stat dir      (miss)        ' + filepath + '   ' + res)
+    } else {
+      log('stat                 (fail) ' + filepath + '   ' + res)
+    }
+    return res
+  }
+
+  if (typeof fs.exists === 'function') {
+    nfs.exists = function (filepath: string, cb: Func) {
+      cb = cb || noop
+      const exists = nfs.existsSync(filepath)
+      if (!exists) {
+        return originalFsMethods.exists(filepath, cb)
+      }
+      process.nextTick(() => cb(exists))
+    }
+  }
+
+  if (typeof fs.copyFile === 'function') {
+    nfs.copyFile = function (filepath: string, dest: string, flags: number, callback: Func) {
+      setupManifest()
+      const entry = manifest[getKey(filepath)]
+      if (!entry) {
+        return originalFsMethods.copyFile.apply(fs, arguments)
+      }
+      if (typeof flags === 'function') {
+        callback = flags
+        flags = 0
+      }
+      nfs.readFile(filepath, (err: any, buffer: any) => {
+        if (err) {
+          return callback(err)
+        }
+        originalFsMethods.writeFile(dest, buffer, (err: any) => {
+          if (err) {
+            return callback(err)
+          }
+          callback(null)
+        })
+      })
+    }
+    nfs.copyFileSync = function (filepath: string, dest: string) {
+      setupManifest()
+      const entry = manifest[getKey(filepath)]
+      if (!entry) {
+        return originalFsMethods.copyFileSync.apply(fs, arguments)
+      }
+      return originalFsMethods.writeFileSync(dest, nfs.readFileSync(filepath))
+    }
+  }
+
+  if (typeof fs.realpath.native === 'function') {
+    nfs.realpath.native = function realpathNative(filepath: any, options: any, cb: any): void {
+      setupManifest()
+      const key = getKey(filepath)
+      if (isString(filepath) && (manifest[filepath] || manifest[key])) {
+        return process.nextTick(() => cb(null, filepath))
+      }
+      return originalFsMethods.realpath.native.call(fs, filepath, options, cb)
+    }
+    nfs.realpathSync.native = function realpathSyncNative(filepath: any, options: any) {
+      setupManifest()
+      const key = getKey(filepath)
+      if (manifest[key]) {
+        return filepath
+      }
+      return originalFsMethods.realpathSync.native.call(fs, filepath, options)
+    }
+  }
+
+  Object.assign(fs, nfs)
+
   lazyRestoreFs = () => {
-    Object.assign(fs, originalFsMethods);
+    Object.keys(nfs).forEach((key) => {
-    Object.assign(patches, originalPatches);
+      fs[key] = originalFsMethods[key]
-    if (_origFindPath !== null) {
+    })
-      try {
+    lazyRestoreFs = () => void 0
-        const Module = require("module");
+    return void 0
-        (Module as any)._findPath = _origFindPath;
+  }
-      } catch (_) {}
+  return true
-      _origFindPath = null;
-    }
-    lazyRestoreFs = () => {};
-  };
 }
 
 function restoreFs() {
-  lazyRestoreFs();
+  lazyRestoreFs()
 }
 
-export { shimFs, restoreFs };
+export { shimFs, restoreFs }

src/logger.ts

@@ -1,65 +1,67 @@
-import colors from "chalk";
+import type { Func } from './util.js'
-import ora from "ora";
+import { color, esm } from './util.js'
 
-const frameLength = 120;
+const frameLength = 120
 
 export interface LogStep {
-  modify(text: string, color?: string): void;
+  modify: (text: string, color?: string) => void
-  log(text: string, color?: string): void;
+  log: (text: string, color?: string) => void
-  pause(): void;
+  pause: () => void
-  resume(): void;
+  resume: () => void
 }
 
 export class Logger {
-  public verbose: boolean;
+  public verbose: boolean
-  private silent: boolean;
+  private readonly silent: boolean
-  private ora: any;
+  private ora: any
-  private modify: Function;
+  private readonly modify: Func
-  public write: (text: string, color?: string) => void;
+  public write: (text: string, color?: string) => void
 
-  constructor(level: "verbose" | "silent" | "info") {
+  constructor(level: 'verbose' | 'silent' | 'info') {
-    this.verbose = level === "verbose";
+    this.verbose = level === 'verbose'
-    this.silent = level === "silent";
+    this.silent = level === 'silent'
     if (!this.silent) {
-      this.ora = ora({
+      this.ora = esm.ora?.default({
-        text: "Starting...",
+        text: 'Starting...',
-        color: "blue",
+        color: 'blue',
-        spinner: "dots",
+        spinner: 'dots',
-      });
+      })
-      this.ora.stop();
+      this.ora.stop()
     }
-    const noop = () => { };
+    const noop = () => void 0
-    this.modify = this.silent ? noop : this._modify.bind(this);
+    this.modify = this.silent ? noop : this._modify.bind(this)
-    this.write = this.silent ? noop : this._write.bind(this);
+    this.write = this.silent ? noop : this._write.bind(this)
   }
 
-  flush() {
+  async flush() {
-    !this.silent && this.ora.succeed();
+    !this.silent && this.ora.succeed()
-    return new Promise((resolve) => setTimeout(resolve, frameLength));
+    return await new Promise((resolve) => setTimeout(resolve, frameLength))
   }
 
-  _write(update: string, color = "green") {
+  _write(update: string, clr = 'green') {
-    this.ora.succeed().text = (colors as any)[color](update);
+    this.ora.succeed().text = color(clr, update)
-    this.ora.start();
+    this.ora.start()
   }
 
   _modify(update: string, color = this.ora.color) {
-    this.ora.text = update;
+    this.ora.text = update
-    this.ora.color = color;
+    this.ora.color = color
   }
 
-  step(text: string, method = "succeed"): LogStep {
+  step(text: string, method = 'succeed', clr?: string): LogStep {
     if (this.silent) {
-      return { modify() { }, log() { }, pause() { }, resume() { } };
+      // eslint-disable-next-line @typescript-eslint/no-empty-function
+      return { modify() {}, log() {}, pause() {}, resume() {} }
     }
+    text = color(clr, text)
     if (!this.ora.id) {
-      this.ora.start().text = text;
+      this.ora.start().text = text
-      if (method !== "succeed") {
+      if (method !== 'succeed') {
-        this.ora[method]();
+        this.ora[method]()
       }
     } else {
-      this.ora[method]().text = text;
+      this.ora[method]().text = text
-      this.ora.start();
+      this.ora.start()
     }
 
     return {
@@ -67,6 +69,6 @@ export class Logger {
       log: this.verbose ? this.write : this.modify,
       pause: () => this.ora.stopAndPersist(),
       resume: () => this.ora.start(),
-    } as LogStep;
+    } as LogStep
   }
 }

src/nexe.ts

@@ -1,50 +1,55 @@
-import { compose } from "app-builder";
+import { NexeCompiler } from './compiler.js'
-import { NexeCompiler } from "./compiler";
+import type { NexeOptions, NexePatch } from './options.js'
-import { normalizeOptions, NexeOptions, NexePatch } from "./options";
+import { normalizeOptions } from './options.js'
-import resource from "./steps/resource";
+
-import clean from "./steps/clean";
+import resource from './steps/resource.js'
-import cli from "./steps/cli";
+import clean from './steps/clean.js'
-import bundle from "./steps/bundle";
+import cli from './steps/cli.js'
-import download from "./steps/download";
+import bundle from './steps/bundle.js'
-import shim from "./steps/shim";
+import download from './steps/download.js'
-import artifacts from "./steps/artifacts";
+import shim from './steps/shim.js'
-import patches from "./patches";
+import artifacts from './steps/artifacts.js'
+import patches from './patches/index.js'
+import { initEsm } from './util.js'
 
 async function compile(
   compilerOptions?: Partial<NexeOptions>,
   callback?: (err: Error | null) => void
 ) {
+  await initEsm()
   let error: Error | null = null,
     options: NexeOptions | null = null,
-    compiler: NexeCompiler | null = null;
+    compiler: NexeCompiler | null = null
 
   try {
-    options = normalizeOptions(compilerOptions);
+    options = normalizeOptions(compilerOptions)
-    compiler = new NexeCompiler(options);
+    compiler = new NexeCompiler(options)
-    await compose(
+    const plugins = options.plugins as NexePatch[],
-      clean,
+      buildSteps = options.build ? [artifacts, ...patches, ...(options.patches as NexePatch[])] : []
-      resource,
+    await exec([clean, resource, cli, bundle, shim, download, ...buildSteps, ...plugins], compiler)
-      cli,
-      bundle,
-      shim,
-      download,
-      options.build
-        ? [artifacts, ...patches, ...(options.patches as NexePatch[])]
-        : [],
-      options.plugins as NexePatch[]
-    )(compiler);
   } catch (e: any) {
-    error = e;
+    error = e
   }
 
   if (error) {
-    compiler && compiler.quit(error);
+    compiler?.quit(error)
-    if (callback) return callback(error);
+    if (callback) return callback(error)
-    return Promise.reject(error);
+    throw error
   }
 
-  if (callback) callback(null);
+  if (callback) callback(null)
 }
 
-export { compile, NexeCompiler };
+export { compile, NexeCompiler }
-export { argv, version, NexeOptions, help } from "./options";
+export { argv, version, help } from './options.js'
+export type { NexeOptions } from './options.js'
+
+function exec<T>(mw: any[], ctx: T): Promise<void> | void {
+  let i = -1
+  const nxt = (): void | Promise<void> => {
+    if (++i < mw.length) {
+      return mw[i](ctx, nxt)
+    }
+  }
+  return nxt()
+}

src/options.ts

@@ -1,138 +1,132 @@
-import parseArgv from "minimist";
+import { basename, extname, join, isAbsolute, resolve, dirname } from 'node:path'
-import { NexeCompiler, NexeError } from "./compiler";
+import { fileURLToPath } from 'node:url'
-import { isWindows, STDIN_FLAG } from "./util";
+import { EOL, homedir } from 'node:os'
-import { basename, extname, join, isAbsolute, resolve } from "path";
+import { globalAgent } from 'node:https'
-import { getTarget, NexeTarget } from "./target";
+import { createRequire } from 'node:module'
-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;
 
-export const version = "{{ version }}";
+const dir = typeof __dirname === 'string' ? __dirname : dirname(fileURLToPath(import.meta.url)),
+  cjs = createRequire(dir)
 
-export interface NexePatch {
+import { resolveSync } from 'resolve-dependencies'
-  (compiler: NexeCompiler, next: () => Promise<void>): Promise<void>;
+import parseArgv from 'minimist'
-}
 
-export interface ModuleBundleRule {
+import caw from 'caw'
-  include?: string[];
-  exclude?: string[];
-}
 
-export interface BundleRules {
+import type { NexeCompiler } from './compiler.js'
-  [moduleName: string]: ModuleBundleRule;
+import { NexeError } from './compiler.js'
-}
+import type { NexeTarget } from './target.js'
+import { getTarget } from './target.js'
+import { isWindows, STDIN_FLAG, esm } from './util.js'
+
+export const version = '{{replace:0}}'
+
+export type NexePatch = (compiler: NexeCompiler, next: () => Promise<void>) => Promise<void>
 
 export interface NexeOptions {
-  build: boolean;
+  build: boolean
-  input: string;
+  input: string
-  output: string;
+  output: string
-  targets: (string | NexeTarget)[];
+  targets: Array<string | NexeTarget>
-  name: string;
+  name: string
-  remote: string;
+  remote: string
-  asset: string;
+  asset: string
-  cwd: string;
+  cwd: string
-  fs: boolean | string[];
+  fs: boolean | string[]
-  flags: string[];
+  flags: string[]
-  configure: string[];
+  configure: string[]
-  vcBuild: string[];
+  vcBuild: string[]
-  make: string[];
+  make: string[]
-  snapshot?: string;
+  resources: string[]
-  resources: string[];
+  temp: string
-  temp: string;
+  enableNodeCli: boolean
-  rc: { [key: string]: string };
+  bundle: boolean | string
-  enableNodeCli: boolean;
+  patches: Array<string | NexePatch>
-  bundle: boolean | string;
+  plugins: Array<string | NexePatch>
-  bundleRules?: BundleRules;
+  native: any
-  patches: (string | NexePatch)[];
+  mangle: boolean
-  plugins: (string | NexePatch)[];
+  ghToken: string
-  native: any;
+  sourceUrl?: string
-  mangle: boolean;
+  enableStdIn?: boolean
-  ghToken: string;
+  python?: string
-  sourceUrl?: string;
+  loglevel: 'info' | 'silent' | 'verbose'
-  enableStdIn?: boolean;
+  silent?: boolean
-  python?: string;
+  fakeArgv?: boolean
-  loglevel: "info" | "silent" | "verbose";
+  verbose?: boolean
-  silent?: boolean;
+  info?: boolean
-  fakeArgv?: boolean;
+  debugBundle?: boolean
-  verbose?: boolean;
+  warmup?: string
-  info?: boolean;
+  clean?: boolean
-  ico?: string;
-  debugBundle?: boolean;
-  warmup?: string;
-  clean?: boolean;
   /**
    * Api Only
    */
-  downloadOptions: any;
+  downloadOptions: any
 }
 
 const defaults = {
-  flags: [],
+    flags: [],
-  cwd: process.cwd(),
+    cwd: process.cwd(),
-  fs: true,
+    fs: true,
-  configure: [],
+    configure: [],
-  mangle: true,
+    mangle: true,
-  make: [],
+    make: [],
-  targets: [],
+    targets: [],
-  vcBuild: isWindows ? ["nosign", "release"] : [],
+    vcBuild: isWindows ? ['nosign', 'release'] : [],
-  enableNodeCli: false,
+    enableNodeCli: false,
-  build: false,
+    build: false,
-  bundle: true,
+    bundle: true,
-  patches: [],
+    patches: [],
-  plugins: [],
+    plugins: [],
-  remote: `https://github.com/oxmc/nexe/releases/download/v${require('../package.json').version}/`,
+    remote: 'https://github.com/nexe/nexe/releases/download/v3.3.3/',
-};
+  },
-const alias = {
+  alias = {
-  i: "input",
+    i: 'input',
-  o: "output",
+    o: 'output',
-  v: "version",
+    v: 'version',
-  a: "asset",
+    a: 'asset',
-  t: "target",
+    t: 'target',
-  b: "build",
+    b: 'build',
-  n: "name",
+    n: 'name',
-  r: "resource",
+    r: 'resource',
-  p: "python",
+    p: 'python',
-  f: "flag",
+    f: 'flag',
-  c: "configure",
+    c: 'configure',
-  m: "make",
+    m: 'make',
-  h: "help",
+    h: 'help',
-  l: "loglevel",
+    l: 'loglevel',
-  "fake-argv": "fakeArgv",
+    'fake-argv': 'fakeArgv',
-  "gh-token": "ghToken",
+    'gh-token': 'ghToken',
-};
+  },
-const argv = parseArgv(process.argv, { alias, default: { ...defaults } });
+  argv = parseArgv(process.argv, { alias, default: { ...defaults } }),
-let help = `
+  help = () => {
-${c.bold("nexe <entry-file> [options]")}
+    const c = esm.chalk?.default as typeof import('chalk').default
+    return (
+      EOL +
+      `
+${c.bold('nexe <entry-file> [options]')}
 
-   ${c.underline.bold("Options:")}
+   ${c.underline.bold('Options:')}
 
   -i   --input                      -- application entry point
   -o   --output                     -- path to output file
-  -t   --target                     -- node version description
+  -t   --target                     --  * node version description
   -n   --name                       -- main app module name
-  -r   --resource                   -- *embed files (glob) within the binary
+  -r   --resource                   --  * embed additional files (glob) within the binary
-       --remote                     -- alternate location (URL) to download pre-built base (nexe) binaries from
+       --remote                     -- alternate root directory for pre-built base (nexe) binaries from
        --plugin                     -- extend nexe runtime behavior
 
-   ${c.underline.bold("Building from source:")}
+   ${c.underline.bold('Building from source:')}
 
   -b   --build                      -- build from source
-  -p   --python                     -- python3 (as python) executable path
+  -p   --python                     -- python3 executable path
-  -f   --flag                       -- *v8 flags to include during compilation
+  -f   --flag                       --  * v8 flags to include during compilation
-  -c   --configure                  -- *arguments to the configure step
+  -c   --configure                  --  * arguments to the configure step
-  -m   --make                       -- *arguments to the make/build step
+  -m   --make                       --  * arguments to the make/build step
-       --patch                      -- module with middleware default export for adding a build patch
+       --patch                      --  * extend patches applied to source
        --no-mangle                  -- used when generating base binaries, or when patching _third_party_main manually
-       --snapshot                   -- path to a warmup snapshot
+       --sourceUrl                  -- pass an alternate source tarball (node.tar.gz) url
-       --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:")}
+   ${c.underline.bold('Other options:')}
 
        --bundle                     -- custom bundling module with 'createBundle' export
        --temp                       -- temp file storage default '~/.nexe'
@@ -142,65 +136,50 @@ ${c.bold("nexe <entry-file> [options]")}
        --silent                     -- disable logging
        --verbose                    -- set logging to verbose
 
-       -* variable key name         * option can be used more than once`.trim();
+  "*" indicates an option can be used more than once`.trim() +
-help = EOL + help + EOL;
+      EOL
+    )
+  }
 
 function flatten(...args: any[]): string[] {
-  return ([] as string[]).concat(...args).filter((x) => x);
+  return ([] as string[]).concat(...args).filter((x) => x)
-}
-
-/**
- * Extract keys such as { "rc-CompanyName": "Node.js" } to
- * { CompanyName: "Node.js" }
- * @param {*} match
- * @param {*} options
- */
-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);
 }
 
 function extractLogLevel(options: NexeOptions) {
-  if (options.loglevel) return options.loglevel;
+  if (options.loglevel) return options.loglevel
-  if (options.silent) return "silent";
+  if (options.silent) return 'silent'
-  if (options.verbose) return "verbose";
+  if (options.verbose) return 'verbose'
-  return "info";
+  return 'info'
 }
 
 function isName(name: string) {
-  return name && name !== "index" && name !== STDIN_FLAG;
+  return name && name !== 'index' && name !== STDIN_FLAG
 }
 
 function extractName(options: NexeOptions) {
-  let name = options.name;
+  let name = options.name
-  //try and use the input filename as the output filename if its not index
+  // try and use the input filename as the output filename if its not index
-  if (!isName(name) && typeof options.input === "string") {
+  if (!isName(name) && typeof options.input === 'string') {
-    name = basename(options.input).replace(extname(options.input), "");
+    name = basename(options.input).replace(extname(options.input), '')
   }
-  //try and use the directory as the filename
+  // try and use the directory as the filename
   if (!isName(name) && basename(options.cwd)) {
-    name = basename(options.cwd);
+    name = basename(options.cwd)
   }
 
-  return name.replace(/\.exe$/, "");
+  return name.replace(/\.exe$/, '')
 }
 
 function padRelative(input: string) {
-  let prefix = "";
+  let prefix = ''
-  if (!input.startsWith(".")) {
+  if (!input.startsWith('.')) {
-    prefix = "./";
+    prefix = './'
   }
-  return prefix + input;
+  return prefix + input
 }
 
 function isEntryFile(filename?: string): filename is string {
-  return Boolean(filename && !isAbsolute(filename));
+  return Boolean(filename && !isAbsolute(filename))
 }
 
 export function resolveEntry(
@@ -209,117 +188,106 @@ export function resolveEntry(
   maybeEntry: string | undefined,
   bundle: boolean | string
 ) {
-  let result = null;
+  let result = null
-  if (input === "-" || maybeEntry === "-") {
+  if (input === '-' || maybeEntry === '-') {
-    return STDIN_FLAG;
+    return STDIN_FLAG
   }
   if (input && isAbsolute(input)) {
-    return input;
+    return input
   }
   if (input) {
-    const inputPath = padRelative(input);
+    const inputPath = padRelative(input)
-    result = resolveSync(cwd, inputPath);
+    result = resolveSync(cwd, inputPath)
   }
   if (isEntryFile(maybeEntry) && (!result || !result.absPath)) {
-    const inputPath = padRelative(maybeEntry);
+    const inputPath = padRelative(maybeEntry)
-    result = resolveSync(cwd, inputPath);
+    result = resolveSync(cwd, inputPath)
   }
-  if (
+  if (!process.stdin.isTTY && !result?.absPath && bundle === defaults.bundle) {
-    !process.stdin.isTTY &&
+    return STDIN_FLAG
-    (!result || !result.absPath) &&
-    bundle === defaults.bundle
-  ) {
-    return STDIN_FLAG;
   }
-  if (!result || !result.absPath) {
+  if (!result?.absPath) {
-    result = resolveSync(cwd, ".");
+    result = resolveSync(cwd, '.')
   }
   if (!result.absPath) {
-    throw new NexeError(`Entry file "${input || ""}" not found!`);
+    throw new NexeError(`Entry file "${input || maybeEntry}" not found!`)
   }
-  return result.absPath;
+  return result.absPath
 }
 
 function isCli(options?: Partial<NexeOptions>) {
-  return argv === options;
+  return argv === options
 }
 
 function normalizeOptions(input?: Partial<NexeOptions>): NexeOptions {
-  const options = Object.assign({}, defaults, input) as NexeOptions;
+  const options = Object.assign({}, defaults, input) as NexeOptions,
-  const opts = options as any;
+    opts = options as any,
-  const cwd = (options.cwd = resolve(options.cwd));
+    cwd = (options.cwd = resolve(options.cwd))
   options.temp = options.temp
     ? resolve(cwd, options.temp)
-    : process.env.NEXE_TEMP || join(homedir(), ".nexe");
+    : process.env.NEXE_TEMP || join(homedir(), '.nexe')
-  const maybeEntry = isCli(input) ? argv._[argv._.length - 1] : undefined;
+  const maybeEntry = isCli(input) ? argv._[argv._.length - 1] : undefined
-  options.input = resolveEntry(options.input, cwd, maybeEntry, options.bundle);
+  options.input = resolveEntry(options.input, cwd, maybeEntry, options.bundle)
-  options.enableStdIn = isCli(input) && options.input === STDIN_FLAG;
+  options.enableStdIn = isCli(input) && options.input === STDIN_FLAG
-  options.name = extractName(options);
+  options.name = extractName(options)
-  options.loglevel = extractLogLevel(options);
+  options.loglevel = extractLogLevel(options)
-  options.flags = flatten(opts.flag, options.flags);
+  options.flags = flatten(opts.flag, options.flags)
-  options.targets = flatten(opts.target, options.targets).map(getTarget);
+  options.targets = flatten(opts.target, options.targets).map(getTarget)
-  if (!options.targets.length) {
+  if (options.targets.length === 0) {
-    options.targets.push(getTarget());
+    options.targets.push(getTarget())
   }
-  options.ghToken = options.ghToken || process.env.GITHUB_TOKEN || "";
+  options.ghToken = options.ghToken || process.env.GITHUB_TOKEN || ''
-  options.make = flatten(isWindows ? options.vcBuild : options.make);
+  options.make = flatten(isWindows ? options.vcBuild : options.make)
-  options.configure = flatten(options.configure);
+  options.configure = flatten(options.configure)
-  options.resources = flatten(opts.resource, options.resources);
+  options.resources = flatten(opts.resource, options.resources)
 
-  if (!options.remote.endsWith("/")) {
+  if (!options.remote.endsWith('/')) {
-    options.remote += "/";
+    options.remote += '/'
   }
 
-  options.downloadOptions = options.downloadOptions || {};
+  options.downloadOptions = options.downloadOptions || {}
-  options.downloadOptions.headers = options.downloadOptions.headers || {};
+  options.downloadOptions.headers = options.downloadOptions.headers || {}
-  options.downloadOptions.headers["User-Agent"] =
+  options.downloadOptions.headers['User-Agent'] = 'nexe (https://www.npmjs.com/package/nexe)'
-    "nexe (https://www.npmjs.com/package/nexe)";
   options.downloadOptions.agent = process.env.HTTPS_PROXY
-    ? caw(process.env.HTTPS_PROXY, { protocol: "https" })
+    ? caw(process.env.HTTPS_PROXY, { protocol: 'https' })
-    : options.downloadOptions.agent || require("https").globalAgent;
+    : options.downloadOptions.agent || globalAgent
-  options.downloadOptions.rejectUnauthorized = process.env
+  options.downloadOptions.rejectUnauthorized = !process.env.NODE_TLS_REJECT_UNAUTHORIZED
-    .NODE_TLS_REJECT_UNAUTHORIZED
-    ? false
-    : true;
 
-  options.rc = options.rc || extractCliMap(/^rc-.*/, options);
   options.output =
-    (options.targets[0] as NexeTarget).platform === "windows"
+    (options.targets[0] as NexeTarget).platform === 'windows'
-      ? `${(options.output || options.name).replace(/\.exe$/, "")}.exe`
+      ? `${(options.output || options.name).replace(/\.exe$/, '')}.exe`
-      : `${options.output || options.name}`;
+      : `${options.output || options.name}`
-  options.output = resolve(cwd, options.output);
+  options.output = resolve(cwd, options.output)
 
   const requireDefault = (x: string) => {
-    if (typeof x === "string") {
+    if (typeof x === 'string') {
-      return require(x).default;
+      return cjs(x).default
     }
-    return x;
+    return x
-  };
+  }
 
-  options.mangle = "mangle" in opts ? opts.mangle : true;
+  options.mangle = 'mangle' in opts ? opts.mangle : true
-  options.plugins = flatten(opts.plugin, options.plugins).map(requireDefault);
+  options.plugins = flatten(opts.plugin, options.plugins).map(requireDefault)
-  options.patches = flatten(opts.patch, options.patches).map(requireDefault);
+  options.patches = flatten(opts.patch, options.patches).map(requireDefault)
 
-  if ((!options.mangle && !options.bundle) || options.patches.length) {
+  if ((!options.mangle && !options.bundle) || options.patches.length > 0) {
-    options.build = true;
+    options.build = true
   }
 
   if (options.build) {
-    const { arch } = options.targets[0] as NexeTarget;
+    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(
+      options.configure = Array.from(new Set(options.configure.concat([`--dest-cpu=${arch}`])))
-        new Set(options.configure.concat([`--dest-cpu=${arch}`]))
-      );
     }
   }
 
   Object.keys(alias)
-    .filter((k) => k !== "rc")
+    .filter((k) => k !== 'rc')
-    .forEach((x) => delete opts[x]);
+    .forEach((x) => delete opts[x])
 
-  return options;
+  return options
 }
 
-export { argv, normalizeOptions, help };
+export { argv, normalizeOptions, help }

src/patches/boot-nexe.ts

@@ -1,57 +1,36 @@
-const fs = require("fs"),
+/* eslint-disable @typescript-eslint/no-var-requires */
-  fd = fs.openSync(process.execPath, "r"),
+const fs = require('fs')
-  stat = fs.fstatSync(fd),
+const fd = fs.openSync(process.execPath, 'r'),
+  stat = fs.statSync(process.execPath),
   tailSize = Math.min(stat.size, 16000),
-  tailWindow = Buffer.alloc(tailSize),
+  tailWindow = Buffer.from(Array(tailSize))
-  match = "<nexe" + "~~sentinel>",
-  matchLength = match.length,
-  lastBuffer = Buffer.alloc(matchLength + 32);
 
-let offset = stat.size,
+fs.readSync(fd, tailWindow, 0, tailSize, stat.size - tailSize)
-  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;
-}
 
+const footerPosition = tailWindow.indexOf('<nexe~~sentinel>')
 if (footerPosition == -1) {
-  throw "Invalid Nexe binary";
+  process.stderr.write('\nInvalid Nexe binary\n')
+  process.exit(1)
 }
 
-const contentSize = footer!.readDoubleLE(16),
+const footer = tailWindow.slice(footerPosition, footerPosition + 32),
-  resourceSize = footer!.readDoubleLE(24),
+  contentSize = footer.readDoubleLE(16),
-  contentStart =
+  resourceSize = footer.readDoubleLE(24),
-    offset - tailSize + footerPosition - resourceSize - contentSize,
+  contentStart = stat.size - tailSize + footerPosition - resourceSize - contentSize,
-  resourceStart = contentStart + contentSize;
+  resourceStart = contentStart + contentSize
 
 Object.defineProperty(
   process,
-  "__nexe",
+  '__nexe',
   (function () {
-    let nexeHeader: any = null;
+    let nexeHeader: any = null
     return {
       get: function () {
-        return nexeHeader;
+        return nexeHeader
       },
       set: function (value: any) {
         if (nexeHeader) {
-          throw new Error("This property is readonly");
+          throw new Error('This property is readonly')
         }
         nexeHeader = Object.assign({}, value, {
           blobPath: process.execPath,
@@ -62,38 +41,19 @@ Object.defineProperty(
             resourceSize,
             resourceStart,
           },
-        });
+        })
-        Object.freeze(nexeHeader);
+        Object.freeze(nexeHeader)
       },
       enumerable: false,
       configurable: false,
-    };
+    }
   })()
-);
+)
 
-const contentBuffer = Buffer.alloc(contentSize),
+const contentBuffer = Buffer.from(Array(contentSize))
-  Module = require("module");
+const Module = require('module')
 
-fs.readSync(fd, contentBuffer, 0, contentSize, contentStart);
+fs.readSync(fd, contentBuffer, 0, contentSize, contentStart)
-fs.closeSync(fd);
+fs.closeSync(fd)
 
-// Node 24 changed finalizeResolution in the ESM loader to no longer catch ENOENT
+new Module(process.execPath, null)._compile(contentBuffer.toString(), process.execPath)
-// 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
-);

src/patches/build-fixes.ts

@@ -1,18 +0,0 @@
-import { NexeCompiler } from "../compiler";
-
-export default async function buildFixes(
-  compiler: NexeCompiler,
-  next: () => Promise<void>
-) {
-  if (!compiler.target.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'
-  );
-
-  return next();
-}

src/patches/disable-node-cli.ts

@@ -1,61 +1,20 @@
-import { NexeCompiler } from "../compiler";
+import type { NexeCompiler } from '../compiler.js'
-import { semverGt } from "../util";
+import { NexeError } from '../compiler.js'
+import { semverGt } from '../util.js'
 
-export default async function disableNodeCli(
+export default async function disableNodeCli(compiler: NexeCompiler, next: () => Promise<void>) {
-  compiler: NexeCompiler,
-  next: () => Promise<void>
-) {
   if (compiler.options.enableNodeCli) {
-    return next();
+    return await next()
   }
 
-  if (semverGt(compiler.target.version, "18.99")) {
+  const [regex, replacement] = semverGt(compiler.target.version, '18.99')
-    await compiler.replaceInFileAsync(
+      ? [/(?<!int )ProcessGlobalArgsInternal\(argv[^;]*;/gm, 'ExitCode::kNoFailure']
-      "src/node.cc",
+      : [/(?<!int )ProcessGlobalArgs\(argv[^;]*;/gm, 0],
-      /(?<!static ExitCode )ProcessGlobalArgsInternal\(argv[^;]*;/gm,
+    replaced = await compiler.replaceInFileAsync('src/node.cc', regex, `${replacement};/*$&*/`)
-      "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] ==";
 
-    await compiler.replaceInFileAsync(
+  if (!replaced) {
-      "src/node.cc",
+    throw new NexeError('There was an error applying the Node CLI patch. Please open an issue.')
-      `${nodeccMarker} '-'`,
-      // allow NODE_OPTIONS, introduced in 8.0
-      semverGt(compiler.target.version, "7.99")
-        ? `(${nodeccMarker} (is_env ? '-' : ']'))`
-        : `(${nodeccMarker} ']')`
-    );
   }
 
-  return next();
+  return await next()
 }

src/patches/flags.ts

@@ -1,19 +1,21 @@
-import { NexeCompiler } from "../compiler";
+import type { NexeCompiler } from '../compiler.js'
+import { NexeError } from '../compiler.js'
 
-export default async function flags(
+export default async function flags(compiler: NexeCompiler, next: () => Promise<void>) {
-  compiler: NexeCompiler,
+  const nodeflags = compiler.options.flags
-  next: () => Promise<void>
+  if (nodeflags.length === 0) {
-) {
+    return await next()
-  const nodeflags = compiler.options.flags;
-  if (!nodeflags.length) {
-    return next();
   }
 
-  await compiler.replaceInFileAsync(
+  const replaced = await compiler.replaceInFileAsync(
-    "node.gyp",
+    'node.gyp',
     "'node_v8_options%': ''",
-    `'node_v8_options%': '${nodeflags.join(" ")}'`
+    `'node_v8_options%': '${nodeflags.join(' ')}'`
-  );
+  )
 
-  return next();
+  if (!replaced) {
+    throw new NexeError('Node Flags not applied. Please report an issue')
+  }
+
+  return await next()
 }

src/patches/fs-stat-debug.ts

@@ -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()
-}

src/patches/gyp.ts

@@ -1,21 +0,0 @@
-import { NexeCompiler } from "../compiler";
-
-export default async function nodeGyp(
-  { files, replaceInFileAsync }: NexeCompiler,
-  next: () => Promise<void>
-) {
-  await next();
-
-  const nodeGypMarker = "'lib/fs.js',";
-  await replaceInFileAsync(
-    "node.gyp",
-    nodeGypMarker,
-    `
-    ${nodeGypMarker}
-    ${files
-        .filter((x) => x.filename.startsWith("lib"))
-        .map((x) => `'${x.filename}'`)
-        .toString()},
-  `.trim()
-  );
-}

src/patches/ico.ts

@@ -1,18 +0,0 @@
-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;
-  if (!iconFile) {
-    return next();
-  }
-  await compiler.setFileContentsAsync(
-    "src/res/node.ico",
-    await readFileAsync(normalize(iconFile))
-  );
-  return next();
-}

src/patches/index.ts

@@ -1,15 +1,7 @@
-import gyp from "./gyp";
+import bootNexe from './third-party-main.js'
-import bootNexe from "./third-party-main";
+import cli from './disable-node-cli.js'
-import buildFixes from "./build-fixes";
+import flags from './flags.js'
-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";
 
-// Patches are applied in order, so if a patch depends on another patch, it should be listed after the patch it depends on.
+const patches = [bootNexe, cli, flags]
-// 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];
 
-export default patches;
+export default patches

src/patches/node-rc.ts

@@ -1,31 +0,0 @@
-import { NexeCompiler } from "../compiler";
-
-export default async function nodeRc(
-  compiler: NexeCompiler,
-  next: () => Promise<void>
-) {
-  const options = compiler.options.rc;
-  if (!options) {
-    return next();
-  }
-
-  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]}`);
-    }
-  });
-
-  return next();
-}

src/patches/snapshot.ts

@@ -1,32 +0,0 @@
-import { resolve } from "path";
-import { NexeCompiler } from "../compiler";
-import { semverGt } from "../util";
-
-export default async function (
-  compiler: NexeCompiler,
-  next: () => Promise<void>
-) {
-  const { snapshot, warmup, cwd } = compiler.options;
-
-  if (!snapshot) {
-    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
-    )}'`
-  );
-
-  return next();
-}

src/patches/third-party-main.ts

@@ -1,131 +1,88 @@
-import { NexeCompiler } from "../compiler";
+import { parse } from 'meriyah'
-import { parse } from "meriyah";
+import type { NexeCompiler } from '../compiler.js'
-import { wrap, semverGt } from "../util";
+import { NexeError } from '../compiler.js'
+import { wrap, semverGt } from '../util.js'
 
-function walkSome(node: any, visit: Function) {
+export default async function main(compiler: NexeCompiler, next: () => Promise<void>) {
-  if (!node || typeof node.type !== "string" || node._visited) {
+  let bootFile = 'lib/internal/bootstrap/pre_execution.js'
-    return false;
+  if (semverGt(compiler.target.version, '18.11.99')) {
+    bootFile = 'lib/internal/process/pre_execution.js'
   }
-  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;
-        }
-      }
-    } else if (walkSome(child, visit)) {
-      return true;
-    }
-  }
-  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,
+      specDeviation: true,
     }),
-    location = { start: { line: 0 } };
+    location = { start: { line: 0 } }
 
   walkSome(ast, (node: any) => {
-    if (!location.start.line && node.type === "BlockStatement") {
+    if (!location.start.line && node.type === 'BlockStatement') {
-      //Find the first block statement and mark the location
+      // Find the first block statement and mark the location
-      Object.assign(location, node.loc);
+      Object.assign(location, node.loc)
-      return true;
+      return true
     }
-  });
+  })
 
-  const fileLines = file.contents.toString().split("\n");
+  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")) {
+  fileLines.splice(
-    if (semverGt(version, "12.17.99")) {
+    location.start.line,
-      await compiler.replaceInFileAsync(
+    0,
-        bootFile,
+    '{{replace:lib/MOD/fs/bootstrap.js}}' + '\n' + 'expandArgv1 = false;\n'
-        "initializeFrozenIntrinsics();",
+  )
-        "initializeFrozenIntrinsics();\n" +
+  file.contents = fileLines.join('\n')
-        wrap('{{ file("lib/patches/boot-nexe.js") }}')
+
-      );
+  const boot = await compiler.replaceInFileAsync(
-    } else {
-      await compiler.replaceInFileAsync(
-        bootFile,
-        "initializePolicy();",
-        "initializePolicy();\n" + wrap('{{ file("lib/patches/boot-nexe.js") }}')
-      );
-    }
-    await compiler.replaceInFileAsync(
       bootFile,
-      "assert(!CJSLoader.hasLoadedAnyUserCJSModule)",
+      'initializeFrozenIntrinsics();',
-      "/*assert(!CJSLoader.hasLoadedAnyUserCJSModule)*/"
+      'initializeFrozenIntrinsics();\n' + wrap('{{replace:lib/MOD/patches/boot-nexe.js}}')
-    );
+    ),
-    // Node 22.22+ / 24 removed the ENOENT catch from finalizeResolution in the
+    userModuleAssertion = await compiler.replaceInFileAsync(
-    // ESM resolver. realpathSync calls binding.lstat which throws ENOENT for VFS
+      bootFile,
-    // paths (they don't exist on real FS). Restore the catch so VFS imports work.
+      'assert(!CJSLoader.hasLoadedAnyUserCJSModule)',
-    await compiler.replaceInFileAsync(
+      '/*assert(!CJSLoader.hasLoadedAnyUserCJSModule)*/'
-      "lib/internal/modules/esm/resolve.js",
+    ),
-      /const real = realpathSync\(path, \{ encoding: ['"]utf8['"] \}\);/,
+    workerSupport = await compiler.replaceInFileAsync(
-      "let real; try { real = realpathSync(path, { encoding: 'utf8' }); } catch (e) { if (e.code !== 'ENOENT') throw e; real = path; }"
+      'src/node.cc',
-    );
+      'if (env->worker_context() != nullptr) {',
-    const { contents: nodeccContents } = await compiler.readFileAsync(
+      'if (env->worker_context() == nullptr) {\n' +
-      "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(
+  assertPatches({ boot, userModuleAssertion, workerSupport })
-        "src/node.cc",
+
-        "MaybeLocal<Value> StartMainThreadExecution(Environment* env) {",
+  return await next()
-        "MaybeLocal<Value> StartMainThreadExecution(Environment* env) {\n" +
+}
-        '  return StartExecution(env, "internal/main/run_main_module");\n'
+
-      );
+function assertPatches(patches: Record<string, boolean>) {
-    }
+  if (!Object.values(patches).every((x) => x)) {
-  } else {
+    let message = ''
-    await compiler.setFileContentsAsync(
+    Object.entries(patches).forEach(([k, v]) => {
-      "lib/_third_party_main.js",
+      if (!v) message += `\nFailed to apply patch for: "${k}". Please open an issue.`
-      '{{ file("lib/patches/boot-nexe.js") }}'
+    })
-    );
+    throw new NexeError(message.trim())
-  }
+  }
-  return next();
+}
+
+function walkSome(node: any, visit: (node: any) => boolean | undefined) {
+  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
+        }
+      }
+    } else if (walkSome(child, visit)) {
+      return true
+    }
+  }
+  return false
 }

src/releases.ts

@@ -1,76 +1,64 @@
-import axios from "axios";
+import { platforms, architectures, NexeTarget, getTarget, targetsEqual } from './target.js'
-import {
+export { NexeTarget }
-  platforms,
-  architectures,
-  NexeTarget,
-  getTarget,
-  targetsEqual,
-} from "./target";
-export { NexeTarget };
 
-const versionsToSkip = [
+const versionsToSkip = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 13, 15, 17, 19, 21, 22]
-  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 13, 15, 17, 19, 21, 22,
-];
 export interface GitAsset {
-  name: string;
+  name: string
-  url: string;
+  url: string
-  browser_download_url: string;
+  browser_download_url: string
 }
 
 export interface GitRelease {
-  tag_name: string;
+  tag_name: string
-  assets_url: string;
+  assets_url: string
-  upload_url: string;
+  upload_url: string
-  assets: GitAsset[];
+  assets: GitAsset[]
 }
 
 interface NodeRelease {
-  version: string;
+  version: string
 }
 
-async function getJson<T>(url: string, options?: any): Promise<T> {
+async function getJson<T>(url: string, options?: any) {
-  const response = await axios.get(url, options);
+  const { default: got } = await import('got')
-  return response.data as T;
+  return JSON.parse((await got(url, options)).body) as T
 }
 
 function isBuildableVersion(version: string) {
-  if (version === "12.11.0") {
+  if (version === '12.11.0') {
-    return false;
+    return false
   }
-  return !versionsToSkip.includes(Number(version.split(".")[0]));
+  return !versionsToSkip.includes(Number(version.split('.')[0]))
 }
 
-export function getLatestGitRelease(options?: any): Promise<GitRelease> {
+export async function getLatestGitRelease(options?: any) {
-  return getJson<GitRelease>(
+  return await getJson<GitRelease>(
-    "https://api.github.com/repos/nexe/nexe/releases/latest",
+    'https://api.github.com/repos/nexe/nexe/releases/latest',
     options
-  );
+  )
 }
 
 export async function getUnBuiltReleases(options?: any) {
   const nodeReleases = await getJson<NodeRelease[]>(
-    "https://nodejs.org/download/release/index.json"
+      'https://nodejs.org/download/release/index.json'
-  );
+    ),
-  const existingVersions = (await getLatestGitRelease(options)).assets.map(
+    existingVersions = (await getLatestGitRelease(options)).assets.map((x) => getTarget(x.name)),
-    (x) => getTarget(x.name)
+    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;
+      versionMap[version] = true
       platforms.forEach((platform) => {
         architectures.forEach((arch) => {
-          if (arch === "x86" && platform === "mac") return;
+          if (arch === 'x86' && platform === 'mac') return
-          if (arch.includes("arm")) return;
+          if (arch.includes('arm')) return
-          versions.push(getTarget({ platform, arch, version }));
+          versions.push(getTarget({ platform, arch, version }))
-        });
+        })
-      });
+      })
-      return versions;
+      return versions
     }, [])
-    .filter((x) => !existingVersions.some((t) => targetsEqual(t, x)));
+    .filter((x) => !existingVersions.some((t) => targetsEqual(t, x)))
 }

src/steps/artifacts.ts

@@ -1,35 +1,27 @@
-import { join, dirname } from "path";
+import { join, dirname } from 'node:path'
-import * as fs from "fs";
+import { unlink, readdir, mkdir } from 'node:fs/promises'
-import { promisify } from "util";
-import { readFileAsync, writeFileAsync, isDirectoryAsync } from "../util";
-import mkdirpAsync = require("mkdirp");
-import { NexeCompiler } from "../compiler";
 
-const unlinkAsync = promisify(fs.unlink),
+import { readFile, writeFile, isDirectory } from '../util.js'
-  readdirAsync = promisify(fs.readdir);
+import type { NexeCompiler } from '../compiler.js'
 
-function readDirAsync(dir: string): Promise<string[]> {
+async function readDirAsync(dir: string): Promise<string[]> {
-  return readdirAsync(dir).then((paths) => {
+  return await readdir(dir).then(async (paths) => {
-    return Promise.all(
+    return await Promise.all(
-      paths.map((file: string) => {
+      paths.map(async (file: string) => {
-        const path = join(dir, file);
+        const path = join(dir, file)
-        return isDirectoryAsync(path).then((x) =>
+        return await isDirectory(path).then((x) => (x ? readDirAsync(path) : (path as any)))
-          x ? readDirAsync(path) : (path as any)
-        );
       })
-    ).then((result) => {
+    ).then((result) => result.flat())
-      return [].concat(...(result as any));
+  })
-    });
-  });
 }
 
-function maybeReadFileContentsAsync(file: string) {
+async function maybeReadFileContentsAsync(file: string) {
-  return readFileAsync(file, "utf-8").catch((e) => {
+  return await readFile(file, 'utf-8').catch((e) => {
-    if (e.code === "ENOENT") {
+    if (e.code === 'ENOENT') {
-      return "";
+      return ''
     }
-    throw e;
+    throw e
-  });
+  })
 }
 
 /**
@@ -41,36 +33,30 @@ function maybeReadFileContentsAsync(file: string) {
  *  - 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(
+export default async function artifacts(compiler: NexeCompiler, next: () => Promise<void>) {
-  compiler: NexeCompiler,
+  const { src } = compiler,
-  next: () => Promise<void>
+    temp = join(src, 'nexe')
-) {
+  await mkdir(temp, { recursive: true })
-  const { src } = compiler;
+  const tmpFiles = await readDirAsync(temp)
-  const temp = join(src, "nexe");
-  await mkdirpAsync(temp);
-  const tmpFiles = await readDirAsync(temp);
 
   await Promise.all(
     tmpFiles.map(async (path) => {
-      return compiler.writeFileAsync(
+      return await compiler.writeFileAsync(path.replace(temp, ''), await readFile(path, 'utf-8'))
-        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(async (x) => await unlink(x)))
-  return Promise.all(
+  return await Promise.all(
     compiler.files.map(async (file) => {
-      const sourceFile = join(src, file.filename);
+      const sourceFile = join(src, file.filename),
-      const tempFile = join(temp, file.filename);
+        tempFile = join(temp, file.filename),
-      const fileContents = await maybeReadFileContentsAsync(sourceFile);
+        fileContents = await maybeReadFileContentsAsync(sourceFile)
 
-      await mkdirpAsync(dirname(tempFile));
+      await mkdir(dirname(tempFile), { recursive: true })
-      await writeFileAsync(tempFile, fileContents);
+      await writeFile(tempFile, fileContents)
-      await compiler.writeFileAsync(file.filename, file.contents);
+      await compiler.writeFileAsync(file.filename, file.contents)
     })
-  );
+  )
 }

src/steps/bundle.ts

@@ -1,294 +1,84 @@
-import { NexeCompiler, NexeError } from "../compiler";
+import { resolve, relative } from 'node:path'
-import { resolve, relative, sep, join } from "path";
+import type { Readable } from 'node:stream'
-import resolveFiles, { resolveSync } from "resolve-dependencies";
+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 = {
+import type { NexeCompiler } from '../compiler.js'
-  include?: string[];
+import { NexeError } from '../compiler.js'
-  exclude?: string[];
+import { dequote, STDIN_FLAG } from '../util.js'
-};
 
-function getModuleName(file: string): string | null {
+async function getStdIn(stdin: Readable): Promise<string> {
-  const parts = file.split(/[\\/]/);
+  let out = ''
-  const idx = parts.lastIndexOf("node_modules");
+  return await new Promise((resolve) => {
-  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")
+      .setEncoding('utf8')
-      .on("readable", () => {
+      .on('readable', () => {
-        let current;
+        let current
         while ((current = stdin.read())) {
-          out += current;
+          out += current
         }
       })
-      .on("end", () => resolve(out.trim()));
+      .on('end', () => resolve(out.trim()))
     setTimeout(() => {
       if (!out.trim()) {
-        resolve(out.trim());
+        resolve(out.trim())
       }
-    }, 1000);
+    }, 1000)
-  });
+  })
 }
 
 export default async function bundle(compiler: NexeCompiler, next: any) {
-  const { bundle: doBundle, cwd, input: inputPath, bundleRules } = compiler.options;
+  const { bundle: doBundle, cwd, input: inputPath } = compiler.options
-  
+  let input = inputPath
-  const rules: Record<string, ModuleRule> =
+  compiler.entrypoint = './' + relative(cwd, input)
-    bundleRules && Object.keys(bundleRules).length ? bundleRules : {};
+  compiler.startup = ''
-
-  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));
+    await compiler.addResource(resolve(cwd, input))
-    return next();
+    return next()
   }
 
-  let code = "";
+  let code = ''
-  if (typeof doBundle === "string") {
+  if (typeof doBundle === 'string') {
-    code = await require(doBundle).createBundle(compiler.options);
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    code = await require(doBundle).createBundle(compiler.options)
   }
 
-  if (
+  if (input === STDIN_FLAG && (code = code || dequote(await getStdIn(process.stdin)))) {
-    input === STDIN_FLAG &&
+    compiler.stdinUsed = true
-    (code = code || dequote(await getStdIn(process.stdin)))
+    compiler.entrypoint = './__nexe_stdin.js'
-  ) {
+    await compiler.addResource(resolve(cwd, compiler.entrypoint), code)
-    compiler.stdinUsed = true;
+    return next()
-    compiler.entrypoint = "./__nexe_stdin.js";
-    await compiler.addResource(resolve(cwd, compiler.entrypoint), code);
-    return next();
   }
 
   if (input === STDIN_FLAG) {
-    const maybeInput = resolveSync(cwd, ".");
+    const maybeInput = resolveSync(cwd, '.')
     if (!maybeInput || !maybeInput.absPath) {
-      throw new NexeError("No valid input detected");
+      throw new NexeError('No valid input detected')
     }
-    input = maybeInput.absPath;
+    input = maybeInput.absPath
-    compiler.entrypoint = "./" + relative(cwd, input);
+    compiler.entrypoint = './' + relative(cwd, input)
   }
 
-  const step = compiler.log.step("Resolving dependencies...");
+  const { files, warnings } = resolveFiles(
-
+    input,
-  const { files, warnings } = await resolveFiles(input, {
+    ...Object.keys(compiler.bundle.list).filter((x) => x.endsWith('.js')),
-    cwd,
+    { cwd, expand: 'variable', loadContent: false }
-    expand: "variable",
+  )
-    loadContent: false,
-  });
 
   if (
-    warnings.filter(
+    warnings.filter((x) => x.startsWith('Error parsing file') && !x.includes('node_modules'))
-      (x) => x.startsWith("Error parsing file") && !x.includes("node_modules")
+      .length > 0
-    ).length
   ) {
-    throw new NexeError("Parsing Error:\n" + warnings.join("\n"));
+    throw new NexeError('Parsing Error:\n' + warnings.join('\n'))
   }
 
-  // If no bundle rules, use original behavior
+  warnings.forEach((x: string) => compiler.log.step('[WARNING]: ' + x, 'stopAndPersist', 'yellow'))
-  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) => {
+    Object.entries(files).map(async ([key, file]) => {
-      step.log(`Including dependency: ${file}`);
+      return await compiler.addResource(key, file)
-      return compiler.addResource(file);
     })
-  );
+  )
 
-  return next();
+  return next()
-}
+}

src/steps/clean.ts

@@ -1,24 +1,20 @@
-import { NexeCompiler } from "../compiler";
+import { rm } from 'node:fs/promises'
-import { rimrafAsync } from "../util";
-import { NexeTarget } from "../target";
 
-export default async function clean(
+import type { NexeCompiler } from '../compiler.js'
-  compiler: NexeCompiler,
+import type { NexeTarget } from '../target.js'
-  next: () => Promise<any>
+
-) {
+export default async function clean(compiler: NexeCompiler, next: () => Promise<any>) {
-  const { options } = compiler;
+  const { options } = compiler
   if (options.clean) {
-    let path = compiler.src;
+    let path = compiler.src
     if (!options.build) {
-      path = compiler.getNodeExecutableLocation(
+      path = compiler.getNodeExecutableLocation(compiler.options.targets[0] as NexeTarget)
-        compiler.options.targets[0] as NexeTarget
-      );
     }
-    const step = compiler.log.step("Cleaning up nexe build artifacts...");
+    const step = compiler.log.step('Cleaning up nexe build artifacts...')
-    step.log(`Deleting contents at: ${path}`);
+    step.log(`Deleting contents at: ${path}`)
-    await rimrafAsync(path);
+    await rm(path, { recursive: true, force: true })
-    step.log(`Deleted contents at: ${path}`);
+    step.log(`Deleted contents at: ${path}`)
-    return compiler.quit();
+    return await compiler.quit()
   }
-  return next();
+  return await next()
 }

src/steps/cli.ts

@@ -1,17 +1,8 @@
-import { platform } from "os";
+import { dirname, normalize, relative, resolve } from 'node:path'
-import { dirname, normalize, relative, resolve } from "path";
+import { createWriteStream, chmodSync, statSync, mkdirSync } from 'node:fs'
-import {
+import type { NexeCompiler } from '../compiler.js'
-  createWriteStream,
+import type { NexeTarget } from '../target.js'
-  chmodSync,
+import { STDIN_FLAG } from '../util.js'
-  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");
 
 /**
  * The "cli" step detects the appropriate input. If no input options are passed,
@@ -23,53 +14,45 @@ import mkdirp = require("mkdirp");
  * @param {*} compiler
  * @param {*} next
  */
-export default async function cli(
+export default async function cli(compiler: NexeCompiler, next: () => Promise<void>) {
-  compiler: NexeCompiler,
+  await next()
-  next: () => Promise<void>
-) {
-  await next();
   const { log } = compiler,
     target = compiler.options.targets.shift() as NexeTarget,
     deliverable = await compiler.compileAsync(target),
-    output = normalize(compiler.output!);
+    output = normalize(compiler.output)
 
-  mkdirp.sync(dirname(output));
+  mkdirSync(dirname(output), { recursive: true })
 
-  return new Promise((res, rej) => {
+  return await new Promise((res, rej) => {
-    const step = log.step("Writing result to file");
+    const step = log.step('Writing result to file')
     deliverable
       .pipe(createWriteStream(output))
-      .on("error", rej)
+      .on('error', rej)
-      .once("close", () => {
+      .once('close', (e: Error) => {
-        if (compiler.output) {
+        if (e) {
+          rej(e)
+        } else if (compiler.output) {
           const output = compiler.output,
             mode = statSync(output).mode | 0o111,
             inputFileLogOutput = relative(
               process.cwd(),
-              resolve(
+              resolve(compiler.options.cwd, compiler.entrypoint || compiler.options.input)
-                compiler.options.cwd,
-                compiler.entrypoint || compiler.options.input
-              )
             ),
-            outputFileLogOutput = relative(process.cwd(), output);
+            outputFileLogOutput = relative(process.cwd(), output)
 
-          if (platform() === "darwin") {
+          chmodSync(output, mode.toString(8).slice(-3))
-            step.log("Preparing binary for macOS signing.");
-            writeFileSync(output, patchMachOExecutable(readFileSync(output)));
-          }
-
-          chmodSync(output, mode.toString(8).slice(-3));
           step.log(
-            `Entry: '${compiler.stdinUsed
+            `Entry: '${
-              ? compiler.options.mangle
+              compiler.stdinUsed
-                ? STDIN_FLAG
+                ? compiler.options.mangle
-                : "[none]"
+                  ? STDIN_FLAG
-              : inputFileLogOutput
+                  : '[none]'
+                : inputFileLogOutput
             }' written to: ${outputFileLogOutput}`
-          );
+          )
-          compiler.quit();
+          compiler.quit()
-          res(output);
+          res(output)
         }
-      });
+      })
-  });
+  })
 }

src/steps/download.ts

@@ -1,126 +1,52 @@
-import axios from "axios";
+import { dirname } from 'node:path'
-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";
 
-async function downloadWithProgress(
+import download from 'download'
-  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({
+import { pathExists } from '../util.js'
-    url,
+import type { LogStep } from '../logger.js'
-    method: "GET",
+import type { NexeCompiler } from '../compiler.js'
-    responseType: "stream",
+import { NexeError } from '../compiler.js'
-    ...options,
-  });
 
-  const total = parseInt(String(response.headers["content-length"] || "0"), 10);
+import type { IncomingMessage } from 'node:http'
-  let current = 0;
 
-  // Create write stream
+function fetchNodeSourceAsync(dest: string, url: string, step: LogStep, options = {}) {
-  const writer = createWriteStream(dest);
+  const setText = (p: number) => step.modify(`Downloading Node: ${p.toFixed()}%...`)
-
+  return download(url, dest, Object.assign(options, { extract: true, strip: 1 }))
-  // Handle progress
+    .on('response', (res: IncomingMessage) => {
-  response.data.on("data", (chunk: Buffer) => {
+      const total = Number(res.headers['content-length'])
-    current += chunk.length;
+      let current = 0
-    if (step && total > 0) {
+      res.on('data', (data) => {
-      step.modify(`Downloading...${((current / total) * 100).toFixed()}%`);
+        current += data.length
-    }
+        setText((current / total) * 100)
-  });
+        if (current === total) {
-
+          step.log('Extracting Node...')
-  // 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,
     })
-  );
+    .then(() => step.log(`Node source extracted to: ${dest}`))
-
-  // 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);
+    filename = compiler.getNodeExecutableLocation(target)
 
   try {
-    await downloadWithProgress(
+    await download(remoteAsset, dirname(filename), compiler.options.downloadOptions).on(
-      remoteAsset,
+      'response',
-      filename,
+      (res: IncomingMessage) => {
-      compiler.options.downloadOptions,
+        const total = Number(res.headers['content-length'])
-      step
+        let current = 0
-    );
+        res.on('data', (data) => {
+          current += data.length
+          step?.modify(`Downloading...${((current / total) * 100).toFixed()}%`)
+        })
+      }
+    )
   } catch (e: any) {
-    if (e.response?.status === 404) {
+    if (e.statusCode === 404) {
-      throw new NexeError(
+      throw new NexeError(`${remoteAsset} is not available, create it using the --build flag`)
-        `${remoteAsset} is not available, create it using the --build flag`
-      );
     } else {
-      throw new NexeError("Error downloading prebuilt binary: " + e.message);
+      throw new NexeError('Error downloading prebuilt binary: ' + e)
     }
   }
 }
@@ -130,40 +56,27 @@ async function fetchPrebuiltBinary(compiler: NexeCompiler, step: any) {
  * @param {*} compiler
  * @param {*} next
  */
-export default async function downloadNode(
+export default async function downloadNode(compiler: NexeCompiler, next: () => Promise<void>) {
-  compiler: NexeCompiler,
-  next: () => Promise<void>
-) {
   const { src, log, target } = compiler,
     { version } = target,
     { sourceUrl, downloadOptions, build } = compiler.options,
-    url =
+    url = sourceUrl || `https://nodejs.org/dist/v${version}/node-v${version}.tar.gz`,
-      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}` : ""
+      `Downloading ${build ? '' : 'pre-built '}Node.js${build ? ` source from: ${url}` : ''}`
-      }`
     ),
-    exeLocation = compiler.getNodeExecutableLocation(
+    exeLocation = compiler.getNodeExecutableLocation(build ? undefined : target),
-      build ? undefined : target
+    downloadExists = await pathExists(build ? src : exeLocation)
-    ),
-    downloadExists = await pathExistsAsync(build ? src : exeLocation);
 
   if (downloadExists) {
-    step.log("Already downloaded...");
+    step.log('Already downloaded...')
-    return next();
+    return await next()
   }
 
   if (build) {
-    await fetchNodeSourceAsync(src, url, step, downloadOptions);
+    await fetchNodeSourceAsync(src, url, step, downloadOptions)
   } else {
-    await fetchPrebuiltBinary(compiler, step);
+    await fetchPrebuiltBinary(compiler, step)
   }
 
-  return next();
+  return await next()
-}
-
-// Helper function to create a readable stream
-function createReadStream(path: string) {
-  return require("fs").createReadStream(path);
 }

src/steps/mach-o.ts

@@ -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 };

src/steps/resource.ts

@@ -1,33 +1,34 @@
-import { each } from "../util";
+import { relative } from 'node:path'
-import globs from "globby";
-import { resolve } from "path";
-import { NexeCompiler } from "../compiler";
 
-export default async function resource(
+import fg from 'fast-glob'
-  compiler: NexeCompiler,
+
-  next: () => Promise<any>
+import { each } from '../util.js'
-) {
+import type { NexeCompiler } from '../compiler.js'
-  const { cwd, resources } = compiler.options;
+
-  if (!resources.length) {
+export default async function resource(compiler: NexeCompiler, next: () => Promise<any>) {
-    return next();
+  const { cwd, resources } = compiler.options
+  if (resources.length === 0) {
+    return await next()
   }
-  const step = compiler.log.step("Bundling Resources...");
+  let count = 0
-  let count = 0;
 
-  // workaround for https://github.com/sindresorhus/globby/issues/127
+  resources.forEach((x: string) => {
-  // and https://github.com/mrmlnc/fast-glob#pattern-syntax
+    if (x.includes('node_modules/**')) {
-  const resourcesWithForwardSlashes = resources.map((r) =>
+      compiler.log.step(
-    r.replace(/\\/g, "/")
+        `[WARNING]: pattern "${x}" will include many files, consider narrowing the pattern`,
-  );
+        'stopAndPersist',
-
+        'yellow'
-  await each(
+      )
-    globs(resourcesWithForwardSlashes, { cwd, onlyFiles: true }),
-    async (file) => {
-      count++;
-      step.log(`Including file: ${file}`);
-      await compiler.addResource(resolve(cwd, file));
     }
-  );
+  })
-  step.log(`Included ${count} file(s)`);
+
-  return next();
+  const step = compiler.log.step('Bundling Resources...')
+
+  await each(fg(resources, { cwd, absolute: true, onlyFiles: true }), async (file) => {
+    count++
+    step.log(`Including file: ${relative(cwd, file)}`)
+    await compiler.addResource(file)
+  })
+  compiler.log.step(`Included ${count} file(s)`, 'stopAndPersist')
+  return await next()
 }

src/steps/shim.ts

@@ -1,32 +1,16 @@
-import { NexeCompiler } from "../compiler";
+import type { NexeCompiler } from '../compiler.js'
-import { wrap } from "../util";
+import { wrap } from '../util.js'
 
-export default async function (
+export default async function (compiler: NexeCompiler, next: () => Promise<void>) {
-  compiler: NexeCompiler,
+  await next()
-  next: () => Promise<void>
-) {
-  await next();
   compiler.shims.push(
     wrap(
-      [
+      '' +
-        "process.__nexe = {};",
+        '{{replace:lib/MOD/fs/patch.js}}' +
-        "const fsPatcher = (function() {",
+        '\nshimFs(process.__nexe)' +
-        "const module = {exports: {}};",
+        `\n${compiler.options.fs ? '' : 'restoreFs()'}`
-        "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) {
@@ -35,7 +19,7 @@ export default async function (
       delete process.env.NODE_UNIQUE_ID
     }
   `)
-  );
+  )
 
   compiler.shims.push(
     wrap(`
@@ -47,5 +31,5 @@ export default async function (
         process.argv.splice(1,0, entry)
       }
     `)
-  );
+  )
 }

src/target.ts

@@ -1,107 +1,96 @@
-export type NodePlatform = "windows" | "mac" | "alpine" | "linux";
+export type NodePlatform = 'windows' | 'mac' | 'alpine' | 'linux'
-export type NodeArch = "x86" | "x64" | "arm" | "arm64";
+export type NodeArch = 'x86' | 'x64' | 'arm' | 'arm64'
 
-const platforms: NodePlatform[] = ["windows", "mac", "alpine", "linux"],
+const platforms: NodePlatform[] = ['windows', 'mac', 'alpine', 'linux'],
-  architectures: NodeArch[] = ["x86", "x64", "arm", "arm64"];
+  architectures: NodeArch[] = ['x86', 'x64', 'arm', 'arm64']
 
-export { platforms, architectures };
+export { platforms, architectures }
 
 export interface NexeTarget {
-  version: string;
+  version: string
-  platform: NodePlatform | string;
+  platform: NodePlatform | string
-  arch: NodeArch | string;
+  arch: NodeArch | string
 }
 
 const prettyPlatform: { [key: string]: NodePlatform } = {
-  win32: "windows",
+    win32: 'windows',
-  windows: "windows",
+    windows: 'windows',
-  win: "windows",
+    win: 'windows',
-  darwin: "mac",
+    darwin: 'mac',
-  macos: "mac",
+    macos: 'mac',
-  mac: "mac",
+    mac: 'mac',
-  linux: "linux",
+    linux: 'linux',
-  static: "alpine",
+    static: 'alpine',
-  alpine: "alpine",
+    alpine: 'alpine',
-};
+  },
-
+  prettyArch: { [key: string]: NodeArch } = {
-const prettyArch: { [key: string]: NodeArch } = {
+    x86: 'x86',
-  x86: "x86",
+    arm6: 'arm',
-  arm6: "arm",
+    arm64: 'arm64',
-  arm64: "arm64",
+    arm6l: 'arm',
-  arm6l: "arm",
+    arm: 'arm',
-  arm: "arm",
+    arm7: 'arm',
-  arm7: "arm",
+    arm7l: 'arm',
-  arm7l: "arm",
+    amd64: 'x64',
-  amd64: "x64",
+    ia32: 'x86',
-  ia32: "x86",
+    x32: 'x86',
-  x32: "x86",
+    x64: 'x64',
-  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|\.|\s+/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(
+  constructor(public arch: NodeArch, public platform: NodePlatform, public version: string) {}
-    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 (
+  return a.arch === b.arch && a.platform === b.platform && a.version === b.version
-    a.arch === b.arch && a.platform === b.platform && a.version === b.version
-  );
 }
 
-export function getTarget(
+export function getTarget(target: string | Partial<NexeTarget> = ''): NexeTarget {
-  target: string | Partial<NexeTarget> = ""
+  const currentArch = process.arch
-): NexeTarget {
+  let arch = currentArch in prettyArch ? prettyArch[process.arch] : (process.arch as NodeArch),
-  const currentArch = process.arch;
-  let arch =
-    currentArch in prettyArch
-      ? prettyArch[process.arch]
-      : (process.arch as NodeArch),
     platform = prettyPlatform[process.platform],
-    version = process.version.slice(1);
+    version = process.version.slice(1)
 
-  if (typeof target !== "string") {
+  if (typeof target !== 'string') {
-    target = `${target.platform}-${target.arch}-${target.version}`;
+    target = `${target.platform}-${target.arch}-${target.version}`
   }
 
   target
     .toLowerCase()
-    .split("-")
+    .split('-')
     .forEach((x) => {
       if (isVersion(x)) {
-        version = x.replace(/v/g, "");
+        version = x.replace(/v/g, '')
       }
       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)
 }

src/types.d.ts

@@ -0,0 +1,26 @@
+declare module 'got' {
+  interface GotFn {
+    (url: string, options?: any): Promise<{ body: string }>
+    stream(url: string, optoins?: any): any
+  }
+  const got: GotFn
+  export = got
+}
+
+declare module 'caw'
+
+declare module 'download' {
+  import type { 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
+}

src/util.ts

@@ -1,113 +1,130 @@
-import { readFile, writeFile, stat } from "fs";
+import { readFile, writeFile, stat } from 'node:fs/promises'
-import { execFile } from "child_process";
+import { execFile as exec } from 'node:child_process'
-import { promisify } from "util";
+import { promisify } from 'node:util'
-import rimraf = require("rimraf");
 
-const rimrafAsync = promisify(rimraf);
+export const STDIN_FLAG = '[stdin]'
-export const STDIN_FLAG = "[stdin]";
+
+export const esm: {
+  chalk: typeof import('chalk') | null
+  ora: typeof import('ora') | null
+  got: typeof import('got') | null
+} = {
+  got: null,
+  chalk: null,
+  ora: null,
+}
+
+export async function initEsm() {
+  await Promise.all(
+    (['chalk', 'got', 'ora'] as const).map(async (x) => {
+      esm[x] = await import(x)
+    })
+  )
+}
+
+const id = (x: any) => x
+export function color(color?: string, text?: string) {
+  return !color ? text : ((esm.chalk?.default as any)[color] || id)(text)
+}
+
+export type Func<T = any, Args = any> = (...args: Args[]) => T
 
 export async function each<T>(
   list: T[] | Promise<T[]>,
   action: (item: T, index: number, list: T[]) => Promise<any>
 ) {
-  const l = await list;
+  const l = await list
-  return Promise.all(l.map(action));
+  return await Promise.all(l.map(action))
 }
 
 export function wrap(code: string) {
-  return "!(function () {" + code + "})();";
+  return '!(function () {' + code + '})();'
 }
 
 function falseOnEnoent(e: any) {
-  if (e.code === "ENOENT") {
+  if (e.code === 'ENOENT') {
-    return false;
+    return false
   }
-  throw e;
+  throw e
 }
 
 function padRight(str: string, l: number) {
-  return (str + " ".repeat(l)).slice(0, l);
+  return (str + ' '.repeat(l)).slice(0, l)
 }
 
 const bound: MethodDecorator = function bound<T>(
-  target: Object,
+  target: object,
   propertyKey: string | symbol,
   descriptor: TypedPropertyDescriptor<T>
 ) {
-  const configurable = true;
+  const configurable = true
   return {
     configurable,
     get(this: T) {
-      const value = (descriptor.value as any).bind(this);
+      const value = (descriptor.value as any).bind(this)
       Object.defineProperty(this, propertyKey as string, {
         configurable,
         value,
         writable: true,
-      });
+      })
-      return value;
+      return value
     },
-  };
+  }
-};
+}
 
 function dequote(input: string) {
-  input = input.trim();
+  input = input.trim()
-  const singleQuote = input.startsWith("'") && input.endsWith("'");
+  const singleQuote = input.startsWith("'") && input.endsWith("'"),
-  const doubleQuote = input.startsWith('"') && input.endsWith('"');
+    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): Promise<Buffer>
-  (path: string, encoding: string): Promise<string>;
+  (path: string, encoding: string): Promise<string>
 }
 
-const readFileAsync = promisify(readFile);
+const execFile = promisify(exec),
-const writeFileAsync = promisify(writeFile);
+  isWindows = process.platform === 'win32'
-const statAsync = promisify(stat);
-const execFileAsync = promisify(execFile);
-const isWindows = process.platform === "win32";
 
-function pathExistsAsync(path: string) {
+async function pathExists(path: string) {
-  return statAsync(path)
+  return await stat(path)
-    .then((x) => true)
+    .then(() => true)
-    .catch(falseOnEnoent);
+    .catch(falseOnEnoent)
 }
 
-function isDirectoryAsync(path: string) {
+async function isDirectory(path: string) {
-  return statAsync(path)
+  return await stat(path)
     .then((x) => x.isDirectory())
-    .catch(falseOnEnoent);
+    .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);
+  const [cMajor, cMinor, cPatch] = version.split('.').map(Number)
-  let [major, minor, patch] = operand.split(".").map(Number);
+  let [major, minor, patch] = operand.split('.').map(Number)
-  if (!minor) minor = 0;
+  major = Number(major)
-  if (!patch) patch = 0;
+  if (!minor) minor = 0
+  if (!patch) patch = 0
   return (
     cMajor > major ||
     (cMajor === major && cMinor > minor) ||
     (cMajor === major && cMinor === minor && cPatch > patch)
-  );
+  )
 }
 
 export {
   dequote,
   padRight,
-  semverGt,
   bound,
   isWindows,
-  rimrafAsync,
+  stat,
-  statAsync,
+  execFile,
-  execFileAsync,
+  readFile,
-  readFileAsync,
+  pathExists,
-  pathExistsAsync,
+  isDirectory,
-  isDirectoryAsync,
+  writeFile,
-  writeFileAsync,
+  semverGt,
-};
+}

tasks/asset-build.js

@@ -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()

tasks/asset-test-build.js

@@ -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()

tasks/build.ts

@@ -1,140 +1,65 @@
-import * as nexe from "../lib/nexe";
+import { env } from 'node:process'
-import { getUnBuiltReleases, getLatestGitRelease } from "../lib/releases";
+import { execSync } from 'node:child_process'
-import { runDockerBuild } from "./docker";
+import { buildArm, buildAlpine } from './docker.js'
-import { getTarget, targetsEqual, NexeTarget } from "../lib/target";
-import {
-  pathExistsAsync,
-  readFileAsync,
-  execFileAsync,
-  semverGt,
-} from "../lib/util";
-import axios from "axios";
-import FormData from "form-data";
-import { cpus } from "os";
 
-const env = process.env,
+export async function build(target = env.NEXE_TARGET || null) {
-  isPullRequest = env.BUILD_REASON === "PullRequest",
+  if (!target?.trim()) {
-  isWindows = process.platform === "win32",
+    throw new Error('Environment variable NEXE_TARGET not found. Received: ' + target)
-  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)",
-  };
-
-if (require.main === module) {
-  if (!isPullRequest) {
-    build().catch((x) => {
-      console.error(x);
-      process.exit(1);
-    });
   }
+
+  const done = keepalive()
+  let file = ''
+  try {
+    if (target.includes('alpine')) {
+      file = await buildAlpine(target)
+    } else if (target.includes('arm')) {
+      file = await buildArm(target)
+    } else {
+      file = await nexeBuild(target)
+      assertNexeBinary(file)
+    }
+  } catch (e: any) {
+    done()
+    throw e
+  }
+
+  if (!file) {
+    throw new Error('Binary failed to build')
+  }
+
+  uploadBinary(target, file)
 }
 
-async function build() {
+function nexeBuild(target: string) {
-  const releases = await getUnBuiltReleases({ headers });
+  console.log('building: ' + target)
-  if (!releases.length) {
+  return Promise.resolve('')
-    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;
+function uploadBinary(target: string, file: string) {
-
+  void file
-  if (env.NEXE_VERSION) target = getTarget(env.NEXE_VERSION);
+  console.log('uploading to release')
-  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;
-    }
-
-    // Create form data for file upload
-    const formData = new FormData();
-    formData.append("file", await readFileAsync(output), {
-      filename: target.toString(),
-      contentType: "application/octet-stream",
-    });
-
-    const uploadUrl = gitRelease.upload_url.split("{")[0];
-    await axios
-      .post(uploadUrl, formData, {
-        params: { name: target.toString() },
-        headers: {
-          ...headers,
-          ...formData.getHeaders(),
-        },
-      })
-      .catch((reason) => {
-        console.log(reason && reason.response && reason.response.data);
-        throw reason;
-      });
-    console.log(target + " uploaded.");
-    process.exit(0);
-  }
 }
 
 function keepalive() {
-  const keepalive = setInterval(() => console.log("Building..."), 300 * 1000);
+  const keepalive = setInterval(() => console.log('Building...'), 300 * 1000)
-  return () => clearInterval(keepalive);
+  return () => clearInterval(keepalive)
 }
 
 function assertNexeBinary(file: string) {
-  return execFileAsync(file).catch((e) => {
+  if (!file) throw new Error('Invalid filename: "' + file + '"')
-    if (e && e.stack && e.stack.includes("Invalid Nexe binary")) {
+  let result = ''
-      return;
+  try {
+    result = execSync(file).toString('utf8')
+  } catch (e: any) {
+    if (e && e.stack && e.stack.includes('Invalid Nexe binary')) {
+      return
     }
-    throw e;
+    throw e
-  });
+  }
+  throw new Error('Not a bare nexe binary: ' + result)
 }
+
+build().catch((e) => {
+  console.error(e)
+  process.exit(1)
+})

tasks/docker.d.ts

@@ -0,0 +1,2 @@
+export declare function buildArm(target: string): Promise<string>
+export declare function buildAlpine(target: string): Promise<string>

tasks/docker.ts

@@ -1,79 +1,9 @@
-import { NexeTarget, architectures } from "../lib/target";
+export function buildArm(target: string) {
-import { writeFileAsync, readFileAsync } from "../lib/util";
+  console.log('building arm: ' + target)
-import axios from "axios";
+  return Promise.resolve('')
-import execa = require("execa");
-import { appendFileSync } from "fs";
-
-function alpine(target: NexeTarget) {
-  return `
-FROM ${target.arch === "x64" ? "" : "i386/"}alpine:3.12
-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} && \
-  ./configure --prefix=/usr --fully-static && \
-  make && 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();
 }
 
-function arm(target: NexeTarget) {
+export function buildAlpine(target: string) {
-  return `
+  console.log('building alpine: ' + target)
-FROM hypriot/rpi-node
+  return Promise.resolve('')
-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);
-    }
-  }
 }

tasks/post-build.ts

@@ -1,31 +1,41 @@
-import { writeFileSync, readFileSync } from "fs";
+import { writeFileSync, readFileSync } from 'node:fs'
-import { template } from "lodash";
+import { equal } from 'node:assert'
 
 /**
- * post build step to insert code files into code files.
+ * post build step to insert code files into code files (naively).
+ * '{{replace:path/to/file}}' => "file contents"
  * And the package.json version.
  */
-cp("src/fs/package.json", "lib/fs/package.json");
+const totalReplacements = 8
-cp("src/fs/bootstrap.js", "lib/fs/bootstrap.js");
+let replaced = 0
-cp("src/fs/README.md", "lib/fs/README.md");
+const mods = ['cjs', 'esm'] as const
 
-inject("lib/patches/third-party-main.js");
+mods.forEach((x) => {
-inject("lib/steps/shim.js");
+  inject(x, `lib/${x}/patches/third-party-main.js`)
-inject("lib/options.js", JSON.stringify(require("../package.json").version));
+  inject(x, `lib/${x}/steps/shim.js`)
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  inject(x, `lib/${x}/options.js`, JSON.stringify(require('../package.json').version))
+})
 
-function inject(filename: string, version?: string) {
+function inject(mod: typeof mods[number], filename: string, ...replacements: string[]) {
-  const contents = template(readFileSync(filename, "utf8"), {
+  let contents = readFileSync(filename, 'utf8')
-    interpolate: /['"]\{\{([\s\S]*?)\}\}['"]/,
+  contents = contents.replace(/('{{(.*)}}')/g, (substring: string, ...matches: string[]) => {
-  })({
+    if (!matches || !matches[1]) {
-    file: (path: string) => JSON.stringify(readFileSync(path, "utf8")),
+      return substring
-    version,
+    }
-  });
+    const [replace, file] = matches[1].split(':')
-  writeFileSync(filename, contents);
+    if (replace !== 'replace') {
-  console.log(`Wrote: ${filename}`);
+      return substring
+    }
+    ++replaced
+    console.log('Replacing: ', substring)
+
+    return replacements[+file]
+      ? replacements[+file]
+      : JSON.stringify(readFileSync(file.replace('MOD', mod), 'utf8').replace('"use strict";', ''))
+  })
+  writeFileSync(filename, contents)
+  console.log(`Wrote: ${filename}`)
 }
 
-function cp(from: string, to: string) {
+equal(replaced, totalReplacements, `Expected to replace ${totalReplacements} things`)
-  const file = readFileSync(from);
-  writeFileSync(to, file);
-  console.log("Copied: ", from, "To: ", to);
-}

tasks/tsconfig.json

@@ -1,10 +0,0 @@
-{
-  "extends": "../tsconfig.json",
-  "compilerOptions": {
-    "noEmit": true
-  },
-  "include":[
-    "*.ts"
-  ]
-}
-

test/exports.mjs

@@ -0,0 +1,15 @@
+import * as nexeEsm from '../lib/esm/nexe.js'
+import { createRequire } from 'node:module'
+import { fileURLToPath } from 'node:url'
+import { ok } from 'node:assert'
+
+const cjs = createRequire(fileURLToPath(import.meta.url)),
+  nexeCjs = cjs('../lib/cjs/nexe.js'),
+  exports = ['NexeCompiler', 'argv', 'compile', 'help', 'version']
+
+for (const exp of exports) {
+  ok(exp in nexeCjs)
+  ok(exp in nexeEsm)
+}
+
+console.log('esm and cjs modules match')

test/integration/index.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()

test/integration/tests.integration-spec.js

@@ -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' })
-    })
-  })
-})

test/options.spec.ts

@@ -1,7 +1,8 @@
-import { normalizeOptions } from '../src/options'
+import { describe, it, expect } from 'vitest'
-import { expect } from 'chai'
 import * as path from 'path'
 
+import { normalizeOptions } from '../src/options.js'
+
 const ext = process.platform === 'win32' ? '.exe' : ''
 
 describe('options', () => {
@@ -27,13 +28,13 @@ describe('options', () => {
       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 cwd = path.join(process.cwd(), 'test/fixture'),
-      const options = normalizeOptions({
+        options = normalizeOptions({
-        cwd,
+          cwd,
-        input: 'entry',
+          input: 'entry',
-        output: 'abc',
+          output: 'abc',
-        temp: './d'
+          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}`))
@@ -43,17 +44,17 @@ describe('options', () => {
   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}/`)
+      expect(options.remote).to.equal('https://github.com/nexe/nexe/releases/download/v3.3.3/')
     })
     it('should append trailing slash to third-party remote if necessary', () => {
       const options = normalizeOptions({
-        remote: 'https://sitejs.org/nexe'
+        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/'
+        remote: 'https://sitejs.org/nexe/',
       })
       expect(options.remote).to.equal('https://sitejs.org/nexe/')
     })
@@ -62,13 +63,13 @@ describe('options', () => {
   describe('output', () => {
     it('should work', () => {
       const options = normalizeOptions({
-        output: './some-output'
+        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'
+        input: './test/fixture',
       })
       expect(options.output).to.equal(path.resolve(`./entry${ext}`))
     })

test/target.spec.d.ts

@@ -0,0 +1 @@
+export {}

test/target.spec.ts

@@ -1,9 +1,11 @@
-import { padRight, isWindows } from '../src/util'
+import { describe, it, expect } from 'vitest'
-import { expect } from 'chai'
 import chalk from 'chalk'
-import { getTarget, NexeTarget } from '../src/target'
+
-const b = chalk.blue
+import { padRight } from '../src/util.js'
-const arch = process.arch === 'ia32' ? 'x86' : process.arch
+import { getTarget } from '../src/target.js'
+
+const b = chalk.blue,
+  arch = process.arch === 'ia32' ? 'x86' : process.arch
 
 describe('Targets', () => {
   ;[
@@ -16,7 +18,7 @@ describe('Targets', () => {
     ['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()]
+    ['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)

tsconfig.json

@@ -1,15 +1,25 @@
 {
   "compilerOptions": {
-    "target":"es2015",
+    "outDir": "./lib/types",
+    "target":"es2020",
+    "lib": ["es2020"],
+    "module": "es2020",
+    "allowSyntheticDefaultImports": true,
+    "declaration": true,
     "skipLibCheck": true,
+    "moduleResolution": "node",
     "experimentalDecorators": true,
-    "esModuleInterop": true,
-    "lib": ["es2018"],
-    "module": "commonjs",
-    "outDir": "./lib",
     "strict": true
   },
   "include":[
-    "src/**/*.ts"
+    "src/**/*.ts",
-  ]
+  ],
+  "ts-node": {
+    "transpileOnly": true,
+    "transpiler": "ts-node/transpilers/swc",
+    "compilerOptions": {
+      "esModuleInterop": true,
+      "module": "commonjs"
+    }
+  }
 }

webpack.config.ts

@@ -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',
-});