Update src/steps/download.ts

Co-authored-by: Jared Allard <jaredallard@users.noreply.github.com>
add spacer
2023-11-16 22:52:15 -08:00 · 2023-11-14 16:03:27 -08:00 · 2023-11-12 08:00:56 -06:00 · 2023-08-20 14:43:06 -05:00 · 2022-12-19 16:12:55 -06:00 · 2022-12-19 08:15:24 -06:00
28 changed files with 8234 additions and 1538 deletions
@@ -0,0 +1 @@
+custom: https://www.paypal.me/calebsboyd
@@ -0,0 +1,21 @@
+name: No Response
+
+# Both `issue_comment` and `scheduled` event types are required for this Action
+# to work properly.
+on:
+  issue_comment:
+    types: [created]
+  schedule:
+    # 9AM Central
+    - cron: '0 14 * * *'
+
+jobs:
+  noResponse:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: lee-dohm/no-response@v0.5.0
+        with:
+          token: ${{ github.token }}
+          closeComment: 'Closed awaiting response from OP, please open a new issue with the requested information and/or examples'
+          daysUntilClose: 21
+          responseRequiredLabel: more-information-needed
@@ -1,3 +1,4 @@
+
 <p align="center"><img src="https://cloud.githubusercontent.com/assets/2391349/23598327/a17bb68a-01ee-11e7-8f55-88a5fc96e997.png" /></p>

 <p align="center">
@@ -5,9 +6,10 @@
  <a href="https://www.npmjs.com/package/nexe"><img src="https://img.shields.io/npm/dt/nexe.svg" alt="Downloads"></a>
  <a href="https://www.npmjs.com/package/nexe"><img src="https://img.shields.io/npm/v/nexe.svg" alt="Version"></a>
  <a href="https://www.npmjs.com/package/nexe"><img src="https://img.shields.io/npm/l/nexe.svg" alt="License"></a>
+  <a href="https://discord.gg/2qTH52zNcZ"><img src="https://discordapp.com/api/guilds/814334925049561168/widget.png?style=shield"></a>
 </p>

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

 <p align="center">
@@ -47,9 +49,39 @@ For more CLI options see: `nexe --help`

 Additional files or resources can be added to the binary by passing `-r "glob/pattern/**/*"`. These included files can be read in the application by using `fs.readFile` or `fs.readFileSync`.

-## Compiling Node
+## Compiling the nexe Executable

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

 ## Node.js API

