hanzio 1.1.0 → 2.0.0

package/dist/src/index.js

@@ -1,2332 +1,91 @@
-// 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/headers.ts
-var CANONICAL_HEADER_NAMES = {
-  "content-type": "Content-Type",
-  authorization: "Authorization",
-  accept: "Accept",
-  "user-agent": "User-Agent",
-  "x-request-id": "X-Request-Id",
-  "x-correlation-id": "X-Correlation-Id"
-};
-function normalizeHeaders(headers) {
-  const result = {};
-  const lowerToCanonical = new Map;
-  for (const [key, value] of Object.entries(headers)) {
-    const lower = key.toLowerCase();
-    const canonical = CANONICAL_HEADER_NAMES[lower] ?? key;
-    const existing = lowerToCanonical.get(lower);
-    if (existing && existing !== canonical)
-      delete result[existing];
-    lowerToCanonical.set(lower, canonical);
-    result[canonical] = value;
-  }
-  return result;
-}
-function getHeader(headers, name) {
-  const lower = name.toLowerCase();
-  const canonical = CANONICAL_HEADER_NAMES[lower];
-  if (canonical !== undefined) {
-    if (headers[canonical] !== undefined)
-      return headers[canonical];
-  }
-  for (const [k, v] of Object.entries(headers)) {
-    if (k.toLowerCase() === lower)
-      return v;
-  }
-  return;
-}
-function hasJsonContentType(headers) {
-  const ct = getHeader(headers, "content-type") ?? "";
-  return ct.includes("application/json");
-}
-function buildFetchBody(body, headers) {
-  if (body === undefined || body === null)
-    return;
-  if (body instanceof FormData || body instanceof Blob)
-    return body;
-  if (hasJsonContentType(headers))
-    return JSON.stringify(body);
-  return body;
-}
-function getHeadersAsObject(headers) {
-  const result = {};
-  headers.forEach((value, key) => {
-    result[key] = value;
-  });
-  return result;
-}
-
-// src/api-wrapper/zod-issues.ts
-import { ZodError } from "zod";
-function formatZodIssues(error, rawData) {
-  return error.issues.map((issue) => {
-    const pathArray = [...issue.path];
-    const path = formatIssuePath(pathArray);
-    const value = getValueAtPath(rawData, pathArray);
-    const valuePreview = value === undefined ? undefined : previewValue(value);
-    const raw = issue;
-    const expected = typeof raw.expected === "string" ? raw.expected : undefined;
-    const received = typeof raw.received === "string" ? raw.received : value !== undefined ? typeofVerbose(value) : undefined;
-    const known = new Set([
-      "code",
-      "path",
-      "message",
-      "expected",
-      "received",
-      "fatal"
-    ]);
-    const extra = {};
-    for (const [k, v] of Object.entries(raw)) {
-      if (!known.has(k) && v !== undefined)
-        extra[k] = v;
-    }
-    return {
-      path,
-      pathArray,
-      code: issue.code,
-      message: issue.message,
-      expected,
-      received,
-      value,
-      valuePreview,
-      extra: Object.keys(extra).length > 0 ? extra : undefined
-    };
-  });
-}
-function renderIssueSummary(issues) {
-  if (issues.length === 0)
-    return "(no issues reported)";
-  return issues.map((issue, idx) => {
-    const parts = [];
-    parts.push(`  [${idx + 1}] ${issue.path}: ${issue.message}`);
-    if (issue.expected || issue.received) {
-      const exp = issue.expected ? `expected ${issue.expected}` : "";
-      const rec = issue.received ? `received ${issue.received}` : "";
-      parts.push(`      (${[exp, rec].filter(Boolean).join(", ")})`);
-    }
-    if (issue.valuePreview !== undefined) {
-      parts.push(`      value: ${issue.valuePreview}`);
-    }
-    if (issue.extra) {
-      for (const [k, v] of Object.entries(issue.extra)) {
-        parts.push(`      ${k}: ${previewValue(v, 120)}`);
-      }
-    }
-    return parts.join(`
-`);
-  }).join(`
-`);
-}
-function formatIssuePath(pathArray) {
-  if (pathArray.length === 0)
-    return "<root>";
-  let out = "";
-  for (const segment of pathArray) {
-    if (typeof segment === "number") {
-      out += `[${segment}]`;
-    } else if (/^[A-Za-z_$][\w$]*$/.test(segment)) {
-      out += out === "" ? segment : `.${segment}`;
-    } else {
-      out += `[${JSON.stringify(segment)}]`;
-    }
-  }
-  return out;
-}
-function getValueAtPath(data, pathArray) {
-  let current = data;
-  for (const segment of pathArray) {
-    if (current === null || current === undefined)
-      return;
-    if (typeof current !== "object")
-      return;
-    current = current[segment];
-  }
-  return current;
-}
-function typeofVerbose(value) {
-  if (value === null)
-    return "null";
-  if (Array.isArray(value))
-    return "array";
-  return typeof value;
-}
-function previewValue(value, maxLen = 200) {
-  let str;
-  try {
-    if (value === undefined)
-      str = "undefined";
-    else if (typeof value === "string")
-      str = JSON.stringify(value);
-    else
-      str = JSON.stringify(value);
-  } catch {
-    str = String(value);
-  }
-  if (str === undefined)
-    str = String(value);
-  if (str.length > maxLen)
-    str = `${str.slice(0, maxLen)}…`;
-  return str;
-}
-function makeJsonParseZodError(error, text) {
-  const message = error instanceof Error ? `Response body was not valid JSON: ${error.message}` : "Response body was not valid JSON";
-  const preview = text.length > 200 ? `${text.slice(0, 200)}…` : text;
-  return new ZodError([
-    {
-      code: "custom",
-      path: [],
-      message: `${message} (body preview: ${JSON.stringify(preview)})`,
-      input: text
-    }
-  ]);
-}
-function tryParseJson(body) {
-  if (!body)
-    return;
-  try {
-    return JSON.parse(body);
-  } catch {
-    return;
-  }
-}
-
-// src/api-wrapper/errors.ts
-var MAX_BODY_PREVIEW = 500;
-
-class ApiError extends Error {
-  context;
-  cause;
-  constructor(message, context, options) {
-    super(message);
-    this.name = "ApiError";
-    this.context = context;
-    this.cause = options?.cause;
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      context: this.context
-    };
-  }
-}
-
-class HttpResponseError extends ApiError {
-  status;
-  body;
-  bodyJson;
-  responseHeaders;
-  requestId;
-  constructor(status, body, responseHeaders, context) {
-    const preview = body.length > MAX_BODY_PREVIEW ? `${body.slice(0, MAX_BODY_PREVIEW)}…` : body;
-    super(`HTTP ${status} ${context.method} ${context.url} - ${preview}`, context);
-    this.name = "HttpResponseError";
-    this.status = status;
-    this.body = body;
-    this.responseHeaders = responseHeaders;
-    this.requestId = getHeader(responseHeaders, "x-request-id") ?? getHeader(responseHeaders, "x-correlation-id");
-    this.bodyJson = tryParseJson(body);
-  }
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      status: this.status,
-      body: this.body,
-      bodyJson: this.bodyJson,
-      requestId: this.requestId,
-      responseHeaders: this.responseHeaders
-    };
-  }
-}
-
-class ResponseValidationError extends ApiError {
-  zodError;
-  rawResponse;
-  issues;
-  validationIssues;
-  constructor(zodError, rawResponse, context) {
-    const issues = formatZodIssues(zodError, rawResponse);
-    const summary = renderIssueSummary(issues);
-    super(`Response validation failed (${context.method} ${context.url}):
-${summary}`, context, { cause: zodError });
-    this.name = "ResponseValidationError";
-    this.zodError = zodError;
-    this.rawResponse = rawResponse;
-    this.issues = issues;
-    this.validationIssues = issues.map((i) => `${i.path}: ${i.message}`).join("; ");
-  }
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      issues: this.issues,
-      validationIssues: this.validationIssues,
-      rawResponsePreview: previewValue(this.rawResponse, 1000)
-    };
-  }
-}
-
-class RequestValidationError extends ApiError {
-  zodError;
-  target;
-  rawInput;
-  issues;
-  validationIssues;
-  constructor(zodError, target, rawInput, context) {
-    const issues = formatZodIssues(zodError, rawInput);
-    const summary = renderIssueSummary(issues);
-    super(`Request ${target} validation failed (${context.method} ${context.url}):
-${summary}`, context, { cause: zodError });
-    this.name = "RequestValidationError";
-    this.zodError = zodError;
-    this.target = target;
-    this.rawInput = rawInput;
-    this.issues = issues;
-    this.validationIssues = issues.map((i) => `${i.path}: ${i.message}`).join("; ");
-  }
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      target: this.target,
-      issues: this.issues,
-      validationIssues: this.validationIssues
-    };
-  }
-}
-
-class RequestTimeoutError extends ApiError {
-  timeoutMs;
-  constructor(timeoutMs, context) {
-    super(`Request timed out after ${timeoutMs}ms: ${context.method} ${context.url}`, context);
-    this.name = "RequestTimeoutError";
-    this.timeoutMs = timeoutMs;
-  }
-}
-
-class NetworkError extends ApiError {
-  constructor(message, context, cause) {
-    super(message, context, { cause });
-    this.name = "NetworkError";
-  }
-}
-
-class RequestAbortedError extends ApiError {
-  constructor(context, cause) {
-    super(`Request aborted: ${context.method} ${context.url}`, context, {
-      cause
-    });
-    this.name = "RequestAbortedError";
-  }
-}
-
-class ConfigError extends ApiError {
-  constructor(message, context) {
-    super(message, context);
-    this.name = "ConfigError";
-  }
-}
-
-class ActionError extends ApiError {
-  constructor(message, context, cause) {
-    super(message, context, { cause });
-    this.name = "ActionError";
-  }
-}
-var isApiError = (e) => e instanceof ApiError;
-var isHttpResponseError = (e) => e instanceof HttpResponseError;
-var isResponseValidationError = (e) => e instanceof ResponseValidationError;
-var isRequestValidationError = (e) => e instanceof RequestValidationError;
-var isRequestTimeoutError = (e) => e instanceof RequestTimeoutError;
-var isNetworkError = (e) => e instanceof NetworkError;
-var isRequestAbortedError = (e) => e instanceof RequestAbortedError;
-var isConfigError = (e) => e instanceof ConfigError;
-var isActionError = (e) => e instanceof ActionError;
-// src/api-wrapper/builders.ts
-import { ZodError as ZodError2 } from "zod";
-function buildUrl(endpoint, params, reqQuery, baseApiUrls, defaultBaseApiUrl, url, configError) {
-  if (url) {
-    const finalUrl2 = replacePathParams(url, params, configError);
-    const queryString2 = new URLSearchParams(buildQueryParamsRaw(endpoint, reqQuery)).toString();
-    return {
-      finalUrl: finalUrl2,
-      fullUrl: queryString2 ? `${finalUrl2}?${queryString2}` : finalUrl2
-    };
-  }
-  const defaultBaseUrl = defaultBaseApiUrl ?? Object.keys(baseApiUrls)[0];
-  if (!defaultBaseUrl) {
-    throw configError("At least one base API URL is required");
-  }
-  const baseUrlKey = endpoint.baseApiUrl ?? defaultBaseUrl;
-  const configBaseUrl = baseApiUrls[baseUrlKey];
-  if (!configBaseUrl) {
-    throw configError(`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, configError);
-  const queryString = new URLSearchParams(buildQueryParamsRaw(endpoint, reqQuery)).toString();
-  return {
-    finalUrl,
-    fullUrl: queryString ? `${finalUrl}?${queryString}` : finalUrl
-  };
-}
-function buildQueryParamsRaw(endpoint, query) {
-  const defaultParams = endpoint.reqDefaultQueryParams ?? {};
-  const merged = { ...defaultParams, ...query ?? {} };
-  return Object.fromEntries(Object.entries(merged).filter(([, value]) => value !== undefined).map(([key, value]) => [key, String(value)]));
-}
-function buildQueryParams(endpoint, query, ctx) {
-  const defaultParams = endpoint.reqDefaultQueryParams ?? {};
-  let parsedQuery;
-  if (endpoint.reqQuerySchema) {
-    try {
-      parsedQuery = endpoint.reqQuerySchema.parse(query);
-    } catch (error) {
-      if (error instanceof ZodError2) {
-        throw new RequestValidationError(error, "query", query, ctx());
-      }
-      throw error;
-    }
-  } else {
-    parsedQuery = 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, ctx) {
-  if (!endpoint.reqBodySchema)
-    return body;
-  let parsedBody;
-  try {
-    parsedBody = endpoint.reqBodySchema.parse(body);
-  } catch (error) {
-    if (error instanceof ZodError2) {
-      throw new RequestValidationError(error, "body", body, ctx());
-    }
-    throw error;
-  }
-  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, ctx) {
-  const contentType = endpoint.reqBodyFormat === "json" ? "application/json" : undefined;
-  let parsedHeaders;
-  if (endpoint.reqHeadersSchema) {
-    try {
-      parsedHeaders = endpoint.reqHeadersSchema.parse(headers);
-    } catch (error) {
-      if (error instanceof ZodError2) {
-        throw new RequestValidationError(error, "headers", headers, ctx());
-      }
-      throw error;
-    }
-  } else {
-    parsedHeaders = headers ?? {};
-  }
-  return normalizeHeaders({
-    ...defaultHeaders,
-    ...contentType && { "Content-Type": contentType },
-    ...endpoint.defaultHeaders,
-    ...parsedHeaders
-  });
-}
-function replacePathParams(path, params, configError) {
-  return path.replace(/:(\w+)/g, (_, key) => {
-    const value = params?.[key];
-    if (value === undefined) {
-      throw configError(`Missing required path parameter: ${key}`);
-    }
-    return encodeURIComponent(String(value));
-  });
-}
-
-// src/api-wrapper/actions-impl.ts
-function createActionCache() {
-  const store = new Map;
-  const isExpired = (entry) => entry.expiresAt !== undefined && entry.expiresAt <= Date.now();
-  const cache = async (key, fn, options) => {
-    const existing = store.get(key);
-    if (existing && !isExpired(existing)) {
-      if (existing.inflight)
-        return existing.inflight;
-      if (existing.hasValue)
-        return existing.value;
-    }
-    const promise = (async () => fn())();
-    const entry = {
-      hasValue: false,
-      inflight: promise,
-      expiresAt: options?.ttlMs !== undefined ? Date.now() + options.ttlMs : undefined
-    };
-    store.set(key, entry);
-    try {
-      const value = await promise;
-      entry.value = value;
-      entry.hasValue = true;
-      entry.inflight = undefined;
-      return value;
-    } catch (error) {
-      store.delete(key);
-      throw error;
-    }
-  };
-  cache.get = (key) => {
-    const entry = store.get(key);
-    if (!entry || !entry.hasValue)
-      return;
-    if (isExpired(entry)) {
-      store.delete(key);
-      return;
-    }
-    return entry.value;
-  };
-  cache.set = (key, value, options) => {
-    store.set(key, {
-      value,
-      hasValue: true,
-      expiresAt: options?.ttlMs !== undefined ? Date.now() + options.ttlMs : undefined
-    });
-  };
-  cache.invalidate = (key) => {
-    store.delete(key);
-  };
-  cache.clear = () => {
-    store.clear();
-  };
-  return cache;
-}
-function makeDefineAction() {
-  function defineAction(...args) {
-    if (args.length === 0) {
-      return (def2) => ({
-        ...def2,
-        noRuntimeInput: false
-      });
-    }
-    const def = args[0];
-    return {
-      ...def,
-      noRuntimeInput: true
-    };
-  }
-  return defineAction;
-}
-var defineAction = makeDefineAction();
-
-// src/api-wrapper/redaction.ts
-var SENSITIVE_HEADER_KEYS = new Set([
-  "authorization",
-  "cookie",
-  "set-cookie",
-  "x-api-key",
-  "x-auth-token"
-]);
-var SENSITIVE_BODY_KEYS = new Set([
-  "password",
-  "token",
-  "accesstoken",
-  "access_token",
-  "refreshtoken",
-  "refresh_token",
-  "secret",
-  "client_secret",
-  "apikey",
-  "api_key"
-]);
-function redactHeaders(headers) {
-  if (!headers)
-    return;
-  const out = {};
-  for (const [k, v] of Object.entries(headers)) {
-    if (SENSITIVE_HEADER_KEYS.has(k.toLowerCase())) {
-      out[k] = "[REDACTED]";
-    } else {
-      out[k] = v;
-    }
-  }
-  return out;
-}
-function redactBody(body) {
-  if (body === null || body === undefined)
-    return body;
-  if (typeof body !== "object" || Array.isArray(body)) {
-    return body;
-  }
-  const rec = body;
-  const out = { ...rec };
-  for (const key of Object.keys(out)) {
-    if (SENSITIVE_BODY_KEYS.has(key.toLowerCase())) {
-      out[key] = "[REDACTED]";
-    }
-  }
-  return out;
-}
-function defaultRedactContext(ctx) {
-  return {
-    ...ctx,
-    requestHeaders: redactHeaders(ctx.requestHeaders),
-    requestBody: redactBody(ctx.requestBody),
-    meta: ctx.meta
-  };
-}
-
-// src/api-wrapper/error-reporting.ts
-function applyErrorContextRedaction(ctx, config) {
-  const base = defaultRedactContext(ctx);
-  return config.redact ? config.redact(base) : base;
-}
-async function reportApiError(err, config) {
-  err.context = applyErrorContextRedaction(err.context, config);
-  try {
-    await config.onError?.(err);
-  } catch {}
-  config.logger?.error?.(err);
-  return err;
-}
-
-// src/api-wrapper/size.ts
-function calculateSizeInMb(data) {
-  let bytes;
-  if (data === undefined || data === null) {
-    bytes = 0;
-  } else if (data instanceof Blob) {
-    bytes = data.size;
-  } else if (typeof FormData !== "undefined" && data instanceof FormData) {
-    bytes = 0;
-    data.forEach((value) => {
-      if (value instanceof Blob)
-        bytes += value.size;
-      else
-        bytes += new TextEncoder().encode(String(value)).length;
-    });
-  } else if (typeof data === "string") {
-    bytes = new TextEncoder().encode(data).length;
-  } else {
-    bytes = new TextEncoder().encode(JSON.stringify(data) ?? "").length;
-  }
-  return bytes / (1024 * 1024);
-}
-
-// src/api-wrapper/transport.ts
-import { ZodError as ZodError3 } from "zod";
-async function validateResponse(schema, data, ctx) {
-  try {
-    return await schema.parseAsync(data);
-  } catch (error) {
-    if (error instanceof ZodError3) {
-      throw new ResponseValidationError(error, data, ctx());
-    }
-    throw error;
-  }
-}
-async function httpRequest(config, ctx) {
-  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 timeoutController = new AbortController;
-  const timeout = config.timeoutMs === undefined ? undefined : setTimeout(() => timeoutController.abort(), config.timeoutMs);
-  const signal = mergeSignals(timeoutController.signal, config.userSignal);
-  try {
-    return await config.fetchFn(fullUrl, {
-      method: config.method,
-      headers: config.headers,
-      body: buildFetchBody(config.body, config.headers),
-      signal
-    });
-  } catch (error) {
-    if (isDomAbortError(error)) {
-      if (config.userSignal?.aborted) {
-        throw new RequestAbortedError(ctx(), error);
-      }
-      if (timeoutController.signal.aborted && config.timeoutMs !== undefined) {
-        throw new RequestTimeoutError(config.timeoutMs, ctx());
-      }
-      throw new RequestAbortedError(ctx(), error);
-    }
-    throw new NetworkError(error instanceof Error ? error.message : String(error), ctx(), error);
-  } finally {
-    if (timeout)
-      clearTimeout(timeout);
-  }
-}
-function isDomAbortError(error) {
-  return typeof error === "object" && error !== null && "name" in error && error.name === "AbortError";
-}
-function mergeSignals(a, b) {
-  if (!b)
-    return a;
-  const anyFn = AbortSignal.any;
-  if (typeof anyFn === "function")
-    return anyFn([a, b]);
-  const controller = new AbortController;
-  const onAbort = () => controller.abort();
-  if (a.aborted)
-    controller.abort();
-  else
-    a.addEventListener("abort", onAbort, { once: true });
-  if (b.aborted)
-    controller.abort();
-  else
-    b.addEventListener("abort", onAbort, { once: true });
-  return controller.signal;
-}
-async function readErrorResponse(response) {
-  const body = await response.text();
-  return {
-    body,
-    headers: getHeadersAsObject(response.headers),
-    status: response.status
-  };
-}
-function getRetryDelay(params) {
-  const { retryDelay, attempt, response } = params;
-  if (response && (response.status === 429 || response.status === 503)) {
-    const retryAfter = response.headers.get("retry-after");
-    if (retryAfter) {
-      const seconds = Number(retryAfter);
-      if (Number.isFinite(seconds))
-        return seconds * 1000;
-      const dateMs = Date.parse(retryAfter);
-      if (!Number.isNaN(dateMs)) {
-        return Math.max(0, dateMs - Date.now());
-      }
-    }
-  }
-  if (typeof retryDelay === "function")
-    return retryDelay(attempt);
-  return retryDelay;
-}
-function shouldAttemptRetryOnError(error) {
-  if (error instanceof HttpResponseError)
-    return false;
-  if (error instanceof ResponseValidationError)
-    return false;
-  if (error instanceof RequestValidationError)
-    return false;
-  if (error instanceof ConfigError)
-    return false;
-  if (error instanceof RequestAbortedError)
-    return false;
-  return true;
-}
-function shouldAttemptRetryOnHttp(retryCtx) {
-  const { error, response } = retryCtx;
-  if (error)
-    return shouldAttemptRetryOnError(error);
-  return response ? response.status >= 500 || response.status === 429 : false;
-}
-async function makeRequestWithRetry(args) {
-  const {
-    config,
-    maxRetries,
-    retryDelay,
-    validateFn,
-    shouldRetry,
-    logger,
-    ctx,
-    endpointName,
-    method,
-    fullUrl,
-    meta,
-    onResponse,
-    onRetry
-  } = args;
-  let retryCount = 0;
-  while (true) {
-    let response;
-    try {
-      logger?.debug?.("API request", config);
-      response = await httpRequest(config, (over) => ctx({ attempt: retryCount, ...over }));
-      await onResponse?.({
-        endpoint: endpointName,
-        method,
-        url: fullUrl,
-        response: response.clone(),
-        attempt: retryCount,
-        meta
-      });
-      if (response.status >= 400) {
-        const retryCtx = {
-          response,
-          retryCount,
-          maxRetries,
-          endpoint: endpointName,
-          method,
-          url: fullUrl
-        };
-        if (retryCount < maxRetries && shouldRetry(retryCtx)) {
-          const delayMs = getRetryDelay({
-            retryDelay,
-            attempt: retryCount,
-            response
-          });
-          await onRetry?.({
-            ...retryCtx,
-            delayMs,
-            nextAttempt: retryCount + 1
-          });
-          retryCount++;
-          await delay(delayMs);
-          continue;
-        }
-        const { body, headers: responseHeaders } = await readErrorResponse(response);
-        throw new HttpResponseError(response.status, body, responseHeaders, ctx({ attempt: retryCount }));
-      }
-      return {
-        validatedData: await validateFn(response),
-        retryCount,
-        httpStatus: response.status
-      };
-    } catch (error) {
-      if (error instanceof HttpResponseError || error instanceof ResponseValidationError || error instanceof RequestValidationError || error instanceof ConfigError || error instanceof RequestAbortedError) {
-        throw error;
-      }
-      const retryCtx = {
-        error,
-        retryCount,
-        maxRetries,
-        endpoint: endpointName,
-        method,
-        url: fullUrl
-      };
-      if (retryCount >= maxRetries || !shouldRetry(retryCtx)) {
-        throw error;
-      }
-      const delayMs = getRetryDelay({
-        retryDelay,
-        attempt: retryCount,
-        response: undefined
-      });
-      await onRetry?.({
-        ...retryCtx,
-        delayMs,
-        nextAttempt: retryCount + 1
-      });
-      retryCount++;
-      await delay(delayMs);
-    }
-  }
-}
-async function validateAndTransformResponse(endpoint, response, ctx) {
-  const responseHeaders = getHeadersAsObject(response.headers);
-  let responseData;
-  if (hasJsonContentType(responseHeaders)) {
-    const text = await response.text();
-    try {
-      responseData = text === "" ? undefined : JSON.parse(text);
-    } catch (error) {
-      throw new ResponseValidationError(makeJsonParseZodError(error, text), text, ctx());
-    }
-  } else {
-    responseData = await response.text();
-  }
-  const transformedData = endpoint.resFormatter ? endpoint.resFormatter(responseData, responseHeaders) : responseData;
-  return validateResponse(endpoint.resSchema, transformedData, ctx);
-}
-function defaultShouldRetry(ctx) {
-  if (ctx.error)
-    return shouldAttemptRetryOnError(ctx.error);
-  return shouldAttemptRetryOnHttp(ctx);
-}
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-// src/api-wrapper/create-client.ts
-function isActionInvokeOptionsOnly(value) {
-  if (value === null || value === undefined)
-    return false;
-  if (typeof value !== "object" || Array.isArray(value))
-    return false;
-  return Object.keys(value).every((k) => k === "signal" || k === "meta");
-}
-function createApiClientImpl(apiConfig) {
-  let actions = {};
-  const cache = createActionCache();
-  const invokeEndpoint = async (endpointKey, input = {}) => {
-    const endpoint = apiConfig.endpoints[endpointKey];
-    const rawInput = input;
-    const endpointName = apiConfig.name ? `${apiConfig.name}.${String(endpointKey)}` : String(endpointKey);
-    const startedAt = Date.now();
-    const maxRetries = input.retries ?? apiConfig.retries ?? 3;
-    const baseContext = {
-      endpoint: endpointName,
-      method: endpoint?.method ?? "GET",
-      url: "",
-      attempt: 0,
-      maxRetries,
-      elapsedMs: 0,
-      meta: input.meta
-    };
-    const elapsed = () => Date.now() - startedAt;
-    const ctx = (over = {}) => ({
-      ...baseContext,
-      elapsedMs: elapsed(),
-      ...over
-    });
-    if (!endpoint) {
-      throw await reportApiError(new ConfigError(`Unknown API endpoint: ${String(endpointKey)}`, ctx()), apiConfig);
-    }
-    baseContext.method = endpoint.method;
-    let finalUrl;
-    let fullUrl;
-    try {
-      const built = buildUrl(endpoint, rawInput.reqParams, rawInput.reqQuery, apiConfig.baseApiUrls, apiConfig.defaultBaseApiUrl, input.url, (msg) => new ConfigError(msg, ctx()));
-      finalUrl = built.finalUrl;
-      fullUrl = built.fullUrl;
-    } catch (e) {
-      if (e instanceof ApiError)
-        throw await reportApiError(e, apiConfig);
-      throw e;
-    }
-    baseContext.url = fullUrl;
-    let queryParams;
-    let body;
-    let headers;
-    try {
-      queryParams = buildQueryParams(endpoint, rawInput.reqQuery, ctx);
-      body = buildRequestBody(endpoint, rawInput.reqBody, ctx);
-      headers = buildHeaders(endpoint, rawInput.reqHeaders, apiConfig.defaultHeaders ?? {}, ctx);
-    } catch (e) {
-      if (e instanceof ApiError)
-        throw await reportApiError(e, apiConfig);
-      throw e;
-    }
-    baseContext.requestHeaders = headers;
-    baseContext.requestBody = body;
-    if (apiConfig.onRequest) {
-      try {
-        const result = await apiConfig.onRequest({
-          endpoint: endpointName,
-          method: endpoint.method,
-          url: fullUrl,
-          headers,
-          body,
-          meta: input.meta
-        });
-        if (result?.headers)
-          headers = result.headers;
-        if (result && "body" in result)
-          body = result.body;
-      } catch (e) {
-        if (e instanceof ApiError)
-          throw await reportApiError(e, apiConfig);
-        throw e;
-      }
-    }
-    const config = {
-      method: endpoint.method,
-      url: finalUrl,
-      queryParams,
-      body,
-      headers,
-      doNotEncodeQueryParams: endpoint.doNotEncodeQueryParams,
-      timeoutMs: input.timeoutMs ?? apiConfig.timeoutMs,
-      fetchFn: input.fetch ?? apiConfig.fetch ?? fetch,
-      userSignal: input.signal
-    };
-    try {
-      const result = await makeRequestWithRetry({
-        config,
-        maxRetries,
-        retryDelay: apiConfig.retryDelayMs ?? 300,
-        validateFn: (response) => validateAndTransformResponse(endpoint, response, ctx),
-        shouldRetry: apiConfig.shouldRetry ?? defaultShouldRetry,
-        logger: apiConfig.logger,
-        ctx,
-        endpointName,
-        method: endpoint.method,
-        fullUrl,
-        meta: input.meta,
-        onResponse: apiConfig.onResponse,
-        onRetry: apiConfig.onRetry
-      });
-      const responseTimeMs = elapsed();
-      const responseSizeMb = calculateSizeInMb(result.validatedData);
-      const requestBodySizeMb = calculateSizeInMb(config.body);
-      return {
-        data: result.validatedData,
-        requestBodySizeMb,
-        responseSizeMb,
-        responseTimeMs,
-        httpStatus: result.httpStatus,
-        retryCount: result.retryCount
-      };
-    } catch (error) {
-      if (error instanceof ApiError)
-        throw await reportApiError(error, apiConfig);
-      throw error;
-    }
-  };
-  async function invokeAction(name, rawInput, options = {}) {
-    const action = actions[name];
-    const inputForHandler = action.noRuntimeInput ? undefined : rawInput;
-    const actionName = apiConfig.name ? `${apiConfig.name}.${name}` : name;
-    const startedAt = Date.now();
-    const baseContext = {
-      endpoint: actionName,
-      method: "GET",
-      url: "",
-      attempt: 0,
-      maxRetries: 0,
-      elapsedMs: 0,
-      meta: options.meta,
-      requestBody: action.noRuntimeInput ? undefined : rawInput
-    };
-    const ctx = (over = {}) => ({
-      ...baseContext,
-      elapsedMs: Date.now() - startedAt,
-      ...over
-    });
-    apiConfig.logger?.debug?.("Action start", { action: actionName });
-    try {
-      const result = await action.handler({
-        input: inputForHandler,
-        api: proxy,
-        signal: options.signal,
-        meta: options.meta,
-        logger: apiConfig.logger,
-        cache
-      });
-      apiConfig.logger?.debug?.("Action end", {
-        action: actionName,
-        elapsedMs: Date.now() - startedAt
-      });
-      return result;
-    } catch (error) {
-      if (error instanceof ApiError) {
-        throw await reportApiError(error, apiConfig);
-      }
-      const wrapped = new ActionError(`Action ${actionName} failed: ${error instanceof Error ? error.message : String(error)}`, ctx(), error);
-      throw await reportApiError(wrapped, apiConfig);
-    }
-  }
-  const request = async (key, input, options) => {
-    if (key in actions) {
-      const action = actions[key];
-      if (action.noRuntimeInput) {
-        if (input === undefined || input === null) {
-          return invokeAction(key, undefined, options ?? {});
-        }
-        if (options !== undefined) {
-          return invokeAction(key, undefined, options);
-        }
-        if (isActionInvokeOptionsOnly(input)) {
-          return invokeAction(key, undefined, input);
-        }
-        return invokeAction(key, undefined, {});
-      }
-      return invokeAction(key, input, options);
-    }
-    return invokeEndpoint(key, input ?? {});
-  };
-  const client = { request, cache };
-  const proxy = new Proxy(client, {
-    get(target, prop, receiver) {
-      if (prop in target || typeof prop !== "string") {
-        return Reflect.get(target, prop, receiver);
-      }
-      if (prop in apiConfig.endpoints) {
-        return (input) => invokeEndpoint(prop, input ?? {});
-      }
-      if (prop in actions) {
-        const action = actions[prop];
-        if (action.noRuntimeInput) {
-          return (first, second) => {
-            if (first === undefined || first === null) {
-              return invokeAction(prop, undefined, second ?? {});
-            }
-            if (second !== undefined) {
-              return invokeAction(prop, undefined, second);
-            }
-            if (isActionInvokeOptionsOnly(first)) {
-              return invokeAction(prop, undefined, first);
-            }
-            return invokeAction(prop, undefined, {});
-          };
-        }
-        return (input, opt) => invokeAction(prop, input, opt);
-      }
-      return;
-    }
-  });
-  const rawActions = apiConfig.actions;
-  if (typeof rawActions === "function") {
-    actions = rawActions({
-      api: proxy,
-      defineAction: makeDefineAction()
-    });
-  } else if (rawActions) {
-    actions = rawActions;
-  }
-  const collisions = Object.keys(actions).filter((key) => (key in apiConfig.endpoints));
-  if (collisions.length > 0) {
-    throw new ConfigError(`Action name(s) collide with endpoint name(s): ${collisions.join(", ")}`, {
-      endpoint: collisions[0],
-      method: "GET",
-      url: "",
-      attempt: 0,
-      maxRetries: 0,
-      elapsedMs: 0
-    });
-  }
-  return proxy;
-}
-var createApiClient = (apiConfig) => createApiClientImpl(apiConfig);
-// 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
-var BYTE_CHUNK_SIZE = 32768;
-var textEncoder = new TextEncoder;
-var textDecoder = new TextDecoder;
-async function jwtSign(payload, secret) {
-  const header = encodeJson({ alg: "HS256" });
-  const body = encodeJson({
-    ...payload,
-    iat: Math.floor(Date.now() / 1000)
-  });
-  const data = `${header}.${body}`;
-  const signature = await sign(data, secret);
-  return `${data}.${encodeBase64Url(signature)}`;
-}
-async function jwtVerify(token, secret) {
-  try {
-    const parts = token.split(".");
-    if (parts.length !== 3)
-      return null;
-    const [encodedHeader, encodedPayload, encodedSignature] = parts;
-    const header = decodeJson(encodedHeader);
-    if (!isJwtHeader(header))
-      return null;
-    const data = `${encodedHeader}.${encodedPayload}`;
-    const signature = decodeBase64Url(encodedSignature);
-    const isValid = await verify(data, signature, secret);
-    if (!isValid)
-      return null;
-    const payload = decodeJson(encodedPayload);
-    if (!isJwtPayload(payload) || !isTimeValid(payload))
-      return null;
-    return payload;
-  } catch (_error) {
-    return null;
-  }
-}
-async function sign(data, secret) {
-  const key = await getKey(secret, ["sign"]);
-  return await getSubtleCrypto().sign("HMAC", key, encodeText(data));
-}
-async function verify(data, signature, secret) {
-  const key = await getKey(secret, ["verify"]);
-  return await getSubtleCrypto().verify("HMAC", key, signature, encodeText(data));
-}
-async function getKey(secret, usages) {
-  return await getSubtleCrypto().importKey("raw", encodeText(secret), {
-    name: "HMAC",
-    hash: "SHA-256"
-  }, false, usages);
-}
-function encodeJson(value) {
-  return encodeBase64Url(encodeText(JSON.stringify(value)));
-}
-function decodeJson(value) {
-  return JSON.parse(textDecoder.decode(decodeBase64Url(value)));
-}
-function encodeBase64Url(value) {
-  const bytes = value instanceof ArrayBuffer ? new Uint8Array(value) : value;
-  return btoa(bytesToBinaryString(bytes)).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
-}
-function decodeBase64Url(value) {
-  const base64 = value.replaceAll("-", "+").replaceAll("_", "/");
-  const padded = base64.padEnd(Math.ceil(base64.length / 4) * 4, "=");
-  return binaryStringToBytes(atob(padded)).buffer;
-}
-function encodeText(value) {
-  return toArrayBuffer(textEncoder.encode(value));
-}
-function toArrayBuffer(bytes) {
-  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
-}
-function bytesToBinaryString(bytes) {
-  let binary = "";
-  for (let offset = 0;offset < bytes.length; offset += BYTE_CHUNK_SIZE) {
-    binary += String.fromCharCode(...bytes.subarray(offset, offset + BYTE_CHUNK_SIZE));
-  }
-  return binary;
-}
-function binaryStringToBytes(binary) {
-  const bytes = new Uint8Array(binary.length);
-  for (let index = 0;index < binary.length; index += 1) {
-    bytes[index] = binary.charCodeAt(index);
-  }
-  return bytes;
-}
-function getSubtleCrypto() {
-  const subtle = globalThis.crypto?.subtle;
-  if (!subtle) {
-    throw new Error("Web Crypto is not available in this runtime");
-  }
-  return subtle;
-}
-function isJwtHeader(value) {
-  return typeof value === "object" && value !== null && "alg" in value && value.alg === "HS256";
-}
-function isJwtPayload(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isTimeValid(payload) {
-  const now = Math.floor(Date.now() / 1000);
-  if (typeof payload.exp === "number" && now >= payload.exp)
-    return false;
-  if (typeof payload.nbf === "number" && now < payload.nbf)
-    return false;
-  return true;
-}
-
-// 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/infisical.ts
-import { z as z4 } from "zod";
-var DEFAULT_INFISICAL_SITE_URL = "https://eu.infisical.com";
-var defaultFetch = globalThis.fetch;
-var infisicalAuthResponseSchema = z4.object({
-  accessToken: z4.string()
-});
-var infisicalSecretSchema = z4.object({
-  secretKey: z4.string(),
-  secretValue: z4.string()
-});
-var infisicalSecretsResponseSchema = z4.object({
-  secrets: z4.array(infisicalSecretSchema)
-});
-async function fetchInfisicalSecrets({
-  keys,
-  projectId,
-  environment,
-  siteUrl,
-  clientId,
-  clientSecret
-}) {
-  const infisical = createInfisicalApiClient(siteUrl);
-  const { data: auth } = await infisical.request("login", {
-    reqBody: {
-      clientId,
-      clientSecret
-    }
-  });
-  const { data } = await infisical.request("listSecrets", {
-    reqHeaders: {
-      Authorization: `Bearer ${auth.accessToken}`
-    },
-    reqQuery: {
-      environment,
-      projectId,
-      secretPath: "/",
-      viewSecretValue: true,
-      expandSecretReferences: true,
-      includeImports: true
-    }
-  });
-  const wantedKeys = new Set(keys);
-  return Object.fromEntries(data.secrets.filter((secret) => wantedKeys.has(secret.secretKey)).map((secret) => [secret.secretKey, secret.secretValue]));
-}
-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");
-  }
-  return fetchInfisicalSecrets({
-    keys,
-    projectId,
-    environment,
-    siteUrl,
-    clientId,
-    clientSecret
-  });
-}
-function createInfisicalApiClient(siteUrl) {
-  return createApiClient({
-    name: "infisical",
-    baseApiUrls: {
-      infisical: siteUrl
-    },
-    defaultBaseApiUrl: "infisical",
-    fetch: getFetch(),
-    retries: 1,
-    endpoints: {
-      login: {
-        method: "POST",
-        path: "/api/v1/auth/universal-auth/login",
-        reqBodySchema: z4.object({
-          clientId: z4.string(),
-          clientSecret: z4.string()
-        }),
-        resSchema: infisicalAuthResponseSchema,
-        reqBodyFormat: "json"
-      },
-      listSecrets: {
-        method: "GET",
-        path: "/api/v4/secrets",
-        reqHeadersSchema: z4.object({
-          Authorization: z4.string()
-        }),
-        reqQuerySchema: z4.object({
-          projectId: z4.string(),
-          environment: z4.string(),
-          secretPath: z4.string(),
-          viewSecretValue: z4.boolean(),
-          expandSecretReferences: z4.boolean(),
-          includeImports: z4.boolean()
-        }),
-        resSchema: infisicalSecretsResponseSchema
-      }
-    }
-  });
-}
-function getFetch() {
-  return globalThis.fetch ?? defaultFetch;
-}
-
-// src/secrets/loaders.ts
-function cloudflareWorkerEnvLoader(workerEnv) {
-  return async (ctx) => {
-    const out = {};
-    for (const key of ctx.keys) {
-      const str = workerBindingToString(workerEnv[key]);
-      if (str !== undefined) {
-        out[key] = str;
-      }
-    }
-    return out;
-  };
-}
-function workerBindingToString(value) {
-  if (value === undefined || value === null) {
-    return;
-  }
-  if (typeof value === "string") {
-    return value === "" ? undefined : value;
-  }
-  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
-    return String(value);
-  }
-  if (typeof value === "object") {
-    return JSON.stringify(value);
-  }
-  return String(value);
-}
-function infisicalLoader(config) {
-  return async (ctx) => fetchInfisicalSecrets({
-    keys: ctx.keys,
-    projectId: config.projectId,
-    environment: ctx.environment,
-    siteUrl: config.siteUrl ?? DEFAULT_INFISICAL_SITE_URL,
-    clientId: config.clientId,
-    clientSecret: config.clientSecret
-  });
-}
-async function processEnvLoader(_ctx) {
-  return {};
-}
-
-// 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/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}`);
-}
-
-// src/secrets/index.ts
-var logger = createCoolLogger();
-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 resolvedOptions = resolveSecretSetOptions(options);
-  let cachedSecrets = null;
-  const loadSecrets = async (force = false) => {
-    const nextSecrets = await loadAndMergeSecrets({
-      keySet,
-      cachedSecrets,
-      force,
-      ...resolvedOptions
-    });
-    cachedSecrets = nextSecrets;
-    return nextSecrets;
-  };
-  const secretSet = createSecretSet({
-    getCachedSecrets: () => cachedSecrets,
-    reload: loadSecrets
-  });
-  await loadSecrets();
-  return secretSet;
-}
-function resolveSecretSetOptions(options) {
-  const environment = resolveEnvironment(options.environment);
-  const loader = options.loader ? options.loader : (context) => loadInfisicalSecrets({
-    ...context,
-    projectId: options.projectId,
-    siteUrl: options.siteUrl ?? DEFAULT_INFISICAL_SITE_URL,
-    clientIdEnvKey: options.clientIdEnvKey ?? "INFISICAL_CLIENT_ID",
-    clientSecretEnvKey: options.clientSecretEnvKey ?? "INFISICAL_CLIENT_SECRET"
-  });
-  return {
-    loader,
-    environment
-  };
-}
-async function loadAndMergeSecrets({
-  keySet,
-  cachedSecrets,
-  loader,
-  environment,
-  force
-}) {
-  const processEnvSecrets = readProcessEnvSecrets(keySet, force ? cachedSecrets : null);
-  const keysMissingFromEnv = keySet.filter((key) => !processEnvSecrets[key]);
-  logSecretEnvironment(environment, keySet.length);
-  const loaderKeys = force ? keySet : keysMissingFromEnv;
-  const loadedSecrets = loaderKeys.length === 0 ? {} : await loader({
-    keys: loaderKeys,
-    environment
-  });
-  const missingKeys = keySet.filter((key) => !(processEnvSecrets[key] ?? loadedSecrets[key]));
-  if (missingKeys.length > 0) {
-    throw new Error(`Missing secrets: ${missingKeys.join(", ")}`);
-  }
-  const nextSecrets = Object.fromEntries(keySet.map((key) => [
-    key,
-    processEnvSecrets[key] ?? loadedSecrets[key]
-  ]));
-  for (const [key, value] of Object.entries(nextSecrets)) {
-    process.env[key] = value;
-  }
-  return nextSecrets;
-}
-function createSecretSet({
-  getCachedSecrets,
-  reload
-}) {
-  const secretSet = {
-    secret(key) {
-      const value = getCachedSecrets()?.[key] ?? process.env[key];
-      if (!value) {
-        throw new Error(`Secret ${key} not found`);
-      }
-      return value;
-    },
-    secrets() {
-      const cachedSecrets = getCachedSecrets();
-      if (!cachedSecrets) {
-        throw new Error("Secrets not initialized.");
-      }
-      return { ...cachedSecrets };
-    },
-    async reload() {
-      await reload(true);
-      return secretSet;
-    }
-  };
-  return secretSet;
-}
-function resolveEnvironment(environment) {
-  if (typeof environment === "function")
-    return environment();
-  return environment ?? getSecretEnvironment();
-}
-function logSecretEnvironment(environment, secretCount) {
-  logger.info(colorize("Loading secrets", "cyan", "bold"), {
-    environment: colorize(environment, "brightCyan", "bold"),
-    count: secretCount
-  });
-}
-function readProcessEnvSecrets(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]]));
-}
+import {
+  chunkArray2,
+  findArrayDifferenceByKey2,
+  getUniqueValues2,
+  compact2,
+  getUniqueValuesByKey2,
+  groupBy2,
+  countBy2,
+  keyBy2,
+  partition2,
+  pickItemsInArray2,
+  toArray2,
+  sumBy2,
+  sortBy2,
+  range2
+} from "../index-hy7kbb99.js";
+import {
+  createCache2
+} from "../index-k9yx6bne.js";
+import {
+  ok2,
+  err2,
+  isSuccess2,
+  isFailure2,
+  unwrapResult2,
+  backgroundPromise2,
+  backgroundPromiseSync2,
+  promiseTimeout2,
+  tryCatch2,
+  PromiseTimeoutError2,
+  withTimeout2,
+  exponentialBackoff2,
+  retry2,
+  pMap2,
+  startTimer2,
+  timed2,
+  anySignal2,
+  timeoutSignal2,
+  raceAbort2,
+  createLatestGuard2
+} from "../index-0zvtcbzy.js";
+import {
+  InvariantError2,
+  getErrorMessage2,
+  toError2,
+  must2,
+  invariant2,
+  isRecord2,
+  isPlainObject2,
+  isDefined2,
+  isTruthy2,
+  isString2,
+  isNumber2,
+  isBoolean2,
+  isFunction2,
+  isOneOf2,
+  hasKey2,
+  isNonEmpty2,
+  nonEmpty2
+} from "../index-8r2vdzjg.js";
+import {
+  extractNumber2,
+  generateId2,
+  sha256Id2,
+  slugify2,
+  stableStringify2,
+  truncate2,
+  normalizeWhitespace2,
+  escapeRegExp2,
+  foldForSearch2,
+  matchesSearch2,
+  initials2,
+  safeJsonParse2
+} from "../index-kj1phgrx.js";
+import {
+  buildQueryString2,
+  replacePathParams2,
+  buildUrl2,
+  normalizeDomain2,
+  getDomainFaviconUrl2,
+  trimTrailingSlash2,
+  ensureLeadingSlash2,
+  buildMailto2,
+  parseRetryAfter2
+} from "../index-mnkcfyx8.js";
 
 // src/typedswitch/index.ts
