fix: cleanup zip finalization

There's probably a cleaner way to do this...

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

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

README.md

@@ -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[]`
@@ -218,6 +252,19 @@ Any modifications made to `NexeFile#contents` will be maintained in the cache _w
 
 In order to use native modules, the native binaries must be shipped alongside the binary generated by nexe.
 
+## 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
 
 Building

azure-pipelines.yml

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

package.json

@@ -2,7 +2,7 @@
   "name": "nexe",
   "description": "Create a single executable out of your Node.js application",
   "license": "MIT",
-  "version": "4.0.0-beta.15",
+  "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,44 +36,59 @@
   "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": "^2.6.0-rc.8",
+    "@yarnpkg/libzip": "^2.2.2",
+    "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": "^11.8.2",
+    "meriyah": "^4.3.3",
+    "minimist": "^1.2.6",
     "mkdirp": "^1.0.4",
-    "multistream": "^4.0.0",
+    "multistream": "^4.1.0",
     "ora": "^3.4.0",
-    "pify": "^4.0.1",
-    "resolve-dependencies": "^6.0.2",
-    "rimraf": "^3.0.2"
+    "resolve-dependencies": "^6.0.8",
+    "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/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": "^6",
+    "@types/globby": "^9",
+    "@types/got": "^9.6.12",
+    "@types/highland": "^2.12.14",
+    "@types/lodash": "^4.14.173",
+    "@types/minimist": "^1.2.2",
+    "@types/mkdirp": "^1.0.2",
+    "@types/mocha": "^9.0.0",
+    "@types/multistream": "^4.1.0",
+    "@types/node": "^16.10.2",
     "@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.2",
-    "mocha": "^7.1.1",
-    "prettier": "^2.0.5",
-    "ts-node": "^8.9.0",
+    "@types/rimraf": "3.0.2",
+    "@types/semver": "^7.3.8",
+    "chai": "^4.3.6",
+    "execa": "^5.1.1",
+    "lodash": "^4.17.21",
+    "mocha": "^10.0.0",
+    "prettier": "^2.6.2",
+    "ts-node": "^10.7.0",
     "tslint": "^6.1.1",
     "tslint-config-prettier": "^1.18.0",
     "tslint-plugin-prettier": "^2.3.0",
-    "typescript": "^3.8.3"
+    "typescript": "^4.6.4",
+    "webpack-cli": "^4.8.0"
   }
 }

src/compiler.ts

@@ -16,9 +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'
@@ -110,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)
@@ -198,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())
     }
@@ -208,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,
@@ -292,24 +289,34 @@ 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 resources = this.bundle.renderIndex()
-    this.shims.unshift(wrap(`process.__nexe = ${JSON.stringify({ resources })};\n`))
+    const launchCode = this.code()
+    const codeSize = Buffer.byteLength(launchCode)
+    const sentinel = Buffer.from('<nexe~~sentinel>')
 
-    const code = this.code(),
-      codeSize = Buffer.byteLength(code),
-      lengths = Buffer.from(Array(16))
+    let vfsSize = 0
+    const streams = [binary, toStream(launchCode), this.bundle.toStream().pipe(new Transform({
+      transform: (chunk, _, cb) => {
+        vfsSize || this.bundle.finalize()
+        chunk && (vfsSize += chunk.length)
+        cb(null, chunk)
+      },
+    }))]
 
-    lengths.writeDoubleLE(codeSize, 0)
-    lengths.writeDoubleLE(this.bundle.size, 8)
-    return new (MultiStream as any)([
-      binary,
-      toStream(code),
-      this.bundle.toStream(),
-      toStream(Buffer.concat([Buffer.from('<nexe~~sentinel>'), lengths])),
-    ])
+    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

