@elmohq/sdk 0.0.0-claim → 0.1.0

package/src/internal/binding/rest/binding.ts

@@ -0,0 +1,127 @@
+import { toAPIError, undeclaredBody, unreadableBody } from './errors';
+import type { BuildURL } from './url';
+import { essenceOf, NO_BODY, readText, selectCodec } from '../../codec/registry';
+import { baseURLOf } from '../../core/config';
+import { classifyError, ElmoError, isStructured, unansweredError } from '../../core/errors';
+import { metadataValue } from '../../core/metadata';
+import type {
+  Binding,
+  CallableDescriptor,
+  Codec,
+  Credential,
+  PreparedRequest,
+  ResolvedOptions,
+  Result,
+} from '../../core/types';
+
+const DEFAULT_ACCEPT = 'application/json';
+
+function placeInHeader(credential: Credential, request: PreparedRequest<string>): void {
+  request.meta[credential.name.toLowerCase()] = credential.value;
+}
+
+type Placer = (credential: Credential, request: PreparedRequest<string>) => void;
+
+const PLACERS: Partial<Readonly<Record<Credential['in'], Placer>>> = { header: placeInHeader };
+
+function declaredReply(value: unknown, raw: Response, request: PreparedRequest<string>): unknown {
+  if (request.callable.returns !== 'json' || isStructured(value)) return value;
+  throw undeclaredBody(raw, value);
+}
+
+function parserFor(contentType: string | null): 'blob' | 'json' | 'text' {
+  if (!contentType) return 'text';
+  const essence = essenceOf(contentType);
+  if (essence === 'application/json' || essence.endsWith('+json')) return 'json';
+  if (essence.startsWith('text/')) return 'text';
+  return 'blob';
+}
+
+function asksForJSON(request: PreparedRequest<string>): boolean {
+  const accept = metadataValue(request.meta['accept']);
+  return !!accept && accept.split(',').every((one) => parserFor(one) === 'json');
+}
+
+function jsonOrText(text: string): unknown {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+
+async function readBody(
+  raw: Response,
+  request: PreparedRequest<string>,
+  codecs: ReadonlyArray<Codec> = [],
+): Promise<unknown> {
+  if (raw.body === null || raw.headers.get('content-length') === '0') return NO_BODY;
+
+  const contentType = raw.headers.get('content-type');
+  const codec = selectCodec(codecs, contentType ?? undefined);
+  const parser = parserFor(contentType);
+  const copy = raw.ok ? undefined : raw.clone();
+
+  try {
+    if (codec?.decode) return await codec.decode(raw);
+    if (parser === 'blob') return await raw.blob();
+
+    const text = await readText(raw, parser === 'json');
+    if (text === '') return NO_BODY;
+    if (parser === 'json') return JSON.parse(text);
+    return asksForJSON(request) ? jsonOrText(text) : text;
+  } catch (error) {
+    if (error instanceof ElmoError) throw error;
+    if (classifyError(error) === 'abort') throw unansweredError(error);
+    if (copy) {
+      return readText(copy).catch(() => {
+        throw unreadableBody(raw, error);
+      });
+    }
+    throw unreadableBody(raw, error);
+  }
+}
+
+export function createRestBinding(buildURL: BuildURL): Binding<string> {
+  return {
+    accept: DEFAULT_ACCEPT,
+    applyAuth(credential: Credential, request: PreparedRequest<string>): void {
+      const place = PLACERS[credential.in];
+      if (!place) {
+        throw new ElmoError(
+          `This client places no credential in the ${credential.in}, so "${request.callable.address}" cannot be authenticated.`,
+        );
+      }
+      place(credential, request);
+    },
+    name: 'rest',
+    readError(result: Result, request: PreparedRequest<string>): unknown {
+      const { response } = result;
+      if (!response || (response.ok && result.error === undefined)) return;
+      return toAPIError(response.status, result.error, response, request.unauthenticated);
+    },
+    async readResult(
+      raw: Response,
+      request: PreparedRequest<string>,
+      codecs: ReadonlyArray<Codec>,
+    ): Promise<Result> {
+      if (request.options.unread) return { ok: raw.ok, response: raw, status: raw.status };
+
+      const value =
+        raw.status === 204 || raw.status === 205 ? NO_BODY : await readBody(raw, request, codecs);
+
+      return raw.ok
+        ? { data: declaredReply(value, raw, request), ok: true, response: raw, status: raw.status }
+        : { error: value, ok: false, response: raw, status: raw.status };
+    },
+    resolveAddress(callable: CallableDescriptor, options: ResolvedOptions): string {
+      return buildURL({
+        address: callable.address,
+        baseURL: baseURLOf(options, callable.baseURL),
+        path: options.path,
+        query: options.query,
+        serialization: callable.serialization,
+      });
+    },
+  };
+}

package/src/internal/binding/rest/errors.ts

@@ -0,0 +1,107 @@
+import { APIError, DecodeError, safeAddress } from '../../core/errors';
+
+export function undeclaredBody(response: Response, value: unknown): DecodeError {
+  const where = response.url ? ` for "${safeAddress(response.url)}"` : '';
+  const contentType = response.headers.get('content-type');
+  const said = contentType ? ` Its content type said "${contentType}".` : '';
+  const got =
+    value === null || value === undefined
+      ? 'no JSON object or list, where the API description declares one.'
+      : `a body that is not the JSON object or list the API description declares.${said}`;
+  return new DecodeError(`The API answered ${response.status}${where} with ${got}`, {
+    response,
+    value,
+  });
+}
+
+export function unreadableBody(response: Response, cause: unknown): DecodeError {
+  const where = response.url ? ` for "${safeAddress(response.url)}"` : '';
+  const contentType = response.headers.get('content-type');
+  const said = contentType ? ` Its content type said "${contentType}".` : '';
+  return new DecodeError(
+    `The API answered ${response.status}${where} with a body this client could not read.${said}`,
+    { cause, response },
+  );
+}
+
+/** The API could not read the request, so it did not act on it. */
+export class BadRequestError extends APIError {
+  override readonly name = 'BadRequestError';
+  declare readonly status: 400;
+}
+
+/** No usable credential reached the API: it was missing, unreadable, or rejected. */
+export class AuthenticationError extends APIError {
+  override readonly name = 'AuthenticationError';
+  declare readonly status: 401;
+}
+
+/** The plan or the quota on this account does not cover the call. */
+export class PaymentRequiredError extends APIError {
+  override readonly name = 'PaymentRequiredError';
+  declare readonly status: 402;
+}
+
+/** The credential was accepted, but it does not grant this call. */
+export class PermissionDeniedError extends APIError {
+  override readonly name = 'PermissionDeniedError';
+  declare readonly status: 403;
+}
+
+/** Nothing is at this address, or the credential may not see what is. */
+export class NotFoundError extends APIError {
+  override readonly name = 'NotFoundError';
+  declare readonly status: 404;
+}
+
+/** The call collided with the resource's current state: a duplicate, or a concurrent change. */
+export class ConflictError extends APIError {
+  override readonly name = 'ConflictError';
+  declare readonly status: 409;
+}
+
+/** The request was read, and its contents were rejected. */
+export class UnprocessableEntityError extends APIError {
+  override readonly name = 'UnprocessableEntityError';
+  declare readonly status: 422;
+}
+
+/** Too many calls. {@link APIError.retryAfterMs} carries how long the API asked to wait. */
+export class RateLimitError extends APIError {
+  override readonly name = 'RateLimitError';
+  declare readonly status: 429;
+}
+
+export type APIErrorClass = new (
+  status: number,
+  body: unknown,
+  response: Response,
+  note?: string,
+) => APIError;
+
+const BY_STATUS: Readonly<Record<number, APIErrorClass>> = {
+  400: BadRequestError,
+  401: AuthenticationError,
+  402: PaymentRequiredError,
+  403: PermissionDeniedError,
+  404: NotFoundError,
+  409: ConflictError,
+  422: UnprocessableEntityError,
+  429: RateLimitError,
+};
+
+/** The API failed after accepting the call. Every status from 500 up arrives as this. */
+export class InternalServerError extends APIError {
+  override readonly name = 'InternalServerError';
+}
+
+export function toAPIError(
+  status: number,
+  error: unknown,
+  response: Response,
+  unauthenticated?: () => string,
+): APIError {
+  const Failure = BY_STATUS[status] ?? (status >= 500 ? InternalServerError : APIError);
+  const note = status === 401 || status === 403 ? unauthenticated?.() : undefined;
+  return new Failure(status, error, response, note);
+}

package/src/internal/binding/rest/path.ts

@@ -0,0 +1,9 @@
+import { toText } from '../../core/text';
+
+export function encodeValue(value: unknown): string {
+  return encodeURIComponent(toText(value));
+}
+
+export function encodeName(name: string): string {
+  return encodeURIComponent(name).replace(/%5B/g, '[').replace(/%5D/g, ']');
+}

package/src/internal/binding/rest/url.ts

@@ -0,0 +1,97 @@
+import { encodeName, encodeValue } from './path';
+import { emptyPathParameter } from '../../core/errors';
+import { scalarText } from '../../core/text';
+import type { SerializationDescriptor } from '../../core/types';
+
+export type BuildURL = (args: {
+  address: string;
+  baseURL?: string | undefined;
+  path?: Record<string, unknown> | undefined;
+  query?: Record<string, unknown> | undefined;
+  serialization?: SerializationDescriptor | undefined;
+}) => string;
+
+const NAMED_PATH_PARAM_RE = /\{([^{}]+)\}/g;
+
+const ABSOLUTE_URL_RE = /^[a-z][a-z\d+.-]*:\/\//i;
+
+function joinPath(base: string, path: string): string {
+  return base.endsWith('/') && path.startsWith('/') ? base + path.slice(1) : base + path;
+}
+
+export function joinURL(baseURL: string | undefined, path: string): string {
+  const base = baseURL ?? '';
+  const hash = base.indexOf('#');
+  const kept = hash === -1 ? base : base.slice(0, hash);
+  const mark = kept.indexOf('?');
+  if (mark === -1) return joinPath(kept, path);
+
+  const joined = joinPath(kept.slice(0, mark), path);
+  const query = kept.slice(mark + 1);
+  if (!query) return joined;
+  return `${joined}${joined.includes('?') ? '&' : '?'}${query}`;
+}
+
+function addressURL(address: string, baseURL: string | undefined): string {
+  const absolute = ABSOLUTE_URL_RE.test(address);
+  const pathURL = absolute || address.startsWith('/') ? address : `/${address}`;
+  return absolute ? pathURL : joinURL(baseURL, pathURL);
+}
+
+function pathValue(value: unknown): string {
+  if (Array.isArray(value)) return value.map(encodeValue).join(',');
+  if (typeof value === 'object' && value !== null && scalarText(value) === undefined) {
+    return Object.entries(value)
+      .flatMap(([key, item]) => [encodeURIComponent(key), encodeValue(item)])
+      .join(',');
+  }
+  return encodeValue(value);
+}
+
+function filledURL(
+  address: string,
+  baseURL: string | undefined,
+  path: Record<string, unknown> | undefined,
+): string {
+  const url = addressURL(address, baseURL);
+  if (!path) return url;
+  return url.replace(NAMED_PATH_PARAM_RE, (_match, name: string) => {
+    const value = path[name];
+    if (value === undefined || value === null || value === '') {
+      throw emptyPathParameter(name, address);
+    }
+    return pathValue(value);
+  });
+}
+
+function withQuery(url: string, query: Record<string, unknown> | undefined): string {
+  if (!query) return url;
+
+  const search: Array<string> = [];
+  for (const [name, value] of Object.entries(query)) {
+    if (value === undefined || value === null) continue;
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (item !== undefined && item !== null) {
+          search.push(`${encodeName(name)}=${encodeValue(item)}`);
+        }
+      }
+      continue;
+    }
+    if (typeof value === 'object' && scalarText(value) === undefined) {
+      for (const [key, item] of Object.entries(value)) {
+        if (item !== undefined && item !== null) {
+          search.push(`${encodeName(key)}=${encodeValue(item)}`);
+        }
+      }
+      continue;
+    }
+    search.push(`${encodeName(name)}=${encodeValue(value)}`);
+  }
+
+  if (!search.length) return url;
+  return `${url}${url.includes('?') ? '&' : '?'}${search.join('&')}`;
+}
+
+export const simpleURL: BuildURL = ({ address, baseURL, path, query }) =>
+  withQuery(filledURL(address, baseURL, path), query);

