@nxgt/httpyz 0.1.0

package/dist/index.js

@@ -0,0 +1,1110 @@
+// src/cancel/abort.ts
+function isAbortError(error) {
+  if (typeof DOMException !== "undefined" && error instanceof DOMException) {
+    return error.name === "AbortError" || error.name === "TimeoutError";
+  }
+  return error instanceof Error && error.name === "AbortError";
+}
+var cancelled = (message) => new DOMException(message, "AbortError");
+function abortable(promise, signal) {
+  if (!signal)
+    return promise;
+  if (signal.aborted)
+    return Promise.reject(signal.reason);
+  return new Promise((resolve, reject) => {
+    const stop = () => reject(signal.reason);
+    signal.addEventListener("abort", stop, { once: true });
+    promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", stop));
+  });
+}
+function joinSignals(...signals) {
+  const present = signals.filter((signal) => signal != null);
+  return present.length > 1 ? AbortSignal.any(present) : present[0];
+}
+// src/cancel/latest.ts
+function createLatest() {
+  const running = new Map;
+  return (key) => {
+    running.get(key)?.abort(cancelled(`A later call with latest: '${key}' replaced this one`));
+    const controller = new AbortController;
+    running.set(key, controller);
+    return controller.signal;
+  };
+}
+
+// src/errors/errors.ts
+class ClientError extends Error {
+  constructor(context, message, options) {
+    const route = `${context.method.toUpperCase()} ${context.path}`;
+    const call = context.operationId === undefined ? route : `${context.operationId} (${route})`;
+    super(`${call}: ${message}`, options);
+    this.name = "ClientError";
+    this.operationId = context.operationId;
+    this.method = context.method;
+    this.path = context.path;
+  }
+}
+
+class NetworkError extends ClientError {
+  constructor(context, options) {
+    super(context, "no reply came back", options);
+    this.name = "NetworkError";
+  }
+}
+
+class TimeoutError extends ClientError {
+  constructor(context, timeout, options) {
+    super(context, `no reply within ${timeout} ms`, options);
+    this.name = "TimeoutError";
+    this.timeout = timeout;
+  }
+}
+
+class UndeclaredStatusError extends ClientError {
+  constructor(context, response) {
+    super(context, `no ${response.status} reply is declared`);
+    this.name = "UndeclaredStatusError";
+    this.status = response.status;
+    this.response = response;
+  }
+}
+
+class ValidationError extends ClientError {
+  constructor(context, failure) {
+    super(context, failure.issues.map((issue) => issue.message).join("; "));
+    this.name = "ValidationError";
+    this.failure = failure;
+  }
+}
+
+class ReplyStatusError extends Error {
+  constructor(reply, expected) {
+    const wanted = expected.length > 0 ? expected.join(" or ") : "2xx";
+    super(`Expected a ${wanted} reply, got ${reply.status}`);
+    this.name = "ReplyStatusError";
+    this.status = reply.status;
+    this.data = reply.data;
+    this.response = reply.response;
+  }
+}
+
+// src/middleware/auth.ts
+function auth({
+  token,
+  refresh,
+  scheme = "Bearer"
+}) {
+  let refreshing;
+  const sign = (request, value) => {
+    if (value)
+      request.headers.set("authorization", `${scheme} ${value}`);
+    return request;
+  };
+  return async (request, next) => {
+    const used = await token();
+    const replay = refresh ? request.clone() : undefined;
+    const response = await next(sign(request, used));
+    if (response.status !== 401 || !replay || !refresh)
+      return response;
+    try {
+      if (await token() === used) {
+        refreshing ??= Promise.resolve().then(refresh).finally(() => {
+          refreshing = undefined;
+        });
+        await abortable(refreshing, request.signal);
+      }
+    } catch (error) {
+      if (request.signal.aborted) {
+        await response.body?.cancel();
+        throw error;
+      }
+      return response;
+    }
+    const fresh = await token();
+    if (!fresh || fresh === used)
+      return response;
+    await response.body?.cancel();
+    return next(sign(replay, fresh));
+  };
+}
+
+// src/middleware/compose.ts
+var compose = (middlewares, send, call) => middlewares.reduceRight((next, middleware) => (request) => middleware(request, next, call), send);
+
+// src/middleware/retry.ts
+var REPEATABLE = [
+  "get",
+  "head",
+  "options",
+  "put",
+  "delete",
+  "trace",
+  "query"
+];
+var TRANSIENT = [408, 429, 502, 503, 504];
+var backoff = (attempt) => Math.random() * 300 * 2 ** (attempt - 1);
+function retrySettings(retry) {
+  if (retry === undefined || retry === false)
+    return;
+  const options = typeof retry === "number" ? { attempts: retry } : retry;
+  const attempts = options.attempts ?? 2;
+  if (attempts <= 0)
+    return;
+  return {
+    attempts,
+    methods: options.methods ?? REPEATABLE,
+    statuses: options.statuses ?? TRANSIENT,
+    delay: options.delay ?? backoff,
+    maxDelay: options.maxDelay ?? 1e4
+  };
+}
+function retryDelay(response, attempt, settings) {
+  const header = response?.headers.get("retry-after")?.trim();
+  if (header) {
+    const wait = /^\d+(?:\.\d+)?$/.test(header) ? Number(header) * 1000 : Date.parse(header) - Date.now();
+    if (!Number.isNaN(wait)) {
+      return wait > settings.maxDelay ? undefined : Math.max(0, wait);
+    }
+  }
+  return Math.min(Math.max(0, settings.delay(attempt)), settings.maxDelay);
+}
+var sleep = (ms, signal) => new Promise((resolve, reject) => {
+  if (signal.aborted)
+    return reject(signal.reason);
+  const stop = () => {
+    clearTimeout(timer);
+    reject(signal.reason);
+  };
+  const timer = setTimeout(() => {
+    signal.removeEventListener("abort", stop);
+    resolve();
+  }, ms);
+  signal.addEventListener("abort", stop, { once: true });
+});
+function retrying(settings) {
+  return async (request, next) => {
+    const method = request.method.toLowerCase();
+    if (!settings.methods.includes(method))
+      return next(request);
+    for (let attempt = 1;; attempt++) {
+      const last = attempt > settings.attempts;
+      const sent = last ? request : request.clone();
+      let wait;
+      try {
+        const response = await next(sent);
+        if (last || !settings.statuses.includes(response.status)) {
+          return response;
+        }
+        wait = retryDelay(response, attempt, settings);
+        if (wait === undefined)
+          return response;
+        await response.body?.cancel();
+      } catch (error) {
+        if (last || !(error instanceof NetworkError))
+          throw error;
+        wait = retryDelay(undefined, attempt, settings) ?? 0;
+      }
+      await sleep(wait, request.signal);
+    }
+  };
+}
+
+// src/schema/standard-schema.ts
+async function check(schema, value, target) {
+  const result = await schema["~standard"].validate(value);
+  if (result.issues === undefined)
+    return { ok: true, value: result.value };
+  return {
+    ok: false,
+    issues: result.issues.map((issue) => {
+      const { code } = issue;
+      return {
+        target,
+        path: (issue.path ?? []).map((key) => typeof key === "object" ? key.key : key).filter((key) => typeof key !== "symbol"),
+        code: typeof code === "string" ? code : "custom",
+        message: issue.message
+      };
+    })
+  };
+}
+
+// src/reply/media-type.ts
+var mediaType = (header) => (header.split(";")[0] ?? "").trim().toLowerCase();
+function mediaKind(type) {
+  if (type === "application/json" || /^application\/[\w.-]+\+json$/.test(type)) {
+    return "json";
+  }
+  if (type === "application/x-www-form-urlencoded" || type === "multipart/form-data") {
+    return "form";
+  }
+  return type.startsWith("text/") ? "text" : "binary";
+}
+function declaredType(content, type) {
+  const types = Object.keys(content);
+  const exact = types.find((key) => key.toLowerCase() === type);
+  if (exact !== undefined)
+    return exact;
+  const range = `${type.split("/")[0]}/*`;
+  if (content[range])
+    return range;
+  if (content["*/*"])
+    return "*/*";
+  const kind = mediaKind(type);
+  if (kind !== "json" && kind !== "text")
+    return;
+  return types.find((key) => content[key]?.kind === kind);
+}
+
+// src/reply/read-reply.ts
+var isSchema = (value) => typeof value === "object" && value !== null && ("~standard" in value);
+function toSpec(responses) {
+  const spec = {};
+  for (const [status, declared] of Object.entries(responses)) {
+    const content = {};
+    if (isSchema(declared)) {
+      content["application/json"] = { kind: "json", schema: declared };
+    } else if (declared !== null) {
+      for (const [type, schema] of Object.entries(declared)) {
+        content[type] = {
+          kind: mediaKind(type.toLowerCase()),
+          ...schema === null ? {} : { schema }
+        };
+      }
+    }
+    spec[Number(status)] = content;
+  }
+  return spec;
+}
+async function readReply(context, spec, response, settings) {
+  const { status } = response;
+  const header = response.headers.get("content-type");
+  const refused = (issues) => new ValidationError(context, {
+    kind: "response",
+    ...context,
+    status,
+    issues
+  });
+  const failure = (code, message) => refused([{ target: "response", path: [], code, message }]);
+  const parse = (text) => {
+    try {
+      return JSON.parse(text);
+    } catch {
+      throw failure("invalid_json", `the ${status} reply is not valid JSON`);
+    }
+  };
+  if (!spec) {
+    const type = header === null ? undefined : mediaType(header);
+    const reply = (data) => ({ status, type, data, response });
+    if (response.body === null)
+      return reply(undefined);
+    switch (type === undefined ? undefined : mediaKind(type)) {
+      case "json": {
+        const text = await response.text();
+        return reply(text === "" ? undefined : parse(text));
+      }
+      case "form":
+        return reply(await response.formData());
+      case "binary":
+        return reply(await response.blob());
+      default: {
+        const text = await response.text();
+        return reply(type === undefined && text === "" ? undefined : text);
+      }
+    }
+  }
+  const declared = spec[status];
+  if (!declared)
+    throw new UndeclaredStatusError(context, response);
+  const types = Object.keys(declared);
+  if (types.length === 0) {
+    return { status, type: undefined, data: undefined, response };
+  }
+  const type = header === null ? types.length === 1 ? types[0] : undefined : declaredType(declared, mediaType(header));
+  const media = type === undefined ? undefined : declared[type];
+  if (type === undefined || media === undefined) {
+    throw failure("invalid_content_type", `a ${status} reply is ${types.join(" or ")}, not ${header ?? "untyped"}`);
+  }
+  const reply = (data) => ({ status, type, data, response });
+  const settle = async (data) => {
+    if (!settings.validate || !media.schema)
+      return reply(data);
+    const result = await check(media.schema, data, "response");
+    if (!result.ok)
+      throw refused(result.issues);
+    return reply(settings.decode ? result.value : data);
+  };
+  switch (media.kind) {
+    case "json": {
+      const text = await response.text();
+      if (text === "" && !(settings.validate && media.schema)) {
+        return reply(undefined);
+      }
+      return settle(parse(text));
+    }
+    case "text":
+      return settle(await response.text());
+    case "form":
+      return reply(await response.formData());
+    default:
+      return reply(await response.blob());
+  }
+}
+
+// src/request/encode.ts
+var text = (value) => value instanceof Date ? value.toISOString() : String(value);
+var absent = (value) => value === undefined || value === null;
+function fillPath(context, param) {
+  return context.path.replace(/\{([^}]+)\}/g, (_, name) => {
+    const value = param?.[name];
+    if (absent(value)) {
+      throw new TypeError(`${context.method.toUpperCase()} ${context.path}: the path parameter ${name} is missing`);
+    }
+    return encodeURIComponent(text(value));
+  });
+}
+function writeQuery(query) {
+  if (query === undefined)
+    return "";
+  if (query instanceof URLSearchParams)
+    return query.toString();
+  const search = new URLSearchParams;
+  for (const [name, value] of Object.entries(query)) {
+    for (const item of Array.isArray(value) ? value : [value]) {
+      if (!absent(item))
+        search.append(name, text(item));
+    }
+  }
+  return search.toString();
+}
+function joinUrl(baseUrl, path, query) {
+  const root = baseUrl === undefined ? "" : String(baseUrl).replace(/\/+$/, "");
+  return `${root}${path}${query === "" ? "" : `?${query}`}`;
+}
+function writeBody(input, headers, own) {
+  const type = (fallback) => headers.set("content-type", own ?? fallback);
+  if (input.json !== undefined) {
+    type("application/json");
+    return JSON.stringify(input.json);
+  }
+  if (input.form !== undefined) {
+    headers.delete("content-type");
+    const { form } = input;
+    if (form instanceof FormData || form instanceof URLSearchParams) {
+      return form;
+    }
+    return [...fields(form)].some(([, value]) => value instanceof Blob) ? toFormData(form) : toSearchParams(form);
+  }
+  if (input.text !== undefined) {
+    type("text/plain");
+    return input.text;
+  }
+  if (input.body !== undefined) {
+    const { body } = input;
+    type(body instanceof Blob && body.type !== "" ? body.type : "application/octet-stream");
+    return body;
+  }
+  return;
+}
+function* fields(form) {
+  for (const [name, value] of Object.entries(form)) {
+    for (const item of Array.isArray(value) ? value : [value]) {
+      if (absent(item))
+        continue;
+      if (item instanceof Blob)
+        yield [name, item];
+      else if (typeof item === "object" && !(item instanceof Date)) {
+        yield [name, JSON.stringify(item)];
+      } else
+        yield [name, text(item)];
+    }
+  }
+}
+function toFormData(form) {
+  const data = new FormData;
+  for (const [name, value] of fields(form))
+    data.append(name, value);
+  return data;
+}
+function toSearchParams(form) {
+  const data = new URLSearchParams;
+  for (const [name, value] of fields(form)) {
+    if (value instanceof Blob) {
+      throw new TypeError(`${name} is a file: an application/x-www-form-urlencoded body cannot carry one`);
+    }
+    data.append(name, value);
+  }
+  return data;
+}
+
+// src/stream/connection.ts
+var failure = (context, status, issues) => new ValidationError(context, {
+  kind: "response",
+  ...context,
+  status,
+  issues
+});
+async function opened(settings, response, types) {
+  const { status } = response;
+  if (status === 204) {
+    await response.body?.cancel();
+    return false;
+  }
+  if (!response.ok)
+    throw new UndeclaredStatusError(settings.context, response);
+  const header = response.headers.get("content-type");
+  if (header === null || !types.includes(mediaType(header)) || !response.body) {
+    await response.body?.cancel();
+    throw failure(settings.context, status, [
+      {
+        target: "response",
+        path: [],
+        code: "invalid_content_type",
+        message: `a ${status} reply is ${types.join(" or ")}, not ${header ?? "untyped"}`
+      }
+    ]);
+  }
+  return true;
+}
+async function settle(settings, status, text, schema, what) {
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    throw failure(settings.context, status, [
+      {
+        target: "response",
+        path: [],
+        code: "invalid_json",
+        message: `${what} is not valid JSON`
+      }
+    ]);
+  }
+  if (!schema || !settings.validate)
+    return value;
+  const result = await check(schema, value, "response");
+  if (!result.ok)
+    throw failure(settings.context, status, result.issues);
+  return settings.decode ? result.value : value;
+}
+function pause(ms, ...signals) {
+  const live = signals.filter((each) => !!each);
+  return new Promise((resolve) => {
+    const done = () => {
+      clearTimeout(timer);
+      for (const each of live)
+        each.removeEventListener("abort", done);
+      resolve();
+    };
+    const timer = setTimeout(done, ms);
+    for (const each of live) {
+      if (each.aborted)
+        return done();
+      each.addEventListener("abort", done, { once: true });
+    }
+  });
+}
+
+class Reading {
+  #reader;
+  #signal;
+  #halt;
+  constructor(signal) {
+    this.closer = new AbortController;
+    this.#halt = () => {
+      this.#reader?.cancel().catch(() => {});
+    };
+    this.#signal = signal;
+    this.closer.signal.addEventListener("abort", this.#halt);
+    signal?.addEventListener("abort", this.#halt);
+  }
+  read(response) {
+    const body = response.body;
+    this.#reader = body.pipeThrough(new TextDecoderStream).getReader();
+    return this.#reader;
+  }
+  stopped() {
+    this.#signal?.throwIfAborted();
+    return this.closer.signal.aborted;
+  }
+  release() {
+    this.#reader?.cancel().catch(() => {});
+    this.#reader = undefined;
+    this.#signal?.removeEventListener("abort", this.#halt);
+  }
+  close() {
+    this.closer.abort();
+  }
+}
+
+// src/stream/sse-parser.ts
+var LINE_END = /\r\n|\r|\n/g;
+function createSseParser(lastEventId) {
+  let buffer = "";
+  let started = false;
+  let afterCr = false;
+  let data = "";
+  let type = "";
+  let id = lastEventId ?? "";
+  let dispatchedId = lastEventId;
+  let retry;
+  const dispatch = (events) => {
+    dispatchedId = id === "" ? undefined : id;
+    if (data === "") {
+      type = "";
+      return;
+    }
+    events.push({
+      event: type === "" ? "message" : type,
+      data: data.endsWith(`
+`) ? data.slice(0, -1) : data,
+      id: dispatchedId
+    });
+    data = "";
+    type = "";
+  };
+  const line = (text, events) => {
+    if (text === "")
+      return dispatch(events);
+    if (text.startsWith(":"))
+      return;
+    const colon = text.indexOf(":");
+    const field = colon === -1 ? text : text.slice(0, colon);
+    let value = colon === -1 ? "" : text.slice(colon + 1);
+    if (value.startsWith(" "))
+      value = value.slice(1);
+    switch (field) {
+      case "event":
+        type = value;
+        break;
+      case "data":
+        data += `${value}
+`;
+        break;
+      case "id":
+        if (!value.includes("\x00"))
+          id = value;
+        break;
+      case "retry":
+        if (/^\d+$/.test(value))
+          retry = Number(value);
+        break;
+    }
+  };
+  return {
+    push(chunk) {
+      let text = chunk;
+      if (!started && text !== "") {
+        started = true;
+        if (text.startsWith("\uFEFF"))
+          text = text.slice(1);
+      }
+      if (afterCr && text !== "") {
+        afterCr = false;
+        if (text.startsWith(`
+`))
+          text = text.slice(1);
+      }
+      buffer += text;
+      const events = [];
+      let start = 0;
+      LINE_END.lastIndex = 0;
+      for (let end = LINE_END.exec(buffer);end !== null; end = LINE_END.exec(buffer)) {
+        if (end[0] === "\r" && end.index === buffer.length - 1) {
+          afterCr = true;
+        }
+        line(buffer.slice(start, end.index), events);
+        start = end.index + end[0].length;
+      }
+      buffer = buffer.slice(start);
+      return events;
+    },
+    get retry() {
+      return retry;
+    },
+    get lastEventId() {
+      return dispatchedId;
+    }
+  };
+}
+
+// src/stream/event-stream.ts
+function eventStream(settings) {
+  const reading = new Reading(settings.signal);
+  let lastEventId = settings.lastEventId;
+  let delay = settings.reconnect ? settings.reconnect.delay : 0;
+  let started = false;
+  const declared = async (raw, status) => {
+    const { events } = settings;
+    if (!events)
+      return raw;
+    if (!Object.hasOwn(events, raw.event)) {
+      settings.onUnknownEvent?.(raw);
+      return;
+    }
+    const schema = events[raw.event];
+    if (!schema)
+      return raw;
+    const what = `the ${raw.event} event's data`;
+    const data = await settle(settings, status, raw.data, schema, what);
+    return { event: raw.event, data, id: raw.id };
+  };
+  const again = async (failures) => {
+    const { reconnect } = settings;
+    if (!reconnect || failures >= reconnect.attempts)
+      return false;
+    await pause(delay, reading.closer.signal, settings.signal);
+    return !reading.stopped();
+  };
+  async function* run() {
+    let failures = 0;
+    try {
+      for (;; ) {
+        let response;
+        try {
+          response = await settings.open(reading.closer.signal, lastEventId);
+        } catch (error) {
+          if (reading.closer.signal.aborted)
+            return;
+          if (error instanceof NetworkError && await again(failures++)) {
+            continue;
+          }
+          throw error;
+        }
+        if (!await opened(settings, response, ["text/event-stream"])) {
+          return;
+        }
+        const parser = createSseParser(lastEventId);
+        const reader = reading.read(response);
+        let dropped;
+        for (;; ) {
+          let chunk;
+          try {
+            chunk = await reader.read();
+          } catch (error) {
+            if (reading.stopped())
+              return;
+            dropped = error;
+            break;
+          }
+          if (reading.stopped())
+            return;
+          if (chunk.done)
+            break;
+          const events = parser.push(chunk.value);
+          lastEventId = parser.lastEventId;
+          delay = parser.retry ?? delay;
+          for (const raw of events) {
+            failures = 0;
+            const event = await declared(raw, response.status);
+            if (event !== undefined)
+              yield event;
+          }
+        }
+        if (!await again(failures++)) {
+          if (dropped === undefined)
+            return;
+          throw new NetworkError(settings.context, { cause: dropped });
+        }
+      }
+    } finally {
+      reading.release();
+    }
+  }
+  return {
+    [Symbol.asyncIterator]() {
+      if (started)
+        throw new TypeError("A stream is read once");
+      started = true;
+      return run();
+    },
+    close: () => reading.close(),
+    get lastEventId() {
+      return lastEventId;
+    }
+  };
+}
+
+// src/stream/line-parser.ts
+var RS = String.fromCharCode(30);
+function createLineParser() {
+  let buffer = "";
+  const records = (texts) => texts.map((text) => text.trim()).filter((text) => text !== "");
+  return {
+    push(chunk) {
+      const parts = (buffer + chunk).replaceAll(RS, `
+`).split(/\r?\n/);
+      buffer = parts.pop() ?? "";
+      return records(parts);
+    },
+    end() {
+      const rest = buffer;
+      buffer = "";
+      return records([rest]);
+    }
+  };
+}
+
+// src/stream/line-stream.ts
+var LINE_TYPES = [
+  "application/jsonl",
+  "application/x-ndjson",
+  "application/ndjson",
+  "application/jsonlines",
+  "application/x-jsonlines",
+  "application/json-seq"
+];
+function lineStream(settings) {
+  const reading = new Reading(settings.signal);
+  let started = false;
+  async function* run() {
+    try {
+      let response;
+      try {
+        response = await settings.open(reading.closer.signal, undefined);
+      } catch (error) {
+        if (reading.closer.signal.aborted)
+          return;
+        throw error;
+      }
+      if (!await opened(settings, response, LINE_TYPES))
+        return;
+      const parser = createLineParser();
+      const reader = reading.read(response);
+      for (;; ) {
+        let chunk;
+        try {
+          chunk = await reader.read();
+        } catch (error) {
+          if (reading.stopped())
+            return;
+          throw new NetworkError(settings.context, { cause: error });
+        }
+        if (reading.stopped())
+          return;
+        const texts = chunk.done ? parser.end() : parser.push(chunk.value);
+        for (const text of texts) {
+          yield await settle(settings, response.status, text, settings.item, "a line");
+        }
+        if (chunk.done)
+          return;
+      }
+    } finally {
+      reading.release();
+    }
+  }
+  return {
+    [Symbol.asyncIterator]() {
+      if (started)
+        throw new TypeError("A stream is read once");
+      started = true;
+      return run();
+    },
+    close: () => reading.close()
+  };
+}
+
+// src/client/create-http-client.ts
+var METHODS = [
+  "get",
+  "put",
+  "post",
+  "delete",
+  "options",
+  "head",
+  "patch",
+  "trace",
+  "query"
+];
+var RECONNECT_DELAY = 3000;
+var contextOf = (method, path, operationId) => operationId === undefined ? { method, path } : { method, path, operationId };
+function createHttpClient(options = {}) {
+  const signer = options.auth ? auth(options.auth) : undefined;
+  const claim = createLatest();
+  const latestSignal = (key) => key === undefined ? undefined : claim(key);
+  const sharedHeaders = async () => new Headers(typeof options.headers === "function" ? await options.headers() : options.headers);
+  const withDeadline = (timeout, signal) => {
+    const deadline = timeout === undefined ? undefined : AbortSignal.timeout(timeout);
+    const signals = [signal, deadline].filter((each) => each != null);
+    return {
+      deadline,
+      signal: signals.length > 1 ? AbortSignal.any(signals) : signals[0]
+    };
+  };
+  const dispatch = async (request, context, timeout, deadline, retry) => {
+    const fetch = options.fetch ?? ((sent) => globalThis.fetch(sent));
+    const send = async (sent) => {
+      try {
+        sent.signal.throwIfAborted();
+        return await fetch(sent);
+      } catch (error) {
+        if (request.signal.aborted)
+          throw error;
+        throw new NetworkError(context, { cause: error });
+      }
+    };
+    const again = retrySettings(retry);
+    const layers = [
+      ...again ? [retrying(again)] : [],
+      ...signer ? [signer] : [],
+      ...options.use ?? []
+    ];
+    try {
+      return await compose(layers, send, context)(request);
+    } catch (error) {
+      if (deadline?.aborted && timeout !== undefined) {
+        throw new TimeoutError(context, timeout, { cause: error });
+      }
+      throw error;
+    }
+  };
+  const build = async (method, path, given, adjust) => {
+    const {
+      param,
+      query,
+      json,
+      form,
+      text,
+      body,
+      operationId,
+      timeout = options.timeout,
+      retry = options.retry,
+      headers: own,
+      signal,
+      ...rest
+    } = given;
+    const context = contextOf(method, path, operationId);
+    const headers = await sharedHeaders();
+    const callHeaders = new Headers(own);
+    callHeaders.forEach((value, name) => {
+      headers.set(name, value);
+    });
+    adjust?.(headers);
+    const url = joinUrl(options.baseUrl, fillPath(context, param), writeQuery(query));
+    const payload = writeBody({ json, form, text, body }, headers, callHeaders.get("content-type"));
+    const init = {
+      ...options.init,
+      ...rest,
+      method: method.toUpperCase(),
+      headers,
+      body: payload,
+      ...payload instanceof ReadableStream ? { duplex: "half" } : {}
+    };
+    return { context, url, init, timeout, retry, signal: signal ?? undefined };
+  };
+  const request = async (method, path, given = {}) => {
+    const {
+      responses,
+      validate = true,
+      decode = true,
+      latest,
+      ...call
+    } = given;
+    const replaced = latestSignal(latest);
+    const built = await build(method, path, call);
+    const { deadline, signal } = withDeadline(built.timeout, joinSignals(built.signal, replaced));
+    const response = await dispatch(new Request(built.url, { ...built.init, signal }), built.context, built.timeout, deadline, built.retry);
+    return readReply(built.context, responses === undefined ? undefined : toSpec(responses), response, { validate, decode });
+  };
+  const opener = (method, path, call, accept) => async (stream, lastEventId) => {
+    const built = await build(method, path, call, (headers) => {
+      if (!headers.has("accept"))
+        headers.set("accept", accept);
+      if (lastEventId !== undefined) {
+        headers.set("last-event-id", lastEventId);
+      }
+    });
+    const deadline = new AbortController;
+    const clock = built.timeout === undefined ? undefined : setTimeout(() => deadline.abort(new DOMException("The stream did not open", "TimeoutError")), built.timeout);
+    const signals = [stream, deadline.signal];
+    if (built.signal)
+      signals.push(built.signal);
+    try {
+      return await dispatch(new Request(built.url, {
+        ...built.init,
+        signal: AbortSignal.any(signals)
+      }), built.context, built.timeout, deadline.signal, built.retry);
+    } finally {
+      clearTimeout(clock);
+    }
+  };
+  const events = (path, given = {}) => {
+    const {
+      events,
+      onUnknownEvent,
+      reconnect,
+      lastEventId,
+      validate = true,
+      decode = true,
+      method = "get",
+      latest,
+      ...own
+    } = given;
+    const call = {
+      ...own,
+      signal: joinSignals(own.signal, latestSignal(latest))
+    };
+    const reconnects = reconnect === undefined ? method !== "post" && method !== "patch" : reconnect !== false;
+    const settings = typeof reconnect === "object" ? reconnect : {};
+    return eventStream({
+      context: contextOf(method, path, call.operationId),
+      open: opener(method, path, call, "text/event-stream"),
+      signal: call.signal ?? undefined,
+      validate,
+      decode,
+      events,
+      onUnknownEvent,
+      reconnect: reconnects && {
+        attempts: settings.attempts ?? Number.POSITIVE_INFINITY,
+        delay: settings.delay ?? RECONNECT_DELAY
+      },
+      lastEventId
+    });
+  };
+  const lines = (path, given = {}) => {
+    const {
+      item,
+      validate = true,
+      decode = true,
+      method = "get",
+      latest,
+      ...own
+    } = given;
+    const call = {
+      ...own,
+      signal: joinSignals(own.signal, latestSignal(latest))
+    };
+    return lineStream({
+      context: contextOf(method, path, call.operationId),
+      open: opener(method, path, call, LINE_TYPES.slice(0, 2).join(", ")),
+      signal: call.signal ?? undefined,
+      validate,
+      decode,
+      item
+    });
+  };
+  const send = async (request, {
+    timeout = options.timeout,
+    retry = options.retry,
+    operationId,
+    latest
+  } = {}) => {
+    const replaced = latestSignal(latest);
+    const method = request.method.toLowerCase();
+    const context = contextOf(method, new URL(request.url).pathname, operationId);
+    const headers = await sharedHeaders();
+    request.headers.forEach((value, name) => {
+      headers.set(name, value);
+    });
+    const { deadline, signal } = withDeadline(timeout, joinSignals(request.signal, replaced));
+    const sent = new Request(request, { headers, signal });
+    return dispatch(sent, context, timeout, deadline, retry);
+  };
+  const surface = (scope) => {
+    const scoped = (given) => {
+      const extra = scope();
+      const own = given ?? {};
+      return extra ? { ...own, signal: joinSignals(own.signal, extra) } : own;
+    };
+    const client = {
+      request: (method, path, given) => request(method, path, scoped(given)),
+      send: (sent, given) => {
+        const extra = scope();
+        return send(extra ? new Request(sent, { signal: joinSignals(sent.signal, extra) }) : sent, given);
+      },
+      events: (path, given) => events(path, scoped(given)),
+      lines: (path, given) => lines(path, scoped(given)),
+      group: () => {
+        let controller = new AbortController;
+        const group = surface(() => joinSignals(scope(), controller.signal));
+        group.cancel = (reason) => {
+          controller.abort(reason ?? cancelled("The group was cancelled"));
+          controller = new AbortController;
+        };
+        Object.defineProperty(group, "signal", {
+          enumerable: true,
+          get: () => controller.signal
+        });
+        return group;
+      }
+    };
+    for (const method of METHODS) {
+      client[method] = (path, given) => request(method, path, scoped(given));
+    }
+    return client;
+  };
+  return surface(() => {
+    return;
+  });
+}
+// src/middleware/cache.ts
+var READS = new Set(["GET", "HEAD", "QUERY"]);
+var reads = (request) => READS.has(request.method.toUpperCase());
+function cache({
+  ttl = 5 * 60 * 1000,
+  maxEntries = 500,
+  cacheable = reads,
+  vary = ["authorization"]
+} = {}) {
+  const entries = new Map;
+  const keyOf = async (request) => {
+    const parts = [
+      request.method,
+      request.url,
+      ...vary.map((name) => `${name}: ${request.headers.get(name) ?? ""}`)
+    ];
+    if (request.body !== null)
+      parts.push(await request.clone().text());
+    return JSON.stringify(parts);
+  };
+  const middleware = async (request, next, call) => {
+    if (!cacheable(request, call))
+      return next(request);
+    const key = await keyOf(request);
+    const hit = entries.get(key);
+    entries.delete(key);
+    if (hit && hit.expiry > Date.now()) {
+      entries.set(key, hit);
+      return hit.response.clone();
+    }
+    const response = await next(request);
+    if (!response.ok)
+      return response;
+    entries.set(key, { expiry: Date.now() + ttl, response: response.clone() });
+    for (const oldest of entries.keys()) {
+      if (entries.size <= maxEntries)
+        break;
+      entries.delete(oldest);
+    }
+    return response;
+  };
+  return Object.assign(middleware, { clear: () => entries.clear() });
+}
+// src/reply/unwrap.ts
+function unwrap(reply, ...statuses) {
+  if (!statuses.includes(reply.status)) {
+    throw new ReplyStatusError(reply, statuses);
+  }
+  return reply.data;
+}
+function ok(reply) {
+  if (reply.status < 200 || reply.status > 299) {
+    throw new ReplyStatusError(reply, []);
+  }
+  return reply.data;
+}
+export {
+  ClientError,
+  NetworkError,
+  ReplyStatusError,
+  TimeoutError,
+  UndeclaredStatusError,
+  ValidationError,
+  cache,
+  createHttpClient,
+  isAbortError,
+  ok,
+  unwrap
+};
+
+//# debugId=96539AFD0E70EDBE64756E2164756E21
+//# sourceMappingURL=index.js.map