@@ -0,0 +1,383 @@
+import { Libzip } from '@yarnpkg/libzip'
+import {
+  FakeFS,
+  PortablePath,
+  ZipFS,
+  ZipOpenFS,
+  RmdirOptions,
+  OpendirOptions,
+} from '@yarnpkg/fslib'
+import { BasePortableFakeFS, Dirent, MkdirOptions, Dir } from '@yarnpkg/fslib/lib/FakeFS'
+import { CustomDir } from '@yarnpkg/fslib/lib/algorithms/opendir'
+import { FSPath, ppath, npath, Filename } from '@yarnpkg/fslib/lib/path'
+import { resolve, toNamespacedPath } from 'path'
+import { constants } from 'fs'
+
+export type SnapshotZipFSOptions = {
+  baseFs: FakeFS<PortablePath>
+  libzip: Libzip | (() => Libzip)
+  zipFs: ZipFS
+}
+
+const uniqBy = (arr: Array<string | Dirent>, pick: (...arg: any[]) => any) => {
+  return arr.filter((x, i, self) => i === self.findIndex((y) => pick(x) === pick(y)))
+}
+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>
+  constructor(opts: SnapshotZipFSOptions) {
+    super()
+    this.zipFs = opts.zipFs
+    this.baseFs = opts.baseFs
+  }
+  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.makeCallPromise(
+      p,
+      async () => {
+        return await this.baseFs.realpathPromise(p)
+      },
+      async (zipFs, { subPath }) => {
+        return await zipFs.realpathPromise(subPath)
+      }
+    )
+  }
+
+  realpathSync(p: PortablePath) {
+    return this.makeCallSync(
+      p,
+      () => {
+        return this.baseFs.realpathSync(p)
+      },
+      (zipFs, { subPath }) => {
+        return zipFs.realpathSync(subPath)
+      }
+    )
+  }
+
+  findZip(p: PortablePath) {
+    p = this.resolve(p)
+    const pathsToTry = Array.from(
+      new Set([
+        p,
+        resolve('/snapshot', p),
+        ppath.resolve(
+          npath.toPortablePath('/snapshot'),
+          npath.toPortablePath(
+            npath.relative(npath.fromPortablePath(process.cwd()), npath.fromPortablePath(p))
+          )
+        ),
+        ppath.resolve(
+          npath.toPortablePath('/snapshot'),
+          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,
+        }
+      }
+    }
+  }
+
+  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 as any[]).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 as any[]).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 Promise.resolve(this.zipFs.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
+  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/bundle.ts

@@ -1,24 +1,10 @@
-import * as fs from 'fs'
-import { promisify } from 'util'
 import { relative } from 'path'
 import { Readable } from 'stream'
-import { argv } from '../options'
 import { File } from 'resolve-dependencies'
-import MultiStream = require('multistream')
+import archiver from 'archiver'
 
-const lstat = promisify(fs.lstat),
-  realpath = promisify(fs.realpath),
-  createReadStream = fs.createReadStream,
-  stat = promisify(fs.stat)
-
-export type MultiStreams = (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
+function makeRelativeToZip(cwd: string, path: string) {
+  return '/snapshot/' + relative(cwd, path)
 }
 
 export function toStream(content: Buffer | string) {
@@ -30,127 +16,36 @@ export function toStream(content: Buffer | string) {
   })
   return readable
 }
-
-async function createFile(absoluteFileName: string) {
-  const stats = await lstat(absoluteFileName),
-    file: File = {
-      size: stats.size,
-      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 {
-  size = 0
   cwd: string
-  rendered = false
-  private offset = 0
-  private index: { [key: string]: [number, number] } = {}
-  private files: { [key: string]: File } = {}
-  streams: MultiStreams = []
+  files = new Set<string>()
+  zip: any
   constructor({ cwd }: { cwd: string } = { cwd: process.cwd() }) {
     this.cwd = cwd
+    this.zip = archiver('zip')
   }
 
   get list() {
-    return Object.keys(this.files)
+    return Array.from(this.files)
   }
 
-  public async addResource(
-    absoluteFileName: string,
-    content?: File | Buffer | string
-  ): Promise<number> {
-    if (this.files[absoluteFileName]) {
-      return this.size
-    }
-    if (typeof content === 'string' || Buffer.isBuffer(content)) {
-      this.files[absoluteFileName] = {
-        size: Buffer.byteLength(content),
-        contents: content as any, //todo type is wrong here... should allow buffer
-        deps: {},
-        absPath: absoluteFileName,
-      }
-    } else if (content) {
-      this.files[content.absPath] = content
-    } else {
-      this.files[absoluteFileName] = {
-        absPath: absoluteFileName,
-        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: [string, File][] = [],
-      symLinks: [string, File][] = []
-    for (const entry of files) {
-      if (entry[1].realPath) {
-        symLinks.push(entry)
+  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 {
-        realFiles.push(entry)
+        this.zip.append(content, { name: destPath })
       }
-    }
-    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
+      this.files.add(destPath)
     }
   }
 
-  toStream() {
-    return new (MultiStream as any)(this.streams)
+  public finalize() {
+    return this.zip.finalize()
+  }
+
+  public toStream(): Readable {
+    return this.zip
   }
 }

src/fs/patch.ts

@@ -1,321 +1,76 @@
-import { Stats } from 'fs'
+import { getLibzipSync } from '@yarnpkg/libzip'
+import { patchFs, npath, PosixFS, NodeFS, ZipFS } from '@yarnpkg/fslib'
+import { SnapshotZipFS } from './SnapshotZipFS'
+import * as assert from 'assert'
+import * as constants from 'constants'
 
-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 || {}
+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, {
+    libzip: getLibzipSync(),
+    readOnly: true,
+  })
+  const snapshotZipFS = new SnapshotZipFS({
+    libzip: getLibzipSync(),
+    zipFs,
+    baseFs: nodeFs,
+  })
+  const posixSnapshotZipFs = new PosixFS(snapshotZipFS)
+  patchFs(fs, posixSnapshotZipFs)
+  const { readFileSync } = fs
 
   let log = (_: string) => true
   let loggedManifest = false
   if ((process.env.DEBUG || '').toLowerCase().includes('nexe:require')) {
     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')
+        // TODO anything meaningful to log here?
         loggedManifest = true
       }
       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(),
-    }
-  }
-
-  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
-  }
-
-  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)
-    }
-  }
-
-  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(`internalModuleReadFile ${args[0]}`)
+    try {
+      return fs.readFileSync(args[0], 'utf-8')
+    } catch (e) {
+      return null
     }
