quickwin 3.0.0 → 3.0.1

package/lib/dumpRects.ts

@@ -1,34 +0,0 @@
-import * as os from 'os'
-import * as gui from 'gui'
-import { GetWindowCmd } from '../constants'
-import { GetClientRect, GetWindow, GetWindowRect, GetWindowText, GetWindowTextLength } from '../lib/windows/user32.js'
-import { WCHAR } from '../lib/ffi/bind.js'
-import { RECT } from '../lib/windows/structs.js'
-
-export function startDumpRects(rootHwnd: gui.HWND, intervalMs: number = 3000): void {
-  function dumpChild(parent: gui.HWND, indent: string): void {
-    var ch = GetWindow(parent, GetWindowCmd.CHILD)
-    var n = 0
-    while (ch) {
-      n++
-      const wr = RECT.alloc()
-      const cr = RECT.alloc()
-      GetWindowRect(ch, wr.ptr)
-      GetClientRect(ch, cr.ptr)
-      const cap = GetWindowTextLength(ch) + 1
-      const textBuf = WCHAR.alloc(cap)
-      GetWindowText(ch, textBuf, cap)
-      var txt = WCHAR.decode(textBuf).slice(0, 16)
-      console.log(indent + '[' + n + '] hwnd=' + String(ch) + ' txt="' + txt + '" wr=' + JSON.stringify(RECT.decode(wr)) + ' cr=' + JSON.stringify(RECT.decode(cr)))
-      dumpChild(ch, indent + '  ')
-      ch = GetWindow(ch, GetWindowCmd.NEXT)
-    }
-    if (n === 0) console.log(indent + '(no children)')
-  }
-  function tick(): void {
-    console.log('--- dump rects ---')
-    dumpChild(rootHwnd, '')
-    os.setTimeout(tick, intervalMs)
-  }
-  tick()
-}

package/lib/exec-log.ts

@@ -1,30 +0,0 @@
-export interface LogEntry {
-    /** epoch 秒 */
-    ts: number
-    /** 展示用命令/请求描述 */
-    cmd: string
-    /** HTTP 状态码（401/404/500/504 等）；异常终止用 -1 */
-    status: number
-    /** X-Exit-Code（子进程退出码）；无则 null */
-    exit: number | null
-    /** 耗时 ms */
-    durMs: number
-    /** 附加说明（如超时/拒绝原因） */
-    note?: string
-}
-
-/** 请求日志：固定容量环形缓冲，GUI ListBox 每行一条。 */
-export class RequestLog {
-    private buf: LogEntry[] = []
-
-    constructor(private readonly cap = 100) { }
-
-    get size(): number { return this.buf.length }
-
-    push(e: LogEntry): void {
-        this.buf.push(e)
-        if (this.buf.length > this.cap) this.buf.splice(0, this.buf.length - this.cap)
-    }
-
-    list(): LogEntry[] { return this.buf.slice() }
-}

package/lib/fetch.ts

