@vigla/kit 0.0.0-stage → 0.1.1

package/src/server/respond.ts

@@ -0,0 +1,488 @@
+import type {
+	Endpoint,
+	PageNode,
+	RequestState,
+	RequestStore,
+	RespondOptions,
+	ServerRoute
+} from '../types/internal/server.ts';
+import type { RequestEvent } from '../types/request.ts';
+import type { ParamValue } from '../types/params.ts';
+import type { Server } from './index.ts';
+import {
+	addDataSuffix,
+	addResolutionSuffix,
+	hasDataSuffix,
+	hasResolutionSuffix,
+	stripDataSuffix,
+	stripResolutionSuffix
+} from '../shared/pathname.ts';
+import { decodePathname, normalizePath, relativePathname } from '../shared/url.ts';
+import { findRoute } from '../shared/routing/index.ts';
+import { isEndpoint, negotiate } from '../shared/http.ts';
+import { Redirect } from '../shared/outcomes.ts';
+import { uneval } from 'devalue';
+import { CookieJar } from './cookies.ts';
+import { csrfResponse } from './csrf.ts';
+import { ResponseHeaders } from './headers.ts';
+import { RequestScope, runRequest } from './scope.ts';
+import { createFetch } from './fetch.ts';
+import { endpointResponse } from './endpoint.ts';
+import { dataResponse } from './data.ts';
+import { pageResponse, pageSettings, errorResponse, fatalResponse } from './page.ts';
+import { resolutionResponse } from './routing.ts';
+import { FrameworkError } from './failure.ts';
+import { appEvent } from './hooks.ts';
+import { renderDocument } from './document.ts';
+import { restrictSearch } from './url.ts';
+import { client_address_unsupported } from './errors.ts';
+import { identity } from '../shared/identity.ts';
+
+const subresources = new Set([
+	'audio',
+	'audioworklet',
+	'font',
+	'image',
+	'json',
+	'manifest',
+	'paintworklet',
+	'report',
+	'script',
+	'serviceworker',
+	'sharedworker',
+	'style',
+	'track',
+	'video',
+	'webidentity',
+	'worker',
+	'xslt'
+]);
+
+function handlesPageMethod(endpoint: Endpoint, method: string): boolean {
+	if (method === 'POST') return !!(endpoint.POST || endpoint.fallback);
+	if (method === 'GET' || method === 'HEAD')
+		return !!(endpoint.GET || endpoint.fallback || (method === 'HEAD' && endpoint.HEAD));
+	return true;
+}
+
+export async function respond(
+	server: Server,
+	request: Request,
+	options: RespondOptions,
+	parent?: RequestStore
+): Promise<Response> {
+	if (request.signal.aborted) throw request.signal.reason;
+	if (parent && parent.state.depth >= 20)
+		return new Response('Internal request depth exceeded', { status: 508 });
+	const url = new URL(request.url);
+	const data = hasDataSuffix(url.pathname);
+	const resolution = hasResolutionSuffix(url.pathname);
+	const remotePrefix = `/${server.manifest.app_path}/remote/`;
+	const remote = url.pathname.startsWith(remotePrefix)
+		? url.pathname.slice(remotePrefix.length).split('/')
+		: null;
+	const rejected = server.options.dev
+		? null
+		: csrfResponse(request, !!remote, server.options.csrf, server.options.paths);
+	if (rejected) return rejected;
+	if (
+		server.options.router.type === 'hash' &&
+		url.pathname !== `${server.options.paths.base}/` &&
+		url.pathname !== '/[fallback]'
+	)
+		return new Response('Not found', { status: 404 });
+	let invalidated: boolean[] | undefined;
+	if (data) {
+		url.pathname =
+			stripDataSuffix(url.pathname) +
+				(url.searchParams.get(`x-${identity.name}-trailing-slash`) === '1' ? '/' : '') || '/';
+		url.searchParams.delete(`x-${identity.name}-trailing-slash`);
+		const mask =
+			url.searchParams.get(`x-${identity.name}-invalidated`) ??
+			request.headers.get(`x-${identity.name}-invalidated`);
+		invalidated = mask?.split('').map((value) => value === '1');
+		url.searchParams.delete(`x-${identity.name}-invalidated`);
+	} else if (resolution) url.pathname = stripResolutionSuffix(url.pathname) || '/';
+	else if (remote && request.headers.has(`x-${identity.name}-pathname`)) {
+		url.pathname = request.headers.get(`x-${identity.name}-pathname`)!;
+		url.search = request.headers.get(`x-${identity.name}-search`) ?? '';
+	}
+	for (const key of url.searchParams.keys())
+		if (key.startsWith(`x-${identity.name}-`))
+			return new Response(`Cannot use reserved query parameter "${key}"`, { status: 400 });
+	const headers = new ResponseHeaders(server.options.dev);
+	const jar = new CookieJar(request, url, server.options.dev, server.cookiePaths);
+	const state: RequestState = {
+		read: options.read ?? server.read,
+		emulator: options.emulator,
+		depth: (parent?.state.depth ?? -1) + 1,
+		error: false,
+		rerouted: null,
+		prerendering: options.prerendering,
+		prerenderDefault: parent?.state.prerenderDefault,
+		fetched: [],
+		resolveOptions: {},
+		isRendering: false,
+		active: true
+	};
+	restrictSearch(url, state);
+	const event = {
+		cookies: jar.cookies,
+		fetch: (...args: Parameters<typeof fetch>) => fetch(...args),
+		getClientAddress:
+			options.getClientAddress ??
+			(() => client_address_unsupported({ adapter: server.options.adapter })),
+		locals: {},
+		params: {},
+		platform: options.emulator?.platform
+			? await options.emulator.platform({ config: {}, prerender: !!state.prerendering?.fallback })
+			: options.platform,
+		request,
+		route: { id: null as string | null },
+		setHeaders: (values: Record<string, string>) => {
+			headers.set(values);
+			if (state.prerendering)
+				for (const [name, value] of Object.entries(values))
+					if (name.toLowerCase() === 'cache-control') state.prerenderCache = value;
+		},
+		url,
+		isDataRequest: data,
+		isSubRequest: !!parent,
+		isRemoteRequest: !!remote,
+		tracing: {
+			enabled: server.options.tracing.server,
+			root: parent?.event.tracing.root ?? server.tracer.current(),
+			current: server.tracer.current()
+		}
+	} satisfies RequestEvent<Record<string, ParamValue>>;
+	const scope = new RequestScope(server, event, state);
+	event.fetch = createFetch(server, scope.store, jar);
+	let route: ServerRoute | undefined;
+	let nodes: Array<PageNode | undefined> = [];
+	try {
+		if (state.prerendering?.fallback) {
+			jar.route('ignore');
+			return finish(await shell(scope.store));
+		}
+		let path = url.pathname;
+		const rerouting = !remote || request.headers.has(`x-${identity.name}-pathname`);
+		if (
+			rerouting &&
+			server.hooks.reroute &&
+			!path.includes(`/${server.manifest.app_dir}/routes/`)
+		) {
+			const before = state.prerendering?.insideReroute;
+			try {
+				if (state.prerendering) state.prerendering.insideReroute = true;
+				path =
+					(await scope.run(() =>
+						server.hooks.reroute!({ url: new URL(url), fetch: event.fetch })
+					)) ?? path;
+				if (path !== url.pathname) state.rerouted = new URL(path, url).href;
+			} finally {
+				if (state.prerendering) state.prerendering.insideReroute = before ?? false;
+			}
+		}
+		let original: string;
+		try {
+			path = decodePathname(path);
+			original = decodePathname(url.pathname);
+		} catch {
+			return finish(
+				await errorResponse(server, scope.store, new FrameworkError(400, 'Malformed URI'))
+			);
+		}
+		if (
+			!state.prerendering?.fallback &&
+			path !== original &&
+			(server.manifest.prerendered_routes.has(path) ||
+				(path.endsWith('/') && server.manifest.prerendered_routes.has(path.slice(0, -1))))
+		) {
+			const target = new URL(request.url);
+			target.pathname = data ? addDataSuffix(path) : resolution ? addResolutionSuffix(path) : path;
+			const response = await fetch(new Request(target, request), { redirect: 'manual' });
+			const headers = new Headers(response.headers);
+			if (headers.has('content-encoding')) {
+				headers.delete('content-encoding');
+				headers.delete('content-length');
+			}
+			state.rerouted = target.href;
+			return finish(
+				new Response(response.body, {
+					status: response.status,
+					statusText: response.statusText,
+					headers
+				})
+			);
+		}
+		const base = server.options.paths.base;
+		if (base && path !== base && !path.startsWith(`${base}/`) && !state.prerendering?.fallback)
+			return finish(new Response('Not found', { status: 404 }));
+		path = path.slice(base.length) || '/';
+		if (resolution) return finish(await resolutionResponse(server, path, new URL(request.url)));
+		if (path === `/${server.manifest.app_dir}/env.js`)
+			return finish(
+				new Response(`export const env=${uneval(server.environment.rendered)};`, {
+					headers: { 'content-type': 'application/javascript' }
+				})
+			);
+		if (path.startsWith(`/${server.manifest.app_dir}/immutable/`))
+			return finish(
+				new Response('Not found', {
+					status: 404,
+					headers: { 'cache-control': 'public, max-age=31536000, immutable' }
+				})
+			);
+		const match =
+			remote && !request.headers.has(`x-${identity.name}-pathname`)
+				? null
+				: findRoute(path, server.manifest.routes, await server.manifest.matchers());
+		route = match?.route;
+		if (match) {
+			event.route = { id: match.route.id };
+			event.params = match.params;
+		}
+		if (route?.page)
+			nodes = await Promise.all(
+				[...route.page.layouts, route.page.leaf].map((id) =>
+					id == null ? undefined : server.manifest.nodes[id]!()
+				)
+			);
+		const endpoint = route?.endpoint ? await route.endpoint() : null;
+		const useEndpoint =
+			!!endpoint &&
+			(!route?.page ||
+				(!state.prerendering &&
+					isEndpoint(request) &&
+					handlesPageMethod(endpoint, request.method)));
+		const slash = remote
+			? 'ignore'
+			: route && (url.pathname === base || url.pathname === `${base}/`)
+				? 'always'
+				: route?.page
+					? pageSettings(nodes).trailingSlash
+					: (endpoint?.trailingSlash ?? 'never');
+		if (options.emulator?.platform && route) {
+			const config = endpoint
+				? (endpoint.config ?? {})
+				: Object.assign(
+						{},
+						...nodes.flatMap((node) => [node?.server?.config, node?.universal?.config])
+					);
+			const prerender = endpoint ? (endpoint.prerender ?? false) : pageSettings(nodes).prerender;
+			if (!endpoint) state.prerenderDefault = prerender;
+			event.platform = await options.emulator.platform({ config, prerender });
+		}
+		let resolved = false;
+		const resolveRequest = async (
+			resolvedEvent: RequestEvent<Record<string, ParamValue>>,
+			resolveOptions = {}
+		): Promise<Response> => {
+			if (resolved) throw new Error('resolve() has already been called');
+			resolved = true;
+			state.resolveOptions = resolveOptions;
+			jar.route(slash);
+			const resolvedUrl = new URL(resolvedEvent.url);
+			if (data) {
+				resolvedUrl.pathname = normalizePath(resolvedUrl.pathname, slash);
+				restrictSearch(resolvedUrl, state);
+			}
+			const store = {
+				...scope.store,
+				event: data ? { ...resolvedEvent, url: resolvedUrl } : resolvedEvent
+			};
+			try {
+				const normalized = normalizePath(url.pathname, slash);
+				if (!data && !remote && normalized !== url.pathname && !state.prerendering?.fallback) {
+					const { search } = new URL(url.href);
+					return new Response(null, {
+						status: 308,
+						headers: {
+							location: relativePathname(url.pathname, normalized) + search,
+							[`x-${identity.name}-normalize`]: '1'
+						}
+					});
+				}
+				if (server.options.router.type === 'hash') return await shell(store);
+				if (remote) {
+					if (!server.options.remote)
+						return new Response('Remote functions are not implemented', { status: 501 });
+					return await runRequest(store, () =>
+						server.options.remote!({
+							id: remote[0] ?? '',
+							name: remote[1] ?? '',
+							argument: remote[2],
+							store
+						})
+					);
+				}
+				if (!route) return await notFound(store);
+				if (data) return await dataResponse(server, store, route.page, invalidated);
+				if (useEndpoint) return await endpointResponse(server, store, endpoint!);
+				if (!route.page)
+					return await errorResponse(server, store, new FrameworkError(404, 'Not Found'));
+				if (request.method === 'OPTIONS')
+					return new Response(null, {
+						status: 204,
+						headers: { allow: `GET, HEAD, OPTIONS${nodes.at(-1)?.server?.actions ? ', POST' : ''}` }
+					});
+				if (!['GET', 'HEAD', 'POST'].includes(request.method))
+					return new Response(`${request.method} method not allowed`, {
+						status: 405,
+						headers: { allow: 'GET, HEAD' }
+					});
+				return await pageResponse(server, store, route, nodes);
+			} finally {
+				headers.seal();
+				jar.seal();
+			}
+		};
+		const resolve = (
+			resolvedEvent: RequestEvent<Record<string, ParamValue>>,
+			resolveOptions = {}
+		): Promise<Response> =>
+			server.tracer.span(
+				`${identity.name}.resolve`,
+				{ 'http.route': resolvedEvent.route.id ?? 'unknown' },
+				async (span) => {
+					const response = await resolveRequest(
+						{ ...resolvedEvent, tracing: { ...resolvedEvent.tracing, current: span } },
+						resolveOptions
+					);
+					span.setAttributes({
+						'http.response.status_code': response.status,
+						'http.response.body.size': response.headers.get('content-length') || 'unknown'
+					});
+					return response;
+				}
+			);
+		const response = await server.tracer.span(
+			`${identity.name}.handle.root`,
+			{
+				'http.route': event.route.id ?? 'unknown',
+				'http.method': request.method,
+				'http.url': url.href,
+				[`${identity.name}.is_data_request`]: data,
+				[`${identity.name}.is_sub_request`]: !!parent
+			},
+			async (span) => {
+				event.tracing = { enabled: server.options.tracing.server, root: span, current: span };
+				return scope.run(() =>
+					server.hooks.handle
+						? server.hooks.handle({ event: appEvent(event), resolve })
+						: resolve(event)
+				);
+			}
+		);
+		if (!(response instanceof Response)) throw new Error('The handle hook must return a Response');
+		return finish(response, !!route?.page && !!endpoint);
+	} catch (error) {
+		if (request.signal.aborted) {
+			scope.close();
+			throw request.signal.reason;
+		}
+		try {
+			if (error instanceof Redirect) {
+				const response = data
+					? Response.json({ type: 'redirect', status: error.status, location: error.location })
+					: request.method === 'POST' &&
+						  negotiate(request.headers.get('accept') ?? '*/*', [
+								'application/json',
+								'text/html'
+						  ]) === 'application/json'
+						? Response.json({ type: 'redirect', status: error.status, location: error.location })
+						: new Response(null, { status: error.status, headers: { location: error.location } });
+				return finish(response);
+			}
+			return finish(await fatalResponse(server, scope.store, error));
+		} catch (fatal) {
+			scope.close();
+			throw fatal;
+		}
+	}
+
+	async function shell(store: RequestStore): Promise<Response> {
+		const layout = await server.manifest.nodes[0]!();
+		return renderDocument(server, store, {
+			branch: [{ depth: 0, node: layout, server: null, data: null }],
+			errors: [],
+			status: 200,
+			error: null,
+			form: null,
+			ssr: false,
+			csr: true
+		});
+	}
+
+	async function notFound(store: RequestStore): Promise<Response> {
+		if (parent?.state.error) {
+			const headers = new Headers(request.headers);
+			headers.set(`x-${identity.name}-error`, 'true');
+			return fetch(request, { headers, redirect: 'manual' });
+		}
+		if (state.depth === 0) {
+			if (data && !state.prerendering && invalidated?.length === 1 && invalidated[0])
+				return dataResponse(server, store, { layouts: [], errors: [], leaf: 0 }, invalidated);
+			if (subresources.has(request.headers.get('sec-fetch-dest') ?? ''))
+				return new Response('Not Found', { status: 404, headers: { vary: 'Sec-Fetch-Dest' } });
+			return errorResponse(server, store, new FrameworkError(404, 'Not Found'));
+		}
+		if (state.prerendering) return new Response('not found', { status: 404 });
+		const response = await fetch(request, { redirect: 'manual' });
+		return new Response(response.body, response);
+	}
+
+	function finish(response: Response, vary = false): Response {
+		const location = response.headers.get('location');
+		if (data && response.status >= 300 && response.status <= 308 && location) {
+			void response.body?.cancel().catch(() => {});
+			const headers = new Headers(response.headers);
+			headers.delete('location');
+			headers.delete('content-length');
+			headers.set('content-type', 'application/json');
+			response = Response.json(
+				{ type: 'redirect', status: response.status, location },
+				{ headers }
+			);
+		}
+		jar.route('ignore');
+		jar.seal();
+		headers.seal();
+		const result = new Headers(response.headers);
+		for (const [name, value] of headers.values) result.set(name, value);
+		jar.apply(result);
+		if (
+			vary &&
+			!result
+				.get('vary')
+				?.split(',')
+				.some((name) => name.trim().toLowerCase() === 'accept')
+		)
+			result.append('vary', 'Accept');
+		if (state.rerouted) result.set(`x-${identity.name}-rerouted-url`, state.rerouted);
+		if (state.prerendering && event.route.id)
+			result.set(`x-${identity.name}-routeid`, encodeURI(event.route.id));
+		const etag = result.get('etag');
+		if (etag && request.headers.get('if-none-match')?.replace(/^W\//, '') === etag) {
+			void response.body?.cancel().catch(() => {});
+			return scope.response(new Response(null, { status: 304, headers: result }));
+		}
+		if (request.method === 'HEAD') {
+			void response.body?.cancel().catch(() => {});
+			return scope.response(
+				new Response(null, {
+					status: response.status,
+					statusText: response.statusText,
+					headers: result
+				})
+			);
+		}
+		return scope.response(
+			new Response(response.body, {
+				status: response.status,
+				statusText: response.statusText,
+				headers: result
+			})
+		);
+	}
+}

package/src/server/routing.ts

@@ -0,0 +1,58 @@
+import { uneval } from 'devalue';
+import type { ClientRoute } from '../types/internal/server.ts';
+import type { Server } from './index.ts';
+import { findRoute } from '../shared/routing/index.ts';
+import { clientPath, documentPaths } from './paths.ts';
+
+export function routeObject(server: Server, route: ClientRoute, url: URL): string {
+	const client = server.manifest.client!;
+	const paths = documentPaths(url.pathname, server.options.paths);
+	const ids = new Set([
+		...route.errors,
+		...route.layouts.map((layout) => layout?.[1]),
+		route.leaf[1]
+	]);
+	const nodes = [...ids]
+		.filter((id): id is number => typeof id === 'number')
+		.map(
+			(id) =>
+				`${JSON.stringify(id)}:()=>${client.nodes?.[id] ? `import(${JSON.stringify(clientPath(client.nodes[id]!, paths))})` : 'Promise.resolve({})'}`
+		);
+	return `{id:${JSON.stringify(route.id)},errors:${JSON.stringify(route.errors)},layouts:${JSON.stringify(route.layouts)},leaf:${JSON.stringify(route.leaf)},nodes:{${nodes.join(',')}}}`;
+}
+
+export async function resolutionResponse(
+	server: Server,
+	path: string,
+	url: URL
+): Promise<Response> {
+	const client = server.manifest.client;
+	if (!client?.routes)
+		return new Response('Server-side route resolution disabled', { status: 400 });
+	const idPrefix = `/${server.manifest.app_dir}/routes`;
+	const byId = path === idPrefix || path.startsWith(`${idPrefix}/`);
+	const routeId = path.slice(idPrefix.length) || '/';
+	try {
+		const matched = byId ? null : findRoute(path, client.routes, await server.manifest.matchers());
+		const route = byId ? client.routes.find((route) => route.id === routeId) : matched?.route;
+		let body = '';
+		if (route) {
+			const paths = documentPaths(url.pathname, server.options.paths);
+			const css = new Set(
+				[...route.errors, ...route.layouts.map((layout) => layout?.[1]), route.leaf[1]].flatMap(
+					(id) => (id == null ? [] : (client.css?.[id] ?? []))
+				)
+			);
+			if (css.size)
+				body += `import(${JSON.stringify(clientPath(client.start, paths))}).then(x=>x.load_css(${JSON.stringify([...css].map((file) => clientPath(file, paths)))}));\n`;
+			body += `export const route=${routeObject(server, route, url)};`;
+			if (!byId) body += `\nexport const params=${uneval(matched?.params ?? {})};`;
+		} else if (byId && server.manifest.routes.some((route) => route.id === routeId && !route.page))
+			body = 'export const endpoint_only=true;';
+		return new Response(body, {
+			headers: { 'content-type': 'application/javascript; charset=utf-8' }
+		});
+	} catch {
+		return new Response('Error resolving route', { status: 500 });
+	}
+}

package/src/server/scope.ts

@@ -0,0 +1,164 @@
+import {
+	AsyncVariable,
+	carryAcrossAwait,
+	getContext,
+	openHydration,
+	root,
+	setContext,
+	type AsyncStore
+} from 'vigla';
+import type { RequestState, RequestStore } from '../types/internal/server.ts';
+import type { RequestEvent } from '../types/request.ts';
+import type { ParamValue } from '../types/params.ts';
+import * as errors from './errors.ts';
+import type { Server } from './index.ts';
+import { publishSnapshots } from './remote/resource.ts';
+
+const requestKey = Symbol('request');
+const current = new AsyncVariable<RequestStore>();
+let carried = false;
+
+export function carryRequests(store: AsyncStore): void {
+	carryAcrossAwait(store);
+	carried = true;
+}
+
+export function findRequest(): RequestStore | undefined {
+	const running = current.get();
+	if (running?.state.active) return running;
+	const store = getContext<RequestStore | undefined>(requestKey);
+	return store?.state.active ? store : undefined;
+}
+
+export function getRequestStore(): RequestStore {
+	return findRequest() ?? errors.request_store_after_await();
+}
+
+export function getRequestEvent(): RequestEvent<Record<string, ParamValue>> {
+	const store = findRequest();
+	if (store) return store.event;
+	if (carried) return errors.request_event_unavailable();
+	return errors.request_event_after_await();
+}
+
+export function getRequestOwner(): RequestStore['owner'] {
+	return getRequestStore().owner;
+}
+
+export function bindRequest(store: RequestStore): void {
+	store.owner.run(() => {
+		setContext(requestKey, store);
+		openHydration({ format: store.options.format, beforeSnapshot: () => publishSnapshots(store) });
+	});
+}
+
+export function requestContext(store: RequestStore): Map<unknown, unknown> {
+	return new Map([[requestKey, store]]);
+}
+
+export function runRequest<T>(store: RequestStore, fn: () => T): T {
+	return current.run(store, () => store.owner.run(fn));
+}
+
+export class RequestScope {
+	readonly store: RequestStore;
+	readonly #signal: AbortSignal;
+	#closed = false;
+	#abortBody: (() => void) | null = null;
+
+	constructor(
+		server: Server,
+		event: RequestEvent<Record<string, ParamValue>>,
+		state: RequestState
+	) {
+		this.#signal = event.request.signal;
+		this.store = {
+			event,
+			state,
+			owner: root(),
+			manifest: server.manifest,
+			options: server.options,
+			environment: server.environment,
+			hooks: server.hooks,
+			tracer: server.tracer,
+			remote: {
+				cache: new Map(),
+				forms: new Map(),
+				formValues: new Map(),
+				batches: new Map(),
+				live: new Map(),
+				explicit: new Map(),
+				implicit: new Map(),
+				requested: new Map(),
+				ignored: new Set(),
+				hydration: new Set(),
+				snapshots: new Map(),
+				query: false,
+				prerender: false,
+				mutation: false
+			}
+		};
+		bindRequest(this.store);
+		this.#signal.addEventListener('abort', this.#abort, { once: true });
+		if (this.#signal.aborted) this.#abort();
+	}
+
+	run<T>(fn: () => T): T {
+		return runRequest(this.store, fn);
+	}
+
+	#abort = (): void => {
+		this.#abortBody?.();
+		this.close();
+	};
+
+	close(): void {
+		if (this.#closed) return;
+		this.#closed = true;
+		this.store.state.active = false;
+		this.#signal.removeEventListener('abort', this.#abort);
+		this.store.owner.dispose();
+	}
+
+	response(response: Response): Response {
+		if (!response.body) {
+			this.close();
+			return response;
+		}
+		const reader = response.body.getReader();
+		const scope = this;
+		const body = new ReadableStream<Uint8Array>(
+			{
+				start(controller) {
+					scope.#abortBody = () => {
+						void reader.cancel(scope.#signal.reason).catch(() => {});
+						controller.error(scope.#signal.reason);
+					};
+					if (scope.#signal.aborted) scope.#abortBody();
+				},
+				async pull(controller) {
+					try {
+						const next = await scope.run(() => reader.read());
+						if (next.done) {
+							controller.close();
+							scope.close();
+						} else controller.enqueue(next.value);
+					} catch (error) {
+						controller.error(error);
+						scope.close();
+					}
+				},
+				async cancel(reason) {
+					scope.close();
+					await reader.cancel(reason);
+				}
+			},
+			{ highWaterMark: 0 }
+		);
+		return new Response(body, {
+			status: response.status,
+			statusText: response.statusText,
+			headers: response.headers
+		});
+	}
+}