-function runSwitch(value, keyOrCases, casesOrDefault, defaultCase) {
+function typedSwitch(value, keyOrCases, casesOrDefault, defaultCase) {
   let key;
   let cases;
   let defaultHandler;
@@ -2334,213 +93,34 @@ function runSwitch(value, keyOrCases, casesOrDefault, defaultCase) {
   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));
+    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" && typeof discriminantValue !== "number" && typeof discriminantValue !== "boolean") {
+      throw new Error(`Invalid discriminant value for key "${discriminantKey}": expected string, number or boolean, received ${typeof discriminantValue}`);
+    }
+    key = String(discriminantValue);
+    cases = casesOrDefault;
+    defaultHandler = defaultCase;
   }
-  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)]));
+  const handler = Object.hasOwn(cases, key) ? cases[key] : undefined;
+  if (handler) {
+    return handler(value);
   }
-  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;
+  if (defaultHandler) {
+    return defaultHandler(value);
   }
-  run();
-}
-function backgroundPromiseSync(promiseFactory, options = {}) {
-  backgroundPromise(promiseFactory, {
-    ...options,
-    scheduler: options.scheduler ?? queueMicrotask
-  });
-}
-function promiseTimeout(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  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}`);
 }
-async function tryCatch(promise) {
-  try {
-    const data = await promise;
-    return { data, error: null };
-  } catch (error) {
-    return { data: null, error };
-  }
+function assertNever(value, message) {
+  throw new Error(message ?? `Unexpected value: ${String(value)}`);
 }
 // src/cache/index.ts
 function cacheFunction(options) {
@@ -2551,84 +131,151 @@ function cacheFunction(options) {
     refreshInBackground = false,
     cacheKeyArgs,
     cacheKeyFn,
-    onBackgroundRefreshError
+    onBackgroundRefreshError,
+    store,
+    onStoreError,
+    maxEntries
   } = options;
+  const externalStore = store;
   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);
-      }
+  const entryLifetimeMs = refreshInBackground ? cacheTimeMs * 2 : cacheTimeMs;
+  let cleanupInterval;
+  const stopCleanup = () => {
+    if (cleanupInterval !== undefined) {
+      clearInterval(cleanupInterval);
+      cleanupInterval = undefined;
     }
-  }, 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 ensureCleanup = () => {
+    if (cleanupInterval !== undefined) {
+      return;
     }
-    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;
+    cleanupInterval = setInterval(() => {
+      const now = Date.now();
+      for (const [key, entry] of cache.entries()) {
+        if (now - entry.timestamp >= entryLifetimeMs) {
+          cache.delete(key);
         }
       }
+      if (cache.size === 0) {
+        stopCleanup();
+      }
+    }, Math.min(cacheTimeMs / 2, 5 * 60 * 1000));
+    cleanupInterval.unref?.();
+  };
+  const buildKey = (args) => {
+    const keyArgs = cacheKeyFn ? cacheKeyFn(...args) : cacheKeyArgs ? cacheKeyArgs.map((i) => args[i]) : args;
+    return `${name}:${stableStringify2(keyArgs)}`;
+  };
+  const isFresh = (entry) => Date.now() - entry.timestamp < cacheTimeMs;
+  const servable = (entry) => entry && (refreshInBackground || isFresh(entry)) ? entry : undefined;
+  const touch = (key, entry) => {
+    cache.delete(key);
+    cache.set(key, entry);
+    if (maxEntries !== undefined && cache.size > maxEntries) {
+      cache.delete(cache.keys().next().value);
+    }
+  };
+  const guardStore = async (operation) => {
+    try {
+      return await operation();
+    } catch (error) {
+      onStoreError?.(error, { name });
+      return;
+    }
+  };
+  const save = (key, value) => {
+    const entry = { value, timestamp: Date.now() };
+    if (externalStore) {
+      return guardStore(() => externalStore.set(key, entry, entryLifetimeMs));
     }
+    touch(key, entry);
+    ensureCleanup();
+  };
+  const run = (key, args, stale) => {
     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);
+    if (!isPromiseLike(result)) {
+      save(key, result);
+      return result;
+    }
+    const promise = Promise.resolve(result).then(async (value) => {
+      if (pendingPromises.get(key) === promise) {
+        await save(key, value);
+      }
+      return value;
+    }, (error) => {
+      if (!stale)
         throw error;
-      });
-      pendingPromises.set(key, promise);
-      return promise;
+      onBackgroundRefreshError?.(error, { name });
+      return stale.value;
+    }).finally(() => {
+      if (pendingPromises.get(key) === promise) {
+        pendingPromises.delete(key);
+      }
+    });
+    pendingPromises.set(key, promise);
+    return promise;
+  };
+  const serve = (key, args, entry) => {
+    if (!isFresh(entry) && !pendingPromises.has(key)) {
+      run(key, args, entry);
     }
-    cache.set(key, { value: result, timestamp: now });
-    return result;
+    return entry.value;
+  };
+  const callWithStore = (cacheStore, key, args) => {
+    const pending = pendingPromises.get(key);
+    if (pending && !refreshInBackground) {
+      return pending;
+    }
+    return (async () => {
+      const entry = await guardStore(() => cacheStore.get(key));
+      const cached = servable(entry);
+      if (cached) {
+        return serve(key, args, cached);
+      }
+      if (entry) {
+        await guardStore(() => cacheStore.delete(key));
+      }
+      return pendingPromises.get(key) ?? run(key, args);
+    })();
+  };
+  const wrappedFn = (...args) => {
+    const key = buildKey(args);
+    if (externalStore) {
+      return callWithStore(externalStore, key, args);
+    }
+    const cached = servable(cache.get(key));
+    if (cached) {
+      touch(key, cached);
+      return serve(key, args, cached);
+    }
+    cache.delete(key);
+    return pendingPromises.get(key) ?? run(key, args);
   };
   wrappedFn.clearCache = () => {
     cache.clear();
     pendingPromises.clear();
-    clearInterval(cleanupInterval);
+    stopCleanup();
+    const clearStore = externalStore?.clear?.bind(externalStore);
+    if (clearStore) {
+      guardStore(clearStore);
+    }
+  };
+  wrappedFn.invalidate = (...args) => {
+    const key = buildKey(args);
+    cache.delete(key);
+    pendingPromises.delete(key);
+    if (externalStore) {
+      guardStore(() => externalStore.delete(key));
+    }
+  };
+  wrappedFn.peek = (...args) => {
+    const key = buildKey(args);
+    if (externalStore) {
+      return guardStore(() => externalStore.get(key)).then((entry) => servable(entry)?.value);
+    }
+    return servable(cache.get(key))?.value;
   };
   return wrappedFn;
 }
@@ -2650,84 +297,54 @@ class SimpleStateMachine {
   }
   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;
+    const entries = Object.entries(actionsMap).filter((entry) => !!entry[1]);
+    const results = await Promise.all(entries.map(([action, targetState]) => this.validateTransition(targetState, { action })));
+    return Object.fromEntries(entries.map(([action], i) => [action, results[i]]));
   }
   async getPossibleTransitions() {
     const possibleTransitions = this.config.stateTransitions[this.getCurrentStatus()] || [];
     const actionsMap = this.config.stateActionMap[this.getCurrentStatus()] || {};
-    const result = {};
-    for (const targetState of possibleTransitions) {
+    const results = await Promise.all(possibleTransitions.map(async (targetState) => {
       const actionsToTarget = Object.entries(actionsMap).filter(([, t]) => t === targetState);
       if (actionsToTarget.length === 0) {
-        result[targetState] = await this.validateTransition(targetState);
-        continue;
+        return this.validateTransition(targetState);
       }
-      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;
+      const rs = await Promise.all(actionsToTarget.map(([action]) => this.validateTransition(targetState, { action })));
+      return rs.includes(true) ? true : rs[rs.length - 1];
+    }));
+    return Object.fromEntries(possibleTransitions.map((targetState, i) => [targetState, results[i]]));
   }
-  async executeAction(action, data) {
+  async canExecute(action) {
     const actionsMap = this.config.stateActionMap[this.getCurrentStatus()];
     if (!actionsMap) {
-      return {
-        success: false,
-        error: `No actions defined for state '${this.getCurrentStatus()}'`
-      };
+      return `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()}'`
-      };
+      return `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 this.validateTransition(targetState, { action });
+  }
+  async executeAction(action, data) {
+    const fromState = this.getCurrentStatus();
+    const validationResult = await this.canExecute(action);
+    if (validationResult !== true) {
+      return { success: false, error: validationResult };
+    }
+    const targetState = this.config.stateActionMap[fromState][action];
+    try {
+      const result = await this.config.actions?.[action]?.(this.item, data);
+      await this.config.onTransition?.(this.item, fromState, targetState, action);
+      if (this.config.applyTransition) {
+        this.item[this.stateKey] = targetState;
       }
+      return { success: true, newState: targetState, result };
+    } catch (error) {
       return {
-        success: true,
-        newState: targetState
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
       };
     }
-    return {
-      success: false,
-      error: validationResult
-    };
   }
   async validateTransition(toState, options) {
     const action = options?.action;
@@ -2745,7 +362,14 @@ class SimpleStateMachine {
     }
     const stateValidator = this.config.validators?.[toState];
     if (stateValidator) {
-      return await stateValidator(this.item, this.getCurrentStatus(), toState, action);
+      const stateResult = await stateValidator(this.item, this.getCurrentStatus(), toState, action);
+      if (stateResult !== true) {
+        return stateResult;
+      }
+    }
+    const actionValidator = action && this.config.actionValidators?.[action];
+    if (actionValidator) {
+      return await actionValidator(this.item, this.getCurrentStatus(), toState, action);
     }
     return true;
   }
@@ -2753,17 +377,23 @@ class SimpleStateMachine {
     return Object.keys(this.config.stateTransitions);
   }
   getInitialState() {
-    return this.getStates()[0];
+    return this.config.initialState ?? this.getStates()[0];
   }
 }
+function createStateMachine(config) {
+  return {
+    config,
+    for: (item, stateKey) => new SimpleStateMachine(config, item, stateKey)
+  };
+}
 // src/math/linearRegressionTrend.ts
-function linearRegressionTrend(values) {
+function linearRegression(values) {
   const n = values.length;
   if (n < 2)
-    return [];
+    return null;
   for (const v of values) {
     if (!Number.isFinite(v))
-      return [];
+      return null;
   }
   let sumX = 0;
   let sumY = 0;
@@ -2779,24 +409,155 @@ function linearRegressionTrend(values) {
   }
   const denom = n * sumX2 - sumX * sumX;
   if (denom === 0)
-    return [];
+    return null;
   const slope = (n * sumXY - sumX * sumY) / denom;
   const intercept = (sumY - slope * sumX) / n;
-  const out = [];
+  const mean = sumY / n;
+  const fitted = [];
+  let ssRes = 0;
+  let ssTot = 0;
   for (let i = 0;i < n; i++) {
-    out.push(intercept + slope * i);
+    const y = values[i];
+    const f = intercept + slope * i;
+    fitted.push(f);
+    ssRes += (y - f) ** 2;
+    ssTot += (y - mean) ** 2;
   }
-  return out;
+  return { slope, intercept, r2: ssTot === 0 ? 1 : 1 - ssRes / ssTot, fitted };
+}
+function linearRegressionTrend(values) {
+  return linearRegression(values)?.fitted ?? [];
+}
+// src/math/scale.ts
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+function lerp(start, end, t) {
+  return start + (end - start) * t;
+}
+function normalize(value, min, max) {
+  if (max <= min)
+    return 0;
+  return clamp((value - min) / (max - min), 0, 1);
+}
+// src/color/contrast.ts
+function colorFunctionArgs(color) {
+  const match = /^(rgb|hsl)a?\(([^()]*)\)$/i.exec(color.trim());
+  const args = match?.[2]?.trim().split(/[\s,/]+/);
+  if (!match || !args || args.length !== 3 && args.length !== 4) {
+    return;
+  }
+  return { name: match[1].toLowerCase(), args };
+}
+function parseChannel(raw, percentOf) {
+  const isPercent = raw.endsWith("%");
+  const text = isPercent ? raw.slice(0, -1) : raw;
+  const n = text === "" ? Number.NaN : Number(text);
+  if (!Number.isFinite(n))
+    return;
+  return isPercent ? n / 100 * percentOf : n;
+}
+function hslToRgb(h, s, l) {
+  const a = s * Math.min(l, 1 - l);
+  const f = (n) => {
+    const k = (n + h / 30) % 12;
+    return (l - a * Math.max(-1, Math.min(k - 3, 9 - k, 1))) * 255;
+  };
+  return [f(0), f(8), f(4)];
+}
+function parseColor(color) {
+  const trimmed = color.trim();
+  const hex = /^#([\da-f]{3,4}|[\da-f]{6}|[\da-f]{8})$/i.exec(trimmed)?.[1];
+  if (hex) {
+    const full = hex.length <= 4 ? hex.replace(/./g, "$&$&") : hex;
+    const [r = 0, g = 0, b = 0, a = 255] = [0, 2, 4, 6].map((i) => i < full.length ? Number.parseInt(full.slice(i, i + 2), 16) : undefined);
+    return { r, g, b, a: a / 255 };
+  }
+  const fn = colorFunctionArgs(trimmed);
+  if (!fn)
+    return;
+  const [x = "", y = "", z = "", alpha = "1"] = fn.args;
+  const isRgb = fn.name === "rgb";
+  const c1 = parseChannel(isRgb ? x : x.replace(/deg$/i, ""), isRgb ? 255 : 360);
+  const c2 = parseChannel(y, isRgb ? 255 : 100);
+  const c3 = parseChannel(z, isRgb ? 255 : 100);
+  const a = parseChannel(alpha, 1);
+  if (c1 === undefined || c2 === undefined || c3 === undefined)
+    return;
+  if (a === undefined)
+    return;
+  const [r, g, b] = isRgb ? [c1, c2, c3] : hslToRgb((c1 % 360 + 360) % 360, clamp(c2 / 100, 0, 1), clamp(c3 / 100, 0, 1));
+  const channel = (v) => Math.round(clamp(v, 0, 255));
+  return { r: channel(r), g: channel(g), b: channel(b), a: clamp(a, 0, 1) };
+}
+function toRgba(color) {
+  if (typeof color !== "string")
+    return color;
+  const parsed = parseColor(color);
+  if (!parsed)
+    throw new TypeError(`Unsupported color: ${color}`);
+  return parsed;
+}
+function toHex(color, options = {}) {
+  const { r, g, b, a } = toRgba(color);
+  const channels = options.alpha ? [r, g, b, a * 255] : [r, g, b];
+  return `#${channels.map((v) => Math.round(clamp(v, 0, 255)).toString(16).padStart(2, "0")).join("")}`;
+}
+function toRgbString(color) {
+  const { r, g, b, a } = toRgba(color);
+  const [rr, gg, bb] = [r, g, b].map((v) => Math.round(clamp(v, 0, 255)));
+  return a < 1 ? `rgba(${rr}, ${gg}, ${bb}, ${a})` : `rgb(${rr}, ${gg}, ${bb})`;
+}
+function relativeLuminance(color) {
+  const { r, g, b } = toRgba(color);
+  const [lr, lg, lb] = [r, g, b].map((v) => {
+    const c = clamp(v, 0, 255) / 255;
+    return c <= 0.03928 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+  });
+  return 0.2126 * lr + 0.7152 * lg + 0.0722 * lb;
+}
+function contrastRatio(a, b) {
+  const la = relativeLuminance(a);
+  const lb = relativeLuminance(b);
+  return (Math.max(la, lb) + 0.05) / (Math.min(la, lb) + 0.05);
 }
