hanzio 1.0.3 → 1.0.6

package/dist/src/index.js

@@ -0,0 +1,1967 @@
+// src/zod/index.ts
+import { z as z3 } from "zod";
+
+// src/zod/jsonToZodSchemaMapper.ts
+import { z } from "zod";
+function jsonToZodSchemaMapper(jsonObject, zodSchema, config) {
+  const result = {};
+  const shape = zodSchema instanceof z.ZodObject ? zodSchema.shape : {};
+  for (const key of Object.keys(shape)) {
+    const fieldConfig = config[key];
+    let value = jsonObject[key];
+    if (fieldConfig) {
+      value = fieldConfig(jsonObject);
+    }
+    if (shape[key] instanceof z.ZodObject && value && typeof value === "object") {
+      result[key] = jsonToZodSchemaMapper(value, shape[key], config[key] || {});
+    } else {
+      result[key] = value;
+    }
+  }
+  return zodSchema.parse(result);
+}
+// src/zod/zodMinMaxFilter.ts
+import { z as z2 } from "zod";
+var zodMinMaxFilter = z2.object({
+  min: z2.number().optional(),
+  max: z2.number().optional()
+});
+function toGteLteFilter(filter) {
+  if (!filter)
+    return;
+  const hasMin = filter.min !== undefined;
+  const hasMax = filter.max !== undefined;
+  if (!hasMin && !hasMax)
+    return;
+  return {
+    ...hasMin && { gte: filter.min },
+    ...hasMax && { lte: filter.max }
+  };
+}
+// src/zod/zodToTypeString.ts
+function getDefProp(def, prop) {
+  return def?.[prop];
+}
+function zodToTypeString(schema, indent = 0) {
+  const pad = "  ".repeat(indent);
+  const innerPad = "  ".repeat(indent + 1);
+  const def = schema._zod?.def ?? schema._def;
+  if (!def)
+    return "unknown";
+  const schemaType = getDefProp(def, "type") ?? getDefProp(def, "typeName");
+  switch (schemaType) {
+    case "object": {
+      const shape = getDefProp(def, "shape");
+      if (!shape || Object.keys(shape).length === 0)
+        return "{}";
+      const fields = Object.entries(shape).map(([key, value]) => {
+        const valueType = getDefProp(value._zod?.def ?? value._def, "type");
+        const isOptional = valueType === "optional";
+        const innerSchema = isOptional ? getDefProp(value._zod?.def ?? value._def, "innerType") ?? value : value;
+        const typeStr = zodToTypeString(innerSchema, indent + 1);
+        return `${innerPad}${key}${isOptional ? "?" : ""}: ${typeStr}`;
+      });
+      return `{
+${fields.join(`
+`)}
+${pad}}`;
+    }
+    case "array": {
+      const itemType = getDefProp(def, "element") ?? getDefProp(def, "type");
+      return itemType ? `${zodToTypeString(itemType, indent)}[]` : "unknown[]";
+    }
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "date":
+      return "Date";
+    case "null":
+      return "null";
+    case "undefined":
+      return "undefined";
+    case "any":
+      return "any";
+    case "unknown":
+      return "unknown";
+    case "record": {
+      const valueType = getDefProp(def, "valueType");
+      return valueType ? `Record<string, ${zodToTypeString(valueType, indent)}>` : "Record<string, unknown>";
+    }
+    case "enum": {
+      const values = getDefProp(def, "values");
+      return values ? values.map((v) => `"${v}"`).join(" | ") : "string";
+    }
+    case "literal": {
+      const value = getDefProp(def, "value");
+      return typeof value === "string" ? `"${value}"` : String(value);
+    }
+    case "union": {
+      const options = getDefProp(def, "options");
+      return options ? options.map((o) => zodToTypeString(o, indent)).join(" | ") : "unknown";
+    }
+    case "optional": {
+      const inner = getDefProp(def, "innerType");
+      return inner ? `${zodToTypeString(inner, indent)} | undefined` : "unknown";
+    }
+    case "nullable": {
+      const inner = getDefProp(def, "innerType");
+      return inner ? `${zodToTypeString(inner, indent)} | null` : "unknown";
+    }
+    case "default": {
+      const inner = getDefProp(def, "innerType");
+      return inner ? zodToTypeString(inner, indent) : "unknown";
+    }
+    case "ZodObject":
+    case "ZodArray":
+    case "ZodString":
+    case "ZodNumber":
+    case "ZodBoolean":
+    case "ZodDate":
+    case "ZodNull":
+    case "ZodUndefined":
+    case "ZodAny":
+    case "ZodUnknown":
+    case "ZodRecord":
+    case "ZodEnum":
+    case "ZodLiteral":
+    case "ZodUnion":
+    case "ZodOptional":
+    case "ZodNullable":
+    case "ZodDefault":
+      return zodToTypeString(schema, indent);
+    default:
+      return "unknown";
+  }
+}
+function zodToExample(schema) {
+  const def = schema._zod?.def ?? schema._def;
+  if (!def)
+    return null;
+  const schemaType = getDefProp(def, "type") ?? getDefProp(def, "typeName");
+  switch (schemaType) {
+    case "object": {
+      const shape = getDefProp(def, "shape");
+      if (!shape)
+        return {};
+      const result = {};
+      for (const [key, value] of Object.entries(shape)) {
+        const valueType = getDefProp(value._zod?.def ?? value._def, "type");
+        const isOptional = valueType === "optional";
+        if (!isOptional) {
+          result[key] = zodToExample(value);
+        }
+      }
+      return result;
+    }
+    case "array": {
+      const itemType = getDefProp(def, "element") ?? getDefProp(def, "type");
+      return itemType ? [zodToExample(itemType)] : [];
+    }
+    case "string":
+      return "";
+    case "number":
+      return 0;
+    case "boolean":
+      return false;
+    case "enum": {
+      const values = getDefProp(def, "values");
+      return values?.[0] ?? "";
+    }
+    case "literal":
+      return getDefProp(def, "value");
+    case "optional":
+    case "default": {
+      const inner = getDefProp(def, "innerType");
+      return inner ? zodToExample(inner) : null;
+    }
+    case "record":
+      return {};
+    default:
+      return null;
+  }
+}
+
+// src/zod/index.ts
+function createZId(typeName) {
+  return z3.string().min(1, `${typeName} ID is required`).brand();
+}
+function zSingleOrArray(schema) {
+  return z3.union([z3.array(schema), schema]);
+}
+function normalizeSingleOrArray(value) {
+  if (value == null)
+    return [];
+  if (Array.isArray(value))
+    return [...value];
+  return [value];
+}
+
+// src/api-wrapper/index.ts
+import { ZodError } from "zod";
+
+class ResponseValidationError extends Error {
+  zodError;
+  rawResponse;
+  validationIssues;
+  constructor(zodError, rawResponse) {
+    const issues = zodError.issues.map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`).join("; ");
+    super(`Response validation failed: ${issues}`);
+    this.name = "ResponseValidationError";
+    this.zodError = zodError;
+    this.rawResponse = rawResponse;
+    this.validationIssues = issues;
+  }
+}
+
+class HttpResponseError extends Error {
+  status;
+  body;
+  constructor(status, body) {
+    super(`HTTP error: ${status} - ${body}`);
+    this.name = "HttpResponseError";
+    this.status = status;
+    this.body = body;
+  }
+}
+function createApiClient(apiConfig) {
+  const request = async (endpointKey, input = {}) => {
+    const endpoint = apiConfig.endpoints[endpointKey];
+    if (!endpoint) {
+      throw new Error(`Unknown API endpoint: ${String(endpointKey)}`);
+    }
+    const { finalUrl, fullUrl } = buildUrl(endpoint, input.reqParams, input.reqQuery, apiConfig.baseApiUrls, apiConfig.defaultBaseApiUrl, input.url);
+    const endpointName = apiConfig.name ? `${apiConfig.name}.${String(endpointKey)}` : String(endpointKey);
+    const startedAt = Date.now();
+    let retryCount = 0;
+    let httpStatus = 0;
+    apiConfig.onRequestStart?.({ endpoint: endpointName, url: fullUrl });
+    try {
+      const config = {
+        method: endpoint.method,
+        url: finalUrl,
+        queryParams: buildQueryParams(endpoint, input.reqQuery),
+        body: buildRequestBody(endpoint, input.reqBody),
+        headers: buildHeaders(endpoint, input.reqHeaders, apiConfig.defaultHeaders ?? {}),
+        doNotEncodeQueryParams: endpoint.doNotEncodeQueryParams,
+        timeoutMs: apiConfig.timeoutMs,
+        fetchFn: apiConfig.fetch ?? fetch
+      };
+      const result = await makeRequestWithRetry(config, apiConfig.retries ?? 3, apiConfig.retryDelayMs ?? 300, (response) => validateAndTransformResponse(endpoint, response), apiConfig.shouldRetry ?? defaultShouldRetry, apiConfig.logger);
+      retryCount = result.retryCount;
+      httpStatus = result.httpStatus;
+      const responseTimeMs = Date.now() - startedAt;
+      const responseSizeMb = calculateSizeInMb(result.validatedData);
+      const requestSizeMb = calculateSizeInMb({
+        method: config.method,
+        url: fullUrl,
+        body: config.body,
+        headers: config.headers
+      });
+      apiConfig.onRequestEnd?.({
+        endpoint: endpointName,
+        url: fullUrl,
+        status: httpStatus,
+        retryCount,
+        responseTimeMs
+      });
+      return {
+        data: result.validatedData,
+        requestSizeMb,
+        responseSizeMb,
+        requestSizeTotalMb: requestSizeMb + responseSizeMb,
+        responseTimeMs,
+        httpStatus,
+        retryCount
+      };
+    } catch (error) {
+      apiConfig.logger?.error?.(error);
+      throw error;
+    }
+  };
+  return { request };
+}
+var createApiWrapper = createApiClient;
+async function validateResponse(schema, data) {
+  try {
+    return await schema.parseAsync(data);
+  } catch (error) {
+    if (error instanceof ZodError) {
+      throw new ResponseValidationError(error, data);
+    }
+    throw error;
+  }
+}
+async function httpRequest(config) {
+  const queryString = config.doNotEncodeQueryParams ? Object.entries(config.queryParams).map(([key, value]) => `${key}=${value}`).join("&") : new URLSearchParams(config.queryParams).toString();
+  const fullUrl = queryString ? `${config.url}?${queryString}` : config.url;
+  const abortController = new AbortController;
+  const timeout = config.timeoutMs === undefined ? undefined : setTimeout(() => abortController.abort(), config.timeoutMs);
+  try {
+    return await config.fetchFn(fullUrl, {
+      method: config.method,
+      headers: config.headers,
+      body: buildFetchBody(config.body, config.headers),
+      signal: abortController.signal
+    });
+  } finally {
+    if (timeout)
+      clearTimeout(timeout);
+  }
+}
+async function makeRequestWithRetry(config, maxRetries, retryDelayMs, validateFn, shouldRetry, logger) {
+  let retryCount = 0;
+  while (true) {
+    try {
+      logger?.debug?.("API request", config);
+      const response = await httpRequest(config);
+      if (response.status >= 400) {
+        if (retryCount < maxRetries && shouldRetry({ response, retryCount, maxRetries })) {
+          retryCount++;
+          await delay(retryDelayMs);
+          continue;
+        }
+        throw new HttpResponseError(response.status, await response.text());
+      }
+      return {
+        validatedData: await validateFn(response),
+        retryCount,
+        httpStatus: response.status
+      };
+    } catch (error) {
+      if (error instanceof HttpResponseError)
+        throw error;
+      if (retryCount >= maxRetries || !shouldRetry({ error, retryCount, maxRetries })) {
+        throw error;
+      }
+      retryCount++;
+      await delay(retryDelayMs);
+    }
+  }
+}
+async function validateAndTransformResponse(endpoint, response) {
+  const responseHeaders = getHeadersAsObject(response.headers);
+  const contentType = responseHeaders["content-type"] ?? "";
+  const responseData = contentType.includes("application/json") ? await response.json() : await response.text();
+  const transformedData = endpoint.resFormatter ? endpoint.resFormatter(responseData, responseHeaders) : responseData;
+  return validateResponse(endpoint.resSchema, transformedData);
+}
+function buildUrl(endpoint, params, reqQuery, baseApiUrls, defaultBaseApiUrl, url) {
+  if (url) {
+    const finalUrl2 = replacePathParams(url, params);
+    const queryString2 = new URLSearchParams(buildQueryParams(endpoint, reqQuery)).toString();
+    return {
+      finalUrl: finalUrl2,
+      fullUrl: queryString2 ? `${finalUrl2}?${queryString2}` : finalUrl2
+    };
+  }
+  const defaultBaseUrl = defaultBaseApiUrl ?? Object.keys(baseApiUrls)[0];
+  if (!defaultBaseUrl) {
+    throw new Error("At least one base API URL is required");
+  }
+  const baseUrlKey = endpoint.baseApiUrl ?? defaultBaseUrl;
+  const configBaseUrl = baseApiUrls[baseUrlKey];
+  if (!configBaseUrl) {
+    throw new Error(`Unknown base API URL: ${baseUrlKey}`);
+  }
+  const baseUrl = typeof configBaseUrl === "function" ? configBaseUrl() : configBaseUrl;
+  const path = typeof endpoint.path === "function" ? endpoint.path(baseUrl) : endpoint.path;
+  const finalUrl = replacePathParams(`${baseUrl}${path}`, params);
+  const queryString = new URLSearchParams(buildQueryParams(endpoint, reqQuery)).toString();
+  return {
+    finalUrl,
+    fullUrl: queryString ? `${finalUrl}?${queryString}` : finalUrl
+  };
+}
+function buildQueryParams(endpoint, query) {
+  const defaultParams = endpoint.reqDefaultQueryParams ?? {};
+  const parsedQuery = endpoint.reqQuerySchema ? endpoint.reqQuerySchema.parse(query) : query ?? {};
+  const merged = { ...defaultParams, ...parsedQuery };
+  return Object.fromEntries(Object.entries(merged).filter(([, value]) => value !== undefined).map(([key, value]) => [key, String(value)]));
+}
+function buildRequestBody(endpoint, body) {
+  if (!endpoint.reqBodySchema)
+    return body;
+  const parsedBody = endpoint.reqBodySchema.parse(body);
+  if (endpoint.reqBodyFormat !== "form-data") {
+    return parsedBody;
+  }
+  const formData = new FormData;
+  for (const [key, value] of Object.entries(parsedBody)) {
+    if (value == null)
+      continue;
+    formData.set(key, value instanceof Blob ? value : String(value));
+  }
+  return formData;
+}
+function buildHeaders(endpoint, headers, defaultHeaders) {
+  const contentType = endpoint.reqBodyFormat === "json" ? "application/json" : undefined;
+  const parsedHeaders = endpoint.reqHeadersSchema ? endpoint.reqHeadersSchema.parse(headers) : headers ?? {};
+  return {
+    ...defaultHeaders,
+    ...contentType && { "Content-Type": contentType },
+    ...endpoint.defaultHeaders,
+    ...parsedHeaders
+  };
+}
+function buildFetchBody(body, headers) {
+  if (body === undefined || body === null)
+    return;
+  if (body instanceof FormData || body instanceof Blob)
+    return body;
+  if (headers["Content-Type"] === "application/json")
+    return JSON.stringify(body);
+  return body;
+}
+function replacePathParams(path, params) {
+  return path.replace(/:(\w+)/g, (_, key) => {
+    const value = params?.[key];
+    if (value === undefined) {
+      throw new Error(`Missing required path parameter: ${key}`);
+    }
+    return encodeURIComponent(String(value));
+  });
+}
+function getHeadersAsObject(headers) {
+  const result = {};
+  headers.forEach((value, key) => {
+    result[key] = value;
+  });
+  return result;
+}
+function calculateSizeInMb(data) {
+  const sizeInBytes = new TextEncoder().encode(JSON.stringify(data)).length;
+  return sizeInBytes / (1024 * 1024);
+}
+function defaultShouldRetry({ error, response }) {
+  if (error)
+    return true;
+  return response ? response.status >= 500 : false;
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/p-queue/index.ts
+class TimeoutError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TimeoutError";
+  }
+}
+
+class PriorityQueue {
+  #queue = [];
+  enqueue(run, options = {}) {
+    const element = {
+      priority: options.priority ?? 0,
+      id: options.id,
+      run
+    };
+    const index = this.#queue.findIndex((item) => item.priority < element.priority);
+    if (index === -1) {
+      this.#queue.push(element);
+      return;
+    }
+    this.#queue.splice(index, 0, element);
+  }
+  dequeue() {
+    return this.#queue.shift()?.run;
+  }
+  filter(options) {
+    return this.#queue.filter((item) => Object.entries(options).every(([key, value]) => item[key] === value)).map((item) => item.run);
+  }
+  setPriority(id, priority) {
+    const index = this.#queue.findIndex((item2) => item2.id === id);
+    if (index === -1) {
+      throw new ReferenceError(`No promise function with the id "${id}" exists in the queue.`);
+    }
+    const [item] = this.#queue.splice(index, 1);
+    this.enqueue(item.run, { ...item, priority });
+  }
+  remove(id) {
+    const index = this.#queue.findIndex((item) => item.id === id);
+    if (index !== -1) {
+      this.#queue.splice(index, 1);
+    }
+  }
+  get size() {
+    return this.#queue.length;
+  }
+}
+
+class PQueue {
+  #listeners = new Map;
+  #queue;
+  #queueClass;
+  #pending = 0;
+  #concurrency;
+  #isPaused;
+  #intervalCap;
+  #interval;
+  #carryoverIntervalCount;
+  #strict;
+  #intervalCount = 0;
+  #intervalEnd = 0;
+  #intervalTimer;
+  #strictTimestamps = [];
+  #rateLimited = false;
+  #idCounter = 1n;
+  #runningTasks = new Map;
+  timeout;
+  constructor(options = {}) {
+    const {
+      concurrency = Number.POSITIVE_INFINITY,
+      autoStart = true,
+      queueClass = PriorityQueue,
+      intervalCap = Number.POSITIVE_INFINITY,
+      interval = 0,
+      carryoverIntervalCount,
+      carryoverConcurrencyCount,
+      strict = false,
+      timeout
+    } = options;
+    if (!(typeof concurrency === "number" && concurrency >= 1)) {
+      throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+    }
+    if (!(typeof intervalCap === "number" && intervalCap >= 1)) {
+      throw new TypeError("Expected `intervalCap` to be a number from 1 and up");
+    }
+    if (!(typeof interval === "number" && Number.isFinite(interval) && interval >= 0)) {
+      throw new TypeError("Expected `interval` to be a finite number >= 0");
+    }
+    if (strict && interval === 0) {
+      throw new TypeError("The `strict` option requires a non-zero `interval`");
+    }
+    if (strict && intervalCap === Number.POSITIVE_INFINITY) {
+      throw new TypeError("The `strict` option requires a finite `intervalCap`");
+    }
+    if (timeout !== undefined && !(Number.isFinite(timeout) && timeout > 0)) {
+      throw new TypeError("Expected `timeout` to be a positive finite number");
+    }
+    this.#queueClass = queueClass;
+    this.#queue = new queueClass;
+    this.#concurrency = concurrency;
+    this.#isPaused = !autoStart;
+    this.#intervalCap = intervalCap;
+    this.#interval = interval;
+    this.#carryoverIntervalCount = carryoverIntervalCount ?? carryoverConcurrencyCount ?? false;
+    this.#strict = strict;
+    this.timeout = timeout;
+  }
+  on(event, listener) {
+    const listeners = this.#listeners.get(event) ?? new Set;
+    listeners.add(listener);
+    this.#listeners.set(event, listeners);
+    return this;
+  }
+  off(event, listener) {
+    this.#listeners.get(event)?.delete(listener);
+    return this;
+  }
+  emit(event, ...arguments_) {
+    const listeners = this.#listeners.get(event);
+    if (!listeners || listeners.size === 0) {
+      return false;
+    }
+    for (const listener of [...listeners]) {
+      listener(...arguments_);
+    }
+    return true;
+  }
+  get concurrency() {
+    return this.#concurrency;
+  }
+  set concurrency(newConcurrency) {
+    if (!(typeof newConcurrency === "number" && newConcurrency >= 1)) {
+      throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+    }
+    this.#concurrency = newConcurrency;
+    this.#processQueue();
+  }
+  get size() {
+    return this.#queue.size;
+  }
+  sizeBy(options) {
+    return this.#queue.filter(options).length;
+  }
+  get pending() {
+    return this.#pending;
+  }
+  get isPaused() {
+    return this.#isPaused;
+  }
+  get isRateLimited() {
+    this.#updateRateLimitState();
+    return this.#rateLimited;
+  }
+  get isSaturated() {
+    return this.#pending >= this.#concurrency && this.#queue.size > 0 || this.isRateLimited && this.#queue.size > 0;
+  }
+  get runningTasks() {
+    return [...this.#runningTasks.values()].map((task) => ({ ...task }));
+  }
+  setPriority(id, priority) {
+    if (typeof priority !== "number" || !Number.isFinite(priority)) {
+      throw new TypeError("Expected `priority` to be a finite number");
+    }
+    this.#queue.setPriority(id, priority);
+  }
+  async add(function_, options = {}) {
+    const taskOptions = {
+      timeout: this.timeout,
+      ...options,
+      id: options.id ?? (this.#idCounter++).toString()
+    };
+    return new Promise((resolve, reject) => {
+      const taskSymbol = Symbol(taskOptions.id);
+      let didRun = false;
+      let queuedAbortHandler;
+      let runningAbortHandler;
+      const cleanupQueuedAbort = () => {
+        if (queuedAbortHandler) {
+          taskOptions.signal?.removeEventListener("abort", queuedAbortHandler);
+          queuedAbortHandler = undefined;
+        }
+      };
+      const run = async () => {
+        didRun = true;
+        cleanupQueuedAbort();
+        this.#pending++;
+        this.#runningTasks.set(taskSymbol, {
+          id: taskOptions.id,
+          priority: taskOptions.priority ?? 0,
+          startTime: Date.now(),
+          timeout: taskOptions.timeout
+        });
+        try {
+          taskOptions.signal?.throwIfAborted();
+          const operation = Promise.resolve(function_({ signal: taskOptions.signal }));
+          const result = await this.#withTimeoutAndAbort(operation, taskOptions, (listener) => {
+            runningAbortHandler = listener;
+          });
+          resolve(result);
+          this.emit("completed", result);
+        } catch (error) {
+          reject(error);
+          this.emit("error", error);
+        } finally {
+          if (runningAbortHandler) {
+            taskOptions.signal?.removeEventListener("abort", runningAbortHandler);
+          }
+          this.#runningTasks.delete(taskSymbol);
+          queueMicrotask(() => {
+            this.#next();
+          });
+        }
+      };
+      if (taskOptions.signal?.aborted) {
+        reject(taskOptions.signal.reason);
+        return;
+      }
+      if (taskOptions.signal) {
+        queuedAbortHandler = () => {
+          if (didRun) {
+            return;
+          }
+          this.#queue.remove?.(taskOptions.id);
+          reject(taskOptions.signal?.reason);
+          this.emit("next");
+          this.#tryToStartAnother();
+        };
+        taskOptions.signal.addEventListener("abort", queuedAbortHandler, {
+          once: true
+        });
+      }
+      this.#queue.enqueue(run, taskOptions);
+      this.emit("add");
+      this.#processQueue();
+    });
+  }
+  async addAll(functions, options) {
+    return Promise.all(functions.map(async (function_) => this.add(function_, options)));
+  }
+  start() {
+    if (!this.#isPaused) {
+      return this;
+    }
+    this.#isPaused = false;
+    this.#processQueue();
+    return this;
+  }
+  pause() {
+    this.#isPaused = true;
+  }
+  clear() {
+    this.#queue = new this.#queueClass;
+    this.#clearIntervalTimer();
+    this.#updateRateLimitState();
+    this.emit("empty");
+    if (this.#pending === 0) {
+      this.emit("idle");
+    }
+    this.emit("next");
+  }
+  async onEmpty() {
+    if (this.#queue.size === 0) {
+      return;
+    }
+    await this.#onEvent("empty");
+  }
+  async onIdle() {
+    if (this.#queue.size === 0 && this.#pending === 0) {
+      return;
+    }
+    await this.#onEvent("idle");
+  }
+  async onPendingZero() {
+    if (this.#pending === 0) {
+      return;
+    }
+    await this.#onEvent("pendingZero");
+  }
+  async onRateLimit() {
+    if (this.isRateLimited) {
+      return;
+    }
+    await this.#onEvent("rateLimit");
+  }
+  async onRateLimitCleared() {
+    if (!this.isRateLimited) {
+      return;
+    }
+    await this.#onEvent("rateLimitCleared");
+  }
+  onError() {
+    return new Promise((_resolve, reject) => {
+      const listener = (error) => {
+        this.off("error", listener);
+        reject(error);
+      };
+      this.on("error", listener);
+    });
+  }
+  async onSizeLessThan(limit) {
+    if (this.#queue.size < limit) {
+      return;
+    }
+    await this.#onEvent("next", () => this.#queue.size < limit);
+  }
+  async#onEvent(event, filter) {
+    return new Promise((resolve) => {
+      const listener = () => {
+        if (filter && !filter()) {
+          return;
+        }
+        this.off(event, listener);
+        resolve();
+      };
+      this.on(event, listener);
+    });
+  }
+  async#withTimeoutAndAbort(operation, options, setAbortListener) {
+    const races = [operation];
+    let timeoutId;
+    if (options.timeout) {
+      races.push(new Promise((_resolve, reject) => {
+        timeoutId = setTimeout(() => {
+          reject(new TimeoutError(`Task timed out after ${options.timeout}ms`));
+        }, options.timeout);
+      }));
+    }
+    if (options.signal) {
+      races.push(new Promise((_resolve, reject) => {
+        const listener = () => {
+          reject(options.signal?.reason);
+        };
+        setAbortListener(listener);
+        options.signal?.addEventListener("abort", listener, { once: true });
+      }));
+    }
+    try {
+      return await Promise.race(races);
+    } finally {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+    }
+  }
+  #next() {
+    this.#pending--;
+    if (this.#pending === 0) {
+      this.emit("pendingZero");
+    }
+    this.#processQueue();
+    this.emit("next");
+  }
+  #processQueue() {
+    while (this.#tryToStartAnother()) {}
+    this.#updateRateLimitState();
+  }
+  #tryToStartAnother() {
+    if (this.#queue.size === 0) {
+      this.#clearIntervalTimer();
+      this.emit("empty");
+      if (this.#pending === 0) {
+        this.emit("idle");
+      }
+      return false;
+    }
+    if (this.#isPaused || this.#pending >= this.#concurrency || !this.#doesIntervalAllowAnother()) {
+      return false;
+    }
+    const job = this.#queue.dequeue();
+    if (!job) {
+      return false;
+    }
+    this.#consumeIntervalSlot();
+    this.emit("active");
+    job();
+    return true;
+  }
+  #doesIntervalAllowAnother() {
+    if (this.#intervalCap === Number.POSITIVE_INFINITY || this.#interval === 0) {
+      return true;
+    }
+    const now = Date.now();
+    if (this.#strict) {
+      this.#strictTimestamps = this.#strictTimestamps.filter((timestamp) => now - timestamp < this.#interval);
+      if (this.#strictTimestamps.length < this.#intervalCap) {
+        return true;
+      }
+      this.#scheduleIntervalResume(this.#interval - (now - this.#strictTimestamps[0]));
+      return false;
+    }
+    if (this.#intervalEnd === 0 || now >= this.#intervalEnd) {
+      this.#intervalCount = this.#carryoverIntervalCount ? this.#pending : 0;
+      this.#intervalEnd = now + this.#interval;
+    }
+    if (this.#intervalCount < this.#intervalCap) {
+      return true;
+    }
+    this.#scheduleIntervalResume(this.#intervalEnd - now);
+    return false;
+  }
+  #consumeIntervalSlot() {
+    if (this.#intervalCap === Number.POSITIVE_INFINITY || this.#interval === 0) {
+      return;
+    }
+    if (this.#strict) {
+      this.#strictTimestamps.push(Date.now());
+      return;
+    }
+    this.#intervalCount++;
+  }
+  #scheduleIntervalResume(delay2) {
+    if (this.#intervalTimer) {
+      return;
+    }
+    this.#intervalTimer = setTimeout(() => {
+      this.#intervalTimer = undefined;
+      this.#processQueue();
+    }, Math.max(0, delay2));
+  }
+  #clearIntervalTimer() {
+    if (this.#intervalTimer) {
+      clearTimeout(this.#intervalTimer);
+      this.#intervalTimer = undefined;
+    }
+  }
+  #updateRateLimitState() {
+    const previous = this.#rateLimited;
+    const isRateLimited = this.#queue.size > 0 && this.#intervalCap !== Number.POSITIVE_INFINITY && this.#interval > 0 && !this.#doesIntervalAllowAnother();
+    this.#rateLimited = isRateLimited;
+    if (previous !== isRateLimited) {
+      this.emit(isRateLimited ? "rateLimit" : "rateLimitCleared");
+    }
+  }
+}
+
+// src/jwt/index.ts
+import * as jose from "jose";
+async function jwtSign(payload, secret) {
+  const secretKey = new TextEncoder().encode(secret);
+  return await new jose.SignJWT(payload).setProtectedHeader({ alg: "HS256" }).setIssuedAt().sign(secretKey);
+}
+async function jwtVerify2(token, secret) {
+  try {
+    const secretKey = new TextEncoder().encode(secret);
+    const { payload } = await jose.jwtVerify(token, secretKey);
+    return payload;
+  } catch (_error) {
+    return null;
+  }
+}
+
+// src/gzip/index.ts
+import pako from "pako";
+function compressString(input) {
+  const uint8Array = new TextEncoder().encode(input);
+  const compressed = pako.deflate(uint8Array);
+  return btoa(String.fromCharCode.apply(null, compressed));
+}
+function decompressString(compressedString) {
+  const compressedData = new Uint8Array(atob(compressedString).split("").map((char) => char.charCodeAt(0)));
+  const decompressed = pako.inflate(compressedData);
+  return new TextDecoder().decode(decompressed);
+}
+
+// src/sitemap/index.ts
+var createTimeoutController = (timeout) => {
+  const controller = new AbortController;
+  setTimeout(() => controller.abort(), timeout);
+  return controller;
+};
+var discoverSitemaps = async (domain) => {
+  const normalizedDomain = domain.replace(/\/$/, "");
+  const commonLocations = [
+    "/sitemap.xml",
+    "/sitemap_index.xml",
+    "/sitemap/",
+    "/sitemaps.xml",
+    "/sitemap/sitemap.xml"
+  ];
+  const sitemaps = new Set;
+  const requestOptions = {
+    headers: {
+      "User-Agent": "SitemapCrawler/1.0"
+    },
+    signal: createTimeoutController(5000).signal
+  };
+  try {
+    const robotsTxt = await fetch(`${normalizedDomain}/robots.txt`, {
+      ...requestOptions
+    });
+    if (robotsTxt.ok) {
+      const text = await robotsTxt.text();
+      const sitemapMatches = text.match(/Sitemap: (.*)/gi);
+      if (sitemapMatches) {
+        sitemapMatches.forEach((match) => {
+          const url = match.replace("Sitemap:", "").trim();
+          sitemaps.add(url);
+        });
+      }
+      if (sitemaps.size > 0) {
+        return [...sitemaps];
+      }
+    }
+  } catch (error) {
+    console.warn("Could not fetch robots.txt:", error instanceof Error ? error.message : "Unknown error");
+  }
+  for (const location of commonLocations) {
+    try {
+      const response = await fetch(`${normalizedDomain}${location}`, {
+        ...requestOptions,
+        method: "HEAD"
+      });
+      if (response.ok) {
+        return [`${normalizedDomain}${location}`];
+      }
+    } catch (_error) {}
+  }
+  return [];
+};
+var getDomainSitemap = async (domain, options = {}) => {
+  const {
+    filterIndexes,
+    concurrency = 10,
+    maxDepth = 5,
+    timeout = 1e4
+  } = options;
+  let normalizedDomain = domain.replace(/\/$/, "");
+  if (!normalizedDomain.startsWith("http")) {
+    normalizedDomain = `https://${normalizedDomain}`;
+  }
+  const sitemapUrls = await discoverSitemaps(normalizedDomain);
+  if (sitemapUrls.length === 0) {
+    throw new Error("No sitemaps found for the domain");
+  }
+  const queue = new PQueue({ concurrency });
+  const result = {
+    links: new Set,
+    visited: new Set
+  };
+  const locRegex = /<loc>([^<]+)<\/loc>/g;
+  const isXmlSitemap = (url) => url.endsWith(".xml") || url.toLowerCase().includes("sitemap");
+  const processSitemap = async (sitemapUrl, depth = 0) => {
+    if (depth > maxDepth || result.visited.has(sitemapUrl)) {
+      return;
+    }
+    result.visited.add(sitemapUrl);
+    try {
+      const controller = createTimeoutController(timeout);
+      const response = await fetch(sitemapUrl, {
+        headers: {
+          "User-Agent": "SitemapCrawler/1.0"
+        },
+        signal: controller.signal
+      });
+      if (!response.ok)
+        throw new Error(`HTTP error! status: ${response.status}`);
+      const data = await response.text();
+      const matches = [...data.matchAll(locRegex)].map((match) => match[1].trim()).filter((link) => {
+        if (filterIndexes && isXmlSitemap(link)) {
+          return link.includes(filterIndexes);
+        }
+        return true;
+      });
+      for (const link of matches) {
+        if (isXmlSitemap(link)) {
+          queue.add(() => processSitemap(link, depth + 1));
+        } else {
+          result.links.add(link);
+        }
+      }
+    } catch (error) {
+      console.warn(`Failed to process sitemap ${sitemapUrl}:`, error instanceof Error ? error.message : "Unknown error");
+    }
+  };
+  await Promise.all(sitemapUrls.map((sitemapUrl) => queue.add(() => processSitemap(sitemapUrl))));
+  await queue.onIdle();
+  return [...result.links];
+};
+
+// src/secrets/vite.ts
+function getViteDefine(secretSet) {
+  return Object.fromEntries(Object.entries(secretSet.secrets()).map(([key, value]) => [
+    `import.meta.env.${key}`,
+    JSON.stringify(value)
+  ]));
+}
+function viteSecretSetPlugin(secretSet) {
+  return {
+    name: "hanzio-secret-set",
+    config: () => ({
+      define: getViteDefine(secretSet)
+    })
+  };
+}
+
+// src/secrets/index.ts
+import { InfisicalSDK } from "@infisical/sdk";
+import { networkInterfaces } from "node:os";
+var DEFAULT_INFISICAL_SITE_URL = "https://eu.infisical.com";
+var LOCAL_IP_VALUE = "LOCAL_IP";
+var VPN_INTERFACE_RE = /^(utun|tun|tailscale|wg|ipsec|ppp)/i;
+function getSecretEnvironment() {
+  const env = process.env.SECRETS_ENV || "development";
+  if (env === "production" || env === "prod")
+    return "prod";
+  if (env === "staging")
+    return "staging";
+  return "dev";
+}
+async function defineSecretSet(keys, options) {
+  const keySet = [...new Set(keys)];
+  const loader = options.loader ?? loadInfisicalSecrets;
+  const getLocalIp = options.getLocalIp ?? getLocalIpAddress;
+  let cachedSecrets = null;
+  const resolveValue = (value) => {
+    if (value === LOCAL_IP_VALUE)
+      return getLocalIp();
+    return value;
+  };
+  const loadSecrets = async (force = false) => {
+    const envSecrets = readEnvSecrets(keySet, force ? cachedSecrets : null);
+    const keysMissingFromEnv = keySet.filter((key) => !envSecrets[key]);
+    const loadedSecrets = keysMissingFromEnv.length === 0 && !force ? {} : await loader({
+      keys: keySet,
+      projectId: options.projectId,
+      environment: resolveEnvironment(options.environment),
+      siteUrl: options.siteUrl ?? DEFAULT_INFISICAL_SITE_URL,
+      clientIdEnvKey: options.clientIdEnvKey ?? "INFISICAL_CLIENT_ID",
+      clientSecretEnvKey: options.clientSecretEnvKey ?? "INFISICAL_CLIENT_SECRET"
+    });
+    const missingKeys = keySet.filter((key) => !(envSecrets[key] ?? loadedSecrets[key]));
+    if (missingKeys.length > 0) {
+      throw new Error(`Missing secrets: ${missingKeys.join(", ")}`);
+    }
+    const nextSecrets = Object.fromEntries(keySet.map((key) => [
+      key,
+      resolveValue(envSecrets[key] ?? loadedSecrets[key])
+    ]));
+    for (const [key, value] of Object.entries(nextSecrets)) {
+      process.env[key] = value;
+    }
+    cachedSecrets = nextSecrets;
+    return nextSecrets;
+  };
+  const secretSet = {
+    secret(key) {
+      const value = cachedSecrets?.[key] ?? process.env[key];
+      if (!value) {
+        throw new Error(`Secret ${key} not found`);
+      }
+      return resolveValue(value);
+    },
+    secrets() {
+      if (!cachedSecrets) {
+        throw new Error("Secrets not initialized.");
+      }
+      return cachedSecrets;
+    },
+    async reload() {
+      await loadSecrets(true);
+      return secretSet;
+    }
+  };
+  await loadSecrets();
+  return secretSet;
+}
+async function loadInfisicalSecrets({
+  keys,
+  projectId,
+  environment,
+  siteUrl,
+  clientIdEnvKey,
+  clientSecretEnvKey
+}) {
+  const clientId = process.env[clientIdEnvKey];
+  const clientSecret = process.env[clientSecretEnvKey];
+  if (!clientId || !clientSecret) {
+    throw new Error("Missing Infisical credentials");
+  }
+  const client = new InfisicalSDK({ siteUrl });
+  await client.auth().universalAuth.login({
+    clientId,
+    clientSecret
+  });
+  const { secrets } = await client.secrets().listSecrets({
+    environment,
+    projectId
+  });
+  const wantedKeys = new Set(keys);
+  return Object.fromEntries(secrets.filter((secret) => wantedKeys.has(secret.secretKey)).map((secret) => [secret.secretKey, secret.secretValue]));
+}
+function resolveEnvironment(environment) {
+  if (typeof environment === "function")
+    return environment();
+  return environment ?? getSecretEnvironment();
+}
+function readEnvSecrets(keys, previousSecrets = null) {
+  return Object.fromEntries(keys.filter((key) => {
+    const value = process.env[key];
+    return value && value !== previousSecrets?.[key];
+  }).map((key) => [key, process.env[key]]));
+}
+function getLocalIpAddress() {
+  const interfaces = networkInterfaces();
+  for (const name of Object.keys(interfaces)) {
+    if (VPN_INTERFACE_RE.test(name))
+      continue;
+    const nets = interfaces[name];
+    if (!nets)
+      continue;
+    for (const net of nets) {
+      if (net.family === "IPv4" && !net.internal) {
+        return net.address;
+      }
+    }
+  }
+  return "127.0.0.1";
+}
+
+// src/typedswitch/index.ts
+function runSwitch(value, keyOrCases, casesOrDefault, defaultCase) {
+  let key;
+  let cases;
+  let defaultHandler;
+  let discriminantKey;
+  if (typeof value === "string") {
+    key = value;
+    cases = keyOrCases;
+    defaultHandler = casesOrDefault;
+  } else {
+    if (typeof keyOrCases !== "string") {
+      throw new Error("Invalid typedSwitch call: object mode requires a string discriminant key");
+    }
+    discriminantKey = keyOrCases;
+    const discriminantValue = value[discriminantKey];
+    if (typeof discriminantValue !== "string") {
+      throw new Error(`Invalid discriminant value for key "${discriminantKey}": expected string, received ${typeof discriminantValue}`);
+    }
+    key = discriminantValue;
+    cases = casesOrDefault;
+    defaultHandler = defaultCase;
+  }
+  const handler = cases[key];
+  if (handler) {
+    return handler(value);
+  }
+  if (defaultHandler) {
+    return defaultHandler(value);
+  }
+  const availableCases = Object.keys(cases).join(", ");
+  const availableCasesSuffix = availableCases.length > 0 ? ` Available cases: ${availableCases}` : " Available cases: (none)";
+  const contextSuffix = discriminantKey ? ` (discriminant key: "${discriminantKey}")` : "";
+  throw new Error(`Unhandled case: ${key}${contextSuffix}.${availableCasesSuffix}`);
+}
+function typedSwitch(value, keyOrCases, casesOrDefault, defaultCase) {
+  return runSwitch(value, keyOrCases, casesOrDefault, defaultCase);
+}
+// src/array/index.ts
+function chunkArray(array, chunkSize) {
+  if (!Number.isInteger(chunkSize) || chunkSize <= 0) {
+    throw new Error("Chunk size must be a positive integer");
+  }
+  const chunks = [];
+  for (let index = 0;index < array.length; index += chunkSize) {
+    chunks.push(array.slice(index, index + chunkSize));
+  }
+  return chunks;
+}
+function findArrayDifferenceByKey(current, next, key) {
+  const currentByKey = new Map(current.map((item) => [String(item[key]), item]));
+  const itemsToDelete = [...current];
+  const newItems = [];
+  const upsertItems = [];
+  for (const item of next) {
+    const keyValue = String(item[key]);
+    if (!currentByKey.has(keyValue)) {
+      newItems.push(item);
+      continue;
+    }
+    upsertItems.push(item);
+    const deleteIndex = itemsToDelete.findIndex((currentItem) => String(currentItem[key]) === keyValue);
+    if (deleteIndex >= 0) {
+      itemsToDelete.splice(deleteIndex, 1);
+    }
+  }
+  return {
+    new: newItems,
+    upsert: upsertItems,
+    delete: itemsToDelete
+  };
+}
+function getUniqueValues(array) {
+  const seen = new Map;
+  for (const element of array) {
+    const key = JSON.stringify(element);
+    if (!seen.has(key)) {
+      seen.set(key, element);
+    }
+  }
+  return Array.from(seen.values());
+}
+function compact(array) {
+  return array.filter((item) => item != null);
+}
+function getUniqueValuesByKey(array, key) {
+  const seen = new Set;
+  const result = [];
+  for (const item of array) {
+    const value = item[key];
+    if (seen.has(value))
+      continue;
+    seen.add(value);
+    result.push(item);
+  }
+  return result;
+}
+function groupBy(array, keyOrFn) {
+  return array.reduce((result, item) => {
+    const groupKey = typeof keyOrFn === "function" ? keyOrFn(item) : item[keyOrFn];
+    result[groupKey] ??= [];
+    result[groupKey].push(item);
+    return result;
+  }, {});
+}
+function keyBy(array, keyOrFn) {
+  const result = {};
+  for (const item of array) {
+    const recordKey = typeof keyOrFn === "function" ? keyOrFn(item) : item[keyOrFn];
+    result[recordKey] = item;
+  }
+  return result;
+}
+function partition(array, predicate) {
+  const matched = [];
+  const unmatched = [];
+  array.forEach((item, index) => {
+    if (predicate(item, index)) {
+      matched.push(item);
+    } else {
+      unmatched.push(item);
+    }
+  });
+  return [matched, unmatched];
+}
+function pickItemsInArray(array, key, values) {
+  return array.filter((item) => values.includes(item[key]));
+}
+// src/string/index.ts
+function extractNumber(value) {
+  if (!value?.trim())
+    return;
+  const cleanedValue = value.replace(/[^\d.,-]/g, "");
+  if (!cleanedValue)
+    return;
+  const parsedNumber = Number.parseFloat(cleanedValue);
+  return Number.isNaN(parsedNumber) ? undefined : parsedNumber;
+}
+function generateId(input) {
+  const data = normalizeIdInput(input);
+  let hash = 0;
+  for (let index = 0;index < data.length; index++) {
+    const char = data.charCodeAt(index);
+    hash = (hash << 5) - hash + char;
+    hash |= 0;
+  }
+  return Math.abs(hash).toString(16).padStart(8, "0");
+}
+function slugify(value) {
+  const source = "àáâäæãåāăąçćčđďèéêëēėęěğǵḧîïíīįìłḿñńǹňôöòóœøōõṕŕřßśšşșťțûüùúūǘůűųẃẍÿýžźż·/_,:;";
+  const replacement = "aaaaaaaaaacccddeeeeeeeegghiiiiiilmnnnnooooooooprrsssssttuuuuuuuuuwxyyzzz------";
+  const specialCharacterPattern = new RegExp(source.split("").join("|"), "g");
+  return value.toString().toLowerCase().replace(/\s+/g, "-").replace(specialCharacterPattern, (character) => replacement.charAt(source.indexOf(character))).replace(/&/g, "-and-").replace(/[^\w-]+/g, "").replace(/--+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
+}
+function normalizeIdInput(input) {
+  if (input === undefined)
+    return "undefined";
+  if (input === null)
+    return "null";
+  if (typeof input === "string") {
+    return decodeURIComponent(input).split("&").sort().join("&");
+  }
+  if (typeof input === "number" || typeof input === "boolean") {
+    return input.toString();
+  }
+  return JSON.stringify(sortJsonValue(input));
+}
+function sortJsonValue(value) {
+  if (value === undefined)
+    return null;
+  if (Array.isArray(value)) {
+    return value.map((item) => sortJsonValue(item));
+  }
+  if (typeof value === "object" && value !== null) {
+    return Object.fromEntries(Object.entries(value).filter(([, itemValue]) => itemValue !== undefined).sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey)).map(([key, itemValue]) => [key, sortJsonValue(itemValue)]));
+  }
+  return value;
+}
+// src/promise/index.ts
+function isSuccess(result) {
+  return result.error === null;
+}
+function isFailure(result) {
+  return result.error !== null;
+}
+function unwrapResult(result) {
+  if (isSuccess(result))
+    return result.data;
+  throw result.error;
+}
+function backgroundPromise(promiseFactory, options = {}) {
+  const run = () => {
+    promiseFactory().then(() => options.onSuccess?.()).catch((error) => options.onError?.(error));
+  };
+  if (options.scheduler) {
+    options.scheduler(run);
+    return;
+  }
+  run();
+}
+function backgroundPromiseSync(promiseFactory, options = {}) {
+  backgroundPromise(promiseFactory, {
+    ...options,
+    scheduler: options.scheduler ?? queueMicrotask
+  });
+}
+function promiseTimeout(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function tryCatch(promise) {
+  try {
+    const data = await promise;
+    return { data, error: null };
+  } catch (error) {
+    return { data: null, error };
+  }
+}
+// src/cache/index.ts
+function cacheFunction(options) {
+  const {
+    name,
+    fn,
+    cacheTimeMs = 10 * 60 * 1000,
+    refreshInBackground = false,
+    cacheKeyArgs,
+    cacheKeyFn,
+    onBackgroundRefreshError
+  } = options;
+  const cache = new Map;
+  const pendingPromises = new Map;
+  const cleanupInterval = setInterval(() => {
+    const now = Date.now();
+    for (const [key, entry] of cache.entries()) {
+      if (now - entry.timestamp >= cacheTimeMs) {
+        cache.delete(key);
+      }
+    }
+  }, Math.min(cacheTimeMs / 2, 5 * 60 * 1000));
+  const wrappedFn = (...args) => {
+    const keyArgs = cacheKeyFn ? cacheKeyFn(...args) : cacheKeyArgs ? cacheKeyArgs.map((i) => args[i]) : args;
+    const key = `${name}:${JSON.stringify(keyArgs)}`;
+    const now = Date.now();
+    const pending = pendingPromises.get(key);
+    if (pending) {
+      return pending;
+    }
+    const cached = cache.get(key);
+    if (cached) {
+      const isCacheFresh = now - cached.timestamp < cacheTimeMs;
+      if (!isCacheFresh && !refreshInBackground) {
+        cache.delete(key);
+      } else {
+        if (isCacheFresh && !refreshInBackground) {
+          return cached.value;
+        }
+        if (refreshInBackground) {
+          const existingPending = pendingPromises.get(key);
+          if (existingPending) {
+            return existingPending;
+          }
+          const backgroundUpdate = fn(...args);
+          if (isPromiseLike(backgroundUpdate)) {
+            const backgroundPromise2 = backgroundUpdate.then((resolvedValue) => {
+              cache.set(key, { value: resolvedValue, timestamp: now });
+              pendingPromises.delete(key);
+              return resolvedValue;
+            }).catch((error) => {
+              pendingPromises.delete(key);
+              onBackgroundRefreshError?.(error, { name });
+            });
+            pendingPromises.set(key, backgroundPromise2);
+          } else {
+            cache.set(key, {
+              value: backgroundUpdate,
+              timestamp: now
+            });
+          }
+          return cached.value;
+        }
+        if (isCacheFresh) {
+          return cached.value;
+        }
+      }
+    }
+    const result = fn(...args);
+    if (isPromiseLike(result)) {
+      const promise = result.then((resolvedValue) => {
+        cache.set(key, { value: resolvedValue, timestamp: now });
+        pendingPromises.delete(key);
+        return resolvedValue;
+      }).catch((error) => {
+        pendingPromises.delete(key);
+        throw error;
+      });
+      pendingPromises.set(key, promise);
+      return promise;
+    }
+    cache.set(key, { value: result, timestamp: now });
+    return result;
+  };
+  wrappedFn.clearCache = () => {
+    cache.clear();
+    pendingPromises.clear();
+    clearInterval(cleanupInterval);
+  };
+  return wrappedFn;
+}
+function isPromiseLike(value) {
+  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+}
+// src/state/index.ts
+class SimpleStateMachine {
+  config;
+  item;
+  stateKey;
+  constructor(config, item, stateKey) {
+    this.config = config;
+    this.item = item;
+    this.stateKey = stateKey;
+  }
+  getCurrentStatus() {
+    return this.item[this.stateKey];
+  }
+  async getAvailableActions() {
+    const actionsMap = this.config.stateActionMap[this.getCurrentStatus()] || {};
+    const result = {};
+    for (const [action, targetState] of Object.entries(actionsMap)) {
+      if (!targetState)
+        continue;
+      const validationResult = await this.validateTransition(targetState, { action });
+      result[action] = validationResult;
+    }
+    return result;
+  }
+  async getPossibleTransitions() {
+    const possibleTransitions = this.config.stateTransitions[this.getCurrentStatus()] || [];
+    const actionsMap = this.config.stateActionMap[this.getCurrentStatus()] || {};
+    const result = {};
+    for (const targetState of possibleTransitions) {
+      const actionsToTarget = Object.entries(actionsMap).filter(([, t]) => t === targetState);
+      if (actionsToTarget.length === 0) {
+        result[targetState] = await this.validateTransition(targetState);
+        continue;
+      }
+      let lastError = true;
+      let anyOk = false;
+      for (const [actionKey] of actionsToTarget) {
+        const r = await this.validateTransition(targetState, {
+          action: actionKey
+        });
+        if (r === true) {
+          anyOk = true;
+          break;
+        }
+        lastError = r;
+      }
+      result[targetState] = anyOk ? true : lastError;
+    }
+    return result;
+  }
+  async executeAction(action, data) {
+    const actionsMap = this.config.stateActionMap[this.getCurrentStatus()];
+    if (!actionsMap) {
+      return {
+        success: false,
+        error: `No actions defined for state '${this.getCurrentStatus()}'`
+      };
+    }
+    const targetState = actionsMap[action];
+    if (!targetState) {
+      return {
+        success: false,
+        error: `Action '${action}' not allowed in state '${this.getCurrentStatus()}'`
+      };
+    }
+    const validationResult = await this.validateTransition(targetState, {
+      action
+    });
+    if (validationResult === true) {
+      if (this.config.actions?.[action]) {
+        try {
+          const result = await this.config.actions[action](this.item, data);
+          return {
+            success: true,
+            newState: targetState,
+            result
+          };
+        } catch (error) {
+          return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error)
+          };
+        }
+      }
+      return {
+        success: true,
+        newState: targetState
+      };
+    }
+    return {
+      success: false,
+      error: validationResult
+    };
+  }
+  async validateTransition(toState, options) {
+    const action = options?.action;
+    if (this.getCurrentStatus() === toState)
+      return true;
+    const allowedTransitions = this.config.stateTransitions[this.getCurrentStatus()] || [];
+    if (!allowedTransitions.includes(toState)) {
+      return `Invalid transition from '${this.getCurrentStatus()}' to '${toState}'`;
+    }
+    if (this.config.globalValidator) {
+      const globalResult = await this.config.globalValidator(this.item, this.getCurrentStatus(), toState, action);
+      if (globalResult !== true) {
+        return globalResult;
+      }
+    }
+    const stateValidator = this.config.validators?.[toState];
+    if (stateValidator) {
+      return await stateValidator(this.item, this.getCurrentStatus(), toState, action);
+    }
+    return true;
+  }
+  getStates() {
+    return Object.keys(this.config.stateTransitions);
+  }
+  getInitialState() {
+    return this.getStates()[0];
+  }
+}
+// src/math/linearRegressionTrend.ts
+function linearRegressionTrend(values) {
+  const n = values.length;
+  if (n < 2)
+    return [];
+  for (const v of values) {
+    if (!Number.isFinite(v))
+      return [];
+  }
+  let sumX = 0;
+  let sumY = 0;
+  let sumXY = 0;
+  let sumX2 = 0;
+  for (let i = 0;i < n; i++) {
+    const x = i;
+    const y = values[i];
+    sumX += x;
+    sumY += y;
+    sumXY += x * y;
+    sumX2 += x * x;
+  }
+  const denom = n * sumX2 - sumX * sumX;
+  if (denom === 0)
+    return [];
+  const slope = (n * sumXY - sumX * sumY) / denom;
+  const intercept = (sumY - slope * sumX) / n;
+  const out = [];
+  for (let i = 0;i < n; i++) {
+    out.push(intercept + slope * i);
+  }
+  return out;
+}
+// src/math/metricsSeriesColors.ts
+var METRICS_SERIES_PALETTE_SIZE = 10;
+function hashStringToColorIndex(str) {
+  let hash = 2166136261;
+  for (let i = 0;i < str.length; i++) {
+    hash ^= str.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return Math.abs(hash) % METRICS_SERIES_PALETTE_SIZE;
+}
+function circularHueDistance(a, b, paletteSize) {
+  const diff = Math.abs(a - b);
+  return Math.min(diff, paletteSize - diff);
+}
+function pickHueMaxMinDistance(candidates, used, paletteSize) {
+  let best = candidates[0] ?? 0;
+  let bestScore = -1;
+  for (const cand of candidates) {
+    let minD = paletteSize;
+    for (const u of used) {
+      minD = Math.min(minD, circularHueDistance(cand, u, paletteSize));
+    }
+    if (minD > bestScore || minD === bestScore && cand < best) {
+      bestScore = minD;
+      best = cand;
+    }
+  }
+  return best;
+}
+function seriesColorKey(label, key) {
+  const fromLabel = label?.trim();
+  if (fromLabel)
+    return fromLabel;
+  return key.trim() || key;
+}
+function resolveSeriesColorMap(keys) {
+  const result = new Map;
+  const uniqueKeys = [...new Set(keys)];
+  if (uniqueKeys.length === 0)
+    return result;
+  const paletteSize = METRICS_SERIES_PALETTE_SIZE;
+  if (uniqueKeys.length === 1) {
+    const only = uniqueKeys[0];
+    result.set(only, hashStringToColorIndex(only));
+    return result;
+  }
+  const usedIndices = new Set;
+  const entries = uniqueKeys.map((key) => ({
+    key,
+    preferred: hashStringToColorIndex(key)
+  }));
+  for (const entry of entries) {
+    if (!usedIndices.has(entry.preferred)) {
+      result.set(entry.key, entry.preferred);
+      usedIndices.add(entry.preferred);
+    }
+  }
+  const unassigned = entries.filter((e) => !result.has(e.key));
+  for (const entry of unassigned) {
+    const unused = [];
+    for (let i = 0;i < paletteSize; i++) {
+      if (!usedIndices.has(i))
+        unused.push(i);
+    }
+    const candidates = unused.length > 0 ? unused : Array.from({ length: paletteSize }, (_, i) => i);
+    const idx = pickHueMaxMinDistance(candidates, usedIndices, paletteSize);
+    result.set(entry.key, idx);
+    usedIndices.add(idx);
+  }
+  return result;
+}
+function createResolveColorsByKeys(keys, getSeriesColor, getSeriesHoverColor) {
+  const colorMap = resolveSeriesColorMap(keys);
+  return {
+    getColor: (key) => getSeriesColor(colorMap.get(key) ?? hashStringToColorIndex(key)),
+    getHoverColor: (key) => getSeriesHoverColor(colorMap.get(key) ?? hashStringToColorIndex(key))
+  };
+}
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+function withAlpha(color, alpha) {
+  const trimmed = color.trim();
+  if (trimmed.startsWith("#")) {
+    const hex = trimmed.slice(1);
+    const normalized = hex.length === 3 ? hex.split("").map((c) => c + c).join("") : hex;
+    if (normalized.length === 6) {
+      const r = Number.parseInt(normalized.slice(0, 2), 16);
+      const g = Number.parseInt(normalized.slice(2, 4), 16);
+      const b = Number.parseInt(normalized.slice(4, 6), 16);
+      return `rgba(${r}, ${g}, ${b}, ${alpha})`;
+    }
+  }
+  if (trimmed.startsWith("rgb(")) {
+    return trimmed.replace("rgb(", "rgba(").replace(")", `, ${alpha})`);
+  }
+  if (trimmed.startsWith("rgba(")) {
+    return trimmed.replace(/,\s*[\d.]+\)$/, `, ${alpha})`);
+  }
+  return trimmed;
+}
+function getHeatmapCellStyle(params) {
+  const {
+    value,
+    min,
+    max,
+    baseColor,
+    neutralColor,
+    minAlpha = 0.08,
+    maxAlpha = 0.78
+  } = params;
+  if (value === null || value === undefined || Number.isNaN(value)) {
+    return {};
+  }
+  if (!Number.isFinite(min) || !Number.isFinite(max)) {
+    return {};
+  }
+  if (max <= min) {
+    return {
+      backgroundColor: withAlpha(neutralColor ?? baseColor, 0.32)
+    };
+  }
+  const normalized = clamp((value - min) / (max - min), 0, 1);
+  const alpha = minAlpha + (maxAlpha - minAlpha) * normalized;
+  return {
+    backgroundColor: withAlpha(baseColor, alpha)
+  };
+}
+// src/date/index.ts
+function getPreviousReportPeriod(periodType, referenceDate = new Date) {
+  const month = referenceDate.getMonth();
+  const year = referenceDate.getFullYear();
+  switch (periodType) {
+    case "MONTHLY": {
+      const prevMonth = month === 0 ? 11 : month - 1;
+      const prevYear = month === 0 ? year - 1 : year;
+      return {
+        start: new Date(prevYear, prevMonth, 1),
+        end: new Date(year, month, 0)
+      };
+    }
+    case "QUARTERLY": {
+      const qStart = Math.floor(month / 3) * 3;
+      const prevQStart = qStart === 0 ? 9 : qStart - 3;
+      const prevQYear = qStart === 0 ? year - 1 : year;
+      return {
+        start: new Date(prevQYear, prevQStart, 1),
+        end: new Date(prevQYear, prevQStart + 3, 0)
+      };
+    }
+    case "YEARLY": {
+      return {
+        start: new Date(year - 1, 0, 1),
+        end: new Date(year - 1, 11, 31)
+      };
+    }
+  }
+}
+function formatPeriodLabel(start, end, includeDay = false) {
+  const s = start instanceof Date ? start : new Date(start);
+  const e = end instanceof Date ? end : new Date(end);
+  const opts = {
+    year: "numeric",
+    month: "long",
+    ...includeDay && { day: "numeric" }
+  };
+  return `${s.toLocaleDateString("en-GB", opts)} — ${e.toLocaleDateString("en-GB", opts)}`;
+}
+// src/url/index.ts
+function getDomainFaviconUrl(domain, size = 128) {
+  return `https://www.google.com/s2/favicons?domain=${encodeURIComponent(domain)}&sz=${size}`;
+}
+// src/cool-console-log/index.ts
+var terminalColors = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  italic: "\x1B[3m",
+  underline: "\x1B[4m",
+  black: "\x1B[30m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m",
+  brightRed: "\x1B[91m",
+  brightGreen: "\x1B[92m",
+  brightYellow: "\x1B[93m",
+  brightBlue: "\x1B[94m",
+  brightMagenta: "\x1B[95m",
+  brightCyan: "\x1B[96m",
+  brightWhite: "\x1B[97m",
+  bgBlack: "\x1B[40m",
+  bgRed: "\x1B[41m",
+  bgGreen: "\x1B[42m",
+  bgYellow: "\x1B[43m",
+  bgBlue: "\x1B[44m",
+  bgMagenta: "\x1B[45m",
+  bgCyan: "\x1B[46m",
+  bgWhite: "\x1B[47m"
+};
+var levelColors = {
+  debug: { badge: terminalColors.gray, text: terminalColors.dim },
+  info: { badge: terminalColors.cyan, text: terminalColors.reset },
+  warn: { badge: terminalColors.yellow, text: terminalColors.yellow },
+  error: { badge: terminalColors.red, text: terminalColors.brightRed }
+};
+function formatAttributes(attrs) {
+  if (!attrs || Object.keys(attrs).length === 0)
+    return "";
+  const formatted = Object.entries(attrs).map(([k, v]) => `${terminalColors.dim}${k}=${terminalColors.reset}${v}`).join(" ");
+  return ` ${formatted}`;
+}
+function createCoolLogger(options = {}) {
+  const { colorsInDevOnly = true, onLog } = options;
+  const isDev = true;
+  const useColors = colorsInDevOnly ? isDev : true;
+  const createLogMethod = (level) => (message, attributes) => {
+    onLog?.(level, message, attributes);
+    if (level === "debug" && !isDev)
+      return;
+    if (useColors) {
+      const { badge, text } = levelColors[level];
+      const label = level.toUpperCase().padEnd(5);
+      const attrStr = formatAttributes(attributes);
+      console.log(`${badge}[${label}]${terminalColors.reset} ${text}${message}${terminalColors.reset}${attrStr}`);
+    } else {
+      console[level](`[${level.toUpperCase()}]`, message, attributes ?? "");
+    }
+  };
+  return {
+    debug: createLogMethod("debug"),
+    info: createLogMethod("info"),
+    warn: createLogMethod("warn"),
+    error: createLogMethod("error")
+  };
+}
+function logOperationSummary(operationName, durationMs, success, options = {}) {
+  const { devOnly = true, error } = options;
+  const isDev = true;
+  if (devOnly && !isDev)
+    return;
+  const c = terminalColors;
+  const statusIcon = success ? `${c.brightGreen}✓${c.reset}` : `${c.brightRed}✗${c.reset}`;
+  const statusColor = success ? c.green : c.red;
+  const durationStr = `${c.dim}${durationMs.toFixed(1)}ms${c.reset}`;
+  const errorMessage = error ? ` ${c.dim}·${c.reset} ${c.red}${error instanceof Error ? error.message : String(error)}${c.reset}` : "";
+  console.log(`${statusColor}${c.bold}${operationName}${c.reset} ${statusIcon} ${c.dim}·${c.reset} ${durationStr}${errorMessage}`);
+}
+function colorize(text, color, ...modifiers) {
+  const isDev = true;
+  if (!isDev)
+    return text;
+  const colorCodes = [
+    terminalColors[color],
+    ...modifiers.map((m) => terminalColors[m])
+  ].join("");
+  return `${colorCodes}${text}${terminalColors.reset}`;
+}
+function logBanner(text, color = "cyan", options = {}) {
+  const { devOnly = true } = options;
+  const isDev = true;
+  if (devOnly && !isDev) {
+    console.log(`=== ${text} ===`);
+    return;
+  }
+  const c = terminalColors;
+  const padding = 2;
+  const line = "═".repeat(text.length + padding * 2);
+  console.log(`${c[color]}╔${line}╗${c.reset}`);
+  console.log(`${c[color]}║${" ".repeat(padding)}${c.bold}${text}${c.reset}${c[color]}${" ".repeat(padding)}║${c.reset}`);
+  console.log(`${c[color]}╚${line}╝${c.reset}`);
+}
+export {
+  zodToTypeString,
+  zodToExample,
+  zodMinMaxFilter,
+  zSingleOrArray,
+  withAlpha,
+  viteSecretSetPlugin,
+  unwrapResult,
+  typedSwitch,
+  tryCatch,
+  toGteLteFilter,
+  terminalColors,
+  slugify,
+  seriesColorKey,
+  resolveSeriesColorMap,
+  promiseTimeout,
+  pickItemsInArray,
+  partition,
+  normalizeSingleOrArray,
+  logOperationSummary,
+  logBanner,
+  linearRegressionTrend,
+  keyBy,
+  jwtVerify2 as jwtVerify,
+  jwtSign,
+  jsonToZodSchemaMapper,
+  isSuccess,
+  isFailure,
+  hashStringToColorIndex,
+  groupBy,
+  getViteDefine,
+  getUniqueValuesByKey,
+  getUniqueValues,
+  getSecretEnvironment,
+  getPreviousReportPeriod,
+  getHeatmapCellStyle,
+  getDomainSitemap,
+  getDomainFaviconUrl,
+  generateId,
+  formatPeriodLabel,
+  findArrayDifferenceByKey,
+  extractNumber,
+  defineSecretSet,
+  decompressString,
+  createZId,
+  createResolveColorsByKeys,
+  createCoolLogger,
+  createApiWrapper,
+  createApiClient,
+  compressString,
+  compact,
+  colorize,
+  chunkArray,
+  cacheFunction,
+  backgroundPromiseSync,
+  backgroundPromise,
+  TimeoutError,
+  SimpleStateMachine,
+  ResponseValidationError,
+  PriorityQueue,
+  METRICS_SERIES_PALETTE_SIZE,
+  HttpResponseError
+};