-    log('read          (miss)       ' + filepath)
-    return original.call(this, ...args)
   }
   let returningArray: boolean
   patches.internalModuleReadJSON = function (this: any, original: any, ...args: any[]) {
@@ -326,80 +81,21 @@ function shimFs(binary: NexeBinary, fs: any = require('fs')) {
       : res
   }
   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 = fs.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)
+  // TODO restore patches in restoreFs
 
   lazyRestoreFs = () => {
-    Object.keys(nfs).forEach((key) => {
-      fs[key] = originalFsMethods[key]
-    })
+    Object.assign(fs, originalFsMethods)
     lazyRestoreFs = () => {}
   }
-  return true
 }
 
 function restoreFs() {

src/nexe.ts

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

src/options.ts

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

src/patches/boot-nexe.ts

@@ -1,14 +1,15 @@
 const fs = require('fs'),
   fd = fs.openSync(process.execPath, 'r'),
   stat = fs.statSync(process.execPath),
-  tailSize = Math.min(stat.size, 16000),
+  tailSize = Math.min(stat.size, 4096),
   tailWindow = Buffer.from(Array(tailSize))
 
 fs.readSync(fd, tailWindow, 0, tailSize, stat.size - tailSize)
 
 const footerPosition = tailWindow.indexOf('<nexe~~sentinel>')
-if (footerPosition == -1) {
-  throw 'Invalid Nexe binary'
+if (footerPosition === -1) {
+  process.stderr.write('Invalid Nexe binary')
+  process.exit(1)
 }
 
 const footer = tailWindow.slice(footerPosition, footerPosition + 32),

src/patches/third-party-main.ts

@@ -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')) {
@@ -37,12 +39,10 @@ export default async function main(compiler: NexeCompiler, next: () => Promise<v
 
   const file = await compiler.readFileAsync(bootFile),
     ast = parse(file.contents.toString(), {
-      loc: true,
-      tolerant: true,
       next: true,
       globalReturn: true,
-      node: true,
-      skipShebang: true,
+      loc: true,
+      specDeviation: true,
     }),
     location = { start: { line: 0 } }
 
@@ -58,7 +58,7 @@ export default async function main(compiler: NexeCompiler, next: () => Promise<v
   fileLines.splice(
     location.start.line,
     0,
-    '{{replace:lib/fs/bootstrap.js}}' +
+    '{{ file("lib/fs/bootstrap.js") }}' +
       '\n' +
       (semverGt(version, '11.99') ? 'expandArgv1 = false;\n' : '')
   )
@@ -69,13 +69,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(
@@ -102,7 +102,7 @@ export default async function main(compiler: NexeCompiler, next: () => Promise<v
   } else {
     await compiler.setFileContentsAsync(
       'lib/_third_party_main.js',
-      '{{replace:lib/patches/boot-nexe.js}}'
+      '{{ file("lib/patches/boot-nexe.js") }}'
     )
   }
   return next()

src/steps/bundle.ts

@@ -61,9 +61,11 @@ export default async function bundle(compiler: NexeCompiler, next: any) {
     compiler.entrypoint = './' + relative(cwd, input)
   }
 
-  const { files, warnings } = resolveFiles(
+  const step = compiler.log.step('Resolving dependencies...')
+
+  const { files, warnings } = await resolveFiles(
     input,
-    ...Object.keys(compiler.bundle.list).filter((x) => x.endsWith('.js')),
+    ...Object.keys(compiler.bundle.list).filter((x) => x.endsWith('.js') || x.endsWith('.mjs')),
     { cwd, expand: 'variable', loadContent: false }
   )
 
@@ -76,8 +78,9 @@ export default async function bundle(compiler: NexeCompiler, next: any) {
   //TODO: warnings.forEach((x) => console.log(x))
 
   await Promise.all(
-    Object.entries(files).map(([key, file]) => {
-      return compiler.addResource(key, file)
+    Object.entries(files).map(([key]) => {
+      step.log(`Including dependency: ${key}`)
+      return compiler.addResource(key)
     })
   )
 

src/steps/download.ts

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

src/steps/resource.ts

@@ -1,5 +1,6 @@
 import { each } from '../util'
-import * as globs from 'globby'
+import globs from 'globby'
+import { resolve } from 'path'
 import { NexeCompiler } from '../compiler'
 
 export default async function resource(compiler: NexeCompiler, next: () => Promise<any>) {
@@ -17,7 +18,7 @@ export default async function resource(compiler: NexeCompiler, next: () => Promi
   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()

src/steps/shim.ts

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

src/util.ts

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

tasks/build.ts

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

tasks/docker.ts

@@ -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 {
@@ -58,11 +58,17 @@ export async function runDockerBuild(target: NexeTarget) {
       appendFileSync(outFilename, x.stderr)
       appendFileSync(outFilename, x.stdout)
     })
-    await got(`https://transfer.sh/${Math.random().toString(36).substring(2)}.txt`, {
-      body: await readFileAsync(outFilename),
-      method: 'PUT',
-    })
-      .then((x) => console.log('Posted docker log: ', x.body))
-      .catch((e) => console.log('Error posting log', e))
+    try {
+      const { body } = await got(
+        `https://transfer.sh/${Math.random().toString(36).substring(2)}.txt`,
+        {
+          body: await readFileAsync(outFilename),
+          method: 'PUT',
+        }
+      )
+      console.log('Posted docker log: ', body)
+    } catch (e) {
+      console.log('Error posting log', e)
+    }
   }
 }

tasks/post-build.ts

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

tasks/tsconfig.json

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

test/integration/index.js

@@ -0,0 +1,18 @@
+const { mkdtemp } = require('fs/promises')
+const os = require('os')
+const path = require('path')
+const rimraf = require('rimraf')
+
+async function runTests() {
+  const tempdir = await mkdtemp(path.join(os.tmpdir(), 'nexe-'))
+  process.on('beforeExit', () => rimraf.sync(tempdir))
+  process.chdir(tempdir)
+  const Mocha = require('mocha')
+  const mocha = new Mocha()
+  mocha.addFile('test/integration/tests.integration-spec.js')
+  mocha.run((failures) => {
+    process.exitCode = failures ? 1 : 0
+  })
+}
+
+runTests()

test/integration/tests.integration-spec.js

@@ -0,0 +1,112 @@
+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', () => {
+      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())
+  })
+})

test/mocha.opts

@@ -1,4 +0,0 @@
-./test/**/*.spec.ts
---check-leaks
---require ts-node/register
---recursive

tsconfig.json

@@ -3,6 +3,7 @@
     "target":"es2015",
     "skipLibCheck": true,
     "experimentalDecorators": true,
+    "esModuleInterop": true,
     "lib": ["es2018"],
     "module": "commonjs",
     "outDir": "./lib",

webpack.config.ts

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