@@ -117,10 +149,12 @@ compile({
 - #### `build: boolean`
    - Build node from source, passing this flag tells nexe to download and build from source. Subsequently using this flag will cause nexe to use the previously built binary. To rebuild, first add [`--clean`](#clean-boolean)
 - #### `remote: string`
-    - Provide a custom remote location for fetching pre-built nexe binaries from. This can either be an HTTP or HTTPS URL or a file path.
+    - Provide a custom remote location for fetching pre-built nexe binaries from. This can either be an HTTP or HTTPS URL.
    - default: `null`
+ - #### `asset: string`
+    - Provide a pre-built nexe binary asset, this is a file path is resolved relative to cwd.
 - #### `python: string`
-    - On Linux this is the path pointing to your python2 executable
+    - On Linux this is the path pointing to your python3 executable
    - On Windows this is the directory where `python` can be accessed
    - default: `null`
 - #### `flags: string[]`
@@ -202,7 +236,7 @@ For examples, see the built in patches: [src/patches](src/patches).
    - Quickly perform a replace in a file within the downloaded Node.js source. The rest arguments are passed along to `String.prototype.replace`
 - `readFileAsync(filename: string): Promise<NexeFile>`
    - Access (or create) a file within the downloaded Node.js source.
- - `addResource(filename: string, contents: Buffer): void`
+ - `addResource(filename: string, contents: Buffer): Promise<void>`
    - Add a resource to the nexe bundle
 - `files: NexeFile[]`
    - The cache of the currently read, modified, or created files within the downloaded Node.js source.
@@ -216,9 +250,20 @@ Any modifications made to `NexeFile#contents` will be maintained in the cache _w

 ## Native Modules

-TODO
+In order to use native modules, the native binaries must be shipped alongside the binary generated by nexe.

- [ ] Implement support for `node-pre-gyp#find`.
+## 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`
+		- 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

 ## Contributing

@@ -226,20 +271,10 @@ Building
 ```
 $ git clone git@github.com:nexe/nexe.git
 $ cd nexe
-$ yarn
+$ npm i && npm run build
 ```

 Testing
 ```
 $ npm test
 ```
-
-## Maintainers
-
-[![Jared Allard](https://avatars.githubusercontent.com/u/2391349?s=130)](https://jaredallard.me/) | [![Caleb Boyd](https://avatars.githubusercontent.com/u/5818726?s=130)](https://github.com/calebboyd) | [![Dustin Greif](https://avatars.githubusercontent.com/u/3026298?s=130)](https://github.com/dgreif) |
---|---|---|
-[Jared Allard](https://github.com/jaredallard) | [Caleb Boyd](http://github.com/calebboyd) |  [Dustin Greif](https://github.com/dgreif) |
-
-### Former
-
- [Craig Condon](http://crcn.codes/)
@@ -47,7 +47,7 @@ jobs:
  - 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: choco install visualcpp-build-tools --version 14.0.25420.1 -fy && npm config set msvs_version 2015
+  - 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
@@ -58,8 +58,7 @@ jobs:
      msbuild_args: /3G
    condition: not(contains(variables['Agent.JobName'], 'windows'))
  - powershell: |
-      iex (new-object net.webclient).downloadstring('https://get.scoop.sh')
-      scoop install nasm
+      choco install nasm
      npm install
      npm run ci:build
    displayName: Build Nexe (Windows)
@@ -67,3 +66,8 @@ jobs:
    env:
      GITHUB_TOKEN: $(PersonalGithubToken)
      NEXE_VERBOSE: $(NEXE_VERBOSE)
+  - script: npm run test:integration
+    displayName: Test built artefact
+    env:
+      NEXE_VERBOSE: $(NEXE_VERBOSE)
+      BUILD: ''
@@ -2,7 +2,7 @@
  "name": "nexe",
  "description": "Create a single executable out of your Node.js application",
  "license": "MIT",
-  "version": "4.0.0-beta.11",
+  "version": "5.0.0-beta.1",
  "contributors": [
    "Craig Condon <craig.j.condon@gmail.com> (http://crcn.io)",
    "Jared Allard <jaredallard@outlook.com>",
@@ -11,10 +11,14 @@
  "scripts": {
    "ci:build": "ts-node tasks/build",
    "test": "mocha",
+    "test:integration": "node index.js --target 14.15.3 -i test/integration/index.js -o integration-tests --verbose -r test/integration -r node_modules/ && npm run test:integration:run",
+    "test:integration:run": "run-script-os",
+    "test:integration:run:win32": "integration-tests.exe",
+    "test:integration:run:default": "./integration-tests",
    "lint": "tslint \"{src,plugins,tasks}/**/*.ts\" --fix",
    "prepare": "npm run lint && npm run build && npm test",
    "prebuild": "rimraf lib",
-    "build": "tsc --declaration",
+    "build": "tsc --declaration && tsc -p tasks && webpack",
    "postbuild": "ts-node tasks/post-build"
  },
  "repository": {
@@ -32,45 +36,57 @@
  "engines": {
    "node": ">=10"
  },
+  "mocha": {
+    "spec": "./test/**/*.spec.ts",
+    "checkLeaks": true,
+    "require": [
+      "ts-node/register"
+    ]
+  },
  "dependencies": {
    "@calebboyd/semaphore": "^1.3.1",
-    "app-builder": "^6.2.2",
+    "@yarnpkg/fslib": "^3.0.0-rc.43",
+    "@yarnpkg/libzip": "^3.0.0-rc.43",
+    "app-builder": "^7.0.4",
+    "archiver": "^5.3.1",
    "caw": "^2.0.1",
    "chalk": "^2.4.2",
-    "cherow": "1.6.9",
-    "download": "^7.1.0",
-    "globby": "^11.0.1",
-    "got": "^9.6.0",
-    "minimist": "^1.2.5",
+    "download": "^8.0.0",
+    "globby": "^11.0.2",
+    "got": "^12.6.0",
+    "meriyah": "^4.3.5",
+    "minimist": "^1.2.8",
    "mkdirp": "^1.0.4",
-    "multistream": "^4.0.0",
+    "multistream": "^4.1.0",
    "ora": "^3.4.0",
-    "pify": "^4.0.1",
-    "resolve-dependencies": "^4.2.2",
-    "rimraf": "^3.0.0"
+    "resolve-dependencies": "^6.0.9",
+    "rimraf": "^3.0.2",
+    "run-script-os": "^1.1.6",
+    "webpack-config-prefabs": "0.0.5"
  },
  "devDependencies": {
-    "@types/chai": "^4.2.11",
-    "@types/download": "^6.2.4",
-    "@types/execa": "^2.0.0",
-    "@types/globby": "^9.1.0",
-    "@types/got": "^9.6.10",
-    "@types/minimist": "^1.2.0",
-    "@types/mkdirp": "^1.0.0",
-    "@types/mocha": "^7.0.2",
-    "@types/multistream": "^2.1.1",
+    "@types/archiver": "^5.3.2",
+    "@types/chai": "^4",
+    "@types/download": "^8",
+    "@types/globby": "^9",
+    "@types/lodash": "^4.14.192",
+    "@types/minimist": "^1.2.2",
+    "@types/mkdirp": "^1.0.2",
+    "@types/mocha": "^10.0.1",
+    "@types/multistream": "^4.1.0",
    "@types/ora": "^3.2.0",
-    "@types/pify": "3.0.2",
-    "@types/rimraf": "3.0.0",
-    "@types/semver": "^7.1.0",
-    "chai": "^4.2.0",
-    "execa": "^4.0.0",
-    "mocha": "^7.1.1",
-    "prettier": "^2.0.5",
-    "ts-node": "^8.9.0",
+    "@types/rimraf": "3.0.2",
+    "@types/semver": "^7.3.13",
+    "chai": "^4.3.7",
+    "execa": "^5.1.1",
+    "lodash": "^4.17.21",
+    "mocha": "^10.2.0",
+    "prettier": "^2.8.7",
+    "ts-node": "^10.9.1",
    "tslint": "^6.1.1",
    "tslint-config-prettier": "^1.18.0",
    "tslint-plugin-prettier": "^2.3.0",
-    "typescript": "^3.8.3"
+    "typescript": "^5.0.3",
+    "webpack-cli": "^5.0.1"
  }
 }
@@ -16,8 +16,11 @@ import {
 } from './util'
 import { NexeOptions, version } from './options'
 import { NexeTarget } from './target'
+import { PassThrough, Readable, Stream, Transform } from 'stream'
 import MultiStream = require('multistream')
 import { Bundle, toStream } from './fs/bundle'
+import { File } from 'resolve-dependencies'
+import { FactoryStream, LazyStream } from 'multistream'

 const isBsd = Boolean(~process.platform.indexOf('bsd'))
 const make = isWindows ? 'vcbuild.bat' : isBsd ? 'gmake' : 'make'
@@ -28,7 +31,7 @@ type StringReplacer = (match: string) => string
 export interface NexeFile {
  filename: string
  absPath: string
-  contents: string
+  contents: string | Buffer
 }

 export { NexeOptions }
@@ -109,16 +112,8 @@ export class NexeCompiler {
    //SOMEDAY iterate over multiple targets with `--outDir`
    this.targets = options.targets as NexeTarget[]
    this.target = this.targets[0]
-    if (
-      !(
-        options.remote.startsWith('http://') ||
-        options.remote.startsWith('https://') ||
-        options.remote.startsWith('file://')
-      )
-    ) {
-      throw new NexeError(
-        `Invalid remote URI scheme (must be http, https, or file): ${options.remote}`
-      )
+    if (!/https?\:\/\//.test(options.remote)) {
+      throw new NexeError(`Invalid remote URI scheme (must be http or https): ${options.remote}`)
    }
    this.remoteAsset = options.remote + this.target.toString()
    this.src = join(this.options.temp, this.target.version)
@@ -143,7 +138,7 @@ export class NexeCompiler {
  }

  @bound
-  addResource(absoluteFileName: string, content?: Buffer | string) {
+  addResource(absoluteFileName: string, content?: Buffer | string | File) {
    return this.bundle.addResource(absoluteFileName, content)
  }

@@ -175,11 +170,11 @@ export class NexeCompiler {
  @bound
  async replaceInFileAsync(file: string, replace: string | RegExp, value: string | StringReplacer) {
    const entry = await this.readFileAsync(file)
-    entry.contents = entry.contents.replace(replace, value as any)
+    entry.contents = entry.contents.toString().replace(replace, value as any)
  }

  @bound
-  async setFileContentsAsync(file: string, contents: string) {
+  async setFileContentsAsync(file: string, contents: string | Buffer) {
    const entry = await this.readFileAsync(file)
    entry.contents = contents
  }
@@ -197,6 +192,9 @@ export class NexeCompiler {
  }

  public getNodeExecutableLocation(target?: NexeTarget) {
+    if (this.options.asset) {
+      return resolve(this.options.cwd, this.options.asset)
+    }
    if (target) {
      return join(this.options.temp, target.toString())
    }
@@ -207,7 +205,7 @@ export class NexeCompiler {
    if (this.log.verbose) {
      this.compileStep!.pause()
    }
-    return new Promise((resolve, reject) => {
+    return new Promise<void>((resolve, reject) => {
      spawn(command, args, {
        cwd: this.src,
        env: this.env,
@@ -257,10 +255,7 @@ export class NexeCompiler {
    return createReadStream(this.getNodeExecutableLocation())
  }

-  private async _shouldCompileBinaryAsync(
-    binary: NodeJS.ReadableStream | null,
-    location: string | undefined
-  ) {
+  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

@@ -294,27 +289,40 @@ export class NexeCompiler {
    return [this.shims.join(''), this.startup].join(';')
  }

-  private async _assembleDeliverable(binary: NodeJS.ReadableStream) {
+  private async _assembleDeliverable(binary: Readable) {
    if (!this.options.mangle) {
      return binary
    }
-    const bundle = await this.bundle.toStream()
+    const launchCode = this.code()
+    const codeSize = Buffer.byteLength(launchCode)
+    const sentinel = Buffer.from('<nexe~~sentinel>')

-    this.shims.unshift(
-      wrap(`process.__nexe = ${JSON.stringify({ resources: this.bundle.fileIndex() })};\n`)
-    )
-
-    const startup = this.code(),
-      codeSize = Buffer.byteLength(startup),
-      lengths = Buffer.from(Array(16))
-
-    lengths.writeDoubleLE(codeSize, 0)
-    lengths.writeDoubleLE(this.bundle.size, 8)
-    return new (MultiStream as any)([
+    let vfsSize = 0
+    const streams = [
      binary,
-      toStream(startup),
-      bundle,
-      toStream(Buffer.concat([Buffer.from('<nexe~~sentinel>'), lengths])),
-    ])
+      toStream(launchCode),
+      this.bundle.toStream().pipe(
+        new Transform({
+          transform: (chunk, _, cb) => {
+            vfsSize || this.bundle.finalize()
+            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])))
+      }
+    })
  }
 }
@@ -0,0 +1,395 @@
+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>, 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>) {
+  return uniqBy(arr, (s: string | Dirent) => (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))
+            )
+          )
+        ),
+      ])
+    )
+    for (const path of pathsToTry) {
+      const portablePath = npath.toPortablePath(path)
+      if (this.zipFs.existsSync(portablePath)) {
+        return {
+          subPath: portablePath,
+        }
+      }
+    }
+  }
+
+  async copyFilePromise(sourceP: PortablePath, destP: PortablePath, flags: number = 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: number = 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>>
+  async readdirPromise(
+    p: PortablePath,
+    opts: { withFileTypes: boolean }
+  ): Promise<Array<Filename> | Array<Dirent>>
+  async readdirPromise(
+    p: PortablePath,
+    opts?: { withFileTypes?: boolean } | null
+  ): Promise<Array<string | Dirent>> {
+    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> = 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>
+  readdirSync(p: PortablePath, opts: { withFileTypes: boolean }): Array<Filename> | Array<Dirent>
+  readdirSync(p: PortablePath, opts?: { withFileTypes?: boolean } | null): Array<string | Dirent> {
+    const fallback = () => {
+      return this.baseFs.readdirSync(p, opts as any)
+    }
+    return this.makeCallSync(
+      p,
+      fallback,
+      (zipFs, { subPath }) => {
+        let fallbackPaths: Array<string | Dirent> = []
+        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 opendirPromise(p: PortablePath, opts?: OpendirOptions) {
+    return this.opendirSync(p, opts)
+  }
+
+  opendirSync(p: PortablePath, opts?: OpendirOptions) {
+    const zipInfo = this.findZip(p)
+    let zipFsDir: Dir<PortablePath> | null = null
+    if (zipInfo) {
+      zipFsDir = this.zipFs.opendirSync(zipInfo.subPath)
+    }
+    let realFsDir: Dir<PortablePath> | null = null
+    try {
+      realFsDir = this.baseFs.opendirSync(p)
+    } catch (e) {
+      if (!zipFsDir) throw e
+    }
+    const seen = new Set()
+    const nextDirent = () => {
+      const entry = realFsDir?.readSync() || zipFsDir?.readSync()
+      if (entry && !seen.has(entry.name)) {
+        seen.add(entry.name)
+        return entry
+      }
+      return null
+    }
+
+    const onClose = () => {
+      zipFsDir?.closeSync()
+      realFsDir?.closeSync()
+    }
+
+    return new CustomDir(p, nextDirent, { onClose })
+  }
+
+  accessPromise = ZipOpenFS.prototype.accessPromise
+  accessSync = ZipOpenFS.prototype.accessSync
+  appendFilePromise = ZipOpenFS.prototype.appendFilePromise
+  appendFileSync = ZipOpenFS.prototype.appendFileSync
+  chmodPromise = ZipOpenFS.prototype.chmodPromise
+  chmodSync = ZipOpenFS.prototype.chmodSync
+  fchmodPromise = ZipOpenFS.prototype.fchmodPromise
+  fchmodSync = ZipOpenFS.prototype.fchmodSync
+  chownPromise = ZipOpenFS.prototype.chownPromise
+  chownSync = ZipOpenFS.prototype.chownSync
+  fchownPromise = ZipOpenFS.prototype.fchownPromise
+  fchownSync = ZipOpenFS.prototype.fchownSync
+  closePromise = ZipOpenFS.prototype.closePromise
+  closeSync = ZipOpenFS.prototype.closeSync
+  createReadStream = ZipOpenFS.prototype.createReadStream
+  createWriteStream = ZipOpenFS.prototype.createWriteStream
+  existsPromise = ZipOpenFS.prototype.existsPromise
+  existsSync = ZipOpenFS.prototype.existsSync
+  fstatPromise = ZipOpenFS.prototype.fstatPromise
+  fstatSync = ZipOpenFS.prototype.fstatSync
+  getExtractHint = ZipOpenFS.prototype.getExtractHint
+  getRealPath = ZipOpenFS.prototype.getRealPath
+  linkPromise = ZipOpenFS.prototype.linkPromise
+  linkSync = ZipOpenFS.prototype.linkSync
+  lstatPromise = ZipOpenFS.prototype.lstatPromise
+  lstatSync = ZipOpenFS.prototype.lstatSync
+  openPromise = ZipOpenFS.prototype.openPromise
+  openSync = ZipOpenFS.prototype.openSync
+  readFilePromise = ZipOpenFS.prototype.readFilePromise
+  readFileSync = ZipOpenFS.prototype.readFileSync
+  readlinkPromise = ZipOpenFS.prototype.readlinkPromise
+  readlinkSync = ZipOpenFS.prototype.readlinkSync
+  readPromise = ZipOpenFS.prototype.readPromise
+  readSync = ZipOpenFS.prototype.readSync
+  renamePromise = ZipOpenFS.prototype.renamePromise
+  renameSync = ZipOpenFS.prototype.renameSync
+  resolve = ZipOpenFS.prototype.resolve
+  statPromise = ZipOpenFS.prototype.statPromise
+  statSync = ZipOpenFS.prototype.statSync
+  symlinkPromise = ZipOpenFS.prototype.symlinkPromise
+  symlinkSync = ZipOpenFS.prototype.symlinkSync
+  truncatePromise = ZipOpenFS.prototype.truncatePromise
+  truncateSync = ZipOpenFS.prototype.truncateSync
+  ftruncatePromise = ZipOpenFS.prototype.ftruncatePromise
+  ftruncateSync = ZipOpenFS.prototype.ftruncateSync
+  unlinkPromise = ZipOpenFS.prototype.unlinkPromise
+  unlinkSync = ZipOpenFS.prototype.unlinkSync
+  unwatchFile = ZipOpenFS.prototype.unwatchFile
+  utimesPromise = ZipOpenFS.prototype.utimesPromise
+  utimesSync = ZipOpenFS.prototype.utimesSync
+  lutimesPromise = ZipOpenFS.prototype.utimesPromise
+  lutimesSync = ZipOpenFS.prototype.utimesSync
+  watch = ZipOpenFS.prototype.watch
+  watchFile = ZipOpenFS.prototype.watchFile
+  writeFilePromise = ZipOpenFS.prototype.writeFilePromise
+  writeFileSync = ZipOpenFS.prototype.writeFileSync
+  writePromise = ZipOpenFS.prototype.writePromise
+  writeSync = ZipOpenFS.prototype.writeSync
+
+  // @ts-ignore
+  remapFd = ZipOpenFS.prototype.remapFd
+}
@@ -1,27 +1,10 @@
-import * as fs from 'fs'
-import { promisify } from 'util'
 import { relative } from 'path'
 import { Readable } from 'stream'
-import { each } from '@calebboyd/semaphore'
-import MultiStream = require('multistream')
+import { File } from 'resolve-dependencies'
+import archiver from 'archiver'

-const { createReadStream } = fs,
-  lstat = promisify(fs.lstat),
-  realpath = promisify(fs.realpath),
-  stat = promisify(fs.stat)
-
-export type MultiStreams = (Readable | (() => Readable))[]
-
-function renderSortedObject(entries: [string, [number, number]][], streams: MultiStreams) {
-  return entries.sort().reduce((obj, [key, value]) => {
-    streams.push((value as any).stream)
-    ;(value as any).stream = void 0
-    return Object.assign(obj, { [key]: value })
-  }, {})
-}
-
-function makeRelative(cwd: string, path: string) {
-  return './' + relative(cwd, path)
+function makeRelativeToZip(cwd: string, path: string) {
+  return '/snapshot/' + relative(cwd, path)
 }

 export function toStream(content: Buffer | string) {
@@ -33,82 +16,36 @@ export function toStream(content: Buffer | string) {
  })
  return readable
 }
-
-export type File = { absPath: string; contents: string; deps: FileMap }
-export type FileMap = { [absPath: string]: File | null }
-
-export interface BundleOptions {
-  entries: string[]
-  cwd: string
-  expand: boolean
-  loadContent: boolean
-  files: FileMap
-}
-
 export class Bundle {
-  size = 0
  cwd: string
-  rendered = false
-  files: { [key: string]: string | Buffer | undefined } = {}
-  streams: MultiStreams = []
-  private index: { [relativeFilePath: string]: [number, number] } = {}
+  files = new Set<string>()
+  zip: any
  constructor({ cwd }: { cwd: string } = { cwd: process.cwd() }) {
    this.cwd = cwd
+    this.zip = archiver('zip')
  }

-  addResource(absoluteFileName: string, content?: Buffer | string) {
-    this.files[absoluteFileName] = content
+  get list() {
+    return Array.from(this.files)
  }

-  async addEntry(absoluteFileName: string, content?: Buffer | string) {
-    let length = 0
-    let linkpath = ''
-    if (content !== undefined) {
-      length = Buffer.byteLength(content)
-    } else {
-      let stats = await lstat(absoluteFileName)
-      if (stats.isSymbolicLink()) {
-        linkpath = absoluteFileName
-        absoluteFileName = await realpath(linkpath)
-        stats = await stat(linkpath)
+  public addResource(absoluteFileName: string, content?: File | Buffer | string) {
+    const destPath = makeRelativeToZip(this.cwd, absoluteFileName)
+    if (!this.files.has(destPath)) {
+      if (content == null) {
+        this.zip.file(absoluteFileName, { name: destPath })
+      } else {
+        this.zip.append(content, { name: destPath })
      }
-      length = stats.size
-    }
-    const name = makeRelative(this.cwd, absoluteFileName),
-      existing = this.index[name]
-    if (!existing) {
-      const start = this.size
-      this.size += length
-      this.index[name] = [start, length]
-    }
-    if (linkpath) {
-      const linkName = makeRelative(this.cwd, absoluteFileName)
-      this.index[linkName] = this.index[name]
-    }
-    if (!existing) {
-      ;(this.index[name] as any).stream = () =>
-        content ? toStream(content) : createReadStream(absoluteFileName)
+      this.files.add(destPath)
    }
  }

-  fileIndex() {
-    if (!this.rendered) {
-      throw new Error('Index not rendered must call toStream() first')
-    }
-    return this.index
+  public finalize() {
+    return this.zip.finalize()
  }

-  async toStream() {
-    this.files
-    await each(
-      Object.keys(this.files),
-      (key: string) => {
-        return this.addEntry(key, this.files[key])
-      },
-      { concurrency: 10 }
-    )
-    this.index = renderSortedObject(Object.entries(this.index), this.streams)
-    this.rendered = true
-    return new (MultiStream as any)(this.streams)
+  public toStream(): Readable {
+    return this.zip
  }
 }
@@ -1,398 +1,108 @@
-import { Stats } from 'fs'
+import { ZipFS, getLibzipSync } from '@yarnpkg/libzip'
+import { patchFs, npath, PosixFS, NodeFS } from '@yarnpkg/fslib'
+import { SnapshotZipFS } from './SnapshotZipFS'
+import * as assert from 'assert'
+import * as constants from 'constants'
+import { dirname } from 'path'

-export interface NexeBinary {
+export interface NexeHeader {
  blobPath: string
-  resources: { [key: string]: number[] }
  layout: {
-    stat: Stats
    resourceStart: number
-    contentSize?: number
-    contentStart?: number
-    resourceSize?: number
+    resourceSize: number
+    contentSize: number
+    contentStart: number
  }
 }

 let originalFsMethods: any = null
 let lazyRestoreFs = () => {}
+const patches = (process as any).nexe.patches || {}
+const originalPatches = { ...patches }
+delete (process as any).nexe

-// optional Win32 file namespace prefix followed by drive letter and colon
-const windowsFullPathRegex = /^(\\{2}\?\\)?([a-zA-Z]):/
-
-const upcaseDriveLetter = (s: string): string =>
-  s.replace(windowsFullPathRegex, (_match, ns, drive) => `${ns || ''}${drive.toUpperCase()}:`)
-
-function shimFs(binary: NexeBinary, fs: any = require('fs')) {
+function shimFs(binary: NexeHeader, fs: typeof import('fs') = require('fs')) {
  if (originalFsMethods !== null) {
    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 = () => {},
-    path = require('path'),
-    winPath: (key: string) => string = isWin ? upcaseDriveLetter : (s) => s,
-    baseDir = winPath(path.dirname(process.execPath))
+
+  const realFs: typeof fs = { ...fs }
+  const nodeFs = new NodeFS(realFs)
+
+  const blob = Buffer.allocUnsafe(binary.layout.resourceSize)
+  const blobFd = realFs.openSync(binary.blobPath, 'r')
+  const bytesRead = realFs.readSync(
+    blobFd,
+    blob,
+    0,
+    binary.layout.resourceSize,
+    binary.layout.resourceStart
+  )
+  assert.equal(bytesRead, binary.layout.resourceSize)
+
+  const zipFs = new ZipFS(blob, { readOnly: true })
+  const snapshotZipFS = new SnapshotZipFS({
+    libzip: getLibzipSync(),
+    zipFs,
+    baseFs: nodeFs,
+    root: dirname(process.argv[0]),
+  })
+  const posixSnapshotZipFs = new PosixFS(snapshotZipFS)
+  patchFs(fs, posixSnapshotZipFs)

  let log = (_: string) => true
-  let loggedManifest = false
  if ((process.env.DEBUG || '').toLowerCase().includes('nexe:require')) {
+    process.stderr.write(
+      // @ts-ignore
+      `[nexe] - FILES ${JSON.stringify(Array.from(zipFs.entries.keys()), null, 4)}\n`
+    )
+    process.stderr.write(
+      // @ts-ignore
+      `[nexe] - DIRECTORIES ${JSON.stringify(Array.from(zipFs.listings.keys()), null, 4)}\n`
+    )
    log = (text: string) => {
-      setupManifest()
-      if (!loggedManifest) {
-        process.stderr.write('[nexe] - MANIFEST' + JSON.stringify(manifest, null, 4) + '\n')
-        process.stderr.write('[nexe] - DIRECTORIES' + JSON.stringify(directories, null, 4) + '\n')
-        loggedManifest = true
-      }
-      return process.stderr.write('[nexe] - ' + text + '\n')
+      return process.stderr.write(`[nexe] - ${text}\n`)
    }
  }
-
-  const getKey = function getKey(filepath: string | Buffer | null): string {
-    if (Buffer.isBuffer(filepath)) {
-      filepath = filepath.toString()
-    }
-    if (!isString(filepath)) {
-      return notAFile
-    }
-    let key = path.resolve(baseDir, filepath)
-
-    return winPath(key)
-  }
-
-  const statTime = function () {
-    return {
-      dev: 0,
-      ino: 0,
-      nlink: 0,
-      rdev: 0,
-      uid: 123,
-      gid: 500,
-      blksize: 4096,
-      blocks: 0,
-      atime: new Date(stat.atime),
-      atimeMs: stat.atime.getTime(),
-      mtime: new Date(stat.mtime),
-      mtimeMs: stat.mtime.getTime(),
-      ctime: new Date(stat.ctime),
-      ctimMs: stat.ctime.getTime(),
-      birthtime: new Date(stat.birthtime),
-      birthtimeMs: stat.birthtime.getTime(),
+  function internalModuleReadFile(this: any, original: any, ...args: any[]) {
+    log(`internalModuleReadFile ${args[0]}`)
+    try {
+      return posixSnapshotZipFs.readFileSync(args[0], 'utf-8')
+    } catch (e) {
+      return ''
    }
  }
-
-  let BigInt: Function
-  try {
-    BigInt = eval('BigInt')
-  } catch (ignored) {}
-
-  const createStat = function (extensions: any, options: any) {
-    const stat = Object.assign(new fs.Stats(), binary.layout.stat, statTime(), extensions)
-    if (options && options.bigint && BigInt) {
-      for (const k in stat) {
-        if (Object.prototype.hasOwnProperty.call(stat, k) && typeof stat[k] === 'number') {
-          stat[k] = BigInt(stat[k])
-        }
-      }
-    }
-    return stat
+  if (patches.internalModuleReadFile) {
+    patches.internalModuleReadFile = internalModuleReadFile
  }
-
-  const 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)
-    }
+  let returningArray: boolean
+  patches.internalModuleReadJSON = function (this: any, original: any, ...args: any[]) {
+    if (returningArray == null) returningArray = Array.isArray(original.call(this, ''))
+    const res = internalModuleReadFile.call(this, original, ...args)
+    return returningArray && !Array.isArray(res)
+      ? res === ''
+        ? []
+        : [res, /"(main|name|type|exports|imports)"/.test(res)]
+      : res
  }
-
-  function makeLong(filepath: string) {
-    return (path as any)._makeLong && (path as any)._makeLong(filepath)
-  }
-
-  function fileOpts(options: any) {
-    return !options ? {} : isString(options) ? { encoding: options } : options
-  }
-
-  let setupManifest = () => {
-    Object.keys(manifest).forEach((filepath) => {
-      const entry = manifest[filepath]
-      const absolutePath = getKey(filepath)
-      const longPath = makeLong(absolutePath)
-      const 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)
-      let 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 ('function' === typeof options) {
-          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, options: any) {
-      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
-      const resourceOffset = resourceStart + offset
-      const 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
-      const resourceOffset = resourceStart + offset
-      const 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
-      const resourceOffset = resourceStart + offset
-      const encoding = fileOpts(options).encoding
-      const fd = originalFsMethods.openSync(process.execPath, 'r')
-      const 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: 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.stat.apply(fs, arguments)
-      }
-    },
-  }
-
-  if (typeof fs.exists === 'function') {
-    nfs.exists = function (filepath: string, cb: Function) {
-      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)
-  }
-  patches.internalModuleReadJSON = patches.internalModuleReadFile
  patches.internalModuleStat = function (this: any, original: any, ...args: any[]) {
-    setupManifest()
-    const filepath = getKey(args[0])
-    if (manifest[filepath]) {
-      log('stat     (hit)              ' + filepath + '   ' + 0)
+    log(`internalModuleStat ${args[0]}`)
+    try {
+      const stat = posixSnapshotZipFs.statSync(args[0])
+      if (stat.isDirectory()) return 1
      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: Function) {
-      cb = cb || noop
-      const exists = nfs.existsSync(filepath)
-      if (!exists) {
-        return originalFsMethods.exists(filepath, cb)
-      }
-      process.nextTick(() => cb(exists))
+    } catch (e) {
+      return -constants.ENOENT
    }
  }

-  if (typeof fs.copyFile === 'function') {
-    nfs.copyFile = function (filepath: string, dest: string, flags: number, callback: Function) {
-      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))
-    }
-  }
-
-  Object.assign(fs, nfs)
-
  lazyRestoreFs = () => {
-    Object.keys(nfs).forEach((key) => {
-      fs[key] = originalFsMethods[key]
-    })
+    Object.assign(fs, originalFsMethods)
+    Object.assign(patches, originalPatches)
    lazyRestoreFs = () => {}
  }
-  return true
 }

 function restoreFs() {
@@ -15,7 +15,7 @@ async function compile(
  compilerOptions?: Partial<NexeOptions>,
  callback?: (err: Error | null) => void
 ) {
-  let error = null,
+  let error: Error | null = null,
    options: NexeOptions | null = null,
    compiler: NexeCompiler | null = null

@@ -32,7 +32,7 @@ async function compile(
      options.build ? [artifacts, ...patches, ...(options.patches as NexePatch[])] : [],
      options.plugins as NexePatch[]
    )(compiler)
-  } catch (e) {
+  } catch (e: any) {
    error = e
  }

@@ -1,4 +1,4 @@
-import * as parseArgv from 'minimist'
+import parseArgv from 'minimist'
 import { NexeCompiler, NexeError } from './compiler'
 import { isWindows, STDIN_FLAG } from './util'
 import { basename, extname, join, isAbsolute, resolve } from 'path'
@@ -9,7 +9,7 @@ import { resolveSync } from 'resolve-dependencies'
 const caw = require('caw')
 const c = process.platform === 'win32' ? chalk.constructor({ enabled: false }) : chalk

-export const version = '{{replace:0}}'
+export const version = '{{ version }}'

 export interface NexePatch {
  (compiler: NexeCompiler, next: () => Promise<void>): Promise<void>
@@ -22,6 +22,7 @@ export interface NexeOptions {
  targets: (string | NexeTarget)[]
  name: string
  remote: string
+  asset: string
  cwd: string
  fs: boolean | string[]
  flags: string[]
@@ -77,6 +78,7 @@ const alias = {
  i: 'input',
  o: 'output',
  v: 'version',
+  a: 'asset',
  t: 'target',
  b: 'build',
  n: 'name',
@@ -107,7 +109,7 @@ ${c.bold('nexe <entry-file> [options]')}
   ${c.underline.bold('Building from source:')}

  -b   --build                      -- build from source
-  -p   --python                     -- python2 (as python) executable path
+  -p   --python                     -- python3 (as python) executable path
  -f   --flag                       -- *v8 flags to include during compilation
  -c   --configure                  -- *arguments to the configure step
  -m   --make                       -- *arguments to the make/build step
@@ -259,7 +261,9 @@ function normalizeOptions(input?: Partial<NexeOptions>): NexeOptions {
  options.downloadOptions.agent = process.env.HTTPS_PROXY
    ? caw(process.env.HTTPS_PROXY, { protocol: 'https' })
    : options.downloadOptions.agent || require('https').globalAgent
-  options.downloadOptions.rejectUnauthorized = process.env.HTTPS_PROXY ? false : true
+  options.downloadOptions.rejectUnauthorized = process.env.NODE_TLS_REJECT_UNAUTHORIZED
+    ? false
+    : true

  options.rc = options.rc || extractCliMap(/^rc-.*/, options)
  options.output =
@@ -12,14 +12,15 @@ export default async function nodeRc(compiler: NexeCompiler, next: () => Promise
    let value = options[key]
    const isVar = /^[A-Z_]+$/.test(value)
    value = isVar ? value : `"${value}"`
-    file.contents = file.contents.replace(
-      new RegExp(`VALUE "${key}",.*`),
-      `VALUE "${key}", ${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.replace(new RegExp(x + ' .*$', 'm'), `${x} ${options[x]}`)
+      file.contents = file.contents
+        .toString()
+        .replace(new RegExp(x + ' .*$', 'm'), `${x} ${options[x]}`)
    }
  })

@@ -1,5 +1,5 @@
 import { NexeCompiler } from '../compiler'
-import { parse } from 'cherow'
+import { parse } from 'meriyah'
 import { wrap, semverGt } from '../util'

 function walkSome(node: any, visit: Function) {
@@ -29,6 +29,8 @@ export default async function main(compiler: NexeCompiler, next: () => Promise<v

  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')) {
@@ -36,13 +38,11 @@ export default async function main(compiler: NexeCompiler, next: () => Promise<v
  }

  const file = await compiler.readFileAsync(bootFile),
-    ast = parse(file.contents, {
-      loc: true,
-      tolerant: true,
+    ast = parse(file.contents.toString(), {
      next: true,
      globalReturn: true,
-      node: true,
-      skipShebang: true,
+      loc: true,
+      specDeviation: true,
    }),
    location = { start: { line: 0 } }

@@ -54,14 +54,23 @@ export default async function main(compiler: NexeCompiler, next: () => Promise<v
    }
  })

-  const fileLines = file.contents.split('\n')
-  fileLines.splice(
-    location.start.line,
-    0,
-    '{{replace:lib/fs/bootstrap.js}}' +
-      '\n' +
-      (semverGt(version, '11.99') ? 'expandArgv1 = false;\n' : '')
-  )
+  const fileLines = file.contents.toString().split('\n')
+  if (semverGt(version, '19.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')) {
@@ -69,13 +78,13 @@ export default async function main(compiler: NexeCompiler, next: () => Promise<v
      await compiler.replaceInFileAsync(
        bootFile,
        'initializeFrozenIntrinsics();',
-        'initializeFrozenIntrinsics();\n' + wrap('{{replace:lib/patches/boot-nexe.js}}')
+        'initializeFrozenIntrinsics();\n' + wrap('{{ file("lib/patches/boot-nexe.js") }}')
      )
    } else {
      await compiler.replaceInFileAsync(
        bootFile,
        'initializePolicy();',
-        'initializePolicy();\n' + wrap('{{replace:lib/patches/boot-nexe.js}}')
+        'initializePolicy();\n' + wrap('{{ file("lib/patches/boot-nexe.js") }}')
      )
    }
    await compiler.replaceInFileAsync(
@@ -83,16 +92,26 @@ export default async function main(compiler: NexeCompiler, next: () => Promise<v
      'assert(!CJSLoader.hasLoadedAnyUserCJSModule)',
      '/*assert(!CJSLoader.hasLoadedAnyUserCJSModule)*/'
    )
-    await compiler.replaceInFileAsync(
-      'src/node.cc',
-      'MaybeLocal<Value> StartMainThreadExecution(Environment* env) {',
-      'MaybeLocal<Value> StartMainThreadExecution(Environment* env) {\n' +
-        '  return StartExecution(env, "internal/main/run_main_module");\n'
-    )
+    const { contents: nodeccContents } = await compiler.readFileAsync('src/node.cc')
+    if (nodeccContents.includes('if (env->worker_context() != nullptr) {')) {
+      await compiler.replaceInFileAsync(
+        'src/node.cc',
+        'if (env->worker_context() != nullptr) {',
+        'if (env->worker_context() == nullptr) {\n' +
+          '  return StartExecution(env, "internal/main/run_main_module"); } else {\n'
+      )
+    } else {
+      await compiler.replaceInFileAsync(
+        'src/node.cc',
+        'MaybeLocal<Value> StartMainThreadExecution(Environment* env) {',
+        'MaybeLocal<Value> StartMainThreadExecution(Environment* env) {\n' +
+          '  return StartExecution(env, "internal/main/run_main_module");\n'
+      )
+    }
  } else {
    await compiler.setFileContentsAsync(
      'lib/_third_party_main.js',
-      '{{replace:lib/patches/boot-nexe.js}}'
+      '{{ file("lib/patches/boot-nexe.js") }}'
    )
  }
  return next()
@@ -1,8 +1,7 @@
 import { NexeCompiler, NexeError } from '../compiler'
 import { resolve, relative } from 'path'
-import { each } from '@calebboyd/semaphore'
 import resolveFiles, { resolveSync } from 'resolve-dependencies'
-import { dequote, STDIN_FLAG, semverGt } from '../util'
+import { dequote, STDIN_FLAG, semverGt, each } from '../util'
 import { Readable } from 'stream'

 function getStdIn(stdin: Readable): Promise<string> {
@@ -26,7 +25,7 @@ function getStdIn(stdin: Readable): Promise<string> {
 }

 export default async function bundle(compiler: NexeCompiler, next: any) {
-  const { bundle, cwd, input: inputPath } = compiler.options
+  const { bundle: doBundle, cwd, input: inputPath } = compiler.options
  let input = inputPath
  compiler.entrypoint = './' + relative(cwd, input)

@@ -36,14 +35,14 @@ export default async function bundle(compiler: NexeCompiler, next: any) {
    compiler.startup = ';require("module").runMain();'
  }

-  if (!bundle) {
+  if (!doBundle) {
    await compiler.addResource(resolve(cwd, input))
    return next()
  }

  let code = ''
-  if (typeof bundle === 'string') {
-    code = await require(bundle).createBundle(compiler.options)
+  if (typeof doBundle === 'string') {
+    code = await require(doBundle).createBundle(compiler.options)
  }

  if (input === STDIN_FLAG && (code = code || dequote(await getStdIn(process.stdin)))) {
@@ -62,9 +61,11 @@ export default async function bundle(compiler: NexeCompiler, next: any) {
    compiler.entrypoint = './' + relative(cwd, input)
  }

+  const step = compiler.log.step('Resolving dependencies...')
+
  const { files, warnings } = await resolveFiles(
    input,
-    ...Object.keys(compiler.bundle.files).filter((x) => x.endsWith('.js')),
+    ...Object.keys(compiler.bundle.list).filter((x) => x.endsWith('.js') || x.endsWith('.mjs')),
    { cwd, expand: 'variable', loadContent: false }
  )

@@ -74,6 +75,14 @@ export default async function bundle(compiler: NexeCompiler, next: any) {
    throw new NexeError('Parsing Error:\n' + warnings.join('\n'))
  }

-  Object.keys(files).forEach((x) => compiler.addResource(x))
+  //TODO: warnings.forEach((x) => console.log(x))
+
+  await Promise.all(
+    Object.entries(files).map(([key]) => {
+      step.log(`Including dependency: ${key}`)
+      return compiler.addResource(key)
+    })
+  )
+
  return next()
 }
@@ -38,7 +38,7 @@ async function fetchPrebuiltBinary(compiler: NexeCompiler, step: any) {
        })
      }
    )
-  } catch (e) {
+  } catch (e: any) {
    if (e.statusCode === 404) {
      throw new NexeError(`${remoteAsset} is not available, create it using the --build flag`)
    } else {
@@ -58,7 +58,7 @@ export default async function downloadNode(compiler: NexeCompiler, next: () => P
    { sourceUrl, downloadOptions, build } = compiler.options,
    url = sourceUrl || `https://nodejs.org/dist/v${version}/node-v${version}.tar.gz`,
    step = log.step(
-      `Downloading ${build ? '' : 'pre-built '}Node.js${build ? `source from: ${url}` : ''}`
+      `Downloading ${build ? '' : 'pre-built '}Node.js${build ? ` source from: ${url}` : ''}`
    ),
    exeLocation = compiler.getNodeExecutableLocation(build ? undefined : target),
    downloadExists = await pathExistsAsync(build ? src : exeLocation)
@@ -1,5 +1,6 @@
-import { isDirectoryAsync, each } from '../util'
-import * as globs from 'globby'
+import { each } from '../util'
+import globs from 'globby'
+import { resolve } from 'path'
 import { NexeCompiler } from '../compiler'

 export default async function resource(compiler: NexeCompiler, next: () => Promise<any>) {
@@ -14,13 +15,10 @@ export default async function resource(compiler: NexeCompiler, next: () => Promi
  // and https://github.com/mrmlnc/fast-glob#pattern-syntax
  const resourcesWithForwardSlashes = resources.map((r) => r.replace(/\\/g, '/'))

-  await each(globs(resourcesWithForwardSlashes, { cwd }), async (file) => {
-    if (await isDirectoryAsync(file)) {
-      return
-    }
+  await each(globs(resourcesWithForwardSlashes, { cwd, onlyFiles: true }), async (file) => {
    count++
    step.log(`Including file: ${file}`)
-    await compiler.addResource(file)
+    await compiler.addResource(resolve(cwd, file))
  })
  step.log(`Included ${count} file(s)`)
  return next()
@@ -5,10 +5,17 @@ export default async function (compiler: NexeCompiler, next: () => Promise<void>
  await next()
  compiler.shims.push(
    wrap(
-      '' +
-        '{{replace:lib/fs/patch.js}}' +
-        '\nshimFs(process.__nexe)' +
-        `\n${compiler.options.fs ? '' : 'restoreFs()'}`
+      [
+        'process.__nexe = {};',
+        'const fsPatcher = (function() {',
+        'const module = {exports: {}};',
+        'const exports = module.exports;',
+        '{{file("lib/fs/patch.bundle.js")}}',
+        'return module.exports;',
+        '})()',
+        'fsPatcher.shimFs(process.__nexe);',
+        compiler.options.fs ? '' : 'restoreFs();',
+      ].join('\n')
      //TODO support only restoring specific methods
    )
  )
@@ -1,9 +1,9 @@
 import { readFile, writeFile, stat } from 'fs'
 import { execFile } from 'child_process'
-import pify = require('pify')
+import { promisify } from 'util'
 import rimraf = require('rimraf')

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

 export async function each<T>(
@@ -26,7 +26,7 @@ function falseOnEnoent(e: any) {
 }

 function padRight(str: string, l: number) {
-  return (str + ' '.repeat(l)).substr(0, l)
+  return (str + ' '.repeat(l)).slice(0, l)
 }

 const bound: MethodDecorator = function bound<T>(
@@ -64,10 +64,10 @@ export interface ReadFileAsync {
  (path: string, encoding: string): Promise<string>
 }

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

 function pathExistsAsync(path: string) {
@@ -3,7 +3,7 @@ import { getUnBuiltReleases, getLatestGitRelease } from '../lib/releases'
 import { runDockerBuild } from './docker'
 import { getTarget, targetsEqual, NexeTarget } from '../lib/target'
 import { pathExistsAsync, readFileAsync, execFileAsync, semverGt } from '../lib/util'
-import got = require('got')
+import got from 'got'
 import { cpus } from 'os'

 const env = process.env,
@@ -86,7 +86,7 @@ async function build() {
      return
    }
    await got(gitRelease.upload_url.split('{')[0], {
-      query: { name: target.toString() },
+      searchParams: { name: target.toString() },
      body: await readFileAsync(output),
      headers: {
        ...headers,
@@ -1,6 +1,6 @@
 import { NexeTarget, architectures } from '../lib/target'
 import { writeFileAsync, readFileAsync } from '../lib/util'
-import got = require('got')
+import got from 'got'
 import execa = require('execa')
 import { appendFileSync } from 'fs'

@@ -50,7 +50,7 @@ export async function runDockerBuild(target: NexeTarget) {
    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) {
+  } catch (e: any) {
    console.log('Error running docker')
    appendFileSync(outFilename, e.message)
  } finally {
@@ -1,11 +1,10 @@
 import { writeFileSync, readFileSync } from 'fs'
+import { template } from 'lodash'

 /**
- * post build step to insert code files into code files (naively).
- * '{{replace:path/to/file}}' => "file contents"
+ * post build step to insert code files into code files.
 * And the package.json version.
 */
-//inject('plugins/nexe-daemon/lib/index.js')
 cp('src/fs/package.json', 'lib/fs/package.json')
 cp('src/fs/bootstrap.js', 'lib/fs/bootstrap.js')
 cp('src/fs/README.md', 'lib/fs/README.md')
@@ -14,18 +13,12 @@ inject('lib/patches/third-party-main.js')
 inject('lib/steps/shim.js')
 inject('lib/options.js', JSON.stringify(require('../package.json').version))

-function inject(filename: string, ...replacements: string[]) {
-  let contents = readFileSync(filename, 'utf8')
-  contents = contents.replace(/('{{(.*)}}')/g, (substring: string, ...matches: string[]) => {
-    if (!matches || !matches[1]) {
-      return substring
-    }
-    const [replace, file] = matches[1].split(':')
-    if (replace !== 'replace') {
-      return substring
-    }
-    console.log('Replacing: ', substring)
-    return replacements[+file] ? replacements[+file] : JSON.stringify(readFileSync(file, 'utf8'))
+function inject(filename: string, version?: string) {
+  const contents = template(readFileSync(filename, 'utf8'), {
+    interpolate: /'\{\{([\s\S]*?)\}\}'/,
+  })({
+    file: (path: string) => JSON.stringify(readFileSync(path, 'utf8')),
+    version,
  })
  writeFileSync(filename, contents)
  console.log(`Wrote: ${filename}`)
@@ -0,0 +1,10 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "noEmit": true
+  },
+  "include":[
+    "*.ts"
+  ]
+}
+
@@ -0,0 +1,23 @@
+const { mkdtemp, copyFile } = 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 mkdtemp(path.join(os.tmpdir(), 'nexe-integration-tests-'))
+  const executable = path.join(tempdir, path.basename(process.argv[0]))
+  await copyFile(process.argv[0], executable)
+  process.on('beforeExit', () => rimraf.sync(tempdir))
+  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: tempdir }
+  ).on('exit', (code) => {
+    process.exitCode = code
+  })
+}
+
+runTests()
@@ -0,0 +1,120 @@
+const { expect } = require('chai')
+const fs = require('fs')
+const { dirname, basename } = require('path')
+
+const files = { zipFs: 'test/integration/tests.integration-spec.js', real: 'real', real2: 'real2' }
+describe('SnapshotZipFS', () => {
+  console.error('Note: these tests are order dependant, so subsequent failures are likely a flow on effect.')
+  it('checks existance from the zipFs', () => expect(fs.existsSync(files.zipFs)).to.equal(true))
+  it('checks non-existance from the zipFs', () => expect(fs.existsSync('not found')).to.equal(false))
+  it('reads from the zipFs', () => expect(fs.readFileSync(files.zipFs, 'utf8')).to.include('SnapshotZipFS'))
+  it('copies from the zipFs', () => expect(() => fs.copyFileSync(files.zipFs, files.real)).not.to.throw())
+  it('reads from the real fs', () => expect(fs.readFileSync(files.real, 'utf8')).to.include('SnapshotZipFS'))
+  it('checks non-existance from the real fs', () => expect(fs.existsSync(files.real2)).to.equal(false))
+  it('copies from the real fs', () => expect(() => fs.copyFileSync(files.real, files.real2)).not.to.throw())
+  it('checks existance from the real fs', () => expect(fs.existsSync(files.real2)).to.equal(true))
+  it('unlinks from the real fs', () => expect(() => fs.unlinkSync(files.real2)).not.to.throw())
+  it('symlinks the real fs', () => expect(() => fs.symlinkSync('tmp', files.real2)).not.to.throw())
+  it('readlinks the real fs', () => expect(fs.readlinkSync(files.real2)).to.equal('tmp'))
+  it('truncates the real fs', () => expect(() => fs.truncateSync(files.real)).not.to.throw())
+  it('writeFiles the real fs', () => expect(() => fs.writeFileSync(files.real2, 'testing')).not.to.throw())
+  it('accesses the real fs', () => expect(() => fs.accessSync(files.real)).not.to.throw())
+  it('accesses the zipFs', () => expect(() => fs.accessSync(files.zipFs)).not.to.throw())
+  it('stats the real fs', () => expect(fs.statSync(files.real2).size).to.be.greaterThan(0))
+  it('stats the zipFs', () => expect(fs.statSync(files.zipFs).size).to.be.greaterThan(0))
+  it('readdirs from the zipFs', () => expect(fs.readdirSync(dirname(files.zipFs))).to.include(basename(files.zipFs)))
+  it('readdirs from the real fs', () => expect(fs.readdirSync('.')).to.include(files.real))
+  it('readdirs from both', () => {
+    expect(fs.readdirSync('.')).to.include(files.real),
+    expect(fs.readdirSync('.')).to.include('test')
+  })
+  let dir
+  it('opendirs the zipFs fs', async () => {
+    expect(() => dir = fs.opendirSync(dirname(files.zipFs))).not.to.throw()
+    const names = []
+    for await (const dirent of dir) {
+      names.push(dirent.name)
+    }
+    expect(names).to.include(basename(files.zipFs))
+  })
+  it('opendirs the real fs and zipFs', async () => {
+    expect(() => dir = fs.opendirSync('.')).not.to.throw()
+    const names = []
+    for await (const dirent of dir) {
+      names.push(dirent.name)
+    }
+    expect(names).to.include(files.real)
+    expect(names).to.include('test')
+  })
+  it('createWriteStreams to the real fs', () => expect(() => fs.createWriteStream('createWriteStream')).not.to.throw())
+  it('createReadStreams to the real fs', () => expect(() => fs.createReadStream(files.real)).not.to.throw())
+  it('createReadStreams to the zipFs', () => expect(() => fs.createReadStream(files.zipFs)).not.to.throw())
+  it('renames to the realFs', () => {
+    expect(() => fs.renameSync(files.real2, 'rename')).not.to.throw()
+    expect(fs.existsSync('rename')).to.equal(true)
+  })
+
+  describe('write actions to the zipFs', () => {
+    it(`won't truncate to the zipFs`, () => expect(() => fs.truncateSync(files.zipFs)).to.throw())
+    it(`won't unlink from the zipFs`, () => expect(() => fs.unlinkSync(files.zipFs)).to.throw())
+    it(`won't appendFile to the zipFs`, () => expect(() => fs.appendFileSync(files.zipFs, 'xxx')).to.throw())
+    it(`won't symlink to the zipFs`, () => expect(() => fs.symlinkSync('tmp', files.zipFs)).to.throw())
+    it(`won't chmod to the zipFs`, () => expect(() => fs.chmodSync(files.zipFs, 0o666)).to.throw())
+    it(`won't chown to the zipFs`, () => expect(() => fs.chownSync(files.zipFs, 0, 0)).to.throw())
+    it(`won't writeFile the zipFs`, () => expect(() => fs.writeFileSync(files.zipFs, 'testing')).to.throw())
+    it(`won't createWriteStreams to the zipFs`, () => expect(() => fs.createWriteStream(files.zipFs)).to.throw())
+    it(`won't rename to the zipFs`, () => expect(() => fs.renameSync(files.real, files.zipFs)).to.throw())
+  })
+
+  ;[ 'zipFs', 'real' ].forEach((k) => {
+    it(`watches the ${k} fs`, () => expect(() => fs.watch(files[k], () => null).close()).not.to.throw())
+    it(`watchFiles the ${k} fs`, () => expect(() => fs.watchFile(files[k], () => null)).not.to.throw())
+    it(`unwatchFiles the ${k} fs`, () => expect(() => fs.unwatchFile(files[k])).not.to.throw())
+  })
+  let buffer = Buffer.alloc(8092), fd
+  describe('zipfs file descriptors', () => {
+    it('opens files in the zipFs', () => {
+      expect(() => (fd = fs.openSync(files.zipFs, 'a+'))).not.to.throw()
+      expect(fd).to.not.be.null
+    })
+    it('reads file descriptors from the zipFs', () => {
+      expect(() => fs.readSync(fd, buffer)).not.to.throw()
+      expect(buffer.toString()).to.include('SnapshotZipFS')
+    })
+    it('fstats the zipFs', () => expect(fs.fstatSync(fd).size).to.be.greaterThan(0))
+    it(`won't write to the zipFs`, () => expect(() => fs.writeSync(fd, 'xxx')).to.throw())
+    it(`won't fchmod the zipFs`, () => expect(() => fs.fchmodSync(fd)).to.throw())
+    it(`won't fchown the zipFs`, () => expect(() => fs.fchownSync(fd)).to.throw())
+    it(`won't ftruncate the zipFs`, () => expect(() => fs.ftruncateSync(fd)).to.throw())
+    it('closes file descriptors from the zipFs', () => expect(() => fs.closeSync(fd)).not.to.throw())
+  })
+  fd = null
+  buffer = Buffer.alloc(8092)
+  describe('real file descriptors', () => {
+    it('opens files in the real fs', () => {
+      expect(() => (fd = fs.openSync(files.real2, 'a+'))).not.to.throw()
+      expect(fd).to.not.be.null
+    })
+    it('reads file descriptors from the real fs', () => {
+      expect(() => fs.readSync(fd, buffer)).not.to.throw()
+      expect(buffer.toString()).to.include('SnapshotZipFS')
+    })
+    it('will write to the real fs', () => expect(() => fs.writeSync(fd, 'xxx')).not.to.throw())
+    it('fstats the real fs', () => expect(fs.fstatSync(fd).size).to.be.greaterThan(0))
+    it('closes file descriptors from the real fs', () => expect(() => fs.closeSync(fd)).not.to.throw())
+  })
+  describe('path clashes', () => {
+    it('delegates directory creation to the real fs', () => expect(() => fs.mkdirSync('test')).not.to.throw())
+    it('delegates directory removal to the real fs', () => expect(() => fs.rmdirSync('test')).not.to.throw())
+  })
+  describe('requiring modules', () => {
+    it('resolves modules from the zipFs', () => expect(() => require('resolve-dependencies')).not.to.throw())
+    it('resolves modules from the real fs', () => {
+      fs.mkdirSync('node_modules')
+      fs.mkdirSync('node_modules/fake-package')
+      fs.writeFileSync('node_modules/fake-package/package.json', '{ "name": "fake-package", "main": "some-file.js"}')
+      fs.writeFileSync('node_modules/fake-package/some-file.js', `module.exports = { fake: 'package' }`)
+      expect(require('fake-package')).to.eql({ fake: 'package' })
+    })
+  })
+})
@@ -1,4 +0,0 @@
-./test/**/*.spec.ts
--check-leaks
--require ts-node/register
--recursive
@@ -1,8 +1,9 @@
 {
  "compilerOptions": {
-    "target":"es5",
+    "target":"es2015",
    "skipLibCheck": true,
    "experimentalDecorators": true,
+    "esModuleInterop": true,
    "lib": ["es2018"],
    "module": "commonjs",
    "outDir": "./lib",
@@ -0,0 +1,7 @@
+import * as wcp from 'webpack-config-prefabs'
+export = wcp.nodeLibrary(module, {
+  enableTypescript: true,
+  entry: './src/fs/patch.ts',
+  minimize: false,
+  outputFilepath: './lib/fs/patch.bundle.js',
+});
Author	SHA1	Message	Date
oxmc	c48b40b14e	Update src/steps/download.ts Co-authored-by: Jared Allard <jaredallard@users.noreply.github.com>	2023-11-16 22:52:15 -08:00
oxmc	1267f5d41d	add spacer	2023-11-14 16:03:27 -08:00
bruce-one	2b4abb1b13	Add support for node v20. (#1063 )	2023-11-12 08:00:56 -06:00
bruce-one	ca657b5b06	feat: use yarn fslib/zip for fs shimming (#1048 ) * refactor: compile with esmoudle interop * Rigidify code replacement by using Lodash templates. * Generate zip file bundle. * Use yarn's fslib to implement the fake filesystem. Leverage the work done by yarn, rather than reimplementing from scratch. This means the fake fs is now reading from a zip file in the binary. A few methods need custom implementations as the fake fs is not writable. These were copied and adjusted from the yarn ZipOpenFS. * Add test suite using the built artefact. Smoke tests the different fs methods. Not perfect in any world, but better than nothing. * Fix tsc on Windows - globbing doesn't work there. There's probably a cleaner way to do this... * Bump version. * Dep bumps. * fixup 9d57b32: make fs patch code clearer. * fixup 3771c720: simplify test to just use require directly. --------- Co-authored-by: calebboyd <caleb.boyd@gmail.com>	2023-08-20 14:43:06 -05:00
calebboyd	fdd9d97db3	bump rc.2	2022-12-19 16:12:55 -06:00
bruce-one	a746e00379	fix: node v18.12 startup (#1026 ) Fixes https://github.com/nexe/nexe/issues/1019	2022-12-19 08:15:24 -06:00
calebboyd	1eeac1b538	Revert "build: add workflow for autoclose issues without response" This reverts commit `37ee352408`.	2022-08-10 08:32:37 -05:00
Caleb Boyd	ac1d444b17	refactor: replace cherow with meriyah for parsing es (#986 )	2022-05-05 11:50:46 -05:00
CommanderRoot	af7e1cb1be	refactor: replace deprecated String.prototype.substr() (#975 ) .substr() is deprecated so we replace it with .slice() which works similarily but isn't deprecated Signed-off-by: Tobias Speicher <rootcommander@gmail.com>	2022-05-03 10:51:58 -05:00
bmaupin	ec1fcf66c6	docs: python 3 should be used (#972 )	2022-03-17 13:26:31 -05:00
James McCallum	51b478a18d	fix: use correct ignore ssl env var (#932 )	2021-10-29 06:47:16 -05:00
Akihito Mikazuki	95050d0472	docs:python2 to python3 in cli help	2021-10-04 14:36:04 -05:00
calebboyd	eb2ba5007a	build: typecheck tasks	2021-09-27 12:59:55 -05:00
calebboyd	e5ae6a124a	chore: any error in build log	2021-09-27 09:46:03 -05:00
calebboyd	4cd04d1b0c	chore: bump version	2021-09-26 21:20:48 -05:00
calebboyd	e539093ef4	docs: update readme	2021-09-26 17:15:06 -05:00
calebboyd	805ca35149	chore: update dependencies	2021-09-26 16:59:48 -05:00
calebboyd	37ee352408	build: add workflow for autoclose issues without response	2021-09-26 15:50:55 -05:00
Asher Oto	a9811257ea	docs: update readme (#861 )	2021-09-26 13:43:14 -05:00
bruce-one	dd3dec1f9d	docs: document asset option. (#903 )	2021-09-26 13:37:29 -05:00
bruce-one	fe9f73d22b	fix: support fs.realpath(Sync).native. (#892 )	2021-09-14 10:26:26 -05:00
Caleb Boyd	0c7b942f7f	fix(fs): only override time references (#883 )	2021-04-05 05:55:24 -05:00
Jared Allard	bd09fe59de	docs(README): add discord (#870 )	2021-02-25 19:54:16 -06:00
calebboyd	9962630ace	chore: bump package-lock version and dev deps	2021-02-25 06:37:52 -06:00
Wilmar den Ouden	232e1005e6	fix: update resolve-dependencies to 6.0.5 (#869 )	2021-02-25 06:32:35 -06:00
calebboyd	9f22309949	feat: add asset flag for using cached artifact	2021-01-26 07:16:29 -06:00
calebboyd	cf8e6ff393	fix: got upload searchParams	2021-01-05 12:47:29 -06:00
calebboyd	7275d4b848	fix: update dependencies	2021-01-03 17:00:24 -06:00
calebboyd	06a8242114	fix: resolve resources relative to passed cwd closes #645	2021-01-03 16:25:52 -06:00
calebboyd	2935ee3f93	fix: add lstat patch	2021-01-03 15:29:55 -06:00
calebboyd	9f1f323b09	build: audit fix	2020-12-16 15:08:08 -06:00
bruce-one	0ba696e976	fix: support for 12.19.1. (#835 )	2020-11-21 16:20:38 -06:00
bruce-one	0f0869b292	fix: internal module read json changes 12.18.3 (#803 )	2020-09-24 10:13:22 -05:00
calebboyd	c5dabbf9b4	build: audit fix	2020-07-21 08:59:59 -05:00
calebboyd	e51b6b21a6	fix: set filesize for resource files	2020-07-10 07:12:14 -05:00
calebboyd	2b261728b4	feat: deterministic builds	2020-07-09 10:21:14 -05:00
Caleb Boyd	017abb94cc	docs: add funding.yml	2020-07-01 10:33:33 -05:00