package/src/internal/codec/json.ts

@@ -0,0 +1,66 @@
+import { NO_BODY, readText } from './registry';
+import { ElmoError } from '../core/errors';
+import type { Codec } from '../core/types';
+
+function finite(value: number): number {
+  if (!Number.isFinite(value)) {
+    throw new ElmoError('NaN and Infinity cannot be written as JSON.');
+  }
+  return value;
+}
+
+function refused(value: unknown): ElmoError {
+  const name =
+    typeof value === 'object' && value !== null
+      ? (value.constructor?.name ?? 'Object')
+      : typeof value;
+  return new ElmoError(`A value of type ${name} cannot be written as JSON.`);
+}
+
+function mapKey(key: unknown): string {
+  if (typeof key === 'number') return String(finite(key));
+  if (typeof key === 'string' || typeof key === 'boolean' || typeof key === 'bigint') {
+    return String(key);
+  }
+  throw refused(key);
+}
+
+function jsonValue(_key: string, value: unknown): unknown {
+  if (typeof value === 'bigint') return value.toString();
+  if (typeof value === 'number') return finite(value);
+  if (typeof value !== 'object' || value === null) return value;
+  if (value instanceof Set) return [...value];
+  if (value instanceof Map) {
+    return Object.fromEntries([...value].map(([key, item]) => [mapKey(key), item]));
+  }
+  if (
+    value instanceof ArrayBuffer ||
+    ArrayBuffer.isView(value) ||
+    (typeof Blob !== 'undefined' && value instanceof Blob)
+  ) {
+    throw refused(value);
+  }
+  return value;
+}
+
+export function jsonText(value: unknown): string {
+  try {
+    return JSON.stringify(value, jsonValue);
+  } catch (error) {
+    if (error instanceof ElmoError) throw error;
+    throw new ElmoError(`A value cannot be written as JSON: ${(error as Error).message}`, {
+      cause: error,
+    });
+  }
+}
+
+export const jsonCodec: Codec = {
+  contentType: 'application/json',
+  decode: async (raw) => {
+    const text = await readText(raw, true);
+    return text === '' ? NO_BODY : JSON.parse(text);
+  },
+  encode: jsonText,
+  mediaTypes: ['application/json'],
+  name: 'json',
+};