-// src/math/metricsSeriesColors.ts
+function contrastText(background, options = {}) {
+  const { light = "#ffffff", dark = "#000000" } = options;
+  return contrastRatio(background, light) >= contrastRatio(background, dark) ? light : dark;
+}
+function mix(a, b, weight) {
+  const t = clamp(weight, 0, 1);
+  const at = (x, y) => x + (y - x) * t;
+  return {
+    r: at(a.r, b.r),
+    g: at(a.g, b.g),
+    b: at(a.b, b.b),
+    a: at(a.a, b.a)
+  };
+}
+var hexOf = (color) => toHex(color, { alpha: color.a < 1 });
+function mixColors(a, b, weight) {
+  return hexOf(mix(toRgba(a), toRgba(b), weight));
+}
+function shade(color, amount) {
+  const base = toRgba(color);
+  const v = amount < 0 ? 0 : 255;
+  return hexOf(mix(base, { r: v, g: v, b: v, a: base.a }, Math.abs(amount)));
+}
+// src/color/metricsSeriesColors.ts
 var METRICS_SERIES_PALETTE_SIZE = 10;
-function hashStringToColorIndex(str) {
+function hashStringToColorIndex(str, paletteSize = METRICS_SERIES_PALETTE_SIZE) {
   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;
+  return Math.abs(hash) % paletteSize;
+}
+function pickFromPalette(seed, palette) {
+  if (palette.length === 0)
+    throw new RangeError("palette is empty");
+  return palette[hashStringToColorIndex(seed, palette.length)];
 }
 function circularHueDistance(a, b, paletteSize) {
   const diff = Math.abs(a - b);
@@ -2823,21 +584,20 @@ function seriesColorKey(label, key) {
     return fromLabel;
   return key.trim() || key;
 }
-function resolveSeriesColorMap(keys) {
+function resolveSeriesColorMap(keys, paletteSize = METRICS_SERIES_PALETTE_SIZE) {
   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));
+    result.set(only, hashStringToColorIndex(only, paletteSize));
     return result;
   }
   const usedIndices = new Set;
   const entries = uniqueKeys.map((key) => ({
     key,
-    preferred: hashStringToColorIndex(key)
+    preferred: hashStringToColorIndex(key, paletteSize)
   }));
   for (const entry of entries) {
     if (!usedIndices.has(entry.preferred)) {
@@ -2859,35 +619,25 @@ function resolveSeriesColorMap(keys) {
   }
   return result;
 }
-function createResolveColorsByKeys(keys, getSeriesColor, getSeriesHoverColor) {
-  const colorMap = resolveSeriesColorMap(keys);
+function createResolveColorsByKeys(keys, getSeriesColor, getSeriesHoverColor, paletteSize = METRICS_SERIES_PALETTE_SIZE) {
+  const colorMap = resolveSeriesColorMap(keys, paletteSize);
+  const indexOf = (key) => colorMap.get(key) ?? hashStringToColorIndex(key, paletteSize);
   return {
-    getColor: (key) => getSeriesColor(colorMap.get(key) ?? hashStringToColorIndex(key)),
-    getHoverColor: (key) => getSeriesHoverColor(colorMap.get(key) ?? hashStringToColorIndex(key))
+    getColor: (key) => getSeriesColor(indexOf(key)),
+    getHoverColor: (key) => getSeriesHoverColor(indexOf(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})`);
+  const rgba = parseColor(trimmed);
+  const fn = rgba && colorFunctionArgs(trimmed);
+  if (fn?.name === "hsl") {
+    const [h, s, l] = fn.args;
+    return `hsla(${h}, ${s}, ${l}, ${alpha})`;
   }
-  if (trimmed.startsWith("rgba(")) {
-    return trimmed.replace(/,\s*[\d.]+\)$/, `, ${alpha})`);
-  }
-  return trimmed;
+  if (rgba)
+    return `rgba(${rgba.r}, ${rgba.g}, ${rgba.b}, ${alpha})`;
+  return `color-mix(in srgb, ${trimmed} ${alpha * 100}%, transparent)`;
 }
 function getHeatmapCellStyle(params) {
   const {
@@ -2910,136 +660,440 @@ function getHeatmapCellStyle(params) {
       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)
+    backgroundColor: withAlpha(baseColor, lerp(minAlpha, maxAlpha, normalize(value, min, max)))
   };
 }
 // 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)
-      };
-    }
+var MONTHS_PER_PERIOD = { MONTHLY: 1, QUARTERLY: 3, YEARLY: 12 };
+function ymd(date, utc = false) {
+  return utc ? [date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()] : [date.getFullYear(), date.getMonth(), date.getDate()];
+}
+function startOfDay(y, m, d, utc = false) {
+  return utc ? new Date(Date.UTC(y, m, d)) : new Date(y, m, d);
+}
+function addPeriod(date, type, n, options = {}) {
+  const { utc = false } = options;
+  let [y, m, d] = ymd(date, utc);
+  if (type === "DAILY" || type === "WEEKLY") {
+    d += n * (type === "WEEKLY" ? 7 : 1);
+  } else {
+    m += n * MONTHS_PER_PERIOD[type];
+    d = Math.min(d, new Date(Date.UTC(y, m + 1, 0)).getUTCDate());
   }
+  const out = new Date(date);
+  if (utc)
+    out.setUTCFullYear(y, m, d);
+  else
+    out.setFullYear(y, m, d);
+  return out;
+}
+function getPeriod(type, referenceDate = new Date, offset = 0, options = {}) {
+  const { utc = false, weekStartsOn = 1 } = options;
+  const [y, m, d] = ymd(referenceDate, utc);
+  const weekday = utc ? referenceDate.getUTCDay() : referenceDate.getDay();
+  const anchor = {
+    DAILY: () => startOfDay(y, m, d, utc),
+    WEEKLY: () => startOfDay(y, m, d - (weekday - weekStartsOn + 7) % 7, utc),
+    MONTHLY: () => startOfDay(y, m, 1, utc),
+    QUARTERLY: () => startOfDay(y, m - m % 3, 1, utc),
+    YEARLY: () => startOfDay(y, 0, 1, utc)
+  }[type]();
+  const [ey, em, ed] = ymd(addPeriod(anchor, type, offset + 1, { utc }), utc);
+  return {
+    start: addPeriod(anchor, type, offset, { utc }),
+    end: startOfDay(ey, em, ed - 1, utc)
+  };
+}
+function getPreviousReportPeriod(periodType, referenceDate = new Date) {
+  return getPeriod(periodType, referenceDate, -1);
 }
-function formatPeriodLabel(start, end, includeDay = false) {
+function formatPeriodLabel(start, end, options = false) {
+  const {
+    includeDay = false,
+    locale = "en-GB",
+    separator = " — ",
+    collapse = false,
+    timeZone
+  } = typeof options === "boolean" ? { includeDay: options } : options;
   const s = start instanceof Date ? start : new Date(start);
   const e = end instanceof Date ? end : new Date(end);
-  const opts = {
+  const format = new Intl.DateTimeFormat(locale, {
     year: "numeric",
     month: "long",
-    ...includeDay && { day: "numeric" }
+    ...includeDay && { day: "numeric" },
+    timeZone
+  });
+  return collapse ? format.formatRange(s, e) : `${format.format(s)}${separator}${format.format(e)}`;
+}
+// src/object/index.ts
+function typedKeys(object) {
+  return Object.keys(object);
+}
+function typedEntries(object) {
+  return Object.entries(object);
+}
+function typedFromEntries(entries) {
+  return Object.fromEntries(entries);
+}
+function recordFromKeys(keys, fn) {
+  return typedFromEntries(keys.map((key) => [key, fn(key)]));
+}
+function mapValues(object, fn) {
+  return typedFromEntries(typedEntries(object).map(([key, value]) => [key, fn(value, key)]));
+}
+function pick(object, keys) {
+  const result = {};
+  for (const key of keys) {
+    if (key in object)
+      result[key] = object[key];
+  }
+  return result;
+}
+function omit(object, keys) {
+  const result = { ...object };
+  for (const key of keys)
+    delete result[key];
+  return result;
+}
+var UNSAFE_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+function toPath(path) {
+  if (typeof path !== "string")
+    return path;
+  return path === "" ? [] : path.split(".");
+}
+function getAtPath(object, path) {
+  let current = object;
+  for (const key of toPath(path)) {
+    if (current === null || typeof current !== "object")
+      return;
+    current = current[key];
+  }
+  return current;
+}
+function setAtPath(object, path, value) {
+  const keys = toPath(path);
+  if (keys.length === 0)
+    throw new Error("Path must not be empty");
+  for (const key of keys) {
+    if (UNSAFE_KEYS.has(String(key))) {
+      throw new Error(`Unsafe path segment: ${key}`);
+    }
+  }
+  let current = object;
+  for (let index = 0;index < keys.length - 1; index++) {
+    const key = keys[index];
+    let next = current[key];
+    if (next === null || typeof next !== "object") {
+      next = /^\d+$/.test(String(keys[index + 1])) ? [] : {};
+      current[key] = next;
+    }
+    current = next;
+  }
+  current[keys.at(-1)] = value;
+}
+// src/function/index.ts
+function debounce(fn, waitMs, options = {}) {
+  let timer;
+  let maxTimer;
+  let lastArgs;
+  const cancel = () => {
+    clearTimeout(timer);
+    clearTimeout(maxTimer);
+    timer = maxTimer = lastArgs = undefined;
+  };
+  const flush = () => {
+    const args = lastArgs;
+    cancel();
+    if (args)
+      fn(...args);
+  };
+  const debounced = (...args) => {
+    const idle = timer === undefined;
+    clearTimeout(timer);
+    timer = setTimeout(flush, waitMs);
+    if (options.maxWaitMs !== undefined && maxTimer === undefined) {
+      maxTimer = setTimeout(flush, options.maxWaitMs);
+    }
+    if (idle && options.leading)
+      fn(...args);
+    else
+      lastArgs = args;
+  };
+  return Object.assign(debounced, {
+    cancel,
+    flush,
+    pending: () => lastArgs !== undefined
+  });
+}
+function keyedDebounce(fn, waitMs) {
+  const byKey = new Map;
+  const each = (key, action) => {
+    const targets = key === undefined ? [...byKey.values()] : [byKey.get(key)];
+    for (const debounced of targets)
+      if (debounced)
+        action(debounced);
+  };
+  return {
+    call(key, ...args) {
+      let debounced = byKey.get(key);
+      if (!debounced) {
+        debounced = debounce((...latest) => {
+          byKey.delete(key);
+          fn(key, ...latest);
+        }, waitMs);
+        byKey.set(key, debounced);
+      }
+      debounced(...args);
+    },
+    cancel(key) {
+      each(key, (debounced) => debounced.cancel());
+      if (key === undefined)
+        byKey.clear();
+      else
+        byKey.delete(key);
+    },
+    flush(key) {
+      each(key, (debounced) => debounced.flush());
+    }
+  };
+}
+function throttle(fn, intervalMs, options = {}) {
+  const { trailing = true } = options;
+  let timer;
+  let trailingArgs;
+  const invoke = (args) => {
+    timer = setTimeout(() => {
+      timer = undefined;
+      const next = trailingArgs;
+      trailingArgs = undefined;
+      if (next)
+        invoke(next);
+    }, intervalMs);
+    fn(...args);
+  };
+  const throttled = (...args) => {
+    if (timer === undefined)
+      invoke(args);
+    else if (trailing)
+      trailingArgs = args;
+  };
+  return Object.assign(throttled, {
+    cancel: () => {
+      clearTimeout(timer);
+      timer = trailingArgs = undefined;
+    }
+  });
+}
+function once(fn) {
+  let called = false;
+  let result;
+  return (...args) => {
+    if (!called) {
+      called = true;
+      result = fn(...args);
+    }
+    return result;
   };
-  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}`;
+function createHeartbeat(options) {
+  const {
+    now = Date.now,
+    setTimeout: schedule = (callback, ms) => setTimeout(callback, ms),
+    clearTimeout: unschedule = (timer) => clearTimeout(timer)
+  } = options;
+  let active = false;
+  let lastSentAt = 0;
+  let idleTimer;
+  const stop = () => {
+    if (idleTimer !== undefined)
+      unschedule(idleTimer);
+    idleTimer = undefined;
+    if (!active)
+      return;
+    active = false;
+    options.onStop?.();
+  };
+  return {
+    activity() {
+      const time = now();
+      if (!active || time - lastSentAt >= options.intervalMs) {
+        active = true;
+        lastSentAt = time;
+        options.send();
+      }
+      if (idleTimer !== undefined)
+        unschedule(idleTimer);
+      idleTimer = schedule(stop, options.idleMs);
+    },
+    stop
+  };
+}
+// src/emitter/index.ts
+function createEmitter() {
+  const listeners = new Map;
+  const add = (event, listener, once) => {
+    const map = listeners.get(event) ?? new Map;
+    listeners.set(event, map);
+    map.set(listener, once);
+    return () => {
+      map.delete(listener);
+    };
+  };
+  return {
+    on: (event, listener) => add(event, listener, false),
+    once: (event, listener) => add(event, listener, true),
+    off(event, listener) {
+      listeners.get(event)?.delete(listener);
+    },
+    emit(event, ...[payload]) {
+      const map = listeners.get(event);
+      if (!map)
+        return;
+      const errors = [];
+      for (const [listener, once] of [...map]) {
+        if (!map.has(listener))
+          continue;
+        if (once)
+          map.delete(listener);
+        try {
+          listener(payload);
+        } catch (error) {
+          errors.push(error);
+        }
+      }
+      if (errors.length === 1)
+        throw errors[0];
+      if (errors.length > 1) {
+        throw new AggregateError(errors, `${errors.length} listeners threw for "${String(event)}"`);
+      }
+    },
+    clear(event) {
+      if (event === undefined)
+        listeners.clear();
+      else
+        listeners.delete(event);
+    },
+    listenerCount: (event) => listeners.get(event)?.size ?? 0
+  };
 }
 export {
-  zodToTypeString,
-  zodToExample,
-  zodMinMaxFilter,
-  zSingleOrArray,
-  withAlpha,
-  viteSecretSetPlugin,
-  unwrapResult,
-  typedSwitch,
-  tryCatch,
-  toGteLteFilter,
-  terminalColors,
-  slugify,
-  seriesColorKey,
-  resolveSeriesColorMap,
-  promiseTimeout,
-  processEnvLoader,
-  pickItemsInArray,
-  partition,
-  normalizeSingleOrArray,
-  logOperationSummary,
-  logBanner,
-  loadInfisicalSecrets,
-  linearRegressionTrend,
-  keyBy,
-  jwtVerify,
-  jwtSign,
-  jsonToZodSchemaMapper,
-  isSuccess,
-  isResponseValidationError,
-  isRequestValidationError,
-  isRequestTimeoutError,
-  isRequestAbortedError,
-  isNetworkError,
-  isHttpResponseError,
-  isFailure,
-  isConfigError,
-  isApiError,
-  isActionError,
-  infisicalLoader,
-  hashStringToColorIndex,
-  groupBy,
-  getViteDefine,
-  getUniqueValuesByKey,
-  getUniqueValues,
-  getSecretEnvironment,
-  getPreviousReportPeriod,
-  getHeatmapCellStyle,
-  getDomainSitemap,
-  getDomainFaviconUrl,
-  generateId,
-  formatPeriodLabel,
-  findArrayDifferenceByKey,
-  fetchInfisicalSecrets,
-  extractNumber,
-  defineSecretSet,
-  defineAction,
-  createZId,
-  createResolveColorsByKeys,
-  createCoolLogger,
-  createApiClient,
-  compact,
-  colorize,
-  cloudflareWorkerEnvLoader,
-  chunkArray,
-  cacheFunction,
-  backgroundPromiseSync,
-  backgroundPromise,
-  TimeoutError,
-  SimpleStateMachine,
-  ResponseValidationError,
-  RequestValidationError,
-  RequestTimeoutError,
-  RequestAbortedError,
-  PriorityQueue,
-  NetworkError,
+  InvariantError2 as InvariantError,
   METRICS_SERIES_PALETTE_SIZE,
-  HttpResponseError,
-  DEFAULT_INFISICAL_SITE_URL,
-  ConfigError,
-  ApiError,
-  ActionError
+  PromiseTimeoutError2 as PromiseTimeoutError,
+  SimpleStateMachine,
+  addPeriod,
+  anySignal2 as anySignal,
+  assertNever,
+  backgroundPromise2 as backgroundPromise,
+  backgroundPromiseSync2 as backgroundPromiseSync,
+  buildMailto2 as buildMailto,
+  buildQueryString2 as buildQueryString,
+  buildUrl2 as buildUrl,
+  cacheFunction,
+  chunkArray2 as chunkArray,
+  clamp,
+  compact2 as compact,
+  contrastRatio,
+  contrastText,
+  countBy2 as countBy,
+  createCache2 as createCache,
+  createEmitter,
+  createHeartbeat,
+  createLatestGuard2 as createLatestGuard,
+  createResolveColorsByKeys,
+  createStateMachine,
+  debounce,
+  ensureLeadingSlash2 as ensureLeadingSlash,
+  err2 as err,
+  escapeRegExp2 as escapeRegExp,
+  exponentialBackoff2 as exponentialBackoff,
+  extractNumber2 as extractNumber,
+  findArrayDifferenceByKey2 as findArrayDifferenceByKey,
+  foldForSearch2 as foldForSearch,
+  formatPeriodLabel,
+  generateId2 as generateId,
+  getAtPath,
+  getDomainFaviconUrl2 as getDomainFaviconUrl,
+  getErrorMessage2 as getErrorMessage,
+  getHeatmapCellStyle,
+  getPeriod,
+  getPreviousReportPeriod,
+  getUniqueValues2 as getUniqueValues,
+  getUniqueValuesByKey2 as getUniqueValuesByKey,
+  groupBy2 as groupBy,
+  hasKey2 as hasKey,
+  hashStringToColorIndex,
+  initials2 as initials,
+  invariant2 as invariant,
+  isBoolean2 as isBoolean,
+  isDefined2 as isDefined,
+  isFailure2 as isFailure,
+  isFunction2 as isFunction,
+  isNonEmpty2 as isNonEmpty,
+  isNumber2 as isNumber,
+  isOneOf2 as isOneOf,
+  isPlainObject2 as isPlainObject,
+  isRecord2 as isRecord,
+  isString2 as isString,
+  isSuccess2 as isSuccess,
+  isTruthy2 as isTruthy,
+  keyBy2 as keyBy,
+  keyedDebounce,
+  lerp,
+  linearRegression,
+  linearRegressionTrend,
+  mapValues,
+  matchesSearch2 as matchesSearch,
+  mixColors,
+  must2 as must,
+  nonEmpty2 as nonEmpty,
+  normalize,
+  normalizeDomain2 as normalizeDomain,
+  normalizeWhitespace2 as normalizeWhitespace,
+  ok2 as ok,
+  omit,
+  once,
+  pMap2 as pMap,
+  parseColor,
+  parseRetryAfter2 as parseRetryAfter,
+  partition2 as partition,
+  pick,
+  pickFromPalette,
+  pickItemsInArray2 as pickItemsInArray,
+  promiseTimeout2 as promiseTimeout,
+  raceAbort2 as raceAbort,
+  range2 as range,
+  recordFromKeys,
+  relativeLuminance,
+  replacePathParams2 as replacePathParams,
+  resolveSeriesColorMap,
+  retry2 as retry,
+  safeJsonParse2 as safeJsonParse,
+  seriesColorKey,
+  setAtPath,
+  sha256Id2 as sha256Id,
+  shade,
+  slugify2 as slugify,
+  sortBy2 as sortBy,
+  stableStringify2 as stableStringify,
+  startTimer2 as startTimer,
+  sumBy2 as sumBy,
+  throttle,
+  timed2 as timed,
+  timeoutSignal2 as timeoutSignal,
+  toArray2 as toArray,
+  toError2 as toError,
+  toHex,
+  toRgbString,
+  trimTrailingSlash2 as trimTrailingSlash,
+  truncate2 as truncate,
+  tryCatch2 as tryCatch,
+  typedEntries,
+  typedFromEntries,
+  typedKeys,
+  typedSwitch,
+  unwrapResult2 as unwrapResult,
+  withAlpha,
+  withTimeout2 as withTimeout
 };