--- /dev/null	2025-06-02 02:46:49.384353890 -0500
+++ ./vendor/github.com/fsnotify/fsnotify/backend_aix.go	2025-06-02 02:48:19.573730150 -0500
@@ -0,0 +1,415 @@
+//go:build aix 
+// +build aix 
+
+package fsnotify
+
+import (
+        "errors"
+        "io/ioutil"
+        "os"
+        "path/filepath"
+        "sync"
+        "time"
+)
+
+const (
+        sleepTime time.Duration = 100 * time.Millisecond
+)
+
+// Watcher watches a set of files, delivering events to a channel.
+type Watcher struct{
+    Events chan Event
+        Errors chan error
+    mu       *sync.Mutex // Map access
+    isClosed bool
+    watches map[string]bool        // whatched files (recursive or not)
+    files   map[string]os.FileInfo // map of files.
+    maxEvents int
+    close     chan struct{}
+    done   chan struct{}
+}
+
+func (w *Watcher) listRecursive(name string) (map[string]os.FileInfo, error) {
+        fileList := make(map[string]os.FileInfo)
+
+        return fileList, filepath.Walk(name, func(path string, info os.FileInfo, err error) error {
+                if err != nil {
+                        return err
+                }
+                // Add the path and it's info to the file list.
+                fileList[path] = info
+                return nil
+        })
+}
+
+func (w *Watcher) list(name string) (map[string]os.FileInfo, error) {
+        fileList := make(map[string]os.FileInfo)
+
+        // Make sure name exists.
+        stat, err := os.Stat(name)
+        if err != nil {
+                return nil, err
+        }
+
+        fileList[name] = stat
+
+        // If it's not a directory, just return.
+        if !stat.IsDir() {
+                return fileList, nil
+        }
+
+        // It's a directory.
+        fInfoList, err := ioutil.ReadDir(name)
+        if err != nil {
+                return nil, err
+        }
+        // Add all of the files in the directory to the file list.
+        for _, fInfo := range fInfoList {
+                path := filepath.Join(name, fInfo.Name())
+                fileList[path] = fInfo
+        }
+        return fileList, nil
+}
+
+func (w *Watcher) retrieveFileList() map[string]os.FileInfo {
+        w.mu.Lock()
+        defer w.mu.Unlock()
+
+        fileList := make(map[string]os.FileInfo)
+
+        var list map[string]os.FileInfo
+        var err error
+
+        for name, recursive := range w.watches {
+                if recursive {
+                        list, err = w.listRecursive(name)
+                        if err != nil {
+                                if os.IsNotExist(err) {
+                                        // A watch file can be removed
+                                        continue
+                                } else {
+                                        w.Errors <- err
+                                }
+                        }
+                } else {
+                        list, err = w.list(name)
+                        if err != nil {
+                                if os.IsNotExist(err) {
+                                        // A watch file can be removed
+                                        continue
+                                } else {
+                                        w.Errors <- err
+                                }
+                        }
+                }
+                // Add the file's to the file list.
+                for k, v := range list {
+                        fileList[k] = v
+                }
+        }
+
+        return fileList
+}
+
+func (w *Watcher) pollEvents(files map[string]os.FileInfo, evt chan Event,
+        cancel chan struct{}) {
+        w.mu.Lock()
+        defer w.mu.Unlock()
+
+        // Store create and remove events for use to check for rename events.
+        creates := make(map[string]os.FileInfo)
+        removes := make(map[string]os.FileInfo)
+
+        // Check for removed files.
+        for path, info := range w.files {
+                if _, found := files[path]; !found {
+                        removes[path] = info
+        w.sendEvent(Event{Name: path, Op: Remove})
+                }
+        }
+
+        // Check for created files, writes and chmods.
+        for path, info := range files {
+                oldInfo, found := w.files[path]
+                if !found {
+                        // A file was created.
+                        creates[path] = info
+            w.sendEvent(Event{Name: path, Op: Create})
+                        continue
+                }
+                if oldInfo.ModTime() != info.ModTime() {
+                        if info.IsDir() {
+                                // Modification on the directory means a file
+                                // have been changed (add, remove, etc),
+                                // but not a write event.
+                                continue
+                        }
+                        select {
+                        case <-cancel:
+                                return
+                        case evt <- Event{path, Write}:
+                w.sendEvent(Event{Name: path, Op: Write})
+                        }
+                }
+                if oldInfo.Mode() != info.Mode() {
+                        select {
+                        case <-cancel:
+                                return
+                        case evt <- Event{path, Chmod}:
+                        }
+                }
+        }
+
+        // Check for renames
+        for path1, info1 := range removes {
+                for _, info2 := range creates {
+                        // In some case, a newly created file can have the same
+                        // inode number than a deleted one.
+                        // As os.SameFile is only checking that it might not
+                        // be fully accurate. Checking that both files have the
+                        // same type allows to be a bit more accurate.
+                        if os.SameFile(info1, info2) && info1.IsDir() == info2.IsDir() {
+                                e := Event{
+                                        Op:   Rename,
+                                        Name: path1,
+                                }
+
+                                // Do not delete path2 from creates, as both events
+                                // are needed:
+                                // - path1, Rename
+                                // - path2, Create
+                                delete(removes, path1)
+
+                                select {
+                                case <-cancel:
+                                        return
+                                case evt <- e:
+                                }
+                        }
+                }
+        }
+
+        // Send all the remaining create and remove events.
+        for path, _ := range creates {
+                select {
+                case <-cancel:
+                        return
+                case evt <- Event{path, Create}:
+                }
+        }
+        for path, _ := range removes {
+                select {
+                case <-cancel:
+                        return
+                case evt <- Event{path, Remove}:
+                }
+        }
+}
+
+func (w *Watcher) readEvents() {
+outer:
+        for {
+                // done lets the inner polling cycle loop know when the
+                // current cycle's method has finished executing.
+                done := make(chan struct{})
+
+                // Any events that are found are first piped to evt before
+                // being sent to the main Event channel.
+                evt := make(chan Event)
+
+                // Retrieve the file list for all watched file's and dirs.
+                fileList := w.retrieveFileList()
+
+                // cancel can be used to cancel the current event polling
+                //function.
+                cancel := make(chan struct{})
+
+                // Look for events.
+                go func() {
+                        w.pollEvents(fileList, evt, cancel)
+                        done <- struct{}{}
+                }()
+        inner:
+                for {
+                        select {
+                        case <-w.close:
+                                close(cancel)
+                                select {
+                                case <-done:
+                                }
+                                break outer
+                        case event := <-evt:
+                                select {
+                                case w.Events <- event:
+                                case <-w.close:
+                                        close(cancel)
+                                        break outer
+                                default:
+                                        continue
+
+                                }
+                        case <-done: // Current cycle is finished.
+                                break inner
+                        }
+                }
+
+                // Update the file's list.
+                w.mu.Lock()
+                w.files = fileList
+                w.mu.Unlock()
+
+                // Sleep and then continue to the next loop iteration.
+                time.Sleep(sleepTime)
+        }
+
+        close(w.Events)
+        close(w.Errors)
+
+}
+
+// Add starts watching the named file or directory (non-recursively).
+func (w *Watcher) Add(name string) error {
+        w.mu.Lock()
+        defer w.mu.Unlock()
+        if w.isClosed {
+                return errors.New("watcher instance already closed")
+        }
+
+        name, err := filepath.Abs(name)
+        if err != nil {
+                return err
+        }
+
+        // Add the directory's contents to the files list.
+        fileList, err := w.list(name)
+        if err != nil {
+                return err
+        }
+        for k, v := range fileList {
+                w.files[k] = v
+        }
+
+        // Add the name to the watches list.
+        w.watches[name] = false
+
+        return nil
+}
+
+
+// NewWatcher creates a new Watcher.
+func NewWatcher() (*Watcher, error) {
+        w := &Watcher{
+                Events:  make(chan Event),
+                Errors:  make(chan error),
+                close:   make(chan struct{}),
+                mu:      new(sync.Mutex),
+                files:   make(map[string]os.FileInfo),
+                watches: make(map[string]bool),
+        }
+        go w.readEvents()
+        return w, nil
+}
+
+// Returns true if the event was sent, or false if watcher is closed.
+func (w *Watcher) sendEvent(e Event) bool {
+    select {
+    case w.Events <- e:
+        return true
+    case <-w.done:
+    }
+    return false
+}
+
+func (w *Watcher) Close() error {
+        
+        w.mu.Lock()
+        if w.isClosed {
+                w.mu.Unlock()
+                return nil
+        }
+        w.isClosed = true
+        w.files = make(map[string]os.FileInfo)
+        w.watches = make(map[string]bool)
+        w.mu.Unlock()
+
+        // Send a close signal to the readEvents method.
+        w.close <- struct{}{}
+
+        return nil
+}
+
+// SetRecursive enables watches to also monitor subdirectories. Currently
+// only supported under Windows.
+func (w *Watcher) SetRecursive() error {
+        return errors.New("recursion not supported")
+}
+
+// Add starts monitoring the path for changes.
+//
+// A path can only be watched once; attempting to watch it more than once will
+// return an error. Paths that do not yet exist on the filesystem cannot be
+// added. A watch will be automatically removed if the path is deleted.
+//
+// A path will remain watched if it gets renamed to somewhere else on the same
+// filesystem, but the monitor will get removed if the path gets deleted and
+// re-created, or if it's moved to a different filesystem.
+//
+// Notifications on network filesystems (NFS, SMB, FUSE, etc.) or special
+// filesystems (/proc, /sys, etc.) generally don't work.
+//
+// # Watching directories
+//
+// All files in a directory are monitored, including new files that are created
+// after the watcher is started. Subdirectories are not watched (i.e. it's
+// non-recursive).
+//
+// # Watching files
+//
+// Watching individual files (rather than directories) is generally not
+// recommended as many tools update files atomically. Instead of "just" writing
+// to the file a temporary file will be written to first, and if successful the
+// temporary file is moved to to destination removing the original, or some
+// variant thereof. The watcher on the original file is now lost, as it no
+// longer exists.
+//
+// Instead, watch the parent directory and use Event.Name to filter out files
+// you're not interested in. There is an example of this in [cmd/fsnotify/file.go].
+// Remove stops monitoring the path for changes.
+//
+// Directories are always removed non-recursively. For example, if you added
+// /tmp/dir and /tmp/dir/subdir then you will need to remove both.
+//
+// Removing a path that has not yet been added returns [ErrNonExistentWatch].
+func (w *Watcher) Remove(name string) error {
+        w.mu.Lock()
+        defer w.mu.Unlock()
+
+        name, err := filepath.Abs(name)
+        if err != nil {
+                return err
+        }
+
+        // Remove the name from w's watches list.
+        delete(w.watches, name)
+
+        // If name is a single file, remove it and return.
+        info, found := w.files[name]
+        if !found {
+                return nil // Doesn't exist, just return.
+        }
+        if !info.IsDir() {
+                delete(w.files, name)
+                return nil
+        }
+
+        // Delete the actual directory from w.files
+        delete(w.files, name)
+
+        // If it's a directory, delete all of it's contents from w.files.
+        for path := range w.files {
+                if filepath.Dir(path) == name {
+                        delete(w.files, path)
+                }
+        }
+        return nil
+}