package/src/internal/codec/registry.ts

@@ -0,0 +1,55 @@
+import type { BodyInput, Codec, EncodedBody, ResolvedOptions } from '../core/types';
+
+export const NO_BODY = null;
+
+function charsetOf(contentType: string | null): string | undefined {
+  return contentType?.match(/;\s*charset\s*=\s*"?([^";\s]+)/i)?.[1];
+}
+
+function decoderFor(label: string | undefined, fatal: boolean) {
+  try {
+    return new TextDecoder(label, { fatal });
+  } catch {
+    return new TextDecoder('utf-8', { fatal });
+  }
+}
+
+export async function readText(raw: Response, json = false): Promise<string> {
+  const label = json ? undefined : charsetOf(raw.headers.get('content-type'));
+  return decoderFor(label, raw.ok).decode(await raw.arrayBuffer());
+}
+
+export function essenceOf(mediaType: string): string {
+  return mediaType.split(';', 1)[0]!.trim().toLowerCase();
+}
+
+export function selectCodec(
+  codecs: ReadonlyArray<Codec>,
+  mediaType: string | undefined,
+): Codec | undefined {
+  if (!mediaType) return undefined;
+  const essence = essenceOf(mediaType);
+  const format = essence.replace(/\/.*\+/, '/');
+  return codecs.find((codec) =>
+    codec.mediaTypes.some((candidate) => [essence, format].includes(essenceOf(candidate))),
+  );
+}
+
+export function encodeNamedBody(
+  codecs: ReadonlyArray<Codec>,
+  mediaType: string | undefined,
+  options: ResolvedOptions,
+): EncodedBody | undefined {
+  if (options.body === undefined) return undefined;
+
+  if (options.bodySerializer) {
+    return { contentType: mediaType, payload: options.bodySerializer(options.body) };
+  }
+  if (options.bodySerializer === null) {
+    return { contentType: mediaType, payload: options.body as BodyInput };
+  }
+
+  const codec = selectCodec(codecs, mediaType);
+  if (!codec) return { contentType: mediaType, payload: options.body as BodyInput };
+  return { contentType: codec.contentType, payload: codec.encode(options.body) };
+}

