quickwin 1.0.2 → 1.1.1

package/lib/http-common.ts

@@ -1,399 +1,399 @@
-import './polyfill.js'
-import './stream.js'
-
-// ── Byte helpers ──
-
-export function _concat(parts: Uint8Array[]): Uint8Array<ArrayBuffer> {
-    if (parts.length === 0) return new Uint8Array(0)
-    let totalLen = 0
-    for (const p of parts) totalLen += p.length
-    const result = new Uint8Array(totalLen)
-    let offset = 0
-    for (const p of parts) { result.set(p, offset); offset += p.length }
-    return result
-}
-
-export function _toReadableStream(body: BodyInit): ReadableStream<Uint8Array> {
-    if (body instanceof ReadableStream) return body
-    const bytes = (typeof body === 'string')
-        ? new TextEncoder().encode(body)
-        : (body instanceof ArrayBuffer)
-            ? new Uint8Array(body)
-            : new Uint8Array(body.buffer, body.byteOffset, body.byteLength)
-    return new ReadableStream<Uint8Array>({
-        start(ctrl) {
-            ctrl.enqueue(bytes)
-            ctrl.close()
-        }
-    })
-}
-
-export async function _readStream(stream: ReadableStream<Uint8Array>): Promise<Uint8Array<ArrayBuffer>> {
-    const reader = stream.getReader()
-    const chunks: Uint8Array[] = []
-    while (true) {
-        const { done, value } = await reader.read()
-        if (done) break
-        chunks.push(value)
-    }
-    return _concat(chunks)
-}
-
-export function _hasChunkedEnd(data: Uint8Array): boolean {
-    if (data.length < 7) return false
-    let i = data.length - 7
-    return data[i] === 0x0D && data[i+1] === 0x0A && data[i+2] === 0x30 && data[i+3] === 0x0D && data[i+4] === 0x0A && data[i+5] === 0x0D && data[i+6] === 0x0A
-}
-
-export function decodeChunked(data: Uint8Array): Uint8Array {
-    const chunks: Uint8Array[] = []
-    let pos = 0
-    while (pos < data.length) {
-        let crlf = -1
-        for (let i = pos; i < data.length - 1; i++) {
-            if (data[i] === 0x0D && data[i + 1] === 0x0A) { crlf = i; break }
-        }
-        if (crlf < 0) break
-
-        let size = 0
-        for (let i = pos; i < crlf; i++) {
-            const b = data[i]!
-            if (b >= 0x30 && b <= 0x39) size = size * 16 + (b - 0x30)
-            else if (b >= 0x41 && b <= 0x46) size = size * 16 + (b - 0x37)
-            else if (b >= 0x61 && b <= 0x66) size = size * 16 + (b - 0x57)
-            else break
-        }
-
-        const dataStart = crlf + 2
-        if (size === 0) {
-            for (let i = dataStart; i < data.length - 3; i++) {
-                if (data[i] === 0x0D && data[i+1] === 0x0A && data[i+2] === 0x0D && data[i+3] === 0x0A) {
-                    pos = i + 4; break
-                }
-            }
-            if (pos === dataStart) break
-            break
-        }
-
-        if (dataStart + size > data.length) break
-        chunks.push(data.subarray(dataStart, dataStart + size))
-        pos = dataStart + size + 2
-    }
-    return _concat(chunks)
-}
-
-// ── Headers ──
-
-// Flat array storage: [name0, value0, name1, value1, ...]
-// Pairs at even/odd indices. Strings are immutable, so [...this._headers] is a correct deep copy.
-
-export class HeadersImpl {
-    private _headers: string[] = []
-
-    constructor(init?: HeadersInit) {
-        if (init) {
-            if (init instanceof HeadersImpl) {
-                this._headers = [...init._headers]
-            } else if (Array.isArray(init)) {
-                this._headers = init.flatMap(([k, v]) => [k.toLowerCase(), v])
-            } else if (typeof init === 'object') {
-                this._headers = Object.entries(init).flatMap(([k, v]) => [k.toLowerCase(), v])
-            }
-        }
-    }
-
-    append(name: string, value: string): void {
-        this._headers.push(name.toLowerCase(), value)
-    }
-
-    delete(name: string): void {
-        const key = name.toLowerCase()
-        const h = this._headers
-        let i = h.length - 2
-        while (i >= 0) {
-            if (h[i] === key) { h.splice(i, 2); i -= 2 } else i -= 2
-        }
-    }
-
-    get(name: string): string | null {
-        const key = name.toLowerCase()
-        const matches = [...this.entries()].filter(([k]) => k === key).map(([, v]) => v)
-        return matches.length ? matches.join(', ') : null
-    }
-
-    has(name: string): boolean {
-        return [...this.keys()].includes(name.toLowerCase())
-    }
-
-    set(name: string, value: string): void {
-        const key = name.toLowerCase()
-        const h = this._headers
-        let found = false
-        let i = h.length - 2
-        while (i >= 0) {
-            if (h[i] === key) {
-                if (!found) {
-                    h[i + 1] = value
-                    found = true
-                } else {
-                    h.splice(i, 2)
-                }
-            }
-            i -= 2
-        }
-        if (!found) h.push(key, value)
-    }
-
-    forEach(callback: (value: string, name: string, headers: HeadersImpl) => void): void {
-        for (const [name, value] of this) {
-            callback(value, name, this)
-        }
-    }
-
-    *entries(): IterableIterator<[string, string]> {
-        const h = this._headers
-        for (let i = 0; i < h.length; i += 2) {
-            yield [h[i]!, h[i + 1]!]
-        }
-    }
-
-    *keys(): IterableIterator<string> {
-        for (const [k] of this) yield k
-    }
-
-    *values(): IterableIterator<string> {
-        for (const [, v] of this) yield v
-    }
-
-    [Symbol.iterator](): IterableIterator<[string, string]> {
-        return this.entries()
-    }
-}
-
-// ── Request ──
-
-export class RequestImpl {
-    readonly url: string
-    readonly method: string
-    readonly headers: HeadersImpl
-    private _body: ReadableStream<Uint8Array> | null
-    readonly redirect: RequestRedirect
-    readonly timeout: number
-    readonly maxRedirects: number
-    private _bodyConsumed: boolean = false
-    readonly integrity: string = ''
-    readonly keepalive: boolean = false
-    readonly mode: string = 'cors'
-    readonly cache: string = 'default'
-    readonly credentials: string = 'same-origin'
-    readonly referrer: string = 'about:client'
-    readonly referrerPolicy: string = ''
-    readonly signal: AbortSignal | null = null
-    readonly destination: string = ''
-
-    get body(): ReadableStream<Uint8Array> | null { return this._body }
-
-    get bodyUsed(): boolean {
-        return this._bodyConsumed || (this._body?.locked ?? false)
-    }
-
-    constructor(input: string | RequestImpl, init: RequestInit = {}) {
-        const initBody = init.body
-        if (input instanceof RequestImpl) {
-            this.url = input.url
-            this.method = init.method || input.method
-            this.headers = new HeadersImpl(init.headers || input.headers)
-            if (initBody !== undefined && initBody !== null) {
-                this._body = _toReadableStream(initBody)
-            } else {
-                this._body = input._body
-            }
-            this.redirect = init.redirect || input.redirect
-            this.timeout = init.timeout || input.timeout
-            this.maxRedirects = init.maxRedirects || input.maxRedirects
-        } else {
-            this.url = input
-            this.method = init.method || 'GET'
-            this.headers = new HeadersImpl(init.headers)
-            this._body = initBody !== null && initBody !== undefined ? _toReadableStream(initBody) : null
-            this.redirect = init.redirect || 'follow'
-            this.timeout = init.timeout || 30000
-            this.maxRedirects = init.maxRedirects || 5
-        }
-    }
-
-    async arrayBuffer(): Promise<ArrayBuffer> {
-        if (!this.body) return new ArrayBuffer(0)
-        if (this._bodyConsumed) throw new TypeError('Body already used')
-        this._bodyConsumed = true
-        const bytes = await _readStream(this.body)
-        return bytes.buffer
-    }
-
-    async json<T = unknown>(): Promise<T> {
-        return JSON.parse(await this.text())
-    }
-
-    async text(): Promise<string> {
-        if (!this.body) return ''
-        if (this._bodyConsumed) throw new TypeError('Body already used')
-        this._bodyConsumed = true
-        const bytes = await _readStream(this.body)
-        return new TextDecoder('utf-8').decode(bytes)
-    }
-
-    clone(): RequestImpl {
-        if (this.bodyUsed) throw new TypeError('Body already used')
-        if (this._body) {
-            const [branch1, branch2] = this._body.tee()
-            this._body = branch1
-            const req = new RequestImpl(this.url, {
-                method: this.method,
-                headers: this.headers,
-                body: branch2,
-                redirect: this.redirect,
-                timeout: this.timeout,
-                maxRedirects: this.maxRedirects,
-            })
-            return req
-        }
-        return new RequestImpl(this.url, {
-            method: this.method,
-            headers: this.headers,
-            redirect: this.redirect,
-            timeout: this.timeout,
-            maxRedirects: this.maxRedirects,
-        })
-    }
-}
-
-// ── Response ──
-
-export class ResponseImpl {
-    readonly status: number
-    readonly statusText: string
-    readonly ok: boolean
-
-    private _headers: HeadersImpl
-    _redirected: boolean = false
-    private _type: ResponseType = 'basic'
-    _url: string = ''
-    private _body: ReadableStream<Uint8Array>
-    private _bodyConsumed: boolean = false
-
-    get body(): ReadableStream<Uint8Array> { return this._body }
-    get bodyUsed(): boolean { return this._bodyConsumed || this._body.locked }
-    get headers(): HeadersImpl { return this._headers }
-    get redirected(): boolean { return this._redirected }
-    get type(): ResponseType { return this._type }
-    get url(): string { return this._url }
-
-    constructor(body?: BodyInit | null, init?: ResponseInit) {
-        const status = init?.status ?? 200
-        const statusText = init?.statusText ?? ''
-        const headers = new HeadersImpl(init?.headers)
-        this.status = status
-        this.statusText = statusText
-        this._headers = headers
-        this.ok = status >= 200 && status < 300
-        this._body = body != null ? _toReadableStream(body) : new ReadableStream<Uint8Array>({
-            start(ctrl) { ctrl.close() }
-        })
-    }
-
-    async text(): Promise<string> {
-        if (this.bodyUsed) throw new TypeError('Body already used')
-        this._bodyConsumed = true
-        const bytes = await _readStream(this._body)
-        return new TextDecoder('utf-8').decode(bytes)
-    }
-
-    async json<T = unknown>(): Promise<T> {
-        return JSON.parse(await this.text())
-    }
-
-    async arrayBuffer(): Promise<ArrayBuffer> {
-        if (this.bodyUsed) throw new TypeError('Body already used')
-        this._bodyConsumed = true
-        const bytes = await _readStream(this._body)
-        return bytes.buffer
-    }
-
-    async bytes(): Promise<Uint8Array> {
-        if (this.bodyUsed) throw new TypeError('Body already used')
-        this._bodyConsumed = true
-        return await _readStream(this._body)
-    }
-
-    clone(): Response {
-        if (this.bodyUsed) throw new TypeError('Body already used')
-        const [branch1, branch2] = this._body.tee()
-        this._body = branch1
-        return new ResponseImpl(branch2, { status: this.status, statusText: this.statusText, headers: this._headers })
-    }
-
-    _applyDecompressedBody(stream: ReadableStream<Uint8Array>, _body: ArrayBuffer, newHeaders: HeadersImpl): void {
-        this._bodyConsumed = false
-        this._body = stream
-        this._headers = newHeaders
-    }
-}
-
-// ── Global declarations ──
-
-declare global {
-    type HeadersInit = [string, string][] | Record<string, string> | Headers
-    type BodyInit = ReadableStream<Uint8Array> | string | ArrayBuffer | ArrayBufferView
-    type RequestRedirect = 'error' | 'follow' | 'manual'
-    type RequestCache = 'default' | 'force-cache' | 'no-cache' | 'no-store' | 'only-if-cached' | 'reload'
-    type RequestCredentials = 'include' | 'omit' | 'same-origin'
-    type RequestMode = 'cors' | 'navigate' | 'no-cors' | 'same-origin'
-    type ResponseType = 'basic' | 'cors' | 'default' | 'error' | 'opaque' | 'opaqueredirect'
-
-    interface AbortSignal {
-        readonly aborted: boolean;
-        readonly reason: unknown;
-        onabort: ((event: Event) => void) | null;
-        throwIfAborted(): void;
-    }
-
-    interface RequestInit {
-        body?: BodyInit | null;
-        cache?: RequestCache;
-        credentials?: RequestCredentials;
-        headers?: HeadersInit;
-        integrity?: string;
-        keepalive?: boolean;
-        method?: string;
-        mode?: RequestMode;
-        redirect?: RequestRedirect;
-        referrer?: string;
-        referrerPolicy?: string;
-        signal?: AbortSignal | null;
-        window?: null;
-        timeout?: number;
-        maxRedirects?: number;
-    }
-
-    interface ResponseInit {
-        status?: number;
-        statusText?: string;
-        headers?: HeadersInit;
-    }
-
-    interface Headers extends HeadersImpl {}
-    var Headers: typeof HeadersImpl
-    interface Response extends Omit<ResponseImpl, '_url' | '_redirected' | '_applyDecompressedBody'> {}
-    interface ResponseConstructor {
-        new(body?: BodyInit | null, init?: ResponseInit): Response
-    }
-    var Response: ResponseConstructor
-    interface Request extends RequestImpl {}
-    var Request: typeof RequestImpl
-}
-
-// ── Register globals ──
-
-globalThis.Headers = HeadersImpl
-globalThis.Request = RequestImpl
-globalThis.Response = ResponseImpl
+import './polyfill.js'
+import './stream.js'
+
+// ── Byte helpers ──
+
+export function _concat(parts: Uint8Array[]): Uint8Array<ArrayBuffer> {
+    if (parts.length === 0) return new Uint8Array(0)
+    let totalLen = 0
+    for (const p of parts) totalLen += p.length
+    const result = new Uint8Array(totalLen)
+    let offset = 0
+    for (const p of parts) { result.set(p, offset); offset += p.length }
+    return result
+}
+
+export function _toReadableStream(body: BodyInit): ReadableStream<Uint8Array> {
+    if (body instanceof ReadableStream) return body
+    const bytes = (typeof body === 'string')
+        ? new TextEncoder().encode(body)
+        : (body instanceof ArrayBuffer)
+            ? new Uint8Array(body)
+            : new Uint8Array(body.buffer, body.byteOffset, body.byteLength)
+    return new ReadableStream<Uint8Array>({
+        start(ctrl) {
+            ctrl.enqueue(bytes)
+            ctrl.close()
+        }
+    })
+}
+
+export async function _readStream(stream: ReadableStream<Uint8Array>): Promise<Uint8Array<ArrayBuffer>> {
+    const reader = stream.getReader()
+    const chunks: Uint8Array[] = []
+    while (true) {
+        const { done, value } = await reader.read()
+        if (done) break
+        chunks.push(value)
+    }
+    return _concat(chunks)
+}
+
+export function _hasChunkedEnd(data: Uint8Array): boolean {
+    if (data.length < 7) return false
+    let i = data.length - 7
+    return data[i] === 0x0D && data[i+1] === 0x0A && data[i+2] === 0x30 && data[i+3] === 0x0D && data[i+4] === 0x0A && data[i+5] === 0x0D && data[i+6] === 0x0A
+}
+
+export function decodeChunked(data: Uint8Array): Uint8Array {
+    const chunks: Uint8Array[] = []
+    let pos = 0
+    while (pos < data.length) {
+        let crlf = -1
+        for (let i = pos; i < data.length - 1; i++) {
+            if (data[i] === 0x0D && data[i + 1] === 0x0A) { crlf = i; break }
+        }
+        if (crlf < 0) break
+
+        let size = 0
+        for (let i = pos; i < crlf; i++) {
+            const b = data[i]!
+            if (b >= 0x30 && b <= 0x39) size = size * 16 + (b - 0x30)
+            else if (b >= 0x41 && b <= 0x46) size = size * 16 + (b - 0x37)
+            else if (b >= 0x61 && b <= 0x66) size = size * 16 + (b - 0x57)
+            else break
+        }
+
+        const dataStart = crlf + 2
+        if (size === 0) {
+            for (let i = dataStart; i < data.length - 3; i++) {
+                if (data[i] === 0x0D && data[i+1] === 0x0A && data[i+2] === 0x0D && data[i+3] === 0x0A) {
+                    pos = i + 4; break
+                }
+            }
+            if (pos === dataStart) break
+            break
+        }
+
+        if (dataStart + size > data.length) break
+        chunks.push(data.subarray(dataStart, dataStart + size))
+        pos = dataStart + size + 2
+    }
+    return _concat(chunks)
+}
+
+// ── Headers ──
+
+// Flat array storage: [name0, value0, name1, value1, ...]
+// Pairs at even/odd indices. Strings are immutable, so [...this._headers] is a correct deep copy.
+
+export class HeadersImpl {
+    private _headers: string[] = []
+
+    constructor(init?: HeadersInit) {
+        if (init) {
+            if (init instanceof HeadersImpl) {
+                this._headers = [...init._headers]
+            } else if (Array.isArray(init)) {
+                this._headers = init.flatMap(([k, v]) => [k.toLowerCase(), v])
+            } else if (typeof init === 'object') {
+                this._headers = Object.entries(init).flatMap(([k, v]) => [k.toLowerCase(), v])
+            }
+        }
+    }
+
+    append(name: string, value: string): void {
+        this._headers.push(name.toLowerCase(), value)
+    }
+
+    delete(name: string): void {
+        const key = name.toLowerCase()
+        const h = this._headers
+        let i = h.length - 2
+        while (i >= 0) {
+            if (h[i] === key) { h.splice(i, 2); i -= 2 } else i -= 2
+        }
+    }
+
+    get(name: string): string | null {
+        const key = name.toLowerCase()
+        const matches = [...this.entries()].filter(([k]) => k === key).map(([, v]) => v)
+        return matches.length ? matches.join(', ') : null
+    }
+
+    has(name: string): boolean {
+        return [...this.keys()].includes(name.toLowerCase())
+    }
+
+    set(name: string, value: string): void {
+        const key = name.toLowerCase()
+        const h = this._headers
+        let found = false
+        let i = h.length - 2
+        while (i >= 0) {
+            if (h[i] === key) {
+                if (!found) {
+                    h[i + 1] = value
+                    found = true
+                } else {
+                    h.splice(i, 2)
+                }
+            }
+            i -= 2
+        }
+        if (!found) h.push(key, value)
+    }
+
+    forEach(callback: (value: string, name: string, headers: HeadersImpl) => void): void {
+        for (const [name, value] of this) {
+            callback(value, name, this)
+        }
+    }
+
+    *entries(): IterableIterator<[string, string]> {
+        const h = this._headers
+        for (let i = 0; i < h.length; i += 2) {
+            yield [h[i]!, h[i + 1]!]
+        }
+    }
+
+    *keys(): IterableIterator<string> {
+        for (const [k] of this) yield k
+    }
+
+    *values(): IterableIterator<string> {
+        for (const [, v] of this) yield v
+    }
+
+    [Symbol.iterator](): IterableIterator<[string, string]> {
+        return this.entries()
+    }
+}
+
+// ── Request ──
+
+export class RequestImpl {
+    readonly url: string
+    readonly method: string
+    readonly headers: HeadersImpl
+    private _body: ReadableStream<Uint8Array> | null
+    readonly redirect: RequestRedirect
+    readonly timeout: number
+    readonly maxRedirects: number
+    private _bodyConsumed: boolean = false
+    readonly integrity: string = ''
+    readonly keepalive: boolean = false
+    readonly mode: string = 'cors'
+    readonly cache: string = 'default'
+    readonly credentials: string = 'same-origin'
+    readonly referrer: string = 'about:client'
+    readonly referrerPolicy: string = ''
+    readonly signal: AbortSignal | null = null
+    readonly destination: string = ''
+
+    get body(): ReadableStream<Uint8Array> | null { return this._body }
+
+    get bodyUsed(): boolean {
+        return this._bodyConsumed || (this._body?.locked ?? false)
+    }
+
+    constructor(input: string | RequestImpl, init: RequestInit = {}) {
+        const initBody = init.body
+        if (input instanceof RequestImpl) {
+            this.url = input.url
+            this.method = init.method || input.method
+            this.headers = new HeadersImpl(init.headers || input.headers)
+            if (initBody !== undefined && initBody !== null) {
+                this._body = _toReadableStream(initBody)
+            } else {
+                this._body = input._body
+            }
+            this.redirect = init.redirect || input.redirect
+            this.timeout = init.timeout || input.timeout
+            this.maxRedirects = init.maxRedirects || input.maxRedirects
+        } else {
+            this.url = input
+            this.method = init.method || 'GET'
+            this.headers = new HeadersImpl(init.headers)
+            this._body = initBody !== null && initBody !== undefined ? _toReadableStream(initBody) : null
+            this.redirect = init.redirect || 'follow'
+            this.timeout = init.timeout || 30000
+            this.maxRedirects = init.maxRedirects || 5
+        }
+    }
+
+    async arrayBuffer(): Promise<ArrayBuffer> {
+        if (!this.body) return new ArrayBuffer(0)
+        if (this._bodyConsumed) throw new TypeError('Body already used')
+        this._bodyConsumed = true
+        const bytes = await _readStream(this.body)
+        return bytes.buffer
+    }
+
+    async json<T = unknown>(): Promise<T> {
+        return JSON.parse(await this.text())
+    }
+
+    async text(): Promise<string> {
+        if (!this.body) return ''
+        if (this._bodyConsumed) throw new TypeError('Body already used')
+        this._bodyConsumed = true
+        const bytes = await _readStream(this.body)
+        return new TextDecoder('utf-8').decode(bytes)
+    }
+
+    clone(): RequestImpl {
+        if (this.bodyUsed) throw new TypeError('Body already used')
+        if (this._body) {
+            const [branch1, branch2] = this._body.tee()
+            this._body = branch1
+            const req = new RequestImpl(this.url, {
+                method: this.method,
+                headers: this.headers,
+                body: branch2,
+                redirect: this.redirect,
+                timeout: this.timeout,
+                maxRedirects: this.maxRedirects,
+            })
+            return req
+        }
+        return new RequestImpl(this.url, {
+            method: this.method,
+            headers: this.headers,
+            redirect: this.redirect,
+            timeout: this.timeout,
+            maxRedirects: this.maxRedirects,
+        })
+    }
+}
+
+// ── Response ──
+
+export class ResponseImpl {
+    readonly status: number
+    readonly statusText: string
+    readonly ok: boolean
+
+    private _headers: HeadersImpl
+    _redirected: boolean = false
+    private _type: ResponseType = 'basic'
+    _url: string = ''
+    private _body: ReadableStream<Uint8Array>
+    private _bodyConsumed: boolean = false
+
+    get body(): ReadableStream<Uint8Array> { return this._body }
+    get bodyUsed(): boolean { return this._bodyConsumed || this._body.locked }
+    get headers(): HeadersImpl { return this._headers }
+    get redirected(): boolean { return this._redirected }
+    get type(): ResponseType { return this._type }
+    get url(): string { return this._url }
+
+    constructor(body?: BodyInit | null, init?: ResponseInit) {
+        const status = init?.status ?? 200
+        const statusText = init?.statusText ?? ''
+        const headers = new HeadersImpl(init?.headers)
+        this.status = status
+        this.statusText = statusText
+        this._headers = headers
+        this.ok = status >= 200 && status < 300
+        this._body = body != null ? _toReadableStream(body) : new ReadableStream<Uint8Array>({
+            start(ctrl) { ctrl.close() }
+        })
+    }
+
+    async text(): Promise<string> {
+        if (this.bodyUsed) throw new TypeError('Body already used')
+        this._bodyConsumed = true
+        const bytes = await _readStream(this._body)
+        return new TextDecoder('utf-8').decode(bytes)
+    }
+
+    async json<T = unknown>(): Promise<T> {
+        return JSON.parse(await this.text())
+    }
+
+    async arrayBuffer(): Promise<ArrayBuffer> {
+        if (this.bodyUsed) throw new TypeError('Body already used')
+        this._bodyConsumed = true
+        const bytes = await _readStream(this._body)
+        return bytes.buffer
+    }
+
+    async bytes(): Promise<Uint8Array> {
+        if (this.bodyUsed) throw new TypeError('Body already used')
+        this._bodyConsumed = true
+        return await _readStream(this._body)
+    }
+
+    clone(): Response {
+        if (this.bodyUsed) throw new TypeError('Body already used')
+        const [branch1, branch2] = this._body.tee()
+        this._body = branch1
+        return new ResponseImpl(branch2, { status: this.status, statusText: this.statusText, headers: this._headers })
+    }
+
+    _applyDecompressedBody(stream: ReadableStream<Uint8Array>, _body: ArrayBuffer, newHeaders: HeadersImpl): void {
+        this._bodyConsumed = false
+        this._body = stream
+        this._headers = newHeaders
+    }
+}
+
+// ── Global declarations ──
+
+declare global {
+    type HeadersInit = [string, string][] | Record<string, string> | Headers
+    type BodyInit = ReadableStream<Uint8Array> | string | ArrayBuffer | ArrayBufferView
+    type RequestRedirect = 'error' | 'follow' | 'manual'
+    type RequestCache = 'default' | 'force-cache' | 'no-cache' | 'no-store' | 'only-if-cached' | 'reload'
+    type RequestCredentials = 'include' | 'omit' | 'same-origin'
+    type RequestMode = 'cors' | 'navigate' | 'no-cors' | 'same-origin'
+    type ResponseType = 'basic' | 'cors' | 'default' | 'error' | 'opaque' | 'opaqueredirect'
+
+    interface AbortSignal {
+        readonly aborted: boolean;
+        readonly reason: unknown;
+        onabort: ((event: Event) => void) | null;
+        throwIfAborted(): void;
+    }
+
+    interface RequestInit {
+        body?: BodyInit | null;
+        cache?: RequestCache;
+        credentials?: RequestCredentials;
+        headers?: HeadersInit;
+        integrity?: string;
+        keepalive?: boolean;
+        method?: string;
+        mode?: RequestMode;
+        redirect?: RequestRedirect;
+        referrer?: string;
+        referrerPolicy?: string;
+        signal?: AbortSignal | null;
+        window?: null;
+        timeout?: number;
+        maxRedirects?: number;
+    }
+
+    interface ResponseInit {
+        status?: number;
+        statusText?: string;
+        headers?: HeadersInit;
+    }
+
+    interface Headers extends HeadersImpl {}
+    var Headers: typeof HeadersImpl
+    interface Response extends Omit<ResponseImpl, '_url' | '_redirected' | '_applyDecompressedBody'> {}
+    interface ResponseConstructor {
+        new(body?: BodyInit | null, init?: ResponseInit): Response
+    }
+    var Response: ResponseConstructor
+    interface Request extends RequestImpl {}
+    var Request: typeof RequestImpl
+}
+
+// ── Register globals ──
+
+globalThis.Headers = HeadersImpl
+globalThis.Request = RequestImpl
+globalThis.Response = ResponseImpl