@@ -1,589 +0,0 @@
-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'
-import { FdEvent, ReturnCode, SniType, VerifyMode, WolfsslErrorCode } from '../constants'
-
-// ── 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 }
-}
-
-/** True when the chunked body is complete. With a declared `Trailer`,
- *  the terminating block is followed by 0..n header lines and a final
- *  empty line (`\r\n0\r\n<trailer...>\r\n\r\n`) instead of the bare
- *  `\r\n0\r\n\r\n` form. */
-function chunkedEndReached(data: Uint8Array, hasTrailer: boolean): boolean {
-    if (!hasTrailer) return _hasChunkedEnd(data)
-    const tail = '\r\n0\r\n'
-    for (let i = data.length - 1; i >= 0; i--) {
-        let j = 0
-        while (j < tail.length && i + j < data.length && data[i + j] === tail.charCodeAt(j)) j++
-        if (j === tail.length) {
-            const after = i + tail.length
-            if (data.length >= after + 2 &&
-                data[data.length - 2] === 0x0D && data[data.length - 1] === 0x0A) return true
-        }
-    }
-    return false
-}
-
-// ── 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)
-    if (parsedUrl.protocol !== 'http:' && parsedUrl.protocol !== 'https:') {
-        throw new TypeError('fetch: unsupported protocol "' + parsedUrl.protocol + '"')
-    }
-    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 hasTrailer = false
-    let contentLength = 0
-    let chunkedParts: Uint8Array[] = []
-    let receivedBytes = 0
-
-        const cleanupSocket = (): void => {
-            state = ST_DONE
-            if (timerId) { clearTimeout(timerId); timerId = undefined }
-            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 armTimeout = (): void => {
-            if (timerId) { clearTimeout(timerId); timerId = undefined }
-            timerId = setTimeout(() => {
-                timerId = undefined
-                if (state === ST_DONE) return
-                if (!resolved) {
-                    doReject(new Error('Request timeout'))
-                    return
-                }
-                if (state === ST_RECV_BODY && stream && _controller) {
-                    try { _controller.error(new Error('Body timeout')) } catch { /* already closed */ }
-                    stream = null
-                    cleanupSocket()
-                }
-            }, timeout)
-        }
-
-        const doResolve = (response: ResponseImpl): void => {
-            if (resolved) return
-            resolved = true
-            if (state === ST_DONE) cleanup()
-            else armTimeout()
-            resolve(response)
-        }
-
-        const doReject = (error: Error): void => {
-            if (!resolved) { resolved = true; cleanup(); cleanupSocket(); reject(error) }
-        }
-
-        armTimeout()
-
-        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 & 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 }
-                    if (req.rejectUnauthorized === false) {
-                        wolfssl.wolfSSL_CTX_set_verify(ctx, VerifyMode.SSL_VERIFY_NONE)
-                    } else {
-                        wolfssl.wolfSSL_CTX_set_verify(ctx, VerifyMode.SSL_VERIFY_PEER)
-                        wolfssl.loadTrustedCerts(ctx)
-                    }
-                    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, SniType.WOLFSSL_SNI_HOST_NAME, parsedUrl.hostname)
-                        if (req.rejectUnauthorized !== false) {
-                            wolfssl.wolfSSL_check_domain_name(ssl, parsedUrl.hostname)
-                        }
-                    }
-                    state = ST_HANDSHAKE
-                } else {
-                    sock.send(fd, httpRequest)
-                    state = ST_RECV_HEADERS
-                }
-            }
-
-            if ((event.lNetworkEvents & FdEvent.FD_READ) || (event.lNetworkEvents & FdEvent.FD_WRITE)) {
-                if (state === ST_HANDSHAKE) {
-                    if (!ssl) { doReject(new Error('TLS not initialized')); return }
-                    const ret = wolfssl.wolfSSL_connect(ssl)
-                    if (ret === ReturnCode.SSL_SUCCESS) {
-                        wolfssl.wolfSSL_write(ssl, httpRequest)
-                        state = ST_RECV_HEADERS
-                    } else {
-                        const err = wolfssl.wolfSSL_get_error(ssl, ret)
-                        if (err !== WolfsslErrorCode.WOLFSSL_ERROR_WANT_READ &&
-                            err !== WolfsslErrorCode.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) {
-                            const buf = new ArrayBuffer(8192)
-                            const n = wolfssl.wolfSSL_read(ssl, buf)
-                            if (n > 0) {
-                                data = buf.slice(0, n)
-                            } else {
-                                const err = wolfssl.wolfSSL_get_error(ssl, n)
-                                if (err === WolfsslErrorCode.WOLFSSL_ERROR_WANT_READ ||
-                                    err === WolfsslErrorCode.WOLFSSL_ERROR_WANT_WRITE) break
-                                if (n === 0 || err === WolfsslErrorCode.WOLFSSL_ERROR_ZERO_RETURN) break
-                                doReject(new Error('TLS read failed: ' + err))
-                                return
-                            }
-                        } 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')
-                            hasTrailer = parsed.headers.get('trailer') != null
-                            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 (chunkedEndReached(trailingBodyBytes, hasTrailer)) {
-                                        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) {
-                            const buf = new ArrayBuffer(8192)
-                            const n = wolfssl.wolfSSL_read(ssl, buf)
-                            if (n > 0) {
-                                data = buf.slice(0, n)
-                            } else {
-                                const err = wolfssl.wolfSSL_get_error(ssl, n)
-                                if (err === WolfsslErrorCode.WOLFSSL_ERROR_WANT_READ ||
-                                    err === WolfsslErrorCode.WOLFSSL_ERROR_WANT_WRITE) break
-                                if (n === 0 || err === WolfsslErrorCode.WOLFSSL_ERROR_ZERO_RETURN) break
-                                // Fatal TLS error mid-body: the response already
-                                // resolved, so fail the body stream instead of
-                                // silently waiting for an FD event that never comes.
-                                if (_controller) { try { _controller.error(new Error('TLS read failed: ' + err)) } catch { /* already closed */ } }
-                                stream = null
-                                cleanupSocket()
-                                return
-                            }
-                        } 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 (chunkedEndReached(combined, hasTrailer)) {
-                                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 & 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) {
-                            const buf = new ArrayBuffer(8192)
-                            const n = wolfssl.wolfSSL_read(ssl, buf)
-                            // Best-effort drain: any non-data result (EOF, WANT_*,
-                            // late error) ends the drain — the stream closes below.
-                            if (n > 0) data = buf.slice(0, n)
-                            else break
-                        } 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