package/src/internal/core/backoff.ts

@@ -0,0 +1,170 @@
+/**
+ * How much of each wait is random, so callers that failed together do not all
+ * come back at once.
+ *
+ * A number from 0 to 1 is the random share: `0.25` waits between three
+ * quarters of the computed wait and all of it. `'full'` is 1, `'equal'` is 0.5
+ * and `'none'` is 0. `true` is `'full'` and `false` is `'none'`.
+ */
+export type Jitter = boolean | number | 'equal' | 'full' | 'none';
+
+/** How long the wait before each retry is. */
+export interface BackoffOptions {
+  /**
+   * Base delay in milliseconds.
+   *
+   * @default 500
+   */
+  delay?: number;
+  /**
+   * The share of each delay that is random.
+   *
+   * @default 'full'
+   */
+  jitter?: Jitter;
+  /**
+   * Upper bound on any single delay, in milliseconds.
+   *
+   * @default 30_000
+   */
+  maxDelay?: number;
+  /**
+   * How the wait grows. `'exponential'` doubles the base delay each time, up
+   * to `maxDelay`. `'constant'` waits the base delay every time.
+   *
+   * @default 'exponential'
+   */
+  strategy?: 'constant' | 'exponential';
+}
+
+/** A header the API may name its own wait in, and how to read its value. */
+export interface RetryAfterHeader {
+  /**
+   * Whether a number counts forward from now, or names a moment.
+   *
+   * @default 'duration'
+   */
+  readonly kind?: 'duration' | 'moment';
+  /** Header name, matched case-insensitively. */
+  readonly name: string;
+  /**
+   * What a number in this header counts in.
+   *
+   * @default 'second'
+   */
+  readonly unit?: 'millisecond' | 'second';
+}
+
+function jitterShare(jitter: Jitter): number {
+  if (typeof jitter === 'number') return Math.min(1, Math.max(0, jitter));
+  if (jitter === 'equal') return 0.5;
+  return jitter === true || jitter === 'full' ? 1 : 0;
+}
+
+export function backoffDelay(retry: number, options: BackoffOptions = {}): number {
+  const { delay = 500, jitter = true, maxDelay = 30_000, strategy = 'exponential' } = options;
+  const growth = strategy === 'constant' ? delay : delay && delay * 2 ** retry;
+  const capped = Math.min(growth, maxDelay);
+  const share = jitterShare(jitter);
+  return share ? capped * (1 - share) + Math.random() * capped * share : capped;
+}
+
+export const MAX_RETRY_AFTER = 60_000;
+
+export function exceedsMaxRetryAfter(delay: number | undefined, max?: number): boolean {
+  return delay !== undefined && delay > (max ?? MAX_RETRY_AFTER);
+}
+
+export const TIMER_LIMIT = 2_147_483_647;
+
+export function sleep(ms: number, signal?: AbortSignal): Promise<void> {
+  if (signal?.aborted) return Promise.reject(signal.reason);
+  if (ms <= 0) return Promise.resolve();
+
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(
+      () => {
+        signal?.removeEventListener('abort', onAbort);
+        resolve();
+      },
+      Math.min(ms, TIMER_LIMIT),
+    );
+
+    function onAbort(): void {
+      clearTimeout(timer);
+      reject(signal!.reason);
+    }
+
+    signal?.addEventListener('abort', onAbort, { once: true });
+  });
+}
+
+export const RETRY_AFTER_HEADERS: ReadonlyArray<RetryAfterHeader> = [
+  { name: 'retry-after-ms', unit: 'millisecond' },
+  { name: 'retry-after' },
+  { name: 'x-ratelimit-reset-after' },
+  { kind: 'moment', name: 'x-ratelimit-reset' },
+  { kind: 'moment', name: 'x-rate-limit-reset' },
+];
+
+const ASCTIME = /^[a-z]{3} ([a-z]{3}) +(\d\d?) (\d\d:\d\d:\d\d) (\d{4})$/i;
+
+const MOMENT =
+  /^(?:(\d{4})-(\d\d)-(\d\d)[t ]|(?:[a-z]+, ?)?(\d\d?)[ -]([a-z]{3})[ -](\d\d|\d{4}) )([01]\d|2[0-3]):([0-5]\d)(?::([0-5]\d|60)(?:\.(\d{1,3})\d*)?)? ?(?:z|gmt|utc?|([+-])([01]\d|2[0-3]):?([0-5]\d))$/i;
+
+const MONTHS = 'janfebmaraprmayjunjulaugsepoctnovdec';
+
+function moment(value: string, now: number): number | undefined {
+  const match = MOMENT.exec(value.replace(ASCTIME, '$2 $1 $4 $3 GMT'));
+  if (!match) return undefined;
+  const year = match[6] ?? match[1]!;
+  const day = +(match[4] ?? match[3]!);
+  const month = match[2] ? +match[2] - 1 : MONTHS.indexOf(match[5]!.toLowerCase()) / 3;
+  let full = +year;
+  if (year.length < 3) {
+    const present = new Date(now).getUTCFullYear();
+    full += present - (present % 100);
+    if (full > present + 50) full -= 100;
+  }
+  const date = new Date(0);
+  date.setUTCFullYear(full, month, day);
+  if (!full || date.getUTCMonth() !== month || date.getUTCDate() !== day) return undefined;
+  const zone = (match[11] === '-' ? -1 : 1) * (+(match[12] ?? 0) * 60 + +(match[13] ?? 0));
+  const seconds = (+match[7]! * 60 + +match[8]! - zone) * 60 + +(match[9] ?? 0);
+  return date.getTime() + seconds * 1000 + +(match[10] ?? '').padEnd(3, '0');
+}
+
+const NUMBER = /^[0-9]+(?:\.[0-9]+)?$/;
+
+export function parseRetryAfter(
+  value: string | null | undefined,
+  header: RetryAfterHeader = { name: 'retry-after' },
+  now = Date.now(),
+): number | undefined {
+  if (!value) return undefined;
+
+  if (NUMBER.test(value)) {
+    const number = Number(value);
+    const ms = header.unit === 'millisecond' ? number : number * 1000;
+    return Math.max(0, header.kind === 'moment' ? ms - now : ms);
+  }
+
+  const date = moment(value, now);
+  if (date === undefined) return undefined;
+  return Math.max(0, date - now);
+}
+
+export function retryAfterDelay(
+  response: Response,
+  headers: ReadonlyArray<RetryAfterHeader> = RETRY_AFTER_HEADERS,
+  now = Date.now(),
+): number | undefined {
+  const clock = moment(response.headers.get('date') ?? '', now) ?? now;
+
+  for (const header of headers) {
+    const delay = parseRetryAfter(response.headers.get(header.name), header, clock);
+    if (delay !== undefined) return delay;
+  }
+
+  return undefined;
+}

