bc-api-client 0.1.0-beta.1 → 0.1.0-beta.10

package/dist/index.js

@@ -1,597 +1,15 @@
-// node_modules/.pnpm/ky@1.8.1/node_modules/ky/distribution/errors/HTTPError.js
-var HTTPError = class extends Error {
-  response;
-  request;
-  options;
-  constructor(response, request2, options) {
-    const code = response.status || response.status === 0 ? response.status : "";
-    const title = response.statusText || "";
-    const status = `${code} ${title}`.trim();
-    const reason = status ? `status code ${status}` : "an unknown error";
-    super(`Request failed with ${reason}: ${request2.method} ${request2.url}`);
-    this.name = "HTTPError";
-    this.response = response;
-    this.request = request2;
-    this.options = options;
-  }
-};
-
-// node_modules/.pnpm/ky@1.8.1/node_modules/ky/distribution/errors/TimeoutError.js
-var TimeoutError = class extends Error {
-  request;
-  constructor(request2) {
-    super(`Request timed out: ${request2.method} ${request2.url}`);
-    this.name = "TimeoutError";
-    this.request = request2;
-  }
-};
-
-// node_modules/.pnpm/ky@1.8.1/node_modules/ky/distribution/core/constants.js
-var supportsRequestStreams = (() => {
-  let duplexAccessed = false;
-  let hasContentType = false;
-  const supportsReadableStream = typeof globalThis.ReadableStream === "function";
-  const supportsRequest = typeof globalThis.Request === "function";
-  if (supportsReadableStream && supportsRequest) {
-    try {
-      hasContentType = new globalThis.Request("https://empty.invalid", {
-        body: new globalThis.ReadableStream(),
-        method: "POST",
-        // @ts-expect-error - Types are outdated.
-        get duplex() {
-          duplexAccessed = true;
-          return "half";
-        }
-      }).headers.has("Content-Type");
-    } catch (error) {
-      if (error instanceof Error && error.message === "unsupported BodyInit type") {
-        return false;
-      }
-      throw error;
-    }
-  }
-  return duplexAccessed && !hasContentType;
-})();
-var supportsAbortController = typeof globalThis.AbortController === "function";
-var supportsResponseStreams = typeof globalThis.ReadableStream === "function";
-var supportsFormData = typeof globalThis.FormData === "function";
-var requestMethods = ["get", "post", "put", "patch", "head", "delete"];
-var validate = () => void 0;
-validate();
-var responseTypes = {
-  json: "application/json",
-  text: "text/*",
-  formData: "multipart/form-data",
-  arrayBuffer: "*/*",
-  blob: "*/*"
-};
-var maxSafeTimeout = 2147483647;
-var usualFormBoundarySize = new TextEncoder().encode("------WebKitFormBoundaryaxpyiPgbbPti10Rw").length;
-var stop = Symbol("stop");
-var kyOptionKeys = {
-  json: true,
-  parseJson: true,
-  stringifyJson: true,
-  searchParams: true,
-  prefixUrl: true,
-  retry: true,
-  timeout: true,
-  hooks: true,
-  throwHttpErrors: true,
-  onDownloadProgress: true,
-  onUploadProgress: true,
-  fetch: true
-};
-var requestOptionsRegistry = {
-  method: true,
-  headers: true,
-  body: true,
-  mode: true,
-  credentials: true,
-  cache: true,
-  redirect: true,
-  referrer: true,
-  referrerPolicy: true,
-  integrity: true,
-  keepalive: true,
-  signal: true,
-  window: true,
-  dispatcher: true,
-  duplex: true,
-  priority: true
-};
-
-// node_modules/.pnpm/ky@1.8.1/node_modules/ky/distribution/utils/body.js
-var getBodySize = (body) => {
-  if (!body) {
-    return 0;
-  }
-  if (body instanceof FormData) {
-    let size = 0;
-    for (const [key, value] of body) {
-      size += usualFormBoundarySize;
-      size += new TextEncoder().encode(`Content-Disposition: form-data; name="${key}"`).length;
-      size += typeof value === "string" ? new TextEncoder().encode(value).length : value.size;
-    }
-    return size;
-  }
-  if (body instanceof Blob) {
-    return body.size;
-  }
-  if (body instanceof ArrayBuffer) {
-    return body.byteLength;
-  }
-  if (typeof body === "string") {
-    return new TextEncoder().encode(body).length;
-  }
-  if (body instanceof URLSearchParams) {
-    return new TextEncoder().encode(body.toString()).length;
-  }
-  if ("byteLength" in body) {
-    return body.byteLength;
-  }
-  if (typeof body === "object" && body !== null) {
-    try {
-      const jsonString = JSON.stringify(body);
-      return new TextEncoder().encode(jsonString).length;
-    } catch {
-      return 0;
-    }
-  }
-  return 0;
-};
-var streamResponse = (response, onDownloadProgress) => {
-  const totalBytes = Number(response.headers.get("content-length")) || 0;
-  let transferredBytes = 0;
-  if (response.status === 204) {
-    if (onDownloadProgress) {
-      onDownloadProgress({ percent: 1, totalBytes, transferredBytes }, new Uint8Array());
-    }
-    return new Response(null, {
-      status: response.status,
-      statusText: response.statusText,
-      headers: response.headers
-    });
-  }
-  return new Response(new ReadableStream({
-    async start(controller) {
-      const reader = response.body.getReader();
-      if (onDownloadProgress) {
-        onDownloadProgress({ percent: 0, transferredBytes: 0, totalBytes }, new Uint8Array());
-      }
-      async function read() {
-        const { done, value } = await reader.read();
-        if (done) {
-          controller.close();
-          return;
-        }
-        if (onDownloadProgress) {
-          transferredBytes += value.byteLength;
-          const percent = totalBytes === 0 ? 0 : transferredBytes / totalBytes;
-          onDownloadProgress({ percent, transferredBytes, totalBytes }, value);
-        }
-        controller.enqueue(value);
-        await read();
-      }
-      await read();
-    }
-  }), {
-    status: response.status,
-    statusText: response.statusText,
-    headers: response.headers
-  });
-};
-var streamRequest = (request2, onUploadProgress) => {
-  const totalBytes = getBodySize(request2.body);
-  let transferredBytes = 0;
-  return new Request(request2, {
-    // @ts-expect-error - Types are outdated.
-    duplex: "half",
-    body: new ReadableStream({
-      async start(controller) {
-        const reader = request2.body instanceof ReadableStream ? request2.body.getReader() : new Response("").body.getReader();
-        async function read() {
-          const { done, value } = await reader.read();
-          if (done) {
-            if (onUploadProgress) {
-              onUploadProgress({ percent: 1, transferredBytes, totalBytes: Math.max(totalBytes, transferredBytes) }, new Uint8Array());
-            }
-            controller.close();
-            return;
-          }
-          transferredBytes += value.byteLength;
-          let percent = totalBytes === 0 ? 0 : transferredBytes / totalBytes;
-          if (totalBytes < transferredBytes || percent === 1) {
-            percent = 0.99;
-          }
-          if (onUploadProgress) {
-            onUploadProgress({ percent: Number(percent.toFixed(2)), transferredBytes, totalBytes }, value);
-          }
-          controller.enqueue(value);
-          await read();
-        }
-        await read();
-      }
-    })
-  });
-};
-
-// node_modules/.pnpm/ky@1.8.1/node_modules/ky/distribution/utils/is.js
-var isObject = (value) => value !== null && typeof value === "object";
-
-// node_modules/.pnpm/ky@1.8.1/node_modules/ky/distribution/utils/merge.js
-var validateAndMerge = (...sources) => {
-  for (const source of sources) {
-    if ((!isObject(source) || Array.isArray(source)) && source !== void 0) {
-      throw new TypeError("The `options` argument must be an object");
-    }
-  }
-  return deepMerge({}, ...sources);
-};
-var mergeHeaders = (source1 = {}, source2 = {}) => {
-  const result = new globalThis.Headers(source1);
-  const isHeadersInstance = source2 instanceof globalThis.Headers;
-  const source = new globalThis.Headers(source2);
-  for (const [key, value] of source.entries()) {
-    if (isHeadersInstance && value === "undefined" || value === void 0) {
-      result.delete(key);
-    } else {
-      result.set(key, value);
-    }
-  }
-  return result;
-};
-function newHookValue(original, incoming, property) {
-  return Object.hasOwn(incoming, property) && incoming[property] === void 0 ? [] : deepMerge(original[property] ?? [], incoming[property] ?? []);
-}
-var mergeHooks = (original = {}, incoming = {}) => ({
-  beforeRequest: newHookValue(original, incoming, "beforeRequest"),
-  beforeRetry: newHookValue(original, incoming, "beforeRetry"),
-  afterResponse: newHookValue(original, incoming, "afterResponse"),
-  beforeError: newHookValue(original, incoming, "beforeError")
-});
-var deepMerge = (...sources) => {
-  let returnValue = {};
-  let headers = {};
-  let hooks = {};
-  for (const source of sources) {
-    if (Array.isArray(source)) {
-      if (!Array.isArray(returnValue)) {
-        returnValue = [];
-      }
-      returnValue = [...returnValue, ...source];
-    } else if (isObject(source)) {
-      for (let [key, value] of Object.entries(source)) {
-        if (isObject(value) && key in returnValue) {
-          value = deepMerge(returnValue[key], value);
-        }
-        returnValue = { ...returnValue, [key]: value };
-      }
-      if (isObject(source.hooks)) {
-        hooks = mergeHooks(hooks, source.hooks);
-        returnValue.hooks = hooks;
-      }
-      if (isObject(source.headers)) {
-        headers = mergeHeaders(headers, source.headers);
-        returnValue.headers = headers;
-      }
-    }
-  }
-  return returnValue;
-};
-
-// node_modules/.pnpm/ky@1.8.1/node_modules/ky/distribution/utils/normalize.js
-var normalizeRequestMethod = (input) => requestMethods.includes(input) ? input.toUpperCase() : input;
-var retryMethods = ["get", "put", "head", "delete", "options", "trace"];
-var retryStatusCodes = [408, 413, 429, 500, 502, 503, 504];
-var retryAfterStatusCodes = [413, 429, 503];
-var defaultRetryOptions = {
-  limit: 2,
-  methods: retryMethods,
-  statusCodes: retryStatusCodes,
-  afterStatusCodes: retryAfterStatusCodes,
-  maxRetryAfter: Number.POSITIVE_INFINITY,
-  backoffLimit: Number.POSITIVE_INFINITY,
-  delay: (attemptCount) => 0.3 * 2 ** (attemptCount - 1) * 1e3
-};
-var normalizeRetryOptions = (retry = {}) => {
-  if (typeof retry === "number") {
-    return {
-      ...defaultRetryOptions,
-      limit: retry
-    };
-  }
-  if (retry.methods && !Array.isArray(retry.methods)) {
-    throw new Error("retry.methods must be an array");
-  }
-  if (retry.statusCodes && !Array.isArray(retry.statusCodes)) {
-    throw new Error("retry.statusCodes must be an array");
-  }
-  return {
-    ...defaultRetryOptions,
-    ...retry
-  };
-};
-
-// node_modules/.pnpm/ky@1.8.1/node_modules/ky/distribution/utils/timeout.js
-async function timeout(request2, init, abortController, options) {
-  return new Promise((resolve, reject) => {
-    const timeoutId = setTimeout(() => {
-      if (abortController) {
-        abortController.abort();
-      }
-      reject(new TimeoutError(request2));
-    }, options.timeout);
-    void options.fetch(request2, init).then(resolve).catch(reject).then(() => {
-      clearTimeout(timeoutId);
-    });
-  });
-}
-
-// node_modules/.pnpm/ky@1.8.1/node_modules/ky/distribution/utils/delay.js
-async function delay(ms, { signal }) {
-  return new Promise((resolve, reject) => {
-    if (signal) {
-      signal.throwIfAborted();
-      signal.addEventListener("abort", abortHandler, { once: true });
-    }
-    function abortHandler() {
-      clearTimeout(timeoutId);
-      reject(signal.reason);
-    }
-    const timeoutId = setTimeout(() => {
-      signal?.removeEventListener("abort", abortHandler);
-      resolve();
-    }, ms);
-  });
-}
-
-// node_modules/.pnpm/ky@1.8.1/node_modules/ky/distribution/utils/options.js
-var findUnknownOptions = (request2, options) => {
-  const unknownOptions = {};
-  for (const key in options) {
-    if (!(key in requestOptionsRegistry) && !(key in kyOptionKeys) && !(key in request2)) {
-      unknownOptions[key] = options[key];
-    }
-  }
-  return unknownOptions;
-};
-
-// node_modules/.pnpm/ky@1.8.1/node_modules/ky/distribution/core/Ky.js
-var Ky = class _Ky {
-  static create(input, options) {
-    const ky2 = new _Ky(input, options);
-    const function_ = async () => {
-      if (typeof ky2._options.timeout === "number" && ky2._options.timeout > maxSafeTimeout) {
-        throw new RangeError(`The \`timeout\` option cannot be greater than ${maxSafeTimeout}`);
-      }
-      await Promise.resolve();
-      let response = await ky2._fetch();
-      for (const hook of ky2._options.hooks.afterResponse) {
-        const modifiedResponse = await hook(ky2.request, ky2._options, ky2._decorateResponse(response.clone()));
-        if (modifiedResponse instanceof globalThis.Response) {
-          response = modifiedResponse;
-        }
-      }
-      ky2._decorateResponse(response);
-      if (!response.ok && ky2._options.throwHttpErrors) {
-        let error = new HTTPError(response, ky2.request, ky2._options);
-        for (const hook of ky2._options.hooks.beforeError) {
-          error = await hook(error);
-        }
-        throw error;
-      }
-      if (ky2._options.onDownloadProgress) {
-        if (typeof ky2._options.onDownloadProgress !== "function") {
-          throw new TypeError("The `onDownloadProgress` option must be a function");
-        }
-        if (!supportsResponseStreams) {
-          throw new Error("Streams are not supported in your environment. `ReadableStream` is missing.");
-        }
-        return streamResponse(response.clone(), ky2._options.onDownloadProgress);
-      }
-      return response;
-    };
-    const isRetriableMethod = ky2._options.retry.methods.includes(ky2.request.method.toLowerCase());
-    const result = (isRetriableMethod ? ky2._retry(function_) : function_()).finally(async () => {
-      if (!ky2.request.bodyUsed) {
-        await ky2.request.body?.cancel();
-      }
-    });
-    for (const [type, mimeType] of Object.entries(responseTypes)) {
-      result[type] = async () => {
-        ky2.request.headers.set("accept", ky2.request.headers.get("accept") || mimeType);
-        const response = await result;
-        if (type === "json") {
-          if (response.status === 204) {
-            return "";
-          }
-          const arrayBuffer = await response.clone().arrayBuffer();
-          const responseSize = arrayBuffer.byteLength;
-          if (responseSize === 0) {
-            return "";
-          }
-          if (options.parseJson) {
-            return options.parseJson(await response.text());
-          }
-        }
-        return response[type]();
-      };
-    }
-    return result;
-  }
-  request;
-  abortController;
-  _retryCount = 0;
-  _input;
-  _options;
-  // eslint-disable-next-line complexity
-  constructor(input, options = {}) {
-    this._input = input;
-    this._options = {
-      ...options,
-      headers: mergeHeaders(this._input.headers, options.headers),
-      hooks: mergeHooks({
-        beforeRequest: [],
-        beforeRetry: [],
-        beforeError: [],
-        afterResponse: []
-      }, options.hooks),
-      method: normalizeRequestMethod(options.method ?? this._input.method ?? "GET"),
-      // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
-      prefixUrl: String(options.prefixUrl || ""),
-      retry: normalizeRetryOptions(options.retry),
-      throwHttpErrors: options.throwHttpErrors !== false,
-      timeout: options.timeout ?? 1e4,
-      fetch: options.fetch ?? globalThis.fetch.bind(globalThis)
-    };
-    if (typeof this._input !== "string" && !(this._input instanceof URL || this._input instanceof globalThis.Request)) {
-      throw new TypeError("`input` must be a string, URL, or Request");
-    }
-    if (this._options.prefixUrl && typeof this._input === "string") {
-      if (this._input.startsWith("/")) {
-        throw new Error("`input` must not begin with a slash when using `prefixUrl`");
-      }
-      if (!this._options.prefixUrl.endsWith("/")) {
-        this._options.prefixUrl += "/";
-      }
-      this._input = this._options.prefixUrl + this._input;
-    }
-    if (supportsAbortController) {
-      const originalSignal = this._options.signal ?? this._input.signal;
-      this.abortController = new globalThis.AbortController();
-      this._options.signal = originalSignal ? AbortSignal.any([originalSignal, this.abortController.signal]) : this.abortController.signal;
-    }
-    if (supportsRequestStreams) {
-      this._options.duplex = "half";
-    }
-    if (this._options.json !== void 0) {
-      this._options.body = this._options.stringifyJson?.(this._options.json) ?? JSON.stringify(this._options.json);
-      this._options.headers.set("content-type", this._options.headers.get("content-type") ?? "application/json");
-    }
-    this.request = new globalThis.Request(this._input, this._options);
-    if (this._options.searchParams) {
-      const textSearchParams = typeof this._options.searchParams === "string" ? this._options.searchParams.replace(/^\?/, "") : new URLSearchParams(this._options.searchParams).toString();
-      const searchParams = "?" + textSearchParams;
-      const url = this.request.url.replace(/(?:\?.*?)?(?=#|$)/, searchParams);
-      if ((supportsFormData && this._options.body instanceof globalThis.FormData || this._options.body instanceof URLSearchParams) && !(this._options.headers && this._options.headers["content-type"])) {
-        this.request.headers.delete("content-type");
-      }
-      this.request = new globalThis.Request(new globalThis.Request(url, { ...this.request }), this._options);
-    }
-    if (this._options.onUploadProgress) {
-      if (typeof this._options.onUploadProgress !== "function") {
-        throw new TypeError("The `onUploadProgress` option must be a function");
-      }
-      if (!supportsRequestStreams) {
-        throw new Error("Request streams are not supported in your environment. The `duplex` option for `Request` is not available.");
-      }
-      const originalBody = this.request.body;
-      if (originalBody) {
-        this.request = streamRequest(this.request, this._options.onUploadProgress);
-      }
-    }
-  }
-  _calculateRetryDelay(error) {
-    this._retryCount++;
-    if (this._retryCount > this._options.retry.limit || error instanceof TimeoutError) {
-      throw error;
-    }
-    if (error instanceof HTTPError) {
-      if (!this._options.retry.statusCodes.includes(error.response.status)) {
-        throw error;
-      }
-      const retryAfter = error.response.headers.get("Retry-After") ?? error.response.headers.get("RateLimit-Reset") ?? error.response.headers.get("X-RateLimit-Reset") ?? error.response.headers.get("X-Rate-Limit-Reset");
-      if (retryAfter && this._options.retry.afterStatusCodes.includes(error.response.status)) {
-        let after = Number(retryAfter) * 1e3;
-        if (Number.isNaN(after)) {
-          after = Date.parse(retryAfter) - Date.now();
-        } else if (after >= Date.parse("2024-01-01")) {
-          after -= Date.now();
-        }
-        const max = this._options.retry.maxRetryAfter ?? after;
-        return after < max ? after : max;
-      }
-      if (error.response.status === 413) {
-        throw error;
-      }
-    }
-    const retryDelay = this._options.retry.delay(this._retryCount);
-    return Math.min(this._options.retry.backoffLimit, retryDelay);
-  }
-  _decorateResponse(response) {
-    if (this._options.parseJson) {
-      response.json = async () => this._options.parseJson(await response.text());
-    }
-    return response;
-  }
-  async _retry(function_) {
-    try {
-      return await function_();
-    } catch (error) {
-      const ms = Math.min(this._calculateRetryDelay(error), maxSafeTimeout);
-      if (this._retryCount < 1) {
-        throw error;
-      }
-      await delay(ms, { signal: this._options.signal });
-      for (const hook of this._options.hooks.beforeRetry) {
-        const hookResult = await hook({
-          request: this.request,
-          options: this._options,
-          error,
-          retryCount: this._retryCount
-        });
-        if (hookResult === stop) {
-          return;
-        }
-      }
-      return this._retry(function_);
-    }
-  }
-  async _fetch() {
-    for (const hook of this._options.hooks.beforeRequest) {
-      const result = await hook(this.request, this._options);
-      if (result instanceof Request) {
-        this.request = result;
-        break;
-      }
-      if (result instanceof Response) {
-        return result;
-      }
-    }
-    const nonRequestOptions = findUnknownOptions(this.request, this._options);
-    const mainRequest = this.request;
-    this.request = mainRequest.clone();
-    if (this._options.timeout === false) {
-      return this._options.fetch(mainRequest, nonRequestOptions);
-    }
-    return timeout(mainRequest, nonRequestOptions, this.abortController, this._options);
-  }
-};
-
-// node_modules/.pnpm/ky@1.8.1/node_modules/ky/distribution/index.js
-var createInstance = (defaults) => {
-  const ky2 = (input, options) => Ky.create(input, validateAndMerge(defaults, options));
-  for (const method of requestMethods) {
-    ky2[method] = (input, options) => Ky.create(input, validateAndMerge(defaults, options, { method }));
-  }
-  ky2.create = (newDefaults) => createInstance(validateAndMerge(newDefaults));
-  ky2.extend = (newDefaults) => {
-    if (typeof newDefaults === "function") {
-      newDefaults = newDefaults(defaults ?? {});
-    }
-    return createInstance(validateAndMerge(defaults, newDefaults));
-  };
-  ky2.stop = stop;
-  return ky2;
-};
-var ky = createInstance();
-var distribution_default = ky;
-
 // src/net.ts
+import ky, { HTTPError } from "ky";
+var Methods = {
+  GET: "GET",
+  POST: "POST",
+  PUT: "PUT",
+  DELETE: "DELETE"
+};
+var BASE_URL = "https://api.bigcommerce.com/stores/";
 var CONFIG = {
   /** Base URL for BigCommerce API */
-  BASE_URL: "https://api.bigcommerce.com/stores/",
+  BASE_URL,
   /** Default API version to use */
   DEFAULT_VERSION: "v3",
   /** Maximum delay in milliseconds for rate limit retries */
@@ -603,26 +21,26 @@ var CONFIG = {
   /** Rate limit header names */
   HEADERS: {
     /** Time window for rate limiting in milliseconds */
-    WINDOW: "X-Rate-Limit-Time-Window-Ms",
+    WINDOW: "x-rate-limit-time-window-ms",
     /** Time to wait before retrying after rate limit in milliseconds */
-    RETRY_AFTER: "X-Rate-Limit-Time-Reset-Ms",
+    RETRY_AFTER: "x-rate-limit-time-reset-ms",
     /** Total request quota for the time window */
-    REQUEST_QUOTA: "X-Rate-Limit-Requests-Quota",
+    REQUEST_QUOTA: "x-rate-limit-requests-quota",
     /** Number of requests remaining in the current window */
-    REQUESTS_LEFT: "X-Rate-Limit-Requests-Left"
+    REQUESTS_LEFT: "x-rate-limit-requests-left"
   }
 };
 var RequestError = class extends Error {
-  constructor(status, message2, data, cause) {
-    super(message2, { cause });
+  constructor(status, message, data, cause) {
+    super(message, { cause });
     this.status = status;
-    this.message = message2;
+    this.message = message;
     this.data = data;
     this.cause = cause;
   }
 };
 var request = async (options) => {
-  const { maxDelay = CONFIG.DEFAULT_MAX_DELAY, maxRetries = CONFIG.DEFAULT_MAX_RETRIES } = options;
+  const { maxDelay = CONFIG.DEFAULT_MAX_DELAY, maxRetries = CONFIG.DEFAULT_MAX_RETRIES, logger } = options;
   let retries = 0;
   let lastError = null;
   while (retries < maxRetries) {
@@ -634,6 +52,11 @@ var request = async (options) => {
       if (err.status === 429 && typeof err.data === "object" && err.data !== null && "headers" in err.data) {
         const headers = err.data.headers;
         const retryAfter = Number.parseInt(headers[CONFIG.HEADERS.RETRY_AFTER]);
+        logger?.debug({
+          retryAfter,
+          retries,
+          remaining: headers[CONFIG.HEADERS.REQUESTS_LEFT]
+        }, "Rate limit hit, retrying");
         if (Number.isNaN(retryAfter)) {
           throw new RequestError(
             err.status,
@@ -643,6 +66,10 @@ var request = async (options) => {
           );
         }
         if (retryAfter > maxDelay) {
+          logger?.warn({
+            retryAfter,
+            maxDelay
+          }, "Rate limit delay exceeds maximum allowed delay");
           throw new RequestError(
             err.status,
             `Rate limit exceeded: ${retryAfter}ms, ${err.message}`,
@@ -657,17 +84,30 @@ var request = async (options) => {
       throw err;
     }
   }
+  logger?.error({
+    retries,
+    error: lastError
+  }, "Request failed after maximum retries");
   throw lastError ?? new RequestError(500, "Failed to make request", "Too many retries after rate limit");
 };
 var safeRequest = async (options) => {
+  const { logger } = options;
   let res;
   try {
     res = await call(options);
-  } catch (_error) {
-    if (_error instanceof RequestError) {
-      throw _error;
+  } catch (error) {
+    if (error instanceof RequestError) {
+      throw error;
+    }
+    if (!(error instanceof HTTPError)) {
+      logger?.error({
+        error: error instanceof Error ? {
+          name: error.name,
+          message: error.message
+        } : error
+      }, "Unexpected error during request");
+      throw error;
     }
-    const error = _error;
     let data;
     let errorMessage = error.message;
     try {
@@ -682,12 +122,16 @@ var safeRequest = async (options) => {
     } catch {
       data = "Failed to read error response";
     }
+    logger?.error({
+      status: error?.response?.status,
+      errorMessage
+    }, "HTTP error during request");
     throw new RequestError(
-      error.response.status,
+      error?.response?.status ?? 500,
       errorMessage,
       {
         data,
-        headers: Object.fromEntries(error.response.headers.entries())
+        headers: Object.fromEntries(error?.response?.headers?.entries() ?? [])
       },
       error
     );
@@ -699,6 +143,13 @@ var safeRequest = async (options) => {
   try {
     return JSON.parse(text);
   } catch (error) {
+    logger?.error({
+      status: res.status,
+      error: error instanceof Error ? {
+        name: error.name,
+        message: error.message
+      } : error
+    }, "Failed to parse response");
     throw new RequestError(
       res.status,
       `Failed to parse response: ${text}`,
@@ -707,12 +158,16 @@ var safeRequest = async (options) => {
     );
   }
 };
-var call = (options) => {
-  const { storeHash, accessToken, endpoint, method = "GET", body, version = CONFIG.DEFAULT_VERSION, query } = options;
+var call = async (options) => {
+  const { storeHash, accessToken, endpoint, method = "GET", body, version = CONFIG.DEFAULT_VERSION, query, logger } = options;
   const url = `${CONFIG.BASE_URL}${storeHash}/${version}/${endpoint.replace(/^\//, "")}`;
   const searchParams = query ? new URLSearchParams(query).toString() : "";
   const fullUrl = searchParams ? `${url}?${searchParams}` : url;
   if (fullUrl.length > CONFIG.MAX_URL_LENGTH) {
+    logger?.error({
+      urlLength: fullUrl.length,
+      maxLength: CONFIG.MAX_URL_LENGTH
+    }, "URL length exceeds maximum allowed length");
     throw new RequestError(
       400,
       "URL too long",
@@ -728,129 +183,10 @@ var call = (options) => {
     },
     json: body
   };
-  return distribution_default(fullUrl, request2);
+  const response = await ky(fullUrl, request2);
+  return response;
 };
 
-// node_modules/.pnpm/remeda@2.21.3/node_modules/remeda/dist/chunk-ANXBDSUI.js
-var e = { done: true, hasNext: false };
-var s = { done: false, hasNext: false };
-var a = () => e;
-
-// node_modules/.pnpm/remeda@2.21.3/node_modules/remeda/dist/chunk-3GOCSNFN.js
-function C(t, ...o2) {
-  let n = t, u3 = o2.map((e2) => "lazy" in e2 ? y(e2) : void 0), p = 0;
-  for (; p < o2.length; ) {
-    if (u3[p] === void 0 || !B(n)) {
-      let i2 = o2[p];
-      n = i2(n), p += 1;
-      continue;
-    }
-    let r = [];
-    for (let i2 = p; i2 < o2.length; i2++) {
-      let l = u3[i2];
-      if (l === void 0 || (r.push(l), l.isSingle)) break;
-    }
-    let a3 = [];
-    for (let i2 of n) if (f(i2, a3, r)) break;
-    let { isSingle: s4 } = r.at(-1);
-    n = s4 ? a3[0] : a3, p += r.length;
-  }
-  return n;
-}
-function f(t, o2, n) {
-  if (n.length === 0) return o2.push(t), false;
-  let u3 = t, p = s, e2 = false;
-  for (let [r, a3] of n.entries()) {
-    let { index: s4, items: i2 } = a3;
-    if (i2.push(u3), p = a3(u3, s4, i2), a3.index += 1, p.hasNext) {
-      if (p.hasMany ?? false) {
-        for (let l of p.next) if (f(l, o2, n.slice(r + 1))) return true;
-        return e2;
-      }
-      u3 = p.next;
-    }
-    if (!p.hasNext) break;
-    p.done && (e2 = true);
-  }
-  return p.hasNext && o2.push(u3), e2;
-}
-function y(t) {
-  let { lazy: o2, lazyArgs: n } = t, u3 = o2(...n);
-  return Object.assign(u3, { isSingle: o2.single ?? false, index: 0, items: [] });
-}
-function B(t) {
-  return typeof t == "string" || typeof t == "object" && t !== null && Symbol.iterator in t;
-}
-
-// node_modules/.pnpm/remeda@2.21.3/node_modules/remeda/dist/chunk-LFJW7BOT.js
-function y2(t, i2) {
-  let a3 = i2.length - t.length;
-  if (a3 === 1) {
-    let [n, ...r] = i2;
-    return C(n, { lazy: t, lazyArgs: r });
-  }
-  if (a3 === 0) {
-    let n = { lazy: t, lazyArgs: i2 };
-    return Object.assign((e2) => C(e2, n), n);
-  }
-  throw new Error("Wrong number of arguments");
-}
-
-// node_modules/.pnpm/remeda@2.21.3/node_modules/remeda/dist/chunk-D6FCK2GA.js
-function u(o2, n, a3) {
-  let t = (r) => o2(r, ...n);
-  return a3 === void 0 ? t : Object.assign(t, { lazy: a3, lazyArgs: n });
-}
-
-// node_modules/.pnpm/remeda@2.21.3/node_modules/remeda/dist/chunk-WIMGWYZL.js
-function u2(r, n, o2) {
-  let a3 = r.length - n.length;
-  if (a3 === 0) return r(...n);
-  if (a3 === 1) return u(r, n, o2);
-  throw new Error("Wrong number of arguments");
-}
-
-// node_modules/.pnpm/remeda@2.21.3/node_modules/remeda/dist/chunk-ENS7GPLZ.js
-function a2(...r) {
-  return u2(o, r);
-}
-function o(r, t) {
-  let e2 = [];
-  for (let n = r; n < t; n++) e2.push(n);
-  return e2;
-}
-
-// node_modules/.pnpm/remeda@2.21.3/node_modules/remeda/dist/chunk-ICBBHOCR.js
-function s2(...t) {
-  return y2(i, t);
-}
-function i(t) {
-  if (t.length === 0) return a;
-  let n = /* @__PURE__ */ new Map();
-  for (let r of t) n.set(r, (n.get(r) ?? 0) + 1);
-  return (r) => {
-    let e2 = n.get(r);
-    return e2 === void 0 || e2 === 0 ? s : (e2 === 1 ? n.delete(r) : n.set(r, e2 - 1), { hasNext: true, next: r, done: n.size === 0 });
-  };
-}
-
-// node_modules/.pnpm/remeda@2.21.3/node_modules/remeda/dist/chunk-WFMWIRTS.js
-function f2(...e2) {
-  return u2(s3, e2);
-}
-function s3(e2, n) {
-  if (n < 1) throw new RangeError(`chunk: A chunk size of '${n.toString()}' would result in an infinite array`);
-  if (e2.length === 0) return [];
-  if (n >= e2.length) return [[...e2]];
-  let i2 = Math.ceil(e2.length / n), u3 = new Array(i2);
-  if (n === 1) for (let [r, t] of e2.entries()) u3[r] = [t];
-  else for (let r = 0; r < i2; r += 1) {
-    let t = r * n;
-    u3[r] = e2.slice(t, t + n);
-  }
-  return u3;
-}
-
 // src/util.ts
 var chunkStrLength = (items, options = {}) => {
   const { maxLength = 2048, chunkLength = 250, offset = 0, separatorSize = 1 } = options;
@@ -883,42 +219,109 @@ var chunkStrLength = (items, options = {}) => {
 
 // src/client.ts
 var MAX_PAGE_SIZE = 250;
+var DEFAULT_CONCURRENCY = 10;
+function chunkArray(array, size) {
+  return Array.from(
+    { length: Math.ceil(array.length / size) },
+    (_, i) => array.slice(i * size, i * size + size)
+  );
+}
+function rangeArray(start, end) {
+  return Array.from({ length: end - start + 1 }, (_, i) => start + i);
+}
 var BigCommerceClient = class {
+  /**
+   * Creates a new BigCommerce client instance
+   * @param config - Configuration options for the client
+   * @param config.storeHash - The store hash to use for the client
+   * @param config.accessToken - The API access token to use for the client
+   * @param config.maxRetries - The maximum number of retries for rate limit errors (default: 5)
+   * @param config.maxDelay - Maximum time to wait to retry in case of rate limit errors in milliseconds (default: 60000 - 1 minute). If `X-Rate-Limit-Time-Reset-Ms` header is higher than `maxDelay`, the request will fail immediately.
+   * @param config.concurrency - The default concurrency for concurrent methods (default: 10)
+   * @param config.skipErrors - Whether to skip errors during concurrent requests (default: false)
+   * @param config.logger - Optional logger instance for debugging and error tracking
+   */
   constructor(config) {
     this.config = config;
   }
-  async get(options) {
+  /**
+   * Makes a GET request to the BigCommerce API
+   * @param endpoint - The API endpoint to request
+   * @param options.query - Query parameters to include in the request
+   * @param options.version - API version to use (v2 or v3) (default: v3)
+   * @returns Promise resolving to the response data of type `R`
+   */
+  async get(endpoint, options) {
     return request({
-      ...options,
+      endpoint,
       method: "GET",
+      ...options,
       ...this.config
     });
   }
-  async post(options) {
+  /**
+   * Makes a POST request to the BigCommerce API
+   * @param endpoint - The API endpoint to request
+   * @param options.query - Query parameters to include in the request
+   * @param options.version - API version to use (v2 or v3) (default: v3)
+   * @param options.body - Request body data of type `T`
+   * @returns Promise resolving to the response data of type `R`
+   */
+  async post(endpoint, options) {
     return request({
-      ...options,
+      endpoint,
       method: "POST",
+      ...options,
       ...this.config
     });
   }
-  async put(options) {
+  /**
+   * Makes a PUT request to the BigCommerce API
+   * @param endpoint - The API endpoint to request
+   * @param options.query - Query parameters to include in the request
+   * @param options.version - API version to use (v2 or v3) (default: v3)
+   * @param options.body - Request body data of type `T`
+   * @returns Promise resolving to the response data of type `R`
+   */
+  async put(endpoint, options) {
     return request({
-      ...options,
+      endpoint,
       method: "PUT",
+      ...options,
       ...this.config
     });
   }
-  async delete(endpoint) {
+  /**
+   * Makes a DELETE request to the BigCommerce API
+   * @param endpoint - The API endpoint to delete
+   * @param options.version - API version to use (v2 or v3) (default: v3)
+   * @returns Promise resolving to void
+   */
+  async delete(endpoint, options) {
     await request({
       endpoint,
       method: "DELETE",
+      ...options,
       ...this.config
     });
   }
+  /**
+   * Executes multiple requests concurrently with controlled concurrency
+   * @param requests - Array of request options to execute
+   * @param options.concurrency - Maximum number of concurrent requests, overrides the client's concurrency setting (default: 10)
+   * @param options.skipErrors - Whether to skip errors and continue processing, overrides the client's skipErrors setting (default: false)
+   * @returns Promise resolving to array of response data
+   */
   async concurrent(requests, options) {
-    const chunks = f2(requests, options.concurrency ?? 10);
-    const skipErrors = options.skipErrors ?? false;
+    const chunkSize = options?.concurrency ?? this.config.concurrency ?? DEFAULT_CONCURRENCY;
+    const chunks = chunkArray(requests, chunkSize);
+    const skipErrors = options?.skipErrors ?? this.config.skipErrors ?? false;
     const results = [];
+    this.config.logger?.debug({
+      totalRequests: requests.length,
+      chunkSize,
+      chunks: chunks.length
+    }, "Starting concurrent requests");
     for (const chunk of chunks) {
       const responses = await Promise.allSettled(
         chunk.map(
@@ -935,14 +338,28 @@ var BigCommerceClient = class {
           if (!skipErrors) {
             throw response.reason;
           } else {
-            console.warn(`Error in concurrent request: ${response.reason}`);
+            this.config.logger?.warn({
+              error: response.reason instanceof Error ? {
+                name: response.reason.name,
+                message: response.reason.message
+              } : response.reason
+            }, "Error in concurrent request");
           }
         }
       });
     }
     return results;
   }
-  async collect(options) {
+  /**
+   * Collects all pages of data from a paginated v3 API endpoint.
+   * This method pulls the first page and uses pagination meta to collect the remaining pages concurrently.
+   * @param endpoint - The API endpoint to request
+   * @param options.query - Query parameters to include in the request
+   * @param options.concurrency - Maximum number of concurrent requests, overrides the client's concurrency setting (default: 10)
+   * @param options.skipErrors - Whether to skip errors and continue processing, overrides the client's skipErrors setting (default: false)
+   * @returns Promise resolving to array of all items across all pages
+   */
+  async collect(endpoint, options) {
     if (options.query) {
       if (!options.query.limit) {
         options.query.limit = MAX_PAGE_SIZE.toString();
@@ -950,24 +367,44 @@ var BigCommerceClient = class {
     } else {
       options.query = { limit: MAX_PAGE_SIZE.toString() };
     }
-    const first = await this.get(options);
+    const first = await this.get(endpoint, options);
     if (!Array.isArray(first.data) || !first?.meta?.pagination?.total_pages) {
       return first.data;
     }
     const results = [...first.data];
     const pages = first.meta.pagination.total_pages;
-    const remainingPages = a2(2, pages + 1);
-    const requests = remainingPages.map((page) => ({
-      ...options,
-      query: { ...options.query, page: page.toString() }
-    }));
-    const responses = await this.concurrent(requests, options);
-    responses.forEach((response) => {
-      results.push(...response.data);
-    });
+    if (pages > 1) {
+      this.config.logger?.debug({
+        totalPages: pages,
+        itemsPerPage: first.data.length
+      }, "Collecting remaining pages");
+      const pageRequests = rangeArray(2, pages).map((page) => ({
+        endpoint,
+        method: "GET",
+        query: {
+          ...options.query,
+          page: page.toString()
+        }
+      }));
+      const remainingPages = await this.concurrent(pageRequests, options);
+      remainingPages.forEach((page) => {
+        if (Array.isArray(page.data)) {
+          results.push(...page.data);
+        }
+      });
+    }
     return results;
   }
-  async collectV2(options) {
+  /**
+   * Collects all pages of data from a paginated v2 API endpoint.
+   * This method simply pulls all pages concurrently until a 204 is returned in a batch.
+   * @param endpoint - The API endpoint to request
+   * @param options.query - Query parameters to include in the request
+   * @param options.concurrency - Maximum number of concurrent requests, overrides the client's concurrency setting (default: 10)
+   * @param options.skipErrors - Whether to skip errors and continue processing, overrides the client's skipErrors setting (default: false)
+   * @returns Promise resolving to array of all items across all pages
+   */
+  async collectV2(endpoint, options) {
     if (options.query) {
       if (!options.query.limit) {
         options.query.limit = MAX_PAGE_SIZE.toString();
@@ -978,16 +415,17 @@ var BigCommerceClient = class {
     let done = false;
     const results = [];
     let page = 1;
-    const concurrency = options.concurrency ?? 10;
+    const concurrency = options.concurrency ?? this.config.concurrency ?? DEFAULT_CONCURRENCY;
     while (!done) {
-      const pages = a2(page, page + concurrency);
+      const pages = rangeArray(page, page + concurrency);
       page += concurrency;
       const requests = pages.map((page2) => ({
         ...options,
+        endpoint,
         version: "v2",
         query: { ...options.query, page: page2.toString() }
       }));
-      const responses = await Promise.allSettled(requests.map((request2) => this.get(request2)));
+      const responses = await Promise.allSettled(requests.map((request2) => this.get(endpoint, request2)));
       responses.forEach((response) => {
         if (response.status === "fulfilled") {
           if (response.value) {
@@ -999,10 +437,15 @@ var BigCommerceClient = class {
           if (response.reason instanceof RequestError && response.reason.status === 404) {
             done = true;
           } else {
-            if (!options.skipErrors) {
+            if (!(options.skipErrors ?? this.config.skipErrors ?? false)) {
               throw response.reason;
             } else {
-              console.warn(`Error in collectV2: ${response.reason}`);
+              this.config.logger?.warn({
+                error: response.reason instanceof Error ? {
+                  name: response.reason.name,
+                  message: response.reason.message
+                } : response.reason
+              }, "Error in collectV2");
             }
           }
         }
@@ -1010,7 +453,20 @@ var BigCommerceClient = class {
     }
     return results;
   }
-  async query(options) {
+  /**
+   * Queries multiple values against a single field using the v3 API. 
+   * If the url + query params are too long, the query will be chunked. Otherwise, this method acts like `collect`.
+   * This method does not check for uniqueness of the `values` array.
+   * 
+   * @param endpoint - The API endpoint to request
+   * @param options.key - The field name to query against e.g. `sku:in`
+   * @param options.values - Array of values to query for e.g. `['123', '456', ...]`
+   * @param options.query - Additional query parameters
+   * @param options.concurrency - Maximum number of concurrent requests, overrides the client's concurrency setting (default: 10)
+   * @param options.skipErrors - Whether to skip errors and continue processing, overrides the client's skipErrors setting (default: false)
+   * @returns Promise resolving to array of matching items
+   */
+  async query(endpoint, options) {
     if (options.query) {
       if (!options.query.limit) {
         options.query.limit = MAX_PAGE_SIZE.toString();
@@ -1018,12 +474,21 @@ var BigCommerceClient = class {
     } else {
       options.query = { limit: MAX_PAGE_SIZE.toString() };
     }
+    const { limit: _, ...restQuery } = options.query;
+    const fullUrl = `${BASE_URL}${this.config.storeHash}/v3/${endpoint}?${new URLSearchParams(restQuery).toString()}`;
     const queryStr = options.values.map((value) => `${value}`);
     const chunks = chunkStrLength(queryStr, {
-      chunkLength: MAX_PAGE_SIZE
+      offset: fullUrl.length,
+      chunkLength: Number.parseInt(options.query?.limit) || MAX_PAGE_SIZE
     });
+    this.config.logger?.debug({
+      totalValues: options.values.length,
+      chunks: chunks.length,
+      valuesPerChunk: chunks[0]?.length
+    }, "Querying with chunked values");
     const requests = chunks.map((chunk) => ({
       ...options,
+      endpoint,
       query: { ...options.query, [options.key]: chunk.join(",") }
     }));
     const responses = await this.concurrent(requests, options);
@@ -1031,1092 +496,38 @@ var BigCommerceClient = class {
   }
 };
 
-// node_modules/.pnpm/jose@6.0.11/node_modules/jose/dist/webapi/lib/buffer_utils.js
-var encoder = new TextEncoder();
-var decoder = new TextDecoder();
-var MAX_INT32 = 2 ** 32;
-function concat(...buffers) {
-  const size = buffers.reduce((acc, { length }) => acc + length, 0);
-  const buf = new Uint8Array(size);
-  let i2 = 0;
-  for (const buffer of buffers) {
-    buf.set(buffer, i2);
-    i2 += buffer.length;
-  }
-  return buf;
-}
-
-// node_modules/.pnpm/jose@6.0.11/node_modules/jose/dist/webapi/lib/base64.js
-function decodeBase64(encoded) {
-  if (Uint8Array.fromBase64) {
-    return Uint8Array.fromBase64(encoded);
-  }
-  const binary = atob(encoded);
-  const bytes = new Uint8Array(binary.length);
-  for (let i2 = 0; i2 < binary.length; i2++) {
-    bytes[i2] = binary.charCodeAt(i2);
-  }
-  return bytes;
-}
-
-// node_modules/.pnpm/jose@6.0.11/node_modules/jose/dist/webapi/util/base64url.js
-function decode(input) {
-  if (Uint8Array.fromBase64) {
-    return Uint8Array.fromBase64(typeof input === "string" ? input : decoder.decode(input), {
-      alphabet: "base64url"
-    });
-  }
-  let encoded = input;
-  if (encoded instanceof Uint8Array) {
-    encoded = decoder.decode(encoded);
-  }
-  encoded = encoded.replace(/-/g, "+").replace(/_/g, "/").replace(/\s/g, "");
-  try {
-    return decodeBase64(encoded);
-  } catch {
-    throw new TypeError("The input to be decoded is not correctly encoded.");
-  }
-}
-
-// node_modules/.pnpm/jose@6.0.11/node_modules/jose/dist/webapi/util/errors.js
-var JOSEError = class extends Error {
-  static code = "ERR_JOSE_GENERIC";
-  code = "ERR_JOSE_GENERIC";
-  constructor(message2, options) {
-    super(message2, options);
-    this.name = this.constructor.name;
-    Error.captureStackTrace?.(this, this.constructor);
-  }
-};
-var JWTClaimValidationFailed = class extends JOSEError {
-  static code = "ERR_JWT_CLAIM_VALIDATION_FAILED";
-  code = "ERR_JWT_CLAIM_VALIDATION_FAILED";
-  claim;
-  reason;
-  payload;
-  constructor(message2, payload, claim = "unspecified", reason = "unspecified") {
-    super(message2, { cause: { claim, reason, payload } });
-    this.claim = claim;
-    this.reason = reason;
-    this.payload = payload;
-  }
-};
-var JWTExpired = class extends JOSEError {
-  static code = "ERR_JWT_EXPIRED";
-  code = "ERR_JWT_EXPIRED";
-  claim;
-  reason;
-  payload;
-  constructor(message2, payload, claim = "unspecified", reason = "unspecified") {
-    super(message2, { cause: { claim, reason, payload } });
-    this.claim = claim;
-    this.reason = reason;
-    this.payload = payload;
-  }
-};
-var JOSEAlgNotAllowed = class extends JOSEError {
-  static code = "ERR_JOSE_ALG_NOT_ALLOWED";
-  code = "ERR_JOSE_ALG_NOT_ALLOWED";
-};
-var JOSENotSupported = class extends JOSEError {
-  static code = "ERR_JOSE_NOT_SUPPORTED";
-  code = "ERR_JOSE_NOT_SUPPORTED";
-};
-var JWSInvalid = class extends JOSEError {
-  static code = "ERR_JWS_INVALID";
-  code = "ERR_JWS_INVALID";
-};
-var JWTInvalid = class extends JOSEError {
-  static code = "ERR_JWT_INVALID";
-  code = "ERR_JWT_INVALID";
-};
-var JWSSignatureVerificationFailed = class extends JOSEError {
-  static code = "ERR_JWS_SIGNATURE_VERIFICATION_FAILED";
-  code = "ERR_JWS_SIGNATURE_VERIFICATION_FAILED";
-  constructor(message2 = "signature verification failed", options) {
-    super(message2, options);
-  }
-};
-
-// node_modules/.pnpm/jose@6.0.11/node_modules/jose/dist/webapi/lib/crypto_key.js
-function unusable(name, prop = "algorithm.name") {
-  return new TypeError(`CryptoKey does not support this operation, its ${prop} must be ${name}`);
-}
-function isAlgorithm(algorithm, name) {
-  return algorithm.name === name;
-}
-function getHashLength(hash) {
-  return parseInt(hash.name.slice(4), 10);
-}
-function getNamedCurve(alg) {
-  switch (alg) {
-    case "ES256":
-      return "P-256";
-    case "ES384":
-      return "P-384";
-    case "ES512":
-      return "P-521";
-    default:
-      throw new Error("unreachable");
-  }
-}
-function checkUsage(key, usage) {
-  if (usage && !key.usages.includes(usage)) {
-    throw new TypeError(`CryptoKey does not support this operation, its usages must include ${usage}.`);
-  }
-}
-function checkSigCryptoKey(key, alg, usage) {
-  switch (alg) {
-    case "HS256":
-    case "HS384":
-    case "HS512": {
-      if (!isAlgorithm(key.algorithm, "HMAC"))
-        throw unusable("HMAC");
-      const expected = parseInt(alg.slice(2), 10);
-      const actual = getHashLength(key.algorithm.hash);
-      if (actual !== expected)
-        throw unusable(`SHA-${expected}`, "algorithm.hash");
-      break;
-    }
-    case "RS256":
-    case "RS384":
-    case "RS512": {
-      if (!isAlgorithm(key.algorithm, "RSASSA-PKCS1-v1_5"))
-        throw unusable("RSASSA-PKCS1-v1_5");
-      const expected = parseInt(alg.slice(2), 10);
-      const actual = getHashLength(key.algorithm.hash);
-      if (actual !== expected)
-        throw unusable(`SHA-${expected}`, "algorithm.hash");
-      break;
-    }
-    case "PS256":
-    case "PS384":
-    case "PS512": {
-      if (!isAlgorithm(key.algorithm, "RSA-PSS"))
-        throw unusable("RSA-PSS");
-      const expected = parseInt(alg.slice(2), 10);
-      const actual = getHashLength(key.algorithm.hash);
-      if (actual !== expected)
-        throw unusable(`SHA-${expected}`, "algorithm.hash");
-      break;
-    }
-    case "Ed25519":
-    case "EdDSA": {
-      if (!isAlgorithm(key.algorithm, "Ed25519"))
-        throw unusable("Ed25519");
-      break;
-    }
-    case "ES256":
-    case "ES384":
-    case "ES512": {
-      if (!isAlgorithm(key.algorithm, "ECDSA"))
-        throw unusable("ECDSA");
-      const expected = getNamedCurve(alg);
-      const actual = key.algorithm.namedCurve;
-      if (actual !== expected)
-        throw unusable(expected, "algorithm.namedCurve");
-      break;
-    }
-    default:
-      throw new TypeError("CryptoKey does not support this operation");
-  }
-  checkUsage(key, usage);
-}
-
-// node_modules/.pnpm/jose@6.0.11/node_modules/jose/dist/webapi/lib/invalid_key_input.js
-function message(msg, actual, ...types) {
-  types = types.filter(Boolean);
-  if (types.length > 2) {
-    const last = types.pop();
-    msg += `one of type ${types.join(", ")}, or ${last}.`;
-  } else if (types.length === 2) {
-    msg += `one of type ${types[0]} or ${types[1]}.`;
-  } else {
-    msg += `of type ${types[0]}.`;
-  }
-  if (actual == null) {
-    msg += ` Received ${actual}`;
-  } else if (typeof actual === "function" && actual.name) {
-    msg += ` Received function ${actual.name}`;
-  } else if (typeof actual === "object" && actual != null) {
-    if (actual.constructor?.name) {
-      msg += ` Received an instance of ${actual.constructor.name}`;
-    }
-  }
-  return msg;
-}
-var invalid_key_input_default = (actual, ...types) => {
-  return message("Key must be ", actual, ...types);
-};
-function withAlg(alg, actual, ...types) {
-  return message(`Key for the ${alg} algorithm must be `, actual, ...types);
-}
-
-// node_modules/.pnpm/jose@6.0.11/node_modules/jose/dist/webapi/lib/is_key_like.js
-function isCryptoKey(key) {
-  return key?.[Symbol.toStringTag] === "CryptoKey";
-}
-function isKeyObject(key) {
-  return key?.[Symbol.toStringTag] === "KeyObject";
-}
-var is_key_like_default = (key) => {
-  return isCryptoKey(key) || isKeyObject(key);
-};
-
-// node_modules/.pnpm/jose@6.0.11/node_modules/jose/dist/webapi/lib/is_disjoint.js
-var is_disjoint_default = (...headers) => {
-  const sources = headers.filter(Boolean);
-  if (sources.length === 0 || sources.length === 1) {
-    return true;
-  }
-  let acc;
-  for (const header of sources) {
-    const parameters = Object.keys(header);
-    if (!acc || acc.size === 0) {
-      acc = new Set(parameters);
-      continue;
-    }
-    for (const parameter of parameters) {
-      if (acc.has(parameter)) {
-        return false;
-      }
-      acc.add(parameter);
-    }
-  }
-  return true;
-};
-
-// node_modules/.pnpm/jose@6.0.11/node_modules/jose/dist/webapi/lib/is_object.js
-function isObjectLike(value) {
-  return typeof value === "object" && value !== null;
-}
-var is_object_default = (input) => {
-  if (!isObjectLike(input) || Object.prototype.toString.call(input) !== "[object Object]") {
-    return false;
-  }
-  if (Object.getPrototypeOf(input) === null) {
-    return true;
-  }
-  let proto = input;
-  while (Object.getPrototypeOf(proto) !== null) {
-    proto = Object.getPrototypeOf(proto);
-  }
-  return Object.getPrototypeOf(input) === proto;
-};
-
-// node_modules/.pnpm/jose@6.0.11/node_modules/jose/dist/webapi/lib/check_key_length.js
-var check_key_length_default = (alg, key) => {
-  if (alg.startsWith("RS") || alg.startsWith("PS")) {
-    const { modulusLength } = key.algorithm;
-    if (typeof modulusLength !== "number" || modulusLength < 2048) {
-      throw new TypeError(`${alg} requires key modulusLength to be 2048 bits or larger`);
-    }
-  }
-};
-
-// node_modules/.pnpm/jose@6.0.11/node_modules/jose/dist/webapi/lib/jwk_to_key.js
-function subtleMapping(jwk) {
-  let algorithm;
-  let keyUsages;
-  switch (jwk.kty) {
-    case "RSA": {
-      switch (jwk.alg) {
-        case "PS256":
-        case "PS384":
-        case "PS512":
-          algorithm = { name: "RSA-PSS", hash: `SHA-${jwk.alg.slice(-3)}` };
-          keyUsages = jwk.d ? ["sign"] : ["verify"];
-          break;
-        case "RS256":
-        case "RS384":
-        case "RS512":
-          algorithm = { name: "RSASSA-PKCS1-v1_5", hash: `SHA-${jwk.alg.slice(-3)}` };
-          keyUsages = jwk.d ? ["sign"] : ["verify"];
-          break;
-        case "RSA-OAEP":
-        case "RSA-OAEP-256":
-        case "RSA-OAEP-384":
-        case "RSA-OAEP-512":
-          algorithm = {
-            name: "RSA-OAEP",
-            hash: `SHA-${parseInt(jwk.alg.slice(-3), 10) || 1}`
-          };
-          keyUsages = jwk.d ? ["decrypt", "unwrapKey"] : ["encrypt", "wrapKey"];
-          break;
-        default:
-          throw new JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
-      }
-      break;
-    }
-    case "EC": {
-      switch (jwk.alg) {
-        case "ES256":
-          algorithm = { name: "ECDSA", namedCurve: "P-256" };
-          keyUsages = jwk.d ? ["sign"] : ["verify"];
-          break;
-        case "ES384":
-          algorithm = { name: "ECDSA", namedCurve: "P-384" };
-          keyUsages = jwk.d ? ["sign"] : ["verify"];
-          break;
-        case "ES512":
-          algorithm = { name: "ECDSA", namedCurve: "P-521" };
-          keyUsages = jwk.d ? ["sign"] : ["verify"];
-          break;
-        case "ECDH-ES":
-        case "ECDH-ES+A128KW":
-        case "ECDH-ES+A192KW":
-        case "ECDH-ES+A256KW":
-          algorithm = { name: "ECDH", namedCurve: jwk.crv };
-          keyUsages = jwk.d ? ["deriveBits"] : [];
-          break;
-        default:
-          throw new JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
-      }
-      break;
-    }
-    case "OKP": {
-      switch (jwk.alg) {
-        case "Ed25519":
-        case "EdDSA":
-          algorithm = { name: "Ed25519" };
-          keyUsages = jwk.d ? ["sign"] : ["verify"];
-          break;
-        case "ECDH-ES":
-        case "ECDH-ES+A128KW":
-        case "ECDH-ES+A192KW":
-        case "ECDH-ES+A256KW":
-          algorithm = { name: jwk.crv };
-          keyUsages = jwk.d ? ["deriveBits"] : [];
-          break;
-        default:
-          throw new JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
-      }
-      break;
-    }
-    default:
-      throw new JOSENotSupported('Invalid or unsupported JWK "kty" (Key Type) Parameter value');
-  }
-  return { algorithm, keyUsages };
-}
-var jwk_to_key_default = async (jwk) => {
-  if (!jwk.alg) {
-    throw new TypeError('"alg" argument is required when "jwk.alg" is not present');
-  }
-  const { algorithm, keyUsages } = subtleMapping(jwk);
-  const keyData = { ...jwk };
-  delete keyData.alg;
-  delete keyData.use;
-  return crypto.subtle.importKey("jwk", keyData, algorithm, jwk.ext ?? (jwk.d ? false : true), jwk.key_ops ?? keyUsages);
-};
-
-// node_modules/.pnpm/jose@6.0.11/node_modules/jose/dist/webapi/lib/validate_crit.js
-var validate_crit_default = (Err, recognizedDefault, recognizedOption, protectedHeader, joseHeader) => {
-  if (joseHeader.crit !== void 0 && protectedHeader?.crit === void 0) {
-    throw new Err('"crit" (Critical) Header Parameter MUST be integrity protected');
-  }
-  if (!protectedHeader || protectedHeader.crit === void 0) {
-    return /* @__PURE__ */ new Set();
-  }
-  if (!Array.isArray(protectedHeader.crit) || protectedHeader.crit.length === 0 || protectedHeader.crit.some((input) => typeof input !== "string" || input.length === 0)) {
-    throw new Err('"crit" (Critical) Header Parameter MUST be an array of non-empty strings when present');
-  }
-  let recognized;
-  if (recognizedOption !== void 0) {
-    recognized = new Map([...Object.entries(recognizedOption), ...recognizedDefault.entries()]);
-  } else {
-    recognized = recognizedDefault;
-  }
-  for (const parameter of protectedHeader.crit) {
-    if (!recognized.has(parameter)) {
-      throw new JOSENotSupported(`Extension Header Parameter "${parameter}" is not recognized`);
-    }
-    if (joseHeader[parameter] === void 0) {
-      throw new Err(`Extension Header Parameter "${parameter}" is missing`);
-    }
-    if (recognized.get(parameter) && protectedHeader[parameter] === void 0) {
-      throw new Err(`Extension Header Parameter "${parameter}" MUST be integrity protected`);
-    }
-  }
-  return new Set(protectedHeader.crit);
-};
-
-// node_modules/.pnpm/jose@6.0.11/node_modules/jose/dist/webapi/lib/validate_algorithms.js
-var validate_algorithms_default = (option, algorithms) => {
-  if (algorithms !== void 0 && (!Array.isArray(algorithms) || algorithms.some((s4) => typeof s4 !== "string"))) {
-    throw new TypeError(`"${option}" option must be an array of strings`);
-  }
-  if (!algorithms) {
-    return void 0;
-  }
-  return new Set(algorithms);
-};
-
-// node_modules/.pnpm/jose@6.0.11/node_modules/jose/dist/webapi/lib/is_jwk.js
-function isJWK(key) {
-  return is_object_default(key) && typeof key.kty === "string";
-}
-function isPrivateJWK(key) {
-  return key.kty !== "oct" && typeof key.d === "string";
-}
-function isPublicJWK(key) {
-  return key.kty !== "oct" && typeof key.d === "undefined";
-}
-function isSecretJWK(key) {
-  return key.kty === "oct" && typeof key.k === "string";
-}
-
-// node_modules/.pnpm/jose@6.0.11/node_modules/jose/dist/webapi/lib/normalize_key.js
-var cache;
-var handleJWK = async (key, jwk, alg, freeze = false) => {
-  cache ||= /* @__PURE__ */ new WeakMap();
-  let cached = cache.get(key);
-  if (cached?.[alg]) {
-    return cached[alg];
-  }
-  const cryptoKey = await jwk_to_key_default({ ...jwk, alg });
-  if (freeze)
-    Object.freeze(key);
-  if (!cached) {
-    cache.set(key, { [alg]: cryptoKey });
-  } else {
-    cached[alg] = cryptoKey;
-  }
-  return cryptoKey;
-};
-var handleKeyObject = (keyObject, alg) => {
-  cache ||= /* @__PURE__ */ new WeakMap();
-  let cached = cache.get(keyObject);
-  if (cached?.[alg]) {
-    return cached[alg];
-  }
-  const isPublic = keyObject.type === "public";
-  const extractable = isPublic ? true : false;
-  let cryptoKey;
-  if (keyObject.asymmetricKeyType === "x25519") {
-    switch (alg) {
-      case "ECDH-ES":
-      case "ECDH-ES+A128KW":
-      case "ECDH-ES+A192KW":
-      case "ECDH-ES+A256KW":
-        break;
-      default:
-        throw new TypeError("given KeyObject instance cannot be used for this algorithm");
-    }
-    cryptoKey = keyObject.toCryptoKey(keyObject.asymmetricKeyType, extractable, isPublic ? [] : ["deriveBits"]);
-  }
-  if (keyObject.asymmetricKeyType === "ed25519") {
-    if (alg !== "EdDSA" && alg !== "Ed25519") {
-      throw new TypeError("given KeyObject instance cannot be used for this algorithm");
-    }
-    cryptoKey = keyObject.toCryptoKey(keyObject.asymmetricKeyType, extractable, [
-      isPublic ? "verify" : "sign"
-    ]);
-  }
-  if (keyObject.asymmetricKeyType === "rsa") {
-    let hash;
-    switch (alg) {
-      case "RSA-OAEP":
-        hash = "SHA-1";
-        break;
-      case "RS256":
-      case "PS256":
-      case "RSA-OAEP-256":
-        hash = "SHA-256";
-        break;
-      case "RS384":
-      case "PS384":
-      case "RSA-OAEP-384":
-        hash = "SHA-384";
-        break;
-      case "RS512":
-      case "PS512":
-      case "RSA-OAEP-512":
-        hash = "SHA-512";
-        break;
-      default:
-        throw new TypeError("given KeyObject instance cannot be used for this algorithm");
-    }
-    if (alg.startsWith("RSA-OAEP")) {
-      return keyObject.toCryptoKey({
-        name: "RSA-OAEP",
-        hash
-      }, extractable, isPublic ? ["encrypt"] : ["decrypt"]);
-    }
-    cryptoKey = keyObject.toCryptoKey({
-      name: alg.startsWith("PS") ? "RSA-PSS" : "RSASSA-PKCS1-v1_5",
-      hash
-    }, extractable, [isPublic ? "verify" : "sign"]);
-  }
-  if (keyObject.asymmetricKeyType === "ec") {
-    const nist = /* @__PURE__ */ new Map([
-      ["prime256v1", "P-256"],
-      ["secp384r1", "P-384"],
-      ["secp521r1", "P-521"]
-    ]);
-    const namedCurve = nist.get(keyObject.asymmetricKeyDetails?.namedCurve);
-    if (!namedCurve) {
-      throw new TypeError("given KeyObject instance cannot be used for this algorithm");
-    }
-    if (alg === "ES256" && namedCurve === "P-256") {
-      cryptoKey = keyObject.toCryptoKey({
-        name: "ECDSA",
-        namedCurve
-      }, extractable, [isPublic ? "verify" : "sign"]);
-    }
-    if (alg === "ES384" && namedCurve === "P-384") {
-      cryptoKey = keyObject.toCryptoKey({
-        name: "ECDSA",
-        namedCurve
-      }, extractable, [isPublic ? "verify" : "sign"]);
-    }
-    if (alg === "ES512" && namedCurve === "P-521") {
-      cryptoKey = keyObject.toCryptoKey({
-        name: "ECDSA",
-        namedCurve
-      }, extractable, [isPublic ? "verify" : "sign"]);
-    }
-    if (alg.startsWith("ECDH-ES")) {
-      cryptoKey = keyObject.toCryptoKey({
-        name: "ECDH",
-        namedCurve
-      }, extractable, isPublic ? [] : ["deriveBits"]);
-    }
-  }
-  if (!cryptoKey) {
-    throw new TypeError("given KeyObject instance cannot be used for this algorithm");
-  }
-  if (!cached) {
-    cache.set(keyObject, { [alg]: cryptoKey });
-  } else {
-    cached[alg] = cryptoKey;
-  }
-  return cryptoKey;
-};
-var normalize_key_default = async (key, alg) => {
-  if (key instanceof Uint8Array) {
-    return key;
-  }
-  if (isCryptoKey(key)) {
-    return key;
-  }
-  if (isKeyObject(key)) {
-    if (key.type === "secret") {
-      return key.export();
-    }
-    if ("toCryptoKey" in key && typeof key.toCryptoKey === "function") {
-      try {
-        return handleKeyObject(key, alg);
-      } catch (err) {
-        if (err instanceof TypeError) {
-          throw err;
-        }
-      }
-    }
-    let jwk = key.export({ format: "jwk" });
-    return handleJWK(key, jwk, alg);
-  }
-  if (isJWK(key)) {
-    if (key.k) {
-      return decode(key.k);
-    }
-    return handleJWK(key, key, alg, true);
-  }
-  throw new Error("unreachable");
-};
-
-// node_modules/.pnpm/jose@6.0.11/node_modules/jose/dist/webapi/lib/check_key_type.js
-var tag = (key) => key?.[Symbol.toStringTag];
-var jwkMatchesOp = (alg, key, usage) => {
-  if (key.use !== void 0) {
-    let expected;
-    switch (usage) {
-      case "sign":
-      case "verify":
-        expected = "sig";
-        break;
-      case "encrypt":
-      case "decrypt":
-        expected = "enc";
-        break;
-    }
-    if (key.use !== expected) {
-      throw new TypeError(`Invalid key for this operation, its "use" must be "${expected}" when present`);
-    }
-  }
-  if (key.alg !== void 0 && key.alg !== alg) {
-    throw new TypeError(`Invalid key for this operation, its "alg" must be "${alg}" when present`);
-  }
-  if (Array.isArray(key.key_ops)) {
-    let expectedKeyOp;
-    switch (true) {
-      case (usage === "sign" || usage === "verify"):
-      case alg === "dir":
-      case alg.includes("CBC-HS"):
-        expectedKeyOp = usage;
-        break;
-      case alg.startsWith("PBES2"):
-        expectedKeyOp = "deriveBits";
-        break;
-      case /^A\d{3}(?:GCM)?(?:KW)?$/.test(alg):
-        if (!alg.includes("GCM") && alg.endsWith("KW")) {
-          expectedKeyOp = usage === "encrypt" ? "wrapKey" : "unwrapKey";
-        } else {
-          expectedKeyOp = usage;
-        }
-        break;
-      case (usage === "encrypt" && alg.startsWith("RSA")):
-        expectedKeyOp = "wrapKey";
-        break;
-      case usage === "decrypt":
-        expectedKeyOp = alg.startsWith("RSA") ? "unwrapKey" : "deriveBits";
-        break;
-    }
-    if (expectedKeyOp && key.key_ops?.includes?.(expectedKeyOp) === false) {
-      throw new TypeError(`Invalid key for this operation, its "key_ops" must include "${expectedKeyOp}" when present`);
-    }
-  }
-  return true;
-};
-var symmetricTypeCheck = (alg, key, usage) => {
-  if (key instanceof Uint8Array)
-    return;
-  if (isJWK(key)) {
-    if (isSecretJWK(key) && jwkMatchesOp(alg, key, usage))
-      return;
-    throw new TypeError(`JSON Web Key for symmetric algorithms must have JWK "kty" (Key Type) equal to "oct" and the JWK "k" (Key Value) present`);
-  }
-  if (!is_key_like_default(key)) {
-    throw new TypeError(withAlg(alg, key, "CryptoKey", "KeyObject", "JSON Web Key", "Uint8Array"));
-  }
-  if (key.type !== "secret") {
-    throw new TypeError(`${tag(key)} instances for symmetric algorithms must be of type "secret"`);
-  }
-};
-var asymmetricTypeCheck = (alg, key, usage) => {
-  if (isJWK(key)) {
-    switch (usage) {
-      case "decrypt":
-      case "sign":
-        if (isPrivateJWK(key) && jwkMatchesOp(alg, key, usage))
-          return;
-        throw new TypeError(`JSON Web Key for this operation be a private JWK`);
-      case "encrypt":
-      case "verify":
-        if (isPublicJWK(key) && jwkMatchesOp(alg, key, usage))
-          return;
-        throw new TypeError(`JSON Web Key for this operation be a public JWK`);
-    }
-  }
-  if (!is_key_like_default(key)) {
-    throw new TypeError(withAlg(alg, key, "CryptoKey", "KeyObject", "JSON Web Key"));
-  }
-  if (key.type === "secret") {
-    throw new TypeError(`${tag(key)} instances for asymmetric algorithms must not be of type "secret"`);
-  }
-  if (key.type === "public") {
-    switch (usage) {
-      case "sign":
-        throw new TypeError(`${tag(key)} instances for asymmetric algorithm signing must be of type "private"`);
-      case "decrypt":
-        throw new TypeError(`${tag(key)} instances for asymmetric algorithm decryption must be of type "private"`);
-      default:
-        break;
-    }
-  }
-  if (key.type === "private") {
-    switch (usage) {
-      case "verify":
-        throw new TypeError(`${tag(key)} instances for asymmetric algorithm verifying must be of type "public"`);
-      case "encrypt":
-        throw new TypeError(`${tag(key)} instances for asymmetric algorithm encryption must be of type "public"`);
-      default:
-        break;
-    }
-  }
-};
-var check_key_type_default = (alg, key, usage) => {
-  const symmetric = alg.startsWith("HS") || alg === "dir" || alg.startsWith("PBES2") || /^A(?:128|192|256)(?:GCM)?(?:KW)?$/.test(alg) || /^A(?:128|192|256)CBC-HS(?:256|384|512)$/.test(alg);
-  if (symmetric) {
-    symmetricTypeCheck(alg, key, usage);
-  } else {
-    asymmetricTypeCheck(alg, key, usage);
-  }
-};
-
-// node_modules/.pnpm/jose@6.0.11/node_modules/jose/dist/webapi/lib/subtle_dsa.js
-var subtle_dsa_default = (alg, algorithm) => {
-  const hash = `SHA-${alg.slice(-3)}`;
-  switch (alg) {
-    case "HS256":
-    case "HS384":
-    case "HS512":
-      return { hash, name: "HMAC" };
-    case "PS256":
-    case "PS384":
-    case "PS512":
-      return { hash, name: "RSA-PSS", saltLength: parseInt(alg.slice(-3), 10) >> 3 };
-    case "RS256":
-    case "RS384":
-    case "RS512":
-      return { hash, name: "RSASSA-PKCS1-v1_5" };
-    case "ES256":
-    case "ES384":
-    case "ES512":
-      return { hash, name: "ECDSA", namedCurve: algorithm.namedCurve };
-    case "Ed25519":
-    case "EdDSA":
-      return { name: "Ed25519" };
-    default:
-      throw new JOSENotSupported(`alg ${alg} is not supported either by JOSE or your javascript runtime`);
-  }
-};
-
-// node_modules/.pnpm/jose@6.0.11/node_modules/jose/dist/webapi/lib/get_sign_verify_key.js
-var get_sign_verify_key_default = async (alg, key, usage) => {
-  if (key instanceof Uint8Array) {
-    if (!alg.startsWith("HS")) {
-      throw new TypeError(invalid_key_input_default(key, "CryptoKey", "KeyObject", "JSON Web Key"));
-    }
-    return crypto.subtle.importKey("raw", key, { hash: `SHA-${alg.slice(-3)}`, name: "HMAC" }, false, [usage]);
-  }
-  checkSigCryptoKey(key, alg, usage);
-  return key;
-};
-
-// node_modules/.pnpm/jose@6.0.11/node_modules/jose/dist/webapi/lib/verify.js
-var verify_default = async (alg, key, signature, data) => {
-  const cryptoKey = await get_sign_verify_key_default(alg, key, "verify");
-  check_key_length_default(alg, cryptoKey);
-  const algorithm = subtle_dsa_default(alg, cryptoKey.algorithm);
-  try {
-    return await crypto.subtle.verify(algorithm, cryptoKey, signature, data);
-  } catch {
-    return false;
-  }
-};
-
-// node_modules/.pnpm/jose@6.0.11/node_modules/jose/dist/webapi/jws/flattened/verify.js
-async function flattenedVerify(jws, key, options) {
-  if (!is_object_default(jws)) {
-    throw new JWSInvalid("Flattened JWS must be an object");
-  }
-  if (jws.protected === void 0 && jws.header === void 0) {
-    throw new JWSInvalid('Flattened JWS must have either of the "protected" or "header" members');
-  }
-  if (jws.protected !== void 0 && typeof jws.protected !== "string") {
-    throw new JWSInvalid("JWS Protected Header incorrect type");
-  }
-  if (jws.payload === void 0) {
-    throw new JWSInvalid("JWS Payload missing");
-  }
-  if (typeof jws.signature !== "string") {
-    throw new JWSInvalid("JWS Signature missing or incorrect type");
-  }
-  if (jws.header !== void 0 && !is_object_default(jws.header)) {
-    throw new JWSInvalid("JWS Unprotected Header incorrect type");
-  }
-  let parsedProt = {};
-  if (jws.protected) {
-    try {
-      const protectedHeader = decode(jws.protected);
-      parsedProt = JSON.parse(decoder.decode(protectedHeader));
-    } catch {
-      throw new JWSInvalid("JWS Protected Header is invalid");
-    }
-  }
-  if (!is_disjoint_default(parsedProt, jws.header)) {
-    throw new JWSInvalid("JWS Protected and JWS Unprotected Header Parameter names must be disjoint");
-  }
-  const joseHeader = {
-    ...parsedProt,
-    ...jws.header
-  };
-  const extensions = validate_crit_default(JWSInvalid, /* @__PURE__ */ new Map([["b64", true]]), options?.crit, parsedProt, joseHeader);
-  let b64 = true;
-  if (extensions.has("b64")) {
-    b64 = parsedProt.b64;
-    if (typeof b64 !== "boolean") {
-      throw new JWSInvalid('The "b64" (base64url-encode payload) Header Parameter must be a boolean');
-    }
-  }
-  const { alg } = joseHeader;
-  if (typeof alg !== "string" || !alg) {
-    throw new JWSInvalid('JWS "alg" (Algorithm) Header Parameter missing or invalid');
-  }
-  const algorithms = options && validate_algorithms_default("algorithms", options.algorithms);
-  if (algorithms && !algorithms.has(alg)) {
-    throw new JOSEAlgNotAllowed('"alg" (Algorithm) Header Parameter value not allowed');
-  }
-  if (b64) {
-    if (typeof jws.payload !== "string") {
-      throw new JWSInvalid("JWS Payload must be a string");
-    }
-  } else if (typeof jws.payload !== "string" && !(jws.payload instanceof Uint8Array)) {
-    throw new JWSInvalid("JWS Payload must be a string or an Uint8Array instance");
-  }
-  let resolvedKey = false;
-  if (typeof key === "function") {
-    key = await key(parsedProt, jws);
-    resolvedKey = true;
-  }
-  check_key_type_default(alg, key, "verify");
-  const data = concat(encoder.encode(jws.protected ?? ""), encoder.encode("."), typeof jws.payload === "string" ? encoder.encode(jws.payload) : jws.payload);
-  let signature;
-  try {
-    signature = decode(jws.signature);
-  } catch {
-    throw new JWSInvalid("Failed to base64url decode the signature");
-  }
-  const k = await normalize_key_default(key, alg);
-  const verified = await verify_default(alg, k, signature, data);
-  if (!verified) {
-    throw new JWSSignatureVerificationFailed();
-  }
-  let payload;
-  if (b64) {
-    try {
-      payload = decode(jws.payload);
-    } catch {
-      throw new JWSInvalid("Failed to base64url decode the payload");
-    }
-  } else if (typeof jws.payload === "string") {
-    payload = encoder.encode(jws.payload);
-  } else {
-    payload = jws.payload;
-  }
-  const result = { payload };
-  if (jws.protected !== void 0) {
-    result.protectedHeader = parsedProt;
-  }
-  if (jws.header !== void 0) {
-    result.unprotectedHeader = jws.header;
-  }
-  if (resolvedKey) {
-    return { ...result, key: k };
-  }
-  return result;
-}
-
-// node_modules/.pnpm/jose@6.0.11/node_modules/jose/dist/webapi/jws/compact/verify.js
-async function compactVerify(jws, key, options) {
-  if (jws instanceof Uint8Array) {
-    jws = decoder.decode(jws);
-  }
-  if (typeof jws !== "string") {
-    throw new JWSInvalid("Compact JWS must be a string or Uint8Array");
-  }
-  const { 0: protectedHeader, 1: payload, 2: signature, length } = jws.split(".");
-  if (length !== 3) {
-    throw new JWSInvalid("Invalid Compact JWS");
-  }
-  const verified = await flattenedVerify({ payload, protected: protectedHeader, signature }, key, options);
-  const result = { payload: verified.payload, protectedHeader: verified.protectedHeader };
-  if (typeof key === "function") {
-    return { ...result, key: verified.key };
-  }
-  return result;
-}
-
-// node_modules/.pnpm/jose@6.0.11/node_modules/jose/dist/webapi/lib/epoch.js
-var epoch_default = (date) => Math.floor(date.getTime() / 1e3);
-
-// node_modules/.pnpm/jose@6.0.11/node_modules/jose/dist/webapi/lib/secs.js
-var minute = 60;
-var hour = minute * 60;
-var day = hour * 24;
-var week = day * 7;
-var year = day * 365.25;
-var REGEX = /^(\+|\-)? ?(\d+|\d+\.\d+) ?(seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)(?: (ago|from now))?$/i;
-var secs_default = (str) => {
-  const matched = REGEX.exec(str);
-  if (!matched || matched[4] && matched[1]) {
-    throw new TypeError("Invalid time period format");
-  }
-  const value = parseFloat(matched[2]);
-  const unit = matched[3].toLowerCase();
-  let numericDate;
-  switch (unit) {
-    case "sec":
-    case "secs":
-    case "second":
-    case "seconds":
-    case "s":
-      numericDate = Math.round(value);
-      break;
-    case "minute":
-    case "minutes":
-    case "min":
-    case "mins":
-    case "m":
-      numericDate = Math.round(value * minute);
-      break;
-    case "hour":
-    case "hours":
-    case "hr":
-    case "hrs":
-    case "h":
-      numericDate = Math.round(value * hour);
-      break;
-    case "day":
-    case "days":
-    case "d":
-      numericDate = Math.round(value * day);
-      break;
-    case "week":
-    case "weeks":
-    case "w":
-      numericDate = Math.round(value * week);
-      break;
-    default:
-      numericDate = Math.round(value * year);
-      break;
-  }
-  if (matched[1] === "-" || matched[4] === "ago") {
-    return -numericDate;
-  }
-  return numericDate;
-};
-
-// node_modules/.pnpm/jose@6.0.11/node_modules/jose/dist/webapi/lib/jwt_claims_set.js
-var normalizeTyp = (value) => {
-  if (value.includes("/")) {
-    return value.toLowerCase();
-  }
-  return `application/${value.toLowerCase()}`;
-};
-var checkAudiencePresence = (audPayload, audOption) => {
-  if (typeof audPayload === "string") {
-    return audOption.includes(audPayload);
-  }
-  if (Array.isArray(audPayload)) {
-    return audOption.some(Set.prototype.has.bind(new Set(audPayload)));
-  }
-  return false;
-};
-function validateClaimsSet(protectedHeader, encodedPayload, options = {}) {
-  let payload;
-  try {
-    payload = JSON.parse(decoder.decode(encodedPayload));
-  } catch {
-  }
-  if (!is_object_default(payload)) {
-    throw new JWTInvalid("JWT Claims Set must be a top-level JSON object");
-  }
-  const { typ } = options;
-  if (typ && (typeof protectedHeader.typ !== "string" || normalizeTyp(protectedHeader.typ) !== normalizeTyp(typ))) {
-    throw new JWTClaimValidationFailed('unexpected "typ" JWT header value', payload, "typ", "check_failed");
-  }
-  const { requiredClaims = [], issuer, subject, audience, maxTokenAge } = options;
-  const presenceCheck = [...requiredClaims];
-  if (maxTokenAge !== void 0)
-    presenceCheck.push("iat");
-  if (audience !== void 0)
-    presenceCheck.push("aud");
-  if (subject !== void 0)
-    presenceCheck.push("sub");
-  if (issuer !== void 0)
-    presenceCheck.push("iss");
-  for (const claim of new Set(presenceCheck.reverse())) {
-    if (!(claim in payload)) {
-      throw new JWTClaimValidationFailed(`missing required "${claim}" claim`, payload, claim, "missing");
-    }
-  }
-  if (issuer && !(Array.isArray(issuer) ? issuer : [issuer]).includes(payload.iss)) {
-    throw new JWTClaimValidationFailed('unexpected "iss" claim value', payload, "iss", "check_failed");
-  }
-  if (subject && payload.sub !== subject) {
-    throw new JWTClaimValidationFailed('unexpected "sub" claim value', payload, "sub", "check_failed");
-  }
-  if (audience && !checkAudiencePresence(payload.aud, typeof audience === "string" ? [audience] : audience)) {
-    throw new JWTClaimValidationFailed('unexpected "aud" claim value', payload, "aud", "check_failed");
-  }
-  let tolerance;
-  switch (typeof options.clockTolerance) {
-    case "string":
-      tolerance = secs_default(options.clockTolerance);
-      break;
-    case "number":
-      tolerance = options.clockTolerance;
-      break;
-    case "undefined":
-      tolerance = 0;
-      break;
-    default:
-      throw new TypeError("Invalid clockTolerance option type");
-  }
-  const { currentDate } = options;
-  const now = epoch_default(currentDate || /* @__PURE__ */ new Date());
-  if ((payload.iat !== void 0 || maxTokenAge) && typeof payload.iat !== "number") {
-    throw new JWTClaimValidationFailed('"iat" claim must be a number', payload, "iat", "invalid");
-  }
-  if (payload.nbf !== void 0) {
-    if (typeof payload.nbf !== "number") {
-      throw new JWTClaimValidationFailed('"nbf" claim must be a number', payload, "nbf", "invalid");
-    }
-    if (payload.nbf > now + tolerance) {
-      throw new JWTClaimValidationFailed('"nbf" claim timestamp check failed', payload, "nbf", "check_failed");
-    }
-  }
-  if (payload.exp !== void 0) {
-    if (typeof payload.exp !== "number") {
-      throw new JWTClaimValidationFailed('"exp" claim must be a number', payload, "exp", "invalid");
-    }
-    if (payload.exp <= now - tolerance) {
-      throw new JWTExpired('"exp" claim timestamp check failed', payload, "exp", "check_failed");
-    }
-  }
-  if (maxTokenAge) {
-    const age = now - payload.iat;
-    const max = typeof maxTokenAge === "number" ? maxTokenAge : secs_default(maxTokenAge);
-    if (age - tolerance > max) {
-      throw new JWTExpired('"iat" claim timestamp check failed (too far in the past)', payload, "iat", "check_failed");
-    }
-    if (age < 0 - tolerance) {
-      throw new JWTClaimValidationFailed('"iat" claim timestamp check failed (it should be in the past)', payload, "iat", "check_failed");
-    }
-  }
-  return payload;
-}
-
-// node_modules/.pnpm/jose@6.0.11/node_modules/jose/dist/webapi/jwt/verify.js
-async function jwtVerify(jwt, key, options) {
-  const verified = await compactVerify(jwt, key, options);
-  if (verified.protectedHeader.crit?.includes("b64") && verified.protectedHeader.b64 === false) {
-    throw new JWTInvalid("JWTs MUST NOT use unencoded payload");
-  }
-  const payload = validateClaimsSet(verified.protectedHeader, verified.payload, options);
-  const result = { payload, protectedHeader: verified.protectedHeader };
-  if (typeof key === "function") {
-    return { ...result, key: verified.key };
-  }
-  return result;
-}
-
 // src/auth.ts
+import ky2 from "ky";
+import * as jose from "jose";
 var GRANT_TYPE = "authorization_code";
 var TOKEN_ENDPOINT = "https://login.bigcommerce.com/oauth2/token";
 var ISSUER = "bc";
 var BigCommerceAuth = class {
   /**
-   * Creates a new BigCommerceAuth instance
+   * Creates a new BigCommerceAuth instance for handling OAuth authentication
    * @param config - Configuration options for BigCommerce authentication
+   * @param config.clientId - The OAuth client ID from BigCommerce
+   * @param config.secret - The OAuth client secret from BigCommerce
+   * @param config.redirectUri - The redirect URI registered with BigCommerce
+   * @param config.scopes - Optional array of scopes to validate during auth callback
+   * @param config.logger - Optional logger instance for debugging and error tracking
    * @throws {Error} If the redirect URI is invalid
    */
   constructor(config) {
     this.config = config;
     try {
-      URL.parse(this.config.redirectUri);
+      new URL(this.config.redirectUri);
     } catch (error) {
       throw new Error("Invalid redirect URI", { cause: error });
     }
   }
   /**
    * Requests an access token from BigCommerce
-   * @param data - Either a query string or AuthQuery object containing auth callback data
+   * @param data - Either a query string, URLSearchParams, or AuthQuery object containing auth callback data
    * @returns Promise resolving to the token response
    */
   async requestToken(data) {
-    const query = typeof data === "string" ? this.parseQueryString(data) : data;
+    const query = typeof data === "string" || data instanceof URLSearchParams ? this.parseQueryString(data) : data;
     const tokenRequest = {
       client_id: this.config.clientId,
       client_secret: this.config.secret,
@@ -2124,27 +535,44 @@ var BigCommerceAuth = class {
       grant_type: GRANT_TYPE,
       redirect_uri: this.config.redirectUri
     };
-    return await distribution_default(TOKEN_ENDPOINT, {
+    this.config.logger?.debug({
+      clientId: this.config.clientId,
+      context: query.context,
+      scopes: query.scope
+    }, "Requesting OAuth token");
+    const res = await ky2(TOKEN_ENDPOINT, {
       method: "POST",
       json: tokenRequest
-    }).json();
+    });
+    return res.json();
   }
   /**
    * Verifies a JWT payload from BigCommerce
    * @param jwtPayload - The JWT string to verify
+   * @param storeHash - The store hash for the BigCommerce store
    * @returns Promise resolving to the verified JWT claims
    * @throws {Error} If the JWT is invalid
    */
-  async verify(jwtPayload) {
+  async verify(jwtPayload, storeHash) {
     try {
       const secret = new TextEncoder().encode(this.config.secret);
-      const { payload } = await jwtVerify(jwtPayload, secret, {
+      const { payload } = await jose.jwtVerify(jwtPayload, secret, {
         audience: this.config.clientId,
         issuer: ISSUER,
-        subject: `stores/${this.config.storeHash}`
+        subject: `stores/${storeHash}`
       });
+      this.config.logger?.debug({
+        userId: payload.user?.id,
+        storeHash: payload.sub.split("/")[1]
+      }, "JWT verified successfully");
       return payload;
     } catch (error) {
+      this.config.logger?.error({
+        error: error instanceof Error ? {
+          name: error.name,
+          message: error.message
+        } : error
+      });
       throw new Error("Invalid JWT payload", { cause: error });
     }
   }
@@ -2155,7 +583,7 @@ var BigCommerceAuth = class {
    * @throws {Error} If required parameters are missing or scopes are invalid
    */
   parseQueryString(queryString) {
-    const params = new URLSearchParams(queryString);
+    const params = typeof queryString === "string" ? new URLSearchParams(queryString) : queryString;
     const code = params.get("code");
     const scope = params.get("scope");
     const context = params.get("context");
@@ -2187,22 +615,20 @@ var BigCommerceAuth = class {
    * @throws {Error} If the scopes don't match the expected scopes
    */
   validateScopes(scopes) {
-    const scopesArray = scopes.split(" ");
-    if (this.config.scopes?.length) {
-      const int = s2(scopesArray, this.config.scopes);
-      if (int.length !== scopesArray.length) {
-        throw new Error(`Scope mismatch: ${scopes}; expected: ${this.config.scopes.join(" ")}`);
-      }
+    if (!this.config.scopes) {
+      return;
+    }
+    const grantedScopes = scopes.split(" ");
+    const requiredScopes = this.config.scopes;
+    const missingScopes = requiredScopes.filter((scope) => !grantedScopes.includes(scope));
+    if (missingScopes.length) {
+      throw new Error(`Scope mismatch: ${scopes}; expected: ${this.config.scopes.join(" ")}`);
     }
   }
 };
 export {
   BigCommerceAuth,
-  BigCommerceClient
+  BigCommerceClient,
+  Methods
 };
-/*! Bundled license information:
-
-ky/distribution/index.js:
-  (*! MIT License © Sindre Sorhus *)
-*/
 //# sourceMappingURL=index.js.map