Update license info

Author: marcprux

src/content/docs/blog/skip-free-for-free-software.md

@@ -19,7 +19,7 @@ There are two halves to the Skip project. The first is SkipStone, our integrated
 
 The other half is Skip's ecosystem of libraries and frameworks, which is free and open-source software. These frameworks constitute the essential building blocks of any modern application, and include low-level adaptors from Darwin's Foundation API to the equivalent Android Java API (`skip-foundation`), as well as the high-level SwiftUI user interface widgets that are manifested by Jetpack Compose views on Android (`skip-ui`). In addition, the growing constellation of community frameworks at [github.com/skiptools](http://github.com/skiptools/) provides essential functionality such as SQL database support, media player components, and more. 
 
-These frameworks are free and open-source software whose advancement will rely heavily on community contributions. And so we've made the SkipStone transpiler free, for free software. What this means is that Skip can be used – without cost – for building projects that consist exclusively of source code licensed under one of the General Public Licenses as published by the Free Software Foundation.
+These frameworks are free and open-source software whose advancement will rely heavily on community contributions. And so we've made the SkipStone transpiler free, for free software. What this means is that Skip can be used – without cost – for building projects that consist exclusively of source code licensed under free and open source licenses.
 
 This applies not just to framework development, but also to your own app projects: if your iOS app is free software, then Skip can be used to transpile it into an equivalent free Android app. In this way we hope to encourage and support the proliferation of genuinely native dual-platform apps created with the Skip transpiler and powered by the community-supported ecosystem of high-quality libraries and frameworks.
 

src/content/docs/docs/app-development.md

@@ -239,7 +239,7 @@ The key pattern is:
 The following example from the [Skip Showcase app](https://github.com/skiptools/skipapp-showcase/blob/main/Sources/Showcase/MapPlayground.swift) demonstrates this pattern by embedding an Apple MapKit `Map` on iOS and a Google Maps `GoogleMap` composable on Android:
 
 ```swift
-// Copyright 2023–2025 Skip
+// Copyright 2023–2026 Skip
 import SwiftUI
 #if !SKIP
 import MapKit

src/content/docs/docs/faq.md

@@ -56,7 +56,11 @@ Earlier, Skip would require a license key for non-commercial app development. No
 
 ### Which FOSS license is recommended for framework development? {#foss_license_recommendations}
 
-We generally recommend the LGPL, which provides a good balance of flexibility and freedom. LGPL libraries can be embedded in closed-source commercial applications. Many popular software components like WebKit, JavaScriptCore, and Qt are distributed under the LGPL.
+The standard license for all Skip libraries is the [Mozilla Public License 2.0 (MPL-2.0)](https://www.mozilla.org/MPL/). The MPL provides a good balance of flexibility and freedom: MPL-licensed libraries can be embedded in closed-source commercial applications, and the license's file-level copyleft is straightforward for developers to comply with.
+
+:::note
+Prior to 2026, Skip libraries used the GNU Lesser General Public License (LGPL) with a static linking exception. All Skip libraries have since been harmonized to use the MPL-2.0.
+:::
 
 ### Can Skip Apps be distributed on the Apple App Store and the Google Play Store? {#appstore}
 

src/content/docs/docs/modules/skip-zip/index.md

@@ -34,6 +34,130 @@ let package = Package(
 )
 ```
 
+## Usage
+
+### Local Zip Archives
+
+Use `ZipReader` and `ZipWriter` for working with zip files on disk:
+
+```swift
+import SkipZip
+
+// Reading a zip file
+if let reader = ZipReader(path: "/path/to/archive.zip") {
+    try reader.first()
+    while true {
+        if let name = try reader.currentEntryName {
+            print("Entry: \(name)")
+        }
+        if let data = try reader.currentEntryData {
+            // Process entry data...
+        }
+        if !(try reader.next()) { break }
+    }
+    try reader.close()
+}
+
+// Writing a zip file
+if let writer = ZipWriter(path: "/path/to/output.zip", append: false) {
+    try writer.add(path: "hello.txt", data: "Hello, World!".data(using: .utf8)!, compression: 5)
+    try writer.close()
+}
+```
+
+### Remote Zip Archives
+
+`RemoteZipReader` allows reading individual entries from a remote zip archive over HTTP
+without downloading the entire file. It uses HTTP Range requests to fetch only the
+archive's central directory (metadata) and the specific entries you request.
+
+This is useful for selectively extracting files from large remote archives where
+downloading the full archive would be impractical.
+
+**Requirements:** The HTTP server must support Range requests (indicated by the
+`Accept-Ranges: bytes` header). If the server does not support range requests,
+the operation will fail with a descriptive error.
+
+```swift
+import SkipZip
+
+// Open a remote zip archive (fetches only the metadata)
+let reader = try await RemoteZipReader.open(url: URL(string: "https://example.com/archive.zip")!)
+
+// Browse entries without downloading their data
+for entry in reader.entries {
+    print("\(entry.name): \(entry.uncompressedSize) bytes")
+}
+
+// Fetch and decompress a specific entry
+let data = try await reader.data(forEntryNamed: "README.md")
+print(String(data: data, encoding: .utf8)!)
+```
+
+#### Configuration
+
+`RemoteZipConfiguration` controls retry behavior for transient network failures.
+Retryable conditions include network errors and HTTP status codes 429, 502, 503, and 504.
+
+```swift
+let config = RemoteZipConfiguration(
+    maxRetries: 5,                 // Retry up to 5 times (default: 3)
+    initialBackoffInterval: 1.0,   // Wait 1 second before first retry (default: 0.5)
+    backoffMultiplier: 2.0,        // Double the wait time after each retry (default: 2.0)
+    maxBackoffInterval: 60.0,      // Cap backoff at 60 seconds (default: 30.0)
+    endOfFileReadSize: 131_072     // Read last 128KB to find EOCD (default: 65536)
+)
+
+let reader = try await RemoteZipReader.open(
+    url: archiveURL,
+    session: myURLSession,        // Optional: provide a custom URLSession
+    configuration: config
+)
+```
+
+#### Custom URLSession
+
+You can pass a custom `URLSession` for authentication, caching, or proxy configuration:
+
+```swift
+let sessionConfig = URLSessionConfiguration.default
+sessionConfig.httpAdditionalHeaders = ["Authorization": "Bearer token123"]
+let session = URLSession(configuration: sessionConfig)
+
+let reader = try await RemoteZipReader.open(url: archiveURL, session: session)
+```
+
+#### Error Handling
+
+All errors are reported as `RemoteZipError` with descriptive messages:
+
+```swift
+do {
+    let reader = try await RemoteZipReader.open(url: archiveURL)
+    let data = try await reader.data(forEntryNamed: "file.txt")
+} catch let error as RemoteZipError {
+    switch error {
+    case .serverDoesNotSupportRangeRequests:
+        print("Server doesn't support Range requests")
+    case .entryNotFound(let name):
+        print("Entry '\(name)' not found")
+    case .retryLimitExceeded(let count, let lastError):
+        print("Failed after \(count) retries: \(lastError)")
+    default:
+        print(error.localizedDescription)
+    }
+}
+```
+
+#### Supported Compression Methods
+
+`RemoteZipReader` supports the two most common zip compression methods:
+
+- **STORE** (method 0): No compression; data is returned as-is.
+- **DEFLATE** (method 8): Standard zip compression; data is decompressed automatically.
+
+ZIP64 extensions are supported for archives and entries larger than 4 GB.
+
 ## Building
 
 This project is a Swift Package Manager module that uses the