public Optional<BuildCacheLoadResult> load(BuildCacheKey cacheKey, CacheableEntity cacheableEntity) {
            return getDelegate().load(cacheKey, cacheableEntity);
        }

        @Override
        public void store(BuildCacheKey cacheKey, CacheableEntity entity, Map<String, FileSystemSnapshot> snapshots, Duration executionTime) {
            getDelegate().store(cacheKey, entity, snapshots, executionTime);
        }

// webhook configuration.
func (cm *ClientManager) HookClient(cc ClientConfig) (*rest.RESTClient, error) {
	ccWithNoName := cc
	ccWithNoName.Name = ""
	cacheKey, err := json.Marshal(ccWithNoName)
	if err != nil {
		return nil, err
	}
	if client, ok := cm.cache.Get(string(cacheKey)); ok {
		return client.(*rest.RESTClient), nil
	}

	cfg, err := cm.hookClientConfig(cc)
	if err != nil {
		return nil, err
	}

apiVersion: release-notes/v2
kind: feature
area: extensibility
issue: []
releaseNotes:
  - |
    **Improved** Use tag-stripped URL + checksum as a Wasm module cachekey, and the tagged URL is separately cached. 
    This may increase the chance of cache hit (e.g., trying to find the same image with both of the tagged and digest URLs.)

	errSkewedAuthTime     = errors.New("Skewed authentication date/time")
	errMalformedAuth      = errors.New("Malformed authentication input")
)

type cacheKey struct {
	accessKey, secretKey, audience string
}

var cacheLRU = expirable.NewLRU[cacheKey, string](1000, nil, 15*time.Second)

func authenticateNode(accessKey, secretKey, audience string) (string, error) {
	claims := xjwt.NewStandardClaims()

}

func (t *Transport) IdleConnCountForTesting(scheme, addr string) int {
	t.idleMu.Lock()
	defer t.idleMu.Unlock()
	key := connectMethodKey{"", scheme, addr, false}
	cacheKey := key.String()
	for k, conns := range t.idleConn {
		if k.String() == cacheKey {
			return len(conns)
		}
	}
	return 0
}

func (t *Transport) IdleConnWaitMapSizeForTesting() int {
	t.idleMu.Lock()
	defer t.idleMu.Unlock()

        buildFile << defineCacheableTask()
        when:
        withBuildCache().run("cacheable")
        then:
        def cacheKey = cacheOperations.getCacheKeyForTask(":cacheable")
        def cacheFile = listCacheFiles().find { it.name == cacheKey }
        cacheFile.exists()
        def cacheEntry = new TarTestFixture(cacheFile)
        cacheEntry.assertContainsFile("tree-outputDir/output")

    /**
     * Creates a CachingState for beforeExecutionState, that can be either Enabled or Disabled.
     */
    CachingState createCachingState(BeforeExecutionState beforeExecutionState, HashCode cacheKey, ImmutableList<CachingDisabledReason> cachingDisabledReasons);

    HashCode calculateCacheKey(BeforeExecutionState beforeExecutionState);

    }

    @Override
    public PreviousExecutionState read(Decoder decoder) throws Exception {
        OriginMetadata originMetadata = originMetadataSerializer.read(decoder);

        HashCode cacheKey = hashCodeSerializer.read(decoder);

        ImplementationSnapshot taskImplementation = implementationSnapshotSerializer.read(decoder);

        // We can't use an immutable list here because some hashes can be null

     * @param record The cache record being used for the project, must not be {@code null}.
     */
    void register(MavenProject project, Key cacheKey, CacheRecord record);

                context.setResult(opResult)
                returnValue
            }
    })


internal
fun BuildOperationRunner.withStoreOperation(@Suppress("UNUSED_PARAMETER") cacheKey: String, block: () -> StoreResult) =
    run(object : RunnableBuildOperation {
        override fun description(): BuildOperationDescriptor.Builder = BuildOperationDescriptor