'use strict'

############################################################################################################
#
#===========================================================================================================
UNSTABLE_TEMP_BRICS =

  #===========================================================================================================
  require_temp_internal_tmp: ->
    R = {}
    ```
    /*!
     * Tmp
     *
     * Copyright (c) 2011-2017 KARASZI Istvan <github@spam.raszi.hu>
     *
     * MIT Licensed
     */

    /*
     * Module dependencies.
     */
    const fs = require('node:fs');
    const os = require('node:os');
    const path = require('node:path');
    const crypto = require('node:crypto');
    const _c = { fs: fs.constants, os: os.constants };

    /*
     * The working inner variables.
     */
    const // the random characters to choose from
      RANDOM_CHARS = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz',
      TEMPLATE_PATTERN = /XXXXXX/,
      DEFAULT_TRIES = 3,
      CREATE_FLAGS = (_c.O_CREAT || _c.fs.O_CREAT) | (_c.O_EXCL || _c.fs.O_EXCL) | (_c.O_RDWR || _c.fs.O_RDWR),
      // constants are off on the windows platform and will not match the actual errno codes
      IS_WIN32 = os.platform() === 'win32',
      EBADF = _c.EBADF || _c.os.errno.EBADF,
      ENOENT = _c.ENOENT || _c.os.errno.ENOENT,
      DIR_MODE = 0o700 /* 448 */,
      FILE_MODE = 0o600 /* 384 */,
      EXIT = 'exit',
      // this will hold the objects need to be removed on exit
      _removeObjects = [],
      // API change in fs.rmdirSync leads to error when passing in a second parameter, e.g. the callback
      FN_RMDIR_SYNC = fs.rmdirSync.bind(fs);

    let _gracefulCleanup = false;

    /**
     * Recursively remove a directory and its contents.
     *
     * @param {string} dirPath path of directory to remove
     * @param {Function} callback
     * @private
     */
    function rimraf(dirPath, callback) {
      return fs.rm(dirPath, { recursive: true }, callback);
    }

    /**
     * Recursively remove a directory and its contents, synchronously.
     *
     * @param {string} dirPath path of directory to remove
     * @private
     */
    function FN_RIMRAF_SYNC(dirPath) {
      return fs.rmSync(dirPath, { recursive: true });
    }

    /**
     * Gets a temporary file name.
     *
     * @param {(Options|tmpNameCallback)} options options or callback
     * @param {?tmpNameCallback} callback the callback function
     */
    function tmpName(options, callback) {
      const args = _parseArguments(options, callback),
        opts = args[0],
        cb = args[1];

      _assertAndSanitizeOptions(opts, function (err, sanitizedOptions) {
        if (err) return cb(err);

        let tries = sanitizedOptions.tries;
        (function _getUniqueName() {
          try {
            const name = _generateTmpName(sanitizedOptions);

            // check whether the path exists then retry if needed
            fs.stat(name, function (err) {
              /* istanbul ignore else */
              if (!err) {
                /* istanbul ignore else */
                if (tries-- > 0) return _getUniqueName();

                return cb(new Error('Could not get a unique tmp filename, max tries reached ' + name));
              }

              cb(null, name);
            });
          } catch (err) {
            cb(err);
          }
        })();
      });
    }

    /**
     * Synchronous version of tmpName.
     *
     * @param {Object} options
     * @returns {string} the generated random name
     * @throws {Error} if the options are invalid or could not generate a filename
     */
    function tmpNameSync(options) {
      const args = _parseArguments(options),
        opts = args[0];

      const sanitizedOptions = _assertAndSanitizeOptionsSync(opts);

      let tries = sanitizedOptions.tries;
      do {
        const name = _generateTmpName(sanitizedOptions);
        try {
          fs.statSync(name);
        } catch (e) {
          return name;
        }
      } while (tries-- > 0);

      throw new Error('Could not get a unique tmp filename, max tries reached');
    }

    /**
     * Creates and opens a temporary file.
     *
     * @param {(Options|null|undefined|fileCallback)} options the config options or the callback function or null or undefined
     * @param {?fileCallback} callback
     */
    function file(options, callback) {
      const args = _parseArguments(options, callback),
        opts = args[0],
        cb = args[1];

      // gets a temporary filename
      tmpName(opts, function _tmpNameCreated(err, name) {
        /* istanbul ignore else */
        if (err) return cb(err);

        // create and open the file
        fs.open(name, CREATE_FLAGS, opts.mode || FILE_MODE, function _fileCreated(err, fd) {
          /* istanbu ignore else */
          if (err) return cb(err);

          if (opts.discardDescriptor) {
            return fs.close(fd, function _discardCallback(possibleErr) {
              // the chance of getting an error on close here is rather low and might occur in the most edgiest cases only
              return cb(possibleErr, name, undefined, _prepareTmpFileRemoveCallback(name, -1, opts, false));
            });
          } else {
            // detachDescriptor passes the descriptor whereas discardDescriptor closes it, either way, we no longer care
            // about the descriptor
            const discardOrDetachDescriptor = opts.discardDescriptor || opts.detachDescriptor;
            cb(null, name, fd, _prepareTmpFileRemoveCallback(name, discardOrDetachDescriptor ? -1 : fd, opts, false));
          }
        });
      });
    }

    /**
     * Synchronous version of file.
     *
     * @param {Options} options
     * @returns {FileSyncObject} object consists of name, fd and removeCallback
     * @throws {Error} if cannot create a file
     */
    function fileSync(options) {
      const args = _parseArguments(options),
        opts = args[0];

      const discardOrDetachDescriptor = opts.discardDescriptor || opts.detachDescriptor;
      const name = tmpNameSync(opts);
      let fd = fs.openSync(name, CREATE_FLAGS, opts.mode || FILE_MODE);
      /* istanbul ignore else */
      if (opts.discardDescriptor) {
        fs.closeSync(fd);
        fd = undefined;
      }

      return {
        name: name,
        fd: fd,
        removeCallback: _prepareTmpFileRemoveCallback(name, discardOrDetachDescriptor ? -1 : fd, opts, true)
      };
    }

    /**
     * Creates a temporary directory.
     *
     * @param {(Options|dirCallback)} options the options or the callback function
     * @param {?dirCallback} callback
     */
    function dir(options, callback) {
      const args = _parseArguments(options, callback),
        opts = args[0],
        cb = args[1];

      // gets a temporary filename
      tmpName(opts, function _tmpNameCreated(err, name) {
        /* istanbul ignore else */
        if (err) return cb(err);

        // create the directory
        fs.mkdir(name, opts.mode || DIR_MODE, function _dirCreated(err) {
          /* istanbul ignore else */
          if (err) return cb(err);

          cb(null, name, _prepareTmpDirRemoveCallback(name, opts, false));
        });
      });
    }

    /**
     * Synchronous version of dir.
     *
     * @param {Options} options
     * @returns {DirSyncObject} object consists of name and removeCallback
     * @throws {Error} if it cannot create a directory
     */
    function dirSync(options) {
      const args = _parseArguments(options),
        opts = args[0];

      const name = tmpNameSync(opts);
      fs.mkdirSync(name, opts.mode || DIR_MODE);

      return {
        name: name,
        removeCallback: _prepareTmpDirRemoveCallback(name, opts, true)
      };
    }

    /**
     * Removes files asynchronously.
     *
     * @param {Object} fdPath
     * @param {Function} next
     * @private
     */
    function _removeFileAsync(fdPath, next) {
      const _handler = function (err) {
        if (err && !_isENOENT(err)) {
          // reraise any unanticipated error
          return next(err);
        }
        next();
      };

      if (0 <= fdPath[0])
        fs.close(fdPath[0], function () {
          fs.unlink(fdPath[1], _handler);
        });
      else fs.unlink(fdPath[1], _handler);
    }

    /**
     * Removes files synchronously.
     *
     * @param {Object} fdPath
     * @private
     */
    function _removeFileSync(fdPath) {
      let rethrownException = null;
      try {
        if (0 <= fdPath[0]) fs.closeSync(fdPath[0]);
      } catch (e) {
        // reraise any unanticipated error
        if (!_isEBADF(e) && !_isENOENT(e)) throw e;
      } finally {
        try {
          fs.unlinkSync(fdPath[1]);
        } catch (e) {
          // reraise any unanticipated error
          if (!_isENOENT(e)) rethrownException = e;
        }
      }
      if (rethrownException !== null) {
        throw rethrownException;
      }
    }

    /**
     * Prepares the callback for removal of the temporary file.
     *
     * Returns either a sync callback or a async callback depending on whether
     * fileSync or file was called, which is expressed by the sync parameter.
     *
     * @param {string} name the path of the file
     * @param {number} fd file descriptor
     * @param {Object} opts
     * @param {boolean} sync
     * @returns {fileCallback | fileCallbackSync}
     * @private
     */
    function _prepareTmpFileRemoveCallback(name, fd, opts, sync) {
      const removeCallbackSync = _prepareRemoveCallback(_removeFileSync, [fd, name], sync);
      const removeCallback = _prepareRemoveCallback(_removeFileAsync, [fd, name], sync, removeCallbackSync);

      if (!opts.keep) _removeObjects.unshift(removeCallbackSync);

      return sync ? removeCallbackSync : removeCallback;
    }

    /**
     * Prepares the callback for removal of the temporary directory.
     *
     * Returns either a sync callback or a async callback depending on whether
     * tmpFileSync or tmpFile was called, which is expressed by the sync parameter.
     *
     * @param {string} name
     * @param {Object} opts
     * @param {boolean} sync
     * @returns {Function} the callback
     * @private
     */
    function _prepareTmpDirRemoveCallback(name, opts, sync) {
      const removeFunction = opts.unsafeCleanup ? rimraf : fs.rmdir.bind(fs);
      const removeFunctionSync = opts.unsafeCleanup ? FN_RIMRAF_SYNC : FN_RMDIR_SYNC;
      const removeCallbackSync = _prepareRemoveCallback(removeFunctionSync, name, sync);
      const removeCallback = _prepareRemoveCallback(removeFunction, name, sync, removeCallbackSync);
      if (!opts.keep) _removeObjects.unshift(removeCallbackSync);

      return sync ? removeCallbackSync : removeCallback;
    }

    /**
     * Creates a guarded function wrapping the removeFunction call.
     *
     * The cleanup callback is save to be called multiple times.
     * Subsequent invocations will be ignored.
     *
     * @param {Function} removeFunction
     * @param {string} fileOrDirName
     * @param {boolean} sync
     * @param {cleanupCallbackSync?} cleanupCallbackSync
     * @returns {cleanupCallback | cleanupCallbackSync}
     * @private
     */
    function _prepareRemoveCallback(removeFunction, fileOrDirName, sync, cleanupCallbackSync) {
      let called = false;

      // if sync is true, the next parameter will be ignored
      return function _cleanupCallback(next) {
        /* istanbul ignore else */
        if (!called) {
          // remove cleanupCallback from cache
          const toRemove = cleanupCallbackSync || _cleanupCallback;
          const index = _removeObjects.indexOf(toRemove);
          /* istanbul ignore else */
          if (index >= 0) _removeObjects.splice(index, 1);

          called = true;
          if (sync || removeFunction === FN_RMDIR_SYNC || removeFunction === FN_RIMRAF_SYNC) {
            return removeFunction(fileOrDirName);
          } else {
            return removeFunction(fileOrDirName, next || function () {});
          }
        }
      };
    }

    /**
     * The garbage collector.
     *
     * @private
     */
    function _garbageCollector() {
      /* istanbul ignore else */
      if (!_gracefulCleanup) return;

      // the function being called removes itself from _removeObjects,
      // loop until _removeObjects is empty
      while (_removeObjects.length) {
        try {
          _removeObjects[0]();
        } catch (e) {
          // already removed?
        }
      }
    }

    /**
     * Random name generator based on crypto.
     * Adapted from http://blog.tompawlak.org/how-to-generate-random-values-nodejs-javascript
     *
     * @param {number} howMany
     * @returns {string} the generated random name
     * @private
     */
    function _randomChars(howMany) {
      let value = [],
        rnd = null;

      // make sure that we do not fail because we ran out of entropy
      try {
        rnd = crypto.randomBytes(howMany);
      } catch (e) {
        rnd = crypto.pseudoRandomBytes(howMany);
      }

      for (let i = 0; i < howMany; i++) {
        value.push(RANDOM_CHARS[rnd[i] % RANDOM_CHARS.length]);
      }

      return value.join('');
    }

    /**
     * Checks whether the `obj` parameter is defined or not.
     *
     * @param {Object} obj
     * @returns {boolean} true if the object is undefined
     * @private
     */
    function _isUndefined(obj) {
      return typeof obj === 'undefined';
    }

    /**
     * Parses the function arguments.
     *
     * This function helps to have optional arguments.
     *
     * @param {(Options|null|undefined|Function)} options
     * @param {?Function} callback
     * @returns {Array} parsed arguments
     * @private
     */
    function _parseArguments(options, callback) {
      /* istanbul ignore else */
      if (typeof options === 'function') {
        return [{}, options];
      }

      /* istanbul ignore else */
      if (_isUndefined(options)) {
        return [{}, callback];
      }

      // copy options so we do not leak the changes we make internally
      const actualOptions = {};
      for (const key of Object.getOwnPropertyNames(options)) {
        actualOptions[key] = options[key];
      }

      return [actualOptions, callback];
    }

    /**
     * Resolve the specified path name in respect to tmpDir.
     *
     * The specified name might include relative path components, e.g. ../
     * so we need to resolve in order to be sure that is is located inside tmpDir
     *
     * @private
     */
    function _resolvePath(name, tmpDir, cb) {
      const pathToResolve = path.isAbsolute(name) ? name : path.join(tmpDir, name);

      fs.stat(pathToResolve, function (err) {
        if (err) {
          fs.realpath(path.dirname(pathToResolve), function (err, parentDir) {
            if (err) return cb(err);

            cb(null, path.join(parentDir, path.basename(pathToResolve)));
          });
        } else {
          fs.realpath(pathToResolve, cb);
        }
      });
    }

    /**
     * Resolve the specified path name in respect to tmpDir.
     *
     * The specified name might include relative path components, e.g. ../
     * so we need to resolve in order to be sure that is is located inside tmpDir
     *
     * @private
     */
    function _resolvePathSync(name, tmpDir) {
      const pathToResolve = path.isAbsolute(name) ? name : path.join(tmpDir, name);

      try {
        fs.statSync(pathToResolve);
        return fs.realpathSync(pathToResolve);
      } catch (_err) {
        const parentDir = fs.realpathSync(path.dirname(pathToResolve));

        return path.join(parentDir, path.basename(pathToResolve));
      }
    }

    /**
     * Generates a new temporary name.
     *
     * @param {Object} opts
     * @returns {string} the new random name according to opts
     * @private
     */
    function _generateTmpName(opts) {
      const tmpDir = opts.tmpdir;

      /* istanbul ignore else */
      if (!_isUndefined(opts.name)) {
        return path.join(tmpDir, opts.dir, opts.name);
      }

      /* istanbul ignore else */
      if (!_isUndefined(opts.template)) {
        return path.join(tmpDir, opts.dir, opts.template).replace(TEMPLATE_PATTERN, _randomChars(6));
      }

      // prefix and postfix
      const name = [
        opts.prefix ? opts.prefix : 'tmp',
        '-',
        process.pid,
        '-',
        _randomChars(12),
        opts.postfix ? '-' + opts.postfix : ''
      ].join('');

      return path.join(tmpDir, opts.dir, name);
    }

    /**
     * Asserts and sanitizes the basic options.
     *
     * @private
     */
    function _assertOptionsBase(options) {
      if (!_isUndefined(options.name)) {
        const name = options.name;

        // assert that name is not absolute and does not contain a path
        if (path.isAbsolute(name)) throw new Error(`name option must not contain an absolute path, found "${name}".`);

        // must not fail on valid .<name> or ..<name> or similar such constructs
        const basename = path.basename(name);
        if (basename === '..' || basename === '.' || basename !== name)
          throw new Error(`name option must not contain a path, found "${name}".`);
      }

      /* istanbul ignore else */
      if (!_isUndefined(options.template) && !options.template.match(TEMPLATE_PATTERN)) {
        throw new Error(`Invalid template, found "${options.template}".`);
      }

      /* istanbul ignore else */
      if ((!_isUndefined(options.tries) && isNaN(options.tries)) || options.tries < 0) {
        throw new Error(`Invalid tries, found "${options.tries}".`);
      }

      // if a name was specified we will try once
      options.tries = _isUndefined(options.name) ? options.tries || DEFAULT_TRIES : 1;
      options.keep = !!options.keep;
      options.detachDescriptor = !!options.detachDescriptor;
      options.discardDescriptor = !!options.discardDescriptor;
      options.unsafeCleanup = !!options.unsafeCleanup;

      // for completeness' sake only, also keep (multiple) blanks if the user, purportedly sane, requests us to
      options.prefix = _isUndefined(options.prefix) ? '' : options.prefix;
      options.postfix = _isUndefined(options.postfix) ? '' : options.postfix;
    }

    /**
     * Gets the relative directory to tmpDir.
     *
     * @private
     */
    function _getRelativePath(option, name, tmpDir, cb) {
      if (_isUndefined(name)) return cb(null);

      _resolvePath(name, tmpDir, function (err, resolvedPath) {
        if (err) return cb(err);

        const relativePath = path.relative(tmpDir, resolvedPath);

        if (!resolvedPath.startsWith(tmpDir)) {
          return cb(new Error(`${option} option must be relative to "${tmpDir}", found "${relativePath}".`));
        }

        cb(null, relativePath);
      });
    }

    /**
     * Gets the relative path to tmpDir.
     *
     * @private
     */
    function _getRelativePathSync(option, name, tmpDir) {
      if (_isUndefined(name)) return;

      const resolvedPath = _resolvePathSync(name, tmpDir);
      const relativePath = path.relative(tmpDir, resolvedPath);

      if (!resolvedPath.startsWith(tmpDir)) {
        throw new Error(`${option} option must be relative to "${tmpDir}", found "${relativePath}".`);
      }

      return relativePath;
    }

    /**
     * Asserts whether the specified options are valid, also sanitizes options and provides sane defaults for missing
     * options.
     *
     * @private
     */
    function _assertAndSanitizeOptions(options, cb) {
      _getTmpDir(options, function (err, tmpDir) {
        if (err) return cb(err);

        options.tmpdir = tmpDir;

        try {
          _assertOptionsBase(options, tmpDir);
        } catch (err) {
          return cb(err);
        }

        // sanitize dir, also keep (multiple) blanks if the user, purportedly sane, requests us to
        _getRelativePath('dir', options.dir, tmpDir, function (err, dir) {
          if (err) return cb(err);

          options.dir = _isUndefined(dir) ? '' : dir;

          // sanitize further if template is relative to options.dir
          _getRelativePath('template', options.template, tmpDir, function (err, template) {
            if (err) return cb(err);

            options.template = template;

            cb(null, options);
          });
        });
      });
    }

    /**
     * Asserts whether the specified options are valid, also sanitizes options and provides sane defaults for missing
     * options.
     *
     * @private
     */
    function _assertAndSanitizeOptionsSync(options) {
      const tmpDir = (options.tmpdir = _getTmpDirSync(options));

      _assertOptionsBase(options, tmpDir);

      const dir = _getRelativePathSync('dir', options.dir, tmpDir);
      options.dir = _isUndefined(dir) ? '' : dir;

      options.template = _getRelativePathSync('template', options.template, tmpDir);

      return options;
    }

    /**
     * Helper for testing against EBADF to compensate changes made to Node 7.x under Windows.
     *
     * @private
     */
    function _isEBADF(error) {
      return _isExpectedError(error, -EBADF, 'EBADF');
    }

    /**
     * Helper for testing against ENOENT to compensate changes made to Node 7.x under Windows.
     *
     * @private
     */
    function _isENOENT(error) {
      return _isExpectedError(error, -ENOENT, 'ENOENT');
    }

    /**
     * Helper to determine whether the expected error code matches the actual code and errno,
     * which will differ between the supported node versions.
     *
     * - Node >= 7.0:
     *   error.code {string}
     *   error.errno {number} any numerical value will be negated
     *
     * CAVEAT
     *
     * On windows, the errno for EBADF is -4083 but os.constants.errno.EBADF is different and we must assume that ENOENT
     * is no different here.
     *
     * @param {SystemError} error
     * @param {number} errno
     * @param {string} code
     * @private
     */
    function _isExpectedError(error, errno, code) {
      return IS_WIN32 ? error.code === code : error.code === code && error.errno === errno;
    }

    /**
     * Sets the graceful cleanup.
     *
     * If graceful cleanup is set, tmp will remove all controlled temporary objects on process exit, otherwise the
     * temporary objects will remain in place, waiting to be cleaned up on system restart or otherwise scheduled temporary
     * object removals.
     */
    function setGracefulCleanup() {
      _gracefulCleanup = true;
    }

    /**
     * Returns the currently configured tmp dir from os.tmpdir().
     *
     * @private
     */
    function _getTmpDir(options, cb) {
      return fs.realpath((options && options.tmpdir) || os.tmpdir(), cb);
    }

    /**
     * Returns the currently configured tmp dir from os.tmpdir().
     *
     * @private
     */
    function _getTmpDirSync(options) {
      return fs.realpathSync((options && options.tmpdir) || os.tmpdir());
    }

    // Install process exit listener
    process.addListener(EXIT, _garbageCollector);

    /**
     * Configuration options.
     *
     * @typedef {Object} Options
     * @property {?boolean} keep the temporary object (file or dir) will not be garbage collected
     * @property {?number} tries the number of tries before give up the name generation
     * @property (?int) mode the access mode, defaults are 0o700 for directories and 0o600 for files
     * @property {?string} template the "mkstemp" like filename template
     * @property {?string} name fixed name relative to tmpdir or the specified dir option
     * @property {?string} dir tmp directory relative to the root tmp directory in use
     * @property {?string} prefix prefix for the generated name
     * @property {?string} postfix postfix for the generated name
     * @property {?string} tmpdir the root tmp directory which overrides the os tmpdir
     * @property {?boolean} unsafeCleanup recursively removes the created temporary directory, even when it's not empty
     * @property {?boolean} detachDescriptor detaches the file descriptor, caller is responsible for closing the file, tmp will no longer try closing the file during garbage collection
     * @property {?boolean} discardDescriptor discards the file descriptor (closes file, fd is -1), tmp will no longer try closing the file during garbage collection
     */

    /**
     * @typedef {Object} FileSyncObject
     * @property {string} name the name of the file
     * @property {string} fd the file descriptor or -1 if the fd has been discarded
     * @property {fileCallback} removeCallback the callback function to remove the file
     */

    /**
     * @typedef {Object} DirSyncObject
     * @property {string} name the name of the directory
     * @property {fileCallback} removeCallback the callback function to remove the directory
     */

    /**
     * @callback tmpNameCallback
     * @param {?Error} err the error object if anything goes wrong
     * @param {string} name the temporary file name
     */

    /**
     * @callback fileCallback
     * @param {?Error} err the error object if anything goes wrong
     * @param {string} name the temporary file name
     * @param {number} fd the file descriptor or -1 if the fd had been discarded
     * @param {cleanupCallback} fn the cleanup callback function
     */

    /**
     * @callback fileCallbackSync
     * @param {?Error} err the error object if anything goes wrong
     * @param {string} name the temporary file name
     * @param {number} fd the file descriptor or -1 if the fd had been discarded
     * @param {cleanupCallbackSync} fn the cleanup callback function
     */

    /**
     * @callback dirCallback
     * @param {?Error} err the error object if anything goes wrong
     * @param {string} name the temporary file name
     * @param {cleanupCallback} fn the cleanup callback function
     */

    /**
     * @callback dirCallbackSync
     * @param {?Error} err the error object if anything goes wrong
     * @param {string} name the temporary file name
     * @param {cleanupCallbackSync} fn the cleanup callback function
     */

    /**
     * Removes the temporary created file or directory.
     *
     * @callback cleanupCallback
     * @param {simpleCallback} [next] function to call whenever the tmp object needs to be removed
     */

    /**
     * Removes the temporary created file or directory.
     *
     * @callback cleanupCallbackSync
     */

    /**
     * Callback function for function composition.
     * @see {@link https://github.com/raszi/node-tmp/issues/57|raszi/node-tmp#57}
     *
     * @callback simpleCallback
     */

    // exporting all the needed methods

    // evaluate _getTmpDir() lazily, mainly for simplifying testing but it also will
    // allow users to reconfigure the temporary directory
    Object.defineProperty(R, 'tmpdir', {
      enumerable: true,
      configurable: false,
      get: function () {
        return _getTmpDirSync();
      }
    });

    R.dir = dir;
    R.dirSync = dirSync;

    R.file = file;
    R.fileSync = fileSync;

    R.tmpName = tmpName;
    R.tmpNameSync = tmpNameSync;

    R.setGracefulCleanup = setGracefulCleanup;
    ```
    return R

  #===========================================================================================================
  ### NOTE Future Single-File Module ###
  require_temp: ->

    #=========================================================================================================
    { debug,        } = console

    #---------------------------------------------------------------------------------------------------------
    templates = Object.freeze
      temp:
        keep:     false
        prefix:   'brics.temp-'
        suffix:   ''

    #---------------------------------------------------------------------------------------------------------
    TEMP      = UNSTABLE_TEMP_BRICS.require_temp_internal_tmp()
    internals = { templates, }

    #===========================================================================================================
    class Temp

      #---------------------------------------------------------------------------------------------------------
      constructor: () ->
        return undefined

      #-------------------------------------------------------------------------------------------------------
      with_file: ( cfg, handler ) ->
        switch arity = arguments.length
          when 1 then [ cfg, handler, ] = [ null, cfg, ]
          when 2 then null
          else throw new Error "expected 1 or 2 arguments, got #{arity}"
        cfg   = { templates.temp..., cfg..., }
        type  = Object::toString.call handler
        return @_with_file_async cfg, handler if type is '[object AsyncFunction]'
        return @_with_file_sync  cfg, handler if type is '[object Function]'
        throw new Error "^guy.temp@1^ expected an (sync or async) function, got a #{type}"

      #-------------------------------------------------------------------------------------------------------
      with_directory: ( cfg, handler ) ->
        switch arity = arguments.length
          when 1 then [ cfg, handler, ] = [ null, cfg, ]
          when 2 then null
          else throw new Error "expected 1 or 2 arguments, got #{arity}"
        cfg   = { templates.temp..., cfg..., }
        type  = Object::toString.call handler
        return @_with_directory_async cfg, handler if type is '[object AsyncFunction]'
        return @_with_directory_sync  cfg, handler if type is '[object Function]'
        throw new Error "^guy.temp@2^ expected an (sync or async) function, got a #{type}"

      #-------------------------------------------------------------------------------------------------------
      _with_file_sync: ( cfg, handler ) ->
        { name: path
          fd
          removeCallback } = TEMP.fileSync cfg
        try handler { path, fd, } finally
          removeCallback() unless cfg.keep
        return null

      #-------------------------------------------------------------------------------------------------------
      _with_directory_sync: ( cfg, handler ) ->
        FS              = require 'node:fs'
        { name: path, } = TEMP.dirSync cfg
        try handler { path, } finally
          FS.rmSync path, { recursive: true, } unless cfg.keep
        return null

      #-------------------------------------------------------------------------------------------------------
      _with_file_async: ( cfg, handler ) ->
        { name: path
          fd
          removeCallback } = TEMP.fileSync cfg
        try await handler { path, fd, } finally
          removeCallback() unless cfg.keep
        return null

      #-------------------------------------------------------------------------------------------------------
      _with_directory_async: ( cfg, handler ) ->
        switch arity = arguments.length
          when 1 then [ cfg, handler, ] = [ null, cfg, ]
          when 2 then null
          else throw new Error "expected 1 or 2 arguments, got #{arity}"
        cfg             = { templates.temp..., cfg..., }
        FS              = require 'node:fs'
        { name: path, } = TEMP.dirSync cfg
        try await handler { path, } finally
          FS.rmSync path, { recursive: true, } unless cfg.keep
        return null

      #-------------------------------------------------------------------------------------------------------
      create_directory: ( cfg ) ->
        FS              = require 'node:fs'
        cfg             = { templates.temp..., cfg..., }
        { name: path, } = TEMP.dirSync cfg
        rm              = -> FS.rmSync path, { recursive: true, }
        return { path, rm, }


    #=========================================================================================================
    internals = Object.freeze { internals..., Temp, }
    return exports = {
      temp: new Temp
      # Temp,
      internals, }


#===========================================================================================================
Object.assign module.exports, UNSTABLE_TEMP_BRICS