package/src/internal/core/body.ts

@@ -0,0 +1,54 @@
+import type { Result } from './types';
+
+export function discardBody(result: Result | undefined): void {
+  const { response } = result ?? {};
+  if (response && !response.bodyUsed) void response.body?.cancel().catch(() => {});
+}
+
+export function isStreamed(body: unknown): boolean {
+  if (typeof body !== 'object' || body === null) return false;
+  return typeof (body as ReadableStream).getReader === 'function' || Symbol.asyncIterator in body;
+}
+
+export function replyWith(body: ReadableStream<Uint8Array> | null, response: Response): Response {
+  const reply = new Response(body, {
+    headers: response.headers,
+    status: response.status,
+    statusText: response.statusText,
+  });
+  Object.defineProperty(reply, 'redirected', { value: response.redirected });
+  Object.defineProperty(reply, 'url', { value: response.url });
+  return reply;
+}
+
+export async function bufferReply(response: Response, signal?: AbortSignal): Promise<Response> {
+  if (response.body === null) return response;
+  const reader = response.body.getReader();
+
+  function cancel(): void {
+    void reader.cancel(signal?.reason).catch(() => {});
+  }
+
+  if (signal?.aborted) cancel();
+  signal?.addEventListener('abort', cancel, { once: true });
+
+  const parts: Array<Uint8Array> = [];
+  try {
+    for (;;) {
+      const step = await reader.read();
+      if (step.done) break;
+      parts.push(step.value);
+    }
+  } finally {
+    signal?.removeEventListener('abort', cancel);
+  }
+  if (signal?.aborted) throw signal.reason;
+
+  const body = new ReadableStream<Uint8Array>({
+    start(controller) {
+      for (const part of parts) controller.enqueue(part);
+      controller.close();
+    },
+  });
+  return replyWith(body, response);
+}