|| isPackagedArtifactUpToDate(project, packagedArtifactFile))) {
            return packagedArtifactFile;
        }

        if (!hasBeenPackagedDuringThisSession(project)) {
            // fallback to loose class files only if artifacts haven't been packaged yet
            // and only for plain old jars. Not war files, not ear files, not anything else.

package lru

// golang -lru
// https://github.com/hashicorp/golang-lru
import (
	"sync"
	"time"
)

// EvictCallback is used to get a callback when a cache entry is evicted
type EvictCallback[K comparable, V any] func(key K, value V)

// LRU implements a thread-safe LRU with expirable entries.
type LRU[K comparable, V any] struct {
	size      int
	evictList *LruList[K, V]
	items     map[K]*Entry[K, V]
	onEvict   EvictCallback[K, V]

            if (entry.getInconsistencyCount() > 5) {
                entry.invalidate();
            }
        }
    }
}
```

### 9.2 Fallback Mechanisms
```java
public class DirectoryOperationFallback {
    public SmbFile[] safeListFiles(SmbFile directory) throws IOException {
        try {
            // Try cached listing first

            } finally {
                SMailCallbackContext.clearPreparedMessageHookOnThread();
            }
        }
    }

    /**
     * Retrieves a value from a map with a default fallback.
     *
     * @param dataMap the map to retrieve the value from
     * @param key the key to look up
     * @param defaultValue the default value to return if key is not found or value is blank

	if s3Select.progressReader != nil {
		return s3Select.progressReader.Stats()
	}

	return -1, -1
}

// Open - opens S3 object by using callback for SQL selection query.
// Currently CSV, JSON and Apache Parquet formats are supported.
func (s3Select *S3Select) Open(rsc io.ReadSeekCloser) error {
	offset, length, err := s3Select.ScanRange.StartLen()
	if err != nil {

        return getSystemPropertyAsInt(Constants.LTR_WINDOW_SIZE_PROPERTY, 100);
    }

    /**
     * Gets the permission fields for Entra ID authentication.
     * Uses new entraid.permission.fields key with fallback to legacy aad.permission.fields.
     * @return Array of permission field names.
     */
    default String[] getEntraIdPermissionFields() {
        String value = getSystemProperty("entraid.permission.fields", null);

			}
			s += "}"
		}
		res = append(res, []byte(s)...)
	}
	res = append(res, '}')
	return res, nil
}

// files returns files as callback.
func (x xlMetaInlineData) files(fn func(name string, data []byte)) error {
	if len(x) == 0 {
		return nil
	}
	if !x.versionOK() {
		return errors.New("xlMetaInlineData: unknown version")
	}

pkg database/sql/driver, type Stmt interface, Query([]Value) (Rows, error)
pkg database/sql/driver, type Tx interface { Commit, Rollback }
pkg database/sql/driver, type Tx interface, Commit() error
pkg database/sql/driver, type Tx interface, Rollback() error
pkg database/sql/driver, type Value interface {}
pkg database/sql/driver, type ValueConverter interface { ConvertValue }

     */
    int getLanManCompatibility();

    /**
     *
     * Property {@code jcifs.smb.allowNTLMFallback} (boolean, default true)
     *
     * @return whether to allow fallback from kerberos to NTLM
     */
    boolean isAllowNTLMFallback();

    /**
     * Property {@code jcifs.smb.useRawNTLM} (boolean, default false)
     *

         * Login with no credentials
         */
        NULL,
        /**
         * Guest authentication
         *
         * Allows login with invalid credentials (username and/or password)
         * Fallback to anonymous authentication is permitted
         */
        GUEST,
        /**
         * Regular user authentication
         */
        USER
    }