quickwin 1.0.2 → 1.1.0

package/lib/fetch.ts

@@ -1,502 +1,502 @@
-import * as sock from 'sock'
-import * as wolfssl from 'wolfssl'
-import * as brotli from 'brotli'
-import { parseIni, toIni } from '../lib/cache-utils.js'
-import {
-    _concat,
-    _toReadableStream,
-    _readStream,
-    _hasChunkedEnd,
-    decodeChunked,
-    HeadersImpl,
-    RequestImpl,
-    ResponseImpl,
-} from './http-common.js'
-
-// ── HTTP Response Parser ──
-
-interface ParsedResponse {
-    status: number
-    statusText: string
-    headers: HeadersImpl
-}
-
-function parseHeaders(data: string): ParsedResponse | null {
-    const headerEnd = data.indexOf('\r\n\r\n')
-    if (headerEnd < 0) return null
-
-    const headerPart = data.slice(0, headerEnd)
-    const lines = headerPart.split('\r\n')
-    const statusLine = lines[0]!
-    const match = statusLine.match(/^HTTP\/\d\.\d\s+(\d+)\s+(.*)$/)
-    if (!match) throw new Error('Invalid HTTP response: ' + statusLine)
-
-    const status = parseInt(match[1]!, 10)
-    const statusText = match[2]!
-
-    const headers = new HeadersImpl()
-    for (let i = 1; i < lines.length; i++) {
-        const colonIndex = lines[i]!.indexOf(':')
-        if (colonIndex > 0) {
-            const name = lines[i]!.slice(0, colonIndex).trim()
-            const value = lines[i]!.slice(colonIndex + 1).trim()
-            headers.append(name, value)
-        }
-    }
-
-    return { status, statusText, headers }
-}
-
-// ── State machine constants ──
-
-const ST_CONNECTING = 0
-const ST_HANDSHAKE = 1
-const ST_RECV_HEADERS = 3
-const ST_RECV_BODY = 4
-const ST_DONE = 5
-
-// ── Main fetch request ──
-
-async function fetchRequest(req: RequestImpl): Promise<ResponseImpl> {
-    const parsedUrl = new URL(req.url)
-    const method = req.method
-    const headers = new HeadersImpl(req.headers)
-    const timeout = req.timeout || 30000
-    const isHTTPS = parsedUrl.protocol === 'https:'
-
-    const defaultPort = isHTTPS ? 443 : 80
-    const hostname = parsedUrl.hostname.includes(':') ? `[${parsedUrl.hostname}]` : parsedUrl.hostname
-    const hostHeader = parsedUrl.port && parsedUrl.port !== String(defaultPort)
-        ? hostname + ':' + parsedUrl.port
-        : hostname
-    if (!headers.has('host')) headers.set('Host', hostHeader)
-    if (!headers.has('user-agent')) headers.set('User-Agent', navigator.userAgent)
-    if (!headers.has('connection')) headers.set('Connection', 'close')
-    if (!headers.has('accept-encoding')) headers.set('Accept-Encoding', 'br')
-    let bodyBytes: Uint8Array | null = null
-    if (req.body) {
-        bodyBytes = await _readStream(req.body)
-    }
-    if (bodyBytes && !headers.has('content-length')) headers.set('Content-Length', String(bodyBytes.length))
-
-    return new Promise((resolve, reject) => {
-    let request = method + ' ' + parsedUrl.pathname + (parsedUrl.search || '') + ' HTTP/1.1\r\n'
-    headers.forEach((value: string, name: string) => {
-        request += name + ': ' + value + '\r\n'
-    })
-    request += '\r\n'
-
-    const requestBytes = new TextEncoder().encode(request)
-    const httpRequest = _concat(
-        bodyBytes ? [requestBytes, bodyBytes] : [requestBytes]
-    ).buffer
-
-    let s: sock.SockHandle | null = null
-    let ssl: wolfssl.WOLFSSL | null = null
-    let ctx: wolfssl.WOLFSSL_CTX | null = null
-    let state = ST_CONNECTING
-    let resolved = false
-    let timerId: TimerId | undefined
-    let stream: ReadableStream<Uint8Array> | null = null
-    let _controller: ReadableStreamDefaultController<Uint8Array> | null = null
-    let headerRaw: Uint8Array = new Uint8Array(0)
-    let isChunked = false
-    let contentLength = 0
-    let chunkedParts: Uint8Array[] = []
-    let receivedBytes = 0
-
-        const cleanupSocket = (): void => {
-            state = ST_DONE
-            if (ssl) { wolfssl.wolfSSL_free(ssl); ssl = null }
-            if (ctx) { wolfssl.wolfSSL_CTX_free(ctx); ctx = null }
-            if (s !== null && s >= 0) { sock.closesocket(s); s = null }
-        }
-
-        const cleanup = (): void => {
-            if (timerId) { clearTimeout(timerId); timerId = undefined }
-        }
-
-        const doResolve = (response: ResponseImpl): void => {
-            if (!resolved) { resolved = true; cleanup(); resolve(response) }
-        }
-
-        const doReject = (error: Error): void => {
-            if (!resolved) { resolved = true; cleanup(); cleanupSocket(); reject(error) }
-        }
-
-        timerId = setTimeout(() => {
-            doReject(new Error('Request timeout'))
-        }, timeout)
-
-        s = sock.socket()
-        if (s < 0) { doReject(new Error('Failed to create socket')); return }
-        const fd = s
-
-        sock.set_on_event(fd, (event: { lNetworkEvents: number; iErrorCode: number[] }) => {
-            if (state === ST_DONE) return
-
-            if (event.lNetworkEvents & sock.FdEvent.FD_CONNECT) {
-                const err = event.iErrorCode[0]
-                if (err !== 0) { doReject(new Error('Connection failed: ' + err)); return }
-
-                if (isHTTPS) {
-                    const tlsMethod = wolfssl.wolfTLSv1_2_client_method()
-                    ctx = wolfssl.wolfSSL_CTX_new(tlsMethod)
-                    if (!ctx) { doReject(new Error('SSL_CTX_new failed')); return }
-                    wolfssl.wolfSSL_CTX_set_verify(ctx, wolfssl.VerifyMode.SSL_VERIFY_NONE)
-                    ssl = wolfssl.wolfSSL_new(ctx)
-                    if (!ssl) { doReject(new Error('SSL_new failed')); return }
-                    wolfssl.wolfSSL_set_fd(ssl, sock.get_fd(fd))
-                    if (parsedUrl.hostname) wolfssl.wolfSSL_UseSNI(ssl, wolfssl.SniType.WOLFSSL_SNI_HOST_NAME, parsedUrl.hostname)
-                    state = ST_HANDSHAKE
-                } else {
-                    sock.send(fd, httpRequest)
-                    state = ST_RECV_HEADERS
-                }
-            }
-
-            if ((event.lNetworkEvents & sock.FdEvent.FD_READ) || (event.lNetworkEvents & sock.FdEvent.FD_WRITE)) {
-                if (state === ST_HANDSHAKE) {
-                    if (!ssl) { doReject(new Error('TLS not initialized')); return }
-                    const ret = wolfssl.wolfSSL_connect(ssl)
-                    if (ret === wolfssl.ReturnCode.SSL_SUCCESS) {
-                        wolfssl.wolfSSL_write(ssl, httpRequest)
-                        state = ST_RECV_HEADERS
-                    } else {
-                        const err = wolfssl.wolfSSL_get_error(ssl, ret)
-                        if (err !== wolfssl.ErrorCode.WOLFSSL_ERROR_WANT_READ &&
-                            err !== wolfssl.ErrorCode.WOLFSSL_ERROR_WANT_WRITE) {
-                            doReject(new Error('TLS handshake failed: ' + err))
-                        }
-                    }
-                }
-                else if (state === ST_RECV_HEADERS) {
-                    while (true) {
-                        if (s !== null && s < 0 && !ssl) break
-                        let data: ArrayBuffer | null
-                        if (isHTTPS && ssl) {
-                            data = wolfssl.wolfSSL_read(ssl, 8192)
-                        } else if (s !== null && s >= 0) {
-                            data = sock.recv(s, 8192)
-                        } else { break }
-                        if (!data || data.byteLength === 0) break
-                        const incoming = new Uint8Array(data)
-                        headerRaw = _concat([headerRaw, incoming])
-
-                        let headerEnd = -1
-                        for (let i = 0; i < headerRaw.length - 3; i++) {
-                            if (headerRaw[i] === 0x0D && headerRaw[i+1] === 0x0A && headerRaw[i+2] === 0x0D && headerRaw[i+3] === 0x0A) {
-                                headerEnd = i; break
-                            }
-                        }
-                        if (headerEnd >= 0) {
-                            const headerStr = new TextDecoder('utf-8').decode(headerRaw.subarray(0, headerEnd + 4))
-                            const parsed = parseHeaders(headerStr)
-                            if (!parsed) { doReject(new Error('Failed to parse HTTP headers')); return }
-
-                            const trailingBodyBytes = headerRaw.subarray(headerEnd + 4)
-
-                            isChunked = (parsed.headers.get('transfer-encoding') || '').toLowerCase().includes('chunked')
-                            contentLength = isChunked ? 0 : parseInt(
-                                parsed.headers.get('content-length') || '0', 10
-                            )
-                            _controller = null
-                            stream = new ReadableStream<Uint8Array>({
-                                start(ctrl: ReadableStreamDefaultController<Uint8Array>) { _controller = ctrl },
-                                cancel() { cleanup(); cleanupSocket() }
-                            })
-                            if (trailingBodyBytes.length > 0) {
-                                if (isChunked) {
-                                    chunkedParts = [trailingBodyBytes]
-                                    if (_hasChunkedEnd(trailingBodyBytes)) {
-                                        const decoded = decodeChunked(trailingBodyBytes)
-                                        _controller!.enqueue(decoded)
-                                        _controller!.close()
-                                        state = ST_DONE
-                                        cleanupSocket()
-                                    }
-                                } else {
-                                    receivedBytes += trailingBodyBytes.length
-                                    _controller!.enqueue(trailingBodyBytes)
-                                    if (contentLength > 0 && receivedBytes >= contentLength) {
-                                        _controller!.close()
-                                        state = ST_DONE
-                                        cleanupSocket()
-                                    }
-                                }
-                            }
-
-                            const response = new ResponseImpl(
-                                stream, { status: parsed.status, statusText: parsed.statusText, headers: parsed.headers }
-                            )
-                            if (state !== ST_DONE) {
-                                state = ST_RECV_BODY
-                            }
-                            doResolve(response)
-                            // Break out of header recv loop — any remaining data
-                            // in the socket will be handled by the ST_RECV_BODY path below
-                            break
-                        }
-                    }
-                }
-                else if (state === ST_RECV_BODY && stream) {
-                    while (true) {
-                        if (s !== null && s < 0 && !ssl) break
-                        let data: ArrayBuffer | null
-                        if (isHTTPS && ssl) {
-                            data = wolfssl.wolfSSL_read(ssl, 8192)
-                        } else if (s !== null && s >= 0) {
-                            data = sock.recv(s, 8192)
-                        } else { break }
-                        if (!data || data.byteLength === 0) break
-                        if (isChunked) {
-                            chunkedParts.push(new Uint8Array(data))
-                            const combined = _concat(chunkedParts)
-                            if (_hasChunkedEnd(combined)) {
-                                const decoded = decodeChunked(combined)
-                                _controller!.enqueue(decoded)
-                                _controller!.close()
-                                stream = null
-                                state = ST_DONE
-                                cleanupSocket()
-                                break
-                            }
-                        } else {
-                            receivedBytes += data.byteLength
-                            _controller!.enqueue(new Uint8Array(data))
-                            if (contentLength > 0 && receivedBytes >= contentLength) {
-                                _controller!.close()
-                                state = ST_DONE
-                                cleanupSocket()
-                            }
-                        }
-                    }
-                }
-            }
-
-            if (event.lNetworkEvents & sock.FdEvent.FD_CLOSE) {
-                if (state === ST_DONE) return
-                if (state === ST_RECV_HEADERS) {
-                    doReject(new Error('Connection closed before response'))
-                } else if (state === ST_RECV_BODY && stream) {
-                    let remainingParts: Uint8Array[] = []
-                    while (true) {
-                        if (s !== null && s < 0 && !ssl) break
-                        let data: ArrayBuffer | null
-                        if (isHTTPS && ssl) {
-                            data = wolfssl.wolfSSL_read(ssl, 8192)
-                        } else if (s !== null && s >= 0) {
-                            data = sock.recv(s, 8192)
-                        } else { break }
-                        if (!data || data.byteLength === 0) break
-                        remainingParts.push(new Uint8Array(data))
-                    }
-                    if (isChunked) {
-                        chunkedParts.push(...remainingParts)
-                        const decoded = decodeChunked(_concat(chunkedParts))
-                        _controller!.enqueue(decoded)
-                    } else if (remainingParts.length > 0) {
-                        _controller!.enqueue(_concat(remainingParts))
-                    }
-                    _controller!.close()
-                    stream = null
-                    state = ST_DONE
-                    cleanupSocket()
-                } else {
-                    // ST_CONNECTING or ST_HANDSHAKE — socket died early,
-                    // reject so the Promise doesn't hang forever
-                    doReject(new Error('Connection closed'))
-                }
-            }
-        })
-
-        const ip = sock.resolve(parsedUrl.hostname)
-        if (!ip) {
-            doReject(new Error('DNS resolution failed for: ' + parsedUrl.hostname))
-            return
-        }
-        sock.connect(s, ip, parseInt(parsedUrl.port, 10) || (isHTTPS ? 443 : 80))
-    })
-}
-
-// ── Public fetch (with redirect handling and caching) ──
-
-function parseMaxAge(cc: string): number {
-    const m = cc.match(/max-age=(\d+)/)
-    return m ? parseInt(m[1]!, 10) : 0
-}
-
-interface CacheMeta {
-    storedAt: number;
-    maxAge: number;
-    status: number;
-    statusText: string;
-    headers: Record<string, string>;
-    etag?: string;
-    lastModified?: string;
-}
-
-async function doFetch(url: string | Request, init: RequestInit, redirectCount: number): Promise<ResponseImpl> {
-    let req = new RequestImpl(url, init)
-    const redirectMode = req.redirect || 'follow'
-    const maxRedirects = redirectMode === 'follow' ? (req.maxRedirects || 5) : 0
-    const cache = typeof __httpCache__ !== 'undefined' ? __httpCache__ : null
-    const method = req.method
-    const currentUrl = req.url
-
-    // ── Cache lookup (GET only) ──
-    let cachedMeta: CacheMeta | null = null
-
-    if (cache && method === 'GET') {
-        const metaStr = cache.readMeta(currentUrl)
-        if (metaStr) {
-            const ini = parseIni(metaStr)
-            cachedMeta = {
-                storedAt: parseInt(ini.meta.storedAt || '0', 10),
-                maxAge: parseInt(ini.meta.maxAge || '0', 10),
-                status: parseInt(ini.meta.status || '200', 10),
-                statusText: ini.meta.statusText || 'OK',
-                headers: ini.headers,
-                etag: ini.headers['etag'] || undefined,
-                lastModified: ini.headers['last-modified'] || undefined,
-            }
-            const age = Math.floor(Date.now() / 1000) - cachedMeta.storedAt
-            if (cachedMeta.maxAge > 0 && age < cachedMeta.maxAge) {
-                const body = cache.readBody(currentUrl)
-                if (body) {
-                    ini.meta.lastAccess = String(Math.floor(Date.now() / 1000))
-                    cache.writeMeta(currentUrl, toIni(ini.headers, ini.meta))
-                    const resp = new ResponseImpl(
-                        _toReadableStream(new Uint8Array(body)), { status: cachedMeta.status, statusText: cachedMeta.statusText, headers: new HeadersImpl(cachedMeta.headers || {}) }
-                    )
-                    resp._url = currentUrl
-                    return resp
-                }
-            }
-            if (cachedMeta.etag) req.headers.set('If-None-Match', cachedMeta.etag)
-            if (cachedMeta.lastModified) req.headers.set('If-Modified-Since', cachedMeta.lastModified)
-        }
-    }
-
-    const response = await fetchRequest(req)
-
-    response._url = currentUrl
-
-    // ── Handle brotli Content-Encoding ──
-    const contentEncoding = response.headers.get('content-encoding') || ''
-    if (contentEncoding.includes('br')) {
-        const compressedBody = await response.arrayBuffer()
-        const decompressedBody = brotli.decompress(compressedBody)
-        const newHeaders = new HeadersImpl()
-        response.headers.forEach((v: string, k: string) => {
-            if (k !== 'content-encoding') newHeaders.set(k, v)
-        })
-        newHeaders.set('content-length', String(decompressedBody.byteLength))
-        const stream = _toReadableStream(new Uint8Array(decompressedBody))
-        response._applyDecompressedBody(stream, decompressedBody, newHeaders)
-    }
-
-    // ── Handle 304 Not Modified ──
-    if (response.status === 304 && cachedMeta && cache) {
-        const body = cache.readBody(currentUrl)
-        if (body) {
-            cachedMeta.storedAt = Math.floor(Date.now() / 1000)
-            response.headers.forEach((value: string, name: string) => {
-                cachedMeta.headers[name] = value
-            })
-            const now = String(Math.floor(Date.now() / 1000))
-            const iniMeta: Record<string, string> = {
-                url: currentUrl,
-                storedAt: String(cachedMeta.storedAt),
-                maxAge: String(cachedMeta.maxAge),
-                lastAccess: now,
-                status: String(cachedMeta.status),
-                statusText: cachedMeta.statusText,
-            }
-            cache.writeMeta(currentUrl, toIni(cachedMeta.headers, iniMeta))
-            const resp = new ResponseImpl(
-                _toReadableStream(new Uint8Array(body)), { status: cachedMeta.status, statusText: cachedMeta.statusText, headers: new HeadersImpl(cachedMeta.headers) }
-            )
-            resp._url = currentUrl
-            return resp
-        }
-    }
-
-    // ── Cache 200 GET responses ──
-    if (cache && method === 'GET' && response.status === 200) {
-        const body = await response.arrayBuffer()
-        const cc = response.headers.get('cache-control') || ''
-        const maxAge = parseMaxAge(cc)
-        if (maxAge > 0) {
-            const resHeaders = Object.fromEntries(response.headers)
-            const now = String(Math.floor(Date.now() / 1000))
-            const iniMeta: Record<string, string> = {
-                url: currentUrl,
-                storedAt: now,
-                maxAge: String(maxAge),
-                lastAccess: now,
-                status: String(response.status),
-                statusText: response.statusText,
-            }
-            cache.writeBodyOnly(currentUrl, body)
-            cache.writeMeta(currentUrl, toIni(resHeaders, iniMeta))
-        }
-        const resp = new ResponseImpl(
-            _toReadableStream(new Uint8Array(body)), { status: response.status, statusText: response.statusText, headers: response.headers }
-        )
-        resp._url = currentUrl
-        return resp
-    }
-
-    // ── Redirect handling ──
-    const isRedirect = response.status === 301 || response.status === 302 ||
-                      response.status === 303 || response.status === 307 || response.status === 308
-
-    if (isRedirect) {
-        if (redirectMode === 'error') {
-            response.body.cancel('redirect')
-            throw new TypeError('Redirect not allowed for: ' + currentUrl)
-        }
-        if (redirectMode === 'manual') {
-            response._redirected = true
-            return response
-        }
-        if (redirectCount >= maxRedirects) {
-            response.body.cancel('redirect')
-            throw new TypeError('Redirect count exceeded')
-        }
-
-        const location = response.headers.get('location')
-        if (!location) throw new Error('Redirect response missing Location header')
-
-        response.body.cancel('redirect')
-        const newUrl = new URL(location, currentUrl).href
-        const isGet = response.status === 301 || response.status === 302 || response.status === 303
-        const newInit: RequestInit = {
-            ...init,
-            method: isGet ? 'GET' : req.method,
-            headers: req.headers,
-            body: isGet ? undefined : (req.body ?? undefined),
-        }
-        const result = await doFetch(newUrl, newInit, redirectCount + 1)
-        result._redirected = true
-        return result
-    }
-
-    if (redirectCount > 0) response._redirected = true
-    return response
-}
-
-async function fetch(url: string | Request, init: RequestInit = {}): Promise<ResponseImpl> {
-    return doFetch(url, init, 0)
-}
-
-// ── Global declarations ──
-
-declare global {
-    var fetch: (url: string | Request, init?: RequestInit) => Promise<Response>;
-}
-
-// ── Register globals ──
-
-globalThis.fetch = fetch
+import * as sock from 'sock'
+import * as wolfssl from 'wolfssl'
+import * as brotli from 'brotli'
+import { parseIni, toIni } from '../lib/cache-utils.js'
+import {
+    _concat,
+    _toReadableStream,
+    _readStream,
+    _hasChunkedEnd,
+    decodeChunked,
+    HeadersImpl,
+    RequestImpl,
+    ResponseImpl,
+} from './http-common.js'
+
+// ── HTTP Response Parser ──
+
+interface ParsedResponse {
+    status: number
+    statusText: string
+    headers: HeadersImpl
+}
+
+function parseHeaders(data: string): ParsedResponse | null {
+    const headerEnd = data.indexOf('\r\n\r\n')
+    if (headerEnd < 0) return null
+
+    const headerPart = data.slice(0, headerEnd)
+    const lines = headerPart.split('\r\n')
+    const statusLine = lines[0]!
+    const match = statusLine.match(/^HTTP\/\d\.\d\s+(\d+)\s+(.*)$/)
+    if (!match) throw new Error('Invalid HTTP response: ' + statusLine)
+
+    const status = parseInt(match[1]!, 10)
+    const statusText = match[2]!
+
+    const headers = new HeadersImpl()
+    for (let i = 1; i < lines.length; i++) {
+        const colonIndex = lines[i]!.indexOf(':')
+        if (colonIndex > 0) {
+            const name = lines[i]!.slice(0, colonIndex).trim()
+            const value = lines[i]!.slice(colonIndex + 1).trim()
+            headers.append(name, value)
+        }
+    }
+
+    return { status, statusText, headers }
+}
+
+// ── State machine constants ──
+
+const ST_CONNECTING = 0
+const ST_HANDSHAKE = 1
+const ST_RECV_HEADERS = 3
+const ST_RECV_BODY = 4
+const ST_DONE = 5
+
+// ── Main fetch request ──
+
+async function fetchRequest(req: RequestImpl): Promise<ResponseImpl> {
+    const parsedUrl = new URL(req.url)
+    const method = req.method
+    const headers = new HeadersImpl(req.headers)
+    const timeout = req.timeout || 30000
+    const isHTTPS = parsedUrl.protocol === 'https:'
+
+    const defaultPort = isHTTPS ? 443 : 80
+    const hostname = parsedUrl.hostname.includes(':') ? `[${parsedUrl.hostname}]` : parsedUrl.hostname
+    const hostHeader = parsedUrl.port && parsedUrl.port !== String(defaultPort)
+        ? hostname + ':' + parsedUrl.port
+        : hostname
+    if (!headers.has('host')) headers.set('Host', hostHeader)
+    if (!headers.has('user-agent')) headers.set('User-Agent', navigator.userAgent)
+    if (!headers.has('connection')) headers.set('Connection', 'close')
+    if (!headers.has('accept-encoding')) headers.set('Accept-Encoding', 'br')
+    let bodyBytes: Uint8Array | null = null
+    if (req.body) {
+        bodyBytes = await _readStream(req.body)
+    }
+    if (bodyBytes && !headers.has('content-length')) headers.set('Content-Length', String(bodyBytes.length))
+
+    return new Promise((resolve, reject) => {
+    let request = method + ' ' + parsedUrl.pathname + (parsedUrl.search || '') + ' HTTP/1.1\r\n'
+    headers.forEach((value: string, name: string) => {
+        request += name + ': ' + value + '\r\n'
+    })
+    request += '\r\n'
+
+    const requestBytes = new TextEncoder().encode(request)
+    const httpRequest = _concat(
+        bodyBytes ? [requestBytes, bodyBytes] : [requestBytes]
+    ).buffer
+
+    let s: sock.SockHandle | null = null
+    let ssl: wolfssl.WOLFSSL | null = null
+    let ctx: wolfssl.WOLFSSL_CTX | null = null
+    let state = ST_CONNECTING
+    let resolved = false
+    let timerId: TimerId | undefined
+    let stream: ReadableStream<Uint8Array> | null = null
+    let _controller: ReadableStreamDefaultController<Uint8Array> | null = null
+    let headerRaw: Uint8Array = new Uint8Array(0)
+    let isChunked = false
+    let contentLength = 0
+    let chunkedParts: Uint8Array[] = []
+    let receivedBytes = 0
+
+        const cleanupSocket = (): void => {
+            state = ST_DONE
+            if (ssl) { wolfssl.wolfSSL_free(ssl); ssl = null }
+            if (ctx) { wolfssl.wolfSSL_CTX_free(ctx); ctx = null }
+            if (s !== null && s >= 0) { sock.closesocket(s); s = null }
+        }
+
+        const cleanup = (): void => {
+            if (timerId) { clearTimeout(timerId); timerId = undefined }
+        }
+
+        const doResolve = (response: ResponseImpl): void => {
+            if (!resolved) { resolved = true; cleanup(); resolve(response) }
+        }
+
+        const doReject = (error: Error): void => {
+            if (!resolved) { resolved = true; cleanup(); cleanupSocket(); reject(error) }
+        }
+
+        timerId = setTimeout(() => {
+            doReject(new Error('Request timeout'))
+        }, timeout)
+
+        s = sock.socket()
+        if (s < 0) { doReject(new Error('Failed to create socket')); return }
+        const fd = s
+
+        sock.set_on_event(fd, (event: { lNetworkEvents: number; iErrorCode: number[] }) => {
+            if (state === ST_DONE) return
+
+            if (event.lNetworkEvents & sock.FdEvent.FD_CONNECT) {
+                const err = event.iErrorCode[0]
+                if (err !== 0) { doReject(new Error('Connection failed: ' + err)); return }
+
+                if (isHTTPS) {
+                    const tlsMethod = wolfssl.wolfTLSv1_2_client_method()
+                    ctx = wolfssl.wolfSSL_CTX_new(tlsMethod)
+                    if (!ctx) { doReject(new Error('SSL_CTX_new failed')); return }
+                    wolfssl.wolfSSL_CTX_set_verify(ctx, wolfssl.VerifyMode.SSL_VERIFY_NONE)
+                    ssl = wolfssl.wolfSSL_new(ctx)
+                    if (!ssl) { doReject(new Error('SSL_new failed')); return }
+                    wolfssl.wolfSSL_set_fd(ssl, sock.get_fd(fd))
+                    if (parsedUrl.hostname) wolfssl.wolfSSL_UseSNI(ssl, wolfssl.SniType.WOLFSSL_SNI_HOST_NAME, parsedUrl.hostname)
+                    state = ST_HANDSHAKE
+                } else {
+                    sock.send(fd, httpRequest)
+                    state = ST_RECV_HEADERS
+                }
+            }
+
+            if ((event.lNetworkEvents & sock.FdEvent.FD_READ) || (event.lNetworkEvents & sock.FdEvent.FD_WRITE)) {
+                if (state === ST_HANDSHAKE) {
+                    if (!ssl) { doReject(new Error('TLS not initialized')); return }
+                    const ret = wolfssl.wolfSSL_connect(ssl)
+                    if (ret === wolfssl.ReturnCode.SSL_SUCCESS) {
+                        wolfssl.wolfSSL_write(ssl, httpRequest)
+                        state = ST_RECV_HEADERS
+                    } else {
+                        const err = wolfssl.wolfSSL_get_error(ssl, ret)
+                        if (err !== wolfssl.ErrorCode.WOLFSSL_ERROR_WANT_READ &&
+                            err !== wolfssl.ErrorCode.WOLFSSL_ERROR_WANT_WRITE) {
+                            doReject(new Error('TLS handshake failed: ' + err))
+                        }
+                    }
+                }
+                else if (state === ST_RECV_HEADERS) {
+                    while (true) {
+                        if (s !== null && s < 0 && !ssl) break
+                        let data: ArrayBuffer | null
+                        if (isHTTPS && ssl) {
+                            data = wolfssl.wolfSSL_read(ssl, 8192)
+                        } else if (s !== null && s >= 0) {
+                            data = sock.recv(s, 8192)
+                        } else { break }
+                        if (!data || data.byteLength === 0) break
+                        const incoming = new Uint8Array(data)
+                        headerRaw = _concat([headerRaw, incoming])
+
+                        let headerEnd = -1
+                        for (let i = 0; i < headerRaw.length - 3; i++) {
+                            if (headerRaw[i] === 0x0D && headerRaw[i+1] === 0x0A && headerRaw[i+2] === 0x0D && headerRaw[i+3] === 0x0A) {
+                                headerEnd = i; break
+                            }
+                        }
+                        if (headerEnd >= 0) {
+                            const headerStr = new TextDecoder('utf-8').decode(headerRaw.subarray(0, headerEnd + 4))
+                            const parsed = parseHeaders(headerStr)
+                            if (!parsed) { doReject(new Error('Failed to parse HTTP headers')); return }
+
+                            const trailingBodyBytes = headerRaw.subarray(headerEnd + 4)
+
+                            isChunked = (parsed.headers.get('transfer-encoding') || '').toLowerCase().includes('chunked')
+                            contentLength = isChunked ? 0 : parseInt(
+                                parsed.headers.get('content-length') || '0', 10
+                            )
+                            _controller = null
+                            stream = new ReadableStream<Uint8Array>({
+                                start(ctrl: ReadableStreamDefaultController<Uint8Array>) { _controller = ctrl },
+                                cancel() { cleanup(); cleanupSocket() }
+                            })
+                            if (trailingBodyBytes.length > 0) {
+                                if (isChunked) {
+                                    chunkedParts = [trailingBodyBytes]
+                                    if (_hasChunkedEnd(trailingBodyBytes)) {
+                                        const decoded = decodeChunked(trailingBodyBytes)
+                                        _controller!.enqueue(decoded)
+                                        _controller!.close()
+                                        state = ST_DONE
+                                        cleanupSocket()
+                                    }
+                                } else {
+                                    receivedBytes += trailingBodyBytes.length
+                                    _controller!.enqueue(trailingBodyBytes)
+                                    if (contentLength > 0 && receivedBytes >= contentLength) {
+                                        _controller!.close()
+                                        state = ST_DONE
+                                        cleanupSocket()
+                                    }
+                                }
+                            }
+
+                            const response = new ResponseImpl(
+                                stream, { status: parsed.status, statusText: parsed.statusText, headers: parsed.headers }
+                            )
+                            if (state !== ST_DONE) {
+                                state = ST_RECV_BODY
+                            }
+                            doResolve(response)
+                            // Break out of header recv loop — any remaining data
+                            // in the socket will be handled by the ST_RECV_BODY path below
+                            break
+                        }
+                    }
+                }
+                else if (state === ST_RECV_BODY && stream) {
+                    while (true) {
+                        if (s !== null && s < 0 && !ssl) break
+                        let data: ArrayBuffer | null
+                        if (isHTTPS && ssl) {
+                            data = wolfssl.wolfSSL_read(ssl, 8192)
+                        } else if (s !== null && s >= 0) {
+                            data = sock.recv(s, 8192)
+                        } else { break }
+                        if (!data || data.byteLength === 0) break
+                        if (isChunked) {
+                            chunkedParts.push(new Uint8Array(data))
+                            const combined = _concat(chunkedParts)
+                            if (_hasChunkedEnd(combined)) {
+                                const decoded = decodeChunked(combined)
+                                _controller!.enqueue(decoded)
+                                _controller!.close()
+                                stream = null
+                                state = ST_DONE
+                                cleanupSocket()
+                                break
+                            }
+                        } else {
+                            receivedBytes += data.byteLength
+                            _controller!.enqueue(new Uint8Array(data))
+                            if (contentLength > 0 && receivedBytes >= contentLength) {
+                                _controller!.close()
+                                state = ST_DONE
+                                cleanupSocket()
+                            }
+                        }
+                    }
+                }
+            }
+
+            if (event.lNetworkEvents & sock.FdEvent.FD_CLOSE) {
+                if (state === ST_DONE) return
+                if (state === ST_RECV_HEADERS) {
+                    doReject(new Error('Connection closed before response'))
+                } else if (state === ST_RECV_BODY && stream) {
+                    let remainingParts: Uint8Array[] = []
+                    while (true) {
+                        if (s !== null && s < 0 && !ssl) break
+                        let data: ArrayBuffer | null
+                        if (isHTTPS && ssl) {
+                            data = wolfssl.wolfSSL_read(ssl, 8192)
+                        } else if (s !== null && s >= 0) {
+                            data = sock.recv(s, 8192)
+                        } else { break }
+                        if (!data || data.byteLength === 0) break
+                        remainingParts.push(new Uint8Array(data))
+                    }
+                    if (isChunked) {
+                        chunkedParts.push(...remainingParts)
+                        const decoded = decodeChunked(_concat(chunkedParts))
+                        _controller!.enqueue(decoded)
+                    } else if (remainingParts.length > 0) {
+                        _controller!.enqueue(_concat(remainingParts))
+                    }
+                    _controller!.close()
+                    stream = null
+                    state = ST_DONE
+                    cleanupSocket()
+                } else {
+                    // ST_CONNECTING or ST_HANDSHAKE — socket died early,
+                    // reject so the Promise doesn't hang forever
+                    doReject(new Error('Connection closed'))
+                }
+            }
+        })
+
+        const ip = sock.resolve(parsedUrl.hostname)
+        if (!ip) {
+            doReject(new Error('DNS resolution failed for: ' + parsedUrl.hostname))
+            return
+        }
+        sock.connect(s, ip, parseInt(parsedUrl.port, 10) || (isHTTPS ? 443 : 80))
+    })
+}
+
+// ── Public fetch (with redirect handling and caching) ──
+
+function parseMaxAge(cc: string): number {
+    const m = cc.match(/max-age=(\d+)/)
+    return m ? parseInt(m[1]!, 10) : 0
+}
+
+interface CacheMeta {
+    storedAt: number;
+    maxAge: number;
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    etag?: string;
+    lastModified?: string;
+}
+
+async function doFetch(url: string | Request, init: RequestInit, redirectCount: number): Promise<ResponseImpl> {
+    let req = new RequestImpl(url, init)
+    const redirectMode = req.redirect || 'follow'
+    const maxRedirects = redirectMode === 'follow' ? (req.maxRedirects || 5) : 0
+    const cache = typeof __httpCache__ !== 'undefined' ? __httpCache__ : null
+    const method = req.method
+    const currentUrl = req.url
+
+    // ── Cache lookup (GET only) ──
+    let cachedMeta: CacheMeta | null = null
+
+    if (cache && method === 'GET') {
+        const metaStr = cache.readMeta(currentUrl)
+        if (metaStr) {
+            const ini = parseIni(metaStr)
+            cachedMeta = {
+                storedAt: parseInt(ini.meta.storedAt || '0', 10),
+                maxAge: parseInt(ini.meta.maxAge || '0', 10),
+                status: parseInt(ini.meta.status || '200', 10),
+                statusText: ini.meta.statusText || 'OK',
+                headers: ini.headers,
+                etag: ini.headers['etag'] || undefined,
+                lastModified: ini.headers['last-modified'] || undefined,
+            }
+            const age = Math.floor(Date.now() / 1000) - cachedMeta.storedAt
+            if (cachedMeta.maxAge > 0 && age < cachedMeta.maxAge) {
+                const body = cache.readBody(currentUrl)
+                if (body) {
+                    ini.meta.lastAccess = String(Math.floor(Date.now() / 1000))
+                    cache.writeMeta(currentUrl, toIni(ini.headers, ini.meta))
+                    const resp = new ResponseImpl(
+                        _toReadableStream(new Uint8Array(body)), { status: cachedMeta.status, statusText: cachedMeta.statusText, headers: new HeadersImpl(cachedMeta.headers || {}) }
+                    )
+                    resp._url = currentUrl
+                    return resp
+                }
+            }
+            if (cachedMeta.etag) req.headers.set('If-None-Match', cachedMeta.etag)
+            if (cachedMeta.lastModified) req.headers.set('If-Modified-Since', cachedMeta.lastModified)
+        }
+    }
+
+    const response = await fetchRequest(req)
+
+    response._url = currentUrl
+
+    // ── Handle brotli Content-Encoding ──
+    const contentEncoding = response.headers.get('content-encoding') || ''
+    if (contentEncoding.includes('br')) {
+        const compressedBody = await response.arrayBuffer()
+        const decompressedBody = brotli.decompress(compressedBody)
+        const newHeaders = new HeadersImpl()
+        response.headers.forEach((v: string, k: string) => {
+            if (k !== 'content-encoding') newHeaders.set(k, v)
+        })
+        newHeaders.set('content-length', String(decompressedBody.byteLength))
+        const stream = _toReadableStream(new Uint8Array(decompressedBody))
+        response._applyDecompressedBody(stream, decompressedBody, newHeaders)
+    }
+
+    // ── Handle 304 Not Modified ──
+    if (response.status === 304 && cachedMeta && cache) {
+        const body = cache.readBody(currentUrl)
+        if (body) {
+            cachedMeta.storedAt = Math.floor(Date.now() / 1000)
+            response.headers.forEach((value: string, name: string) => {
+                cachedMeta.headers[name] = value
+            })
+            const now = String(Math.floor(Date.now() / 1000))
+            const iniMeta: Record<string, string> = {
+                url: currentUrl,
+                storedAt: String(cachedMeta.storedAt),
+                maxAge: String(cachedMeta.maxAge),
+                lastAccess: now,
+                status: String(cachedMeta.status),
+                statusText: cachedMeta.statusText,
+            }
+            cache.writeMeta(currentUrl, toIni(cachedMeta.headers, iniMeta))
+            const resp = new ResponseImpl(
+                _toReadableStream(new Uint8Array(body)), { status: cachedMeta.status, statusText: cachedMeta.statusText, headers: new HeadersImpl(cachedMeta.headers) }
+            )
+            resp._url = currentUrl
+            return resp
+        }
+    }
+
+    // ── Cache 200 GET responses ──
+    if (cache && method === 'GET' && response.status === 200) {
+        const body = await response.arrayBuffer()
+        const cc = response.headers.get('cache-control') || ''
+        const maxAge = parseMaxAge(cc)
+        if (maxAge > 0) {
+            const resHeaders = Object.fromEntries(response.headers)
+            const now = String(Math.floor(Date.now() / 1000))
+            const iniMeta: Record<string, string> = {
+                url: currentUrl,
+                storedAt: now,
+                maxAge: String(maxAge),
+                lastAccess: now,
+                status: String(response.status),
+                statusText: response.statusText,
+            }
+            cache.writeBodyOnly(currentUrl, body)
+            cache.writeMeta(currentUrl, toIni(resHeaders, iniMeta))
+        }
+        const resp = new ResponseImpl(
+            _toReadableStream(new Uint8Array(body)), { status: response.status, statusText: response.statusText, headers: response.headers }
+        )
+        resp._url = currentUrl
+        return resp
+    }
+
+    // ── Redirect handling ──
+    const isRedirect = response.status === 301 || response.status === 302 ||
+                      response.status === 303 || response.status === 307 || response.status === 308
+
+    if (isRedirect) {
+        if (redirectMode === 'error') {
+            response.body.cancel('redirect')
+            throw new TypeError('Redirect not allowed for: ' + currentUrl)
+        }
+        if (redirectMode === 'manual') {
+            response._redirected = true
+            return response
+        }
+        if (redirectCount >= maxRedirects) {
+            response.body.cancel('redirect')
+            throw new TypeError('Redirect count exceeded')
+        }
+
+        const location = response.headers.get('location')
+        if (!location) throw new Error('Redirect response missing Location header')
+
+        response.body.cancel('redirect')
+        const newUrl = new URL(location, currentUrl).href
+        const isGet = response.status === 301 || response.status === 302 || response.status === 303
+        const newInit: RequestInit = {
+            ...init,
+            method: isGet ? 'GET' : req.method,
+            headers: req.headers,
+            body: isGet ? undefined : (req.body ?? undefined),
+        }
+        const result = await doFetch(newUrl, newInit, redirectCount + 1)
+        result._redirected = true
+        return result
+    }
+
+    if (redirectCount > 0) response._redirected = true
+    return response
+}
+
+async function fetch(url: string | Request, init: RequestInit = {}): Promise<ResponseImpl> {
+    return doFetch(url, init, 0)
+}
+
+// ── Global declarations ──
+
+declare global {
+    var fetch: (url: string | Request, init?: RequestInit) => Promise<Response>;
+}
+
+// ── Register globals ──
+
+globalThis.fetch = fetch