manifest.getMainAttributes().put(Attributes.Name.CLASS_PATH, jarFile.getName());

    Closer closer = Closer.create();
    try {
      FileOutputStream fileOut = closer.register(new FileOutputStream(jarFile));
      JarOutputStream jarOut = closer.register(new JarOutputStream(fileOut, manifest));
      for (String entry : entries) {
        jarOut.putNextEntry(new ZipEntry(entry));

    manifest.getMainAttributes().put(Attributes.Name.CLASS_PATH, jarFile.getName());

    Closer closer = Closer.create();
    try {
      FileOutputStream fileOut = closer.register(new FileOutputStream(jarFile));
      JarOutputStream jarOut = closer.register(new JarOutputStream(fileOut, manifest));
      for (String entry : entries) {
        jarOut.putNextEntry(new ZipEntry(entry));

## Status

ACCEPTED

## Consequences

* Classes are forced to have consistent nullability annotations.
* IDE warnings become more accurate, reducing warnings fatigue.
* Public API nullability annotations become closer to reality.
* Java compilation of Gradle code suffers from small performance penalty (up to 10%).
* Time has to be allocated to clean up existing projects.
* One has to write NullAway-conformant code even when hacking.

By default, those files are served from a <abbr title="Content Delivery Network: A service, normally composed of several servers, that provides static files, like JavaScript and CSS. It's commonly used to serve those files from the server closer to the client, improving performance.">CDN</abbr>.

But it's possible to customize it, you can set a specific CDN, or serve the files yourself.

## Custom CDN for JavaScript and CSS { #custom-cdn-for-javascript-and-css }

                return originalStream.read(b, off, len);
            }

            @Override
            public void close() throws IOException {
                closedFlag.set(true);
                originalStream.close();
            }

            @Override
            public int available() throws IOException {
                return originalStream.available();
            }

        return fileInputStream.available();
    }

    /**
     * Closes this input stream and releases any system resources associated with the stream.
     * @throws IOException if an I/O error occurs.
     */
    @Override
    public void close() throws IOException {
        try {
            fileInputStream.close();
        } finally {
            FileUtil.deleteInBackground(tempFile);
        }
    }

        measureTime {
          val exception =
            assertFailsWith<IOException> {
              response.trailers()
            }
          assertThat(exception.message).isIn(
            "Socket closed", // HTTP/1.1
            "stream was reset: CANCEL", // HTTP/2
          )
        }
      assertThat(trailersDelay).isGreaterThan(250.milliseconds)
      assertThat(trailersDelay).isLessThan(750.milliseconds)

            failingFactory.destroyObject(pooledObject);
            fail("Should throw exception from close()");
        } catch (Exception e) {
            // Expected - exception should propagate from close()
            assertTrue(e.getMessage().contains("Intentional close failure"));
        }

        // Verify close was attempted
        assertTrue(component.isCloseCalled());
    }

    /**

        this.inputStream = inputStream;
    }

    /**
     * Overrides the close method to ignore the close operation.
     * The underlying input stream will not be closed.
     *
     * @throws IOException if an I/O error occurs (not thrown in this implementation)
     */
    @Override
    public void close() throws IOException {
        // inputStream.close();
    }

    /**

 * </ul>
 *
 * <p>Methods:</p>
 * <ul>
 *   <li>{@code getFile()} - Marks the file as retrieved and returns the file.</li>
 *   <li>{@code close()} - Closes the stream and deletes the temporary file if it is not needed.</li>
 * </ul>
 */
public class ContentOutputStream extends DeferredFileOutputStream {

    /**
     * The logger for this class.
     */