hanzio 1.0.10 → 1.2.0

package/dist/src/index.js

@@ -1,3 +1,728 @@
+// src/typedswitch/index.ts
+function typedSwitch(value, keyOrCases, casesOrDefault, defaultCase) {
+  let key;
+  let cases;
+  let defaultHandler;
+  let discriminantKey;
+  if (typeof value === "string") {
+    key = value;
+    cases = keyOrCases;
+    defaultHandler = casesOrDefault;
+  } else {
+    if (typeof keyOrCases !== "string") {
+      throw new Error("Invalid typedSwitch call: object mode requires a string discriminant key");
+    }
+    discriminantKey = keyOrCases;
+    const discriminantValue = value[discriminantKey];
+    if (typeof discriminantValue !== "string") {
+      throw new Error(`Invalid discriminant value for key "${discriminantKey}": expected string, received ${typeof discriminantValue}`);
+    }
+    key = discriminantValue;
+    cases = casesOrDefault;
+    defaultHandler = defaultCase;
+  }
+  const handler = Object.hasOwn(cases, key) ? cases[key] : undefined;
+  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}`);
+}
+// src/array/index.ts
+function chunkArray(array, chunkSize) {
+  if (!Number.isInteger(chunkSize) || chunkSize <= 0) {
+    throw new Error("Chunk size must be a positive integer");
+  }
+  const chunks = [];
+  for (let index = 0;index < array.length; index += chunkSize) {
+    chunks.push(array.slice(index, index + chunkSize));
+  }
+  return chunks;
+}
+function findArrayDifferenceByKey(current, next, key) {
+  const currentByKey = new Map(current.map((item) => [String(item[key]), item]));
+  const itemsToDelete = [...current];
+  const newItems = [];
+  const upsertItems = [];
+  for (const item of next) {
+    const keyValue = String(item[key]);
+    if (!currentByKey.has(keyValue)) {
+      newItems.push(item);
+      continue;
+    }
+    upsertItems.push(item);
+    const deleteIndex = itemsToDelete.findIndex((currentItem) => String(currentItem[key]) === keyValue);
+    if (deleteIndex >= 0) {
+      itemsToDelete.splice(deleteIndex, 1);
+    }
+  }
+  return {
+    new: newItems,
+    upsert: upsertItems,
+    delete: itemsToDelete
+  };
+}
+function getUniqueValues(array) {
+  const seen = new Map;
+  for (const element of array) {
+    const key = JSON.stringify(element);
+    if (!seen.has(key)) {
+      seen.set(key, element);
+    }
+  }
+  return Array.from(seen.values());
+}
+function compact(array) {
+  return array.filter((item) => item != null);
+}
+function getUniqueValuesByKey(array, key) {
+  const seen = new Set;
+  const result = [];
+  for (const item of array) {
+    const value = item[key];
+    if (seen.has(value))
+      continue;
+    seen.add(value);
+    result.push(item);
+  }
+  return result;
+}
+function groupBy(array, keyOrFn) {
+  return array.reduce((result, item) => {
+    const groupKey = typeof keyOrFn === "function" ? keyOrFn(item) : item[keyOrFn];
+    result[groupKey] ??= [];
+    result[groupKey].push(item);
+    return result;
+  }, {});
+}
+function keyBy(array, keyOrFn) {
+  const result = {};
+  for (const item of array) {
+    const recordKey = typeof keyOrFn === "function" ? keyOrFn(item) : item[keyOrFn];
+    result[recordKey] = item;
+  }
+  return result;
+}
+function partition(array, predicate) {
+  const matched = [];
+  const unmatched = [];
+  array.forEach((item, index) => {
+    if (predicate(item, index)) {
+      matched.push(item);
+    } else {
+      unmatched.push(item);
+    }
+  });
+  return [matched, unmatched];
+}
+function pickItemsInArray(array, key, values) {
+  return array.filter((item) => values.includes(item[key]));
+}
+// src/string/index.ts
+function extractNumber(value) {
+  if (!value?.trim())
+    return;
+  const cleanedValue = value.replace(/[^\d.,-]/g, "");
+  if (!cleanedValue)
+    return;
+  const parsedNumber = Number.parseFloat(cleanedValue);
+  return Number.isNaN(parsedNumber) ? undefined : parsedNumber;
+}
+function generateId(input) {
+  const data = normalizeIdInput(input);
+  let hash = 0;
+  for (let index = 0;index < data.length; index++) {
+    const char = data.charCodeAt(index);
+    hash = (hash << 5) - hash + char;
+    hash |= 0;
+  }
+  return Math.abs(hash).toString(16).padStart(8, "0");
+}
+function slugify(value) {
+  const source = "àáâäæãåāăąçćčđďèéêëēėęěğǵḧîïíīįìłḿñńǹňôöòóœøōõṕŕřßśšşșťțûüùúūǘůűųẃẍÿýžźż·/_,:;";
+  const replacement = "aaaaaaaaaacccddeeeeeeeegghiiiiiilmnnnnooooooooprrsssssttuuuuuuuuuwxyyzzz------";
+  const specialCharacterPattern = new RegExp(source.split("").join("|"), "g");
+  return value.toString().toLowerCase().replace(/\s+/g, "-").replace(specialCharacterPattern, (character) => replacement.charAt(source.indexOf(character))).replace(/&/g, "-and-").replace(/[^\w-]+/g, "").replace(/--+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
+}
+function normalizeIdInput(input) {
+  if (input === undefined)
+    return "undefined";
+  if (input === null)
+    return "null";
+  if (typeof input === "string") {
+    return decodeURIComponent(input).split("&").sort().join("&");
+  }
+  if (typeof input === "number" || typeof input === "boolean") {
+    return input.toString();
+  }
+  return JSON.stringify(sortJsonValue(input));
+}
+function sortJsonValue(value) {
+  if (value === undefined)
+    return null;
+  if (Array.isArray(value)) {
+    return value.map((item) => sortJsonValue(item));
+  }
+  if (typeof value === "object" && value !== null) {
+    return Object.fromEntries(Object.entries(value).filter(([, itemValue]) => itemValue !== undefined).sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey)).map(([key, itemValue]) => [key, sortJsonValue(itemValue)]));
+  }
+  return value;
+}
+// src/promise/index.ts
+function isSuccess(result) {
+  return result.error === null;
+}
+function isFailure(result) {
+  return result.error !== null;
+}
+function unwrapResult(result) {
+  if (isSuccess(result))
+    return result.data;
+  throw result.error;
+}
+function backgroundPromise(promiseFactory, options = {}) {
+  const run = () => {
+    promiseFactory().then(() => options.onSuccess?.()).catch((error) => options.onError?.(error));
+  };
+  if (options.scheduler) {
+    options.scheduler(run);
+    return;
+  }
+  run();
+}
+function backgroundPromiseSync(promiseFactory, options = {}) {
+  backgroundPromise(promiseFactory, {
+    ...options,
+    scheduler: options.scheduler ?? queueMicrotask
+  });
+}
+function promiseTimeout(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function tryCatch(promise) {
+  try {
+    const data = await promise;
+    return { data, error: null };
+  } catch (error) {
+    return { data: null, error };
+  }
+}
+// src/cache/index.ts
+function cacheFunction(options) {
+  const {
+    name,
+    fn,
+    cacheTimeMs = 10 * 60 * 1000,
+    refreshInBackground = false,
+    cacheKeyArgs,
+    cacheKeyFn,
+    onBackgroundRefreshError,
+    store,
+    onStoreError
+  } = options;
+  const externalStore = store;
+  const cache = new Map;
+  const pendingPromises = new Map;
+  const entryLifetimeMs = refreshInBackground ? cacheTimeMs * 2 : cacheTimeMs;
+  let cleanupInterval;
+  const stopCleanup = () => {
+    if (cleanupInterval !== undefined) {
+      clearInterval(cleanupInterval);
+      cleanupInterval = undefined;
+    }
+  };
+  const ensureCleanup = () => {
+    if (cleanupInterval !== undefined) {
+      return;
+    }
+    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}:${JSON.stringify(keyArgs)}`;
+  };
+  const saveEntry = (key, value) => {
+    cache.set(key, { value, timestamp: Date.now() });
+    ensureCleanup();
+  };
+  const fetchAndPopulate = (key, args) => {
+    const result = fn(...args);
+    if (!isPromiseLike(result)) {
+      saveEntry(key, result);
+      return result;
+    }
+    const promise = result.then((value) => {
+      saveEntry(key, value);
+      pendingPromises.delete(key);
+      return value;
+    }).catch((error) => {
+      pendingPromises.delete(key);
+      throw error;
+    });
+    pendingPromises.set(key, promise);
+    return promise;
+  };
+  const startBackgroundRefresh = (key, args, staleValue) => {
+    const result = fn(...args);
+    if (!isPromiseLike(result)) {
+      saveEntry(key, result);
+      return;
+    }
+    const promise = result.then((value) => {
+      saveEntry(key, value);
+      pendingPromises.delete(key);
+      return value;
+    }).catch((error) => {
+      pendingPromises.delete(key);
+      onBackgroundRefreshError?.(error, { name });
+      return staleValue;
+    });
+    pendingPromises.set(key, promise);
+  };
+  const saveToStore = async (cacheStore, key, value) => {
+    try {
+      await cacheStore.set(key, { value, timestamp: Date.now() }, entryLifetimeMs);
+    } catch (error) {
+      onStoreError?.(error, { name });
+    }
+  };
+  const callWithStore = (cacheStore, args) => {
+    const key = buildKey(args);
+    const pending = pendingPromises.get(key);
+    if (pending && !refreshInBackground) {
+      return pending;
+    }
+    return (async () => {
+      let entry;
+      try {
+        entry = await cacheStore.get(key);
+      } catch (error) {
+        onStoreError?.(error, { name });
+      }
+      if (entry) {
+        const isFresh = Date.now() - entry.timestamp < cacheTimeMs;
+        if (isFresh) {
+          return entry.value;
+        }
+        if (refreshInBackground) {
+          if (!pendingPromises.has(key)) {
+            const staleValue = entry.value;
+            const refresh = fn(...args).then(async (value) => {
+              await saveToStore(cacheStore, key, value);
+              pendingPromises.delete(key);
+              return value;
+            }).catch((error) => {
+              pendingPromises.delete(key);
+              onBackgroundRefreshError?.(error, { name });
+              return staleValue;
+            });
+            pendingPromises.set(key, refresh);
+          }
+          return entry.value;
+        }
+        try {
+          await cacheStore.delete(key);
+        } catch (error) {
+          onStoreError?.(error, { name });
+        }
+      }
+      const existing = pendingPromises.get(key);
+      if (existing) {
+        return existing;
+      }
+      const promise = fn(...args).then(async (value) => {
+        await saveToStore(cacheStore, key, value);
+        pendingPromises.delete(key);
+        return value;
+      }).catch((error) => {
+        pendingPromises.delete(key);
+        throw error;
+      });
+      pendingPromises.set(key, promise);
+      return promise;
+    })();
+  };
+  const wrappedFn = (...args) => {
+    if (externalStore) {
+      return callWithStore(externalStore, args);
+    }
+    const key = buildKey(args);
+    const cached = cache.get(key);
+    if (cached) {
+      const isFresh = Date.now() - cached.timestamp < cacheTimeMs;
+      if (isFresh) {
+        return cached.value;
+      }
+      if (refreshInBackground) {
+        if (!pendingPromises.has(key)) {
+          startBackgroundRefresh(key, args, cached.value);
+        }
+        return cached.value;
+      }
+      cache.delete(key);
+    }
+    const pending = pendingPromises.get(key);
+    if (pending) {
+      return pending;
+    }
+    return fetchAndPopulate(key, args);
+  };
+  wrappedFn.clearCache = () => {
+    cache.clear();
+    pendingPromises.clear();
+    stopCleanup();
+    if (externalStore?.clear) {
+      externalStore.clear().catch((error) => {
+        onStoreError?.(error, { name });
+      });
+    }
+  };
+  return wrappedFn;
+}
+function isPromiseLike(value) {
+  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+}
+// src/state/index.ts
+class SimpleStateMachine {
+  config;
+  item;
+  stateKey;
+  constructor(config, item, stateKey) {
+    this.config = config;
+    this.item = item;
+    this.stateKey = stateKey;
+  }
+  getCurrentStatus() {
+    return this.item[this.stateKey];
+  }
+  async getAvailableActions() {
+    const actionsMap = this.config.stateActionMap[this.getCurrentStatus()] || {};
+    const result = {};
+    for (const [action, targetState] of Object.entries(actionsMap)) {
+      if (!targetState)
+        continue;
+      const validationResult = await this.validateTransition(targetState, { action });
+      result[action] = validationResult;
+    }
+    return result;
+  }
+  async getPossibleTransitions() {
+    const possibleTransitions = this.config.stateTransitions[this.getCurrentStatus()] || [];
+    const actionsMap = this.config.stateActionMap[this.getCurrentStatus()] || {};
+    const result = {};
+    for (const targetState of possibleTransitions) {
+      const actionsToTarget = Object.entries(actionsMap).filter(([, t]) => t === targetState);
+      if (actionsToTarget.length === 0) {
+        result[targetState] = await this.validateTransition(targetState);
+        continue;
+      }
+      let lastError = true;
+      let anyOk = false;
+      for (const [actionKey] of actionsToTarget) {
+        const r = await this.validateTransition(targetState, {
+          action: actionKey
+        });
+        if (r === true) {
+          anyOk = true;
+          break;
+        }
+        lastError = r;
+      }
+      result[targetState] = anyOk ? true : lastError;
+    }
+    return result;
+  }
+  async executeAction(action, data) {
+    const actionsMap = this.config.stateActionMap[this.getCurrentStatus()];
+    if (!actionsMap) {
+      return {
+        success: false,
+        error: `No actions defined for state '${this.getCurrentStatus()}'`
+      };
+    }
+    const targetState = actionsMap[action];
+    if (!targetState) {
+      return {
+        success: false,
+        error: `Action '${action}' not allowed in state '${this.getCurrentStatus()}'`
+      };
+    }
+    const validationResult = await this.validateTransition(targetState, {
+      action
+    });
+    if (validationResult === true) {
+      if (this.config.actions?.[action]) {
+        try {
+          const result = await this.config.actions[action](this.item, data);
+          return {
+            success: true,
+            newState: targetState,
+            result
+          };
+        } catch (error) {
+          return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error)
+          };
+        }
+      }
+      return {
+        success: true,
+        newState: targetState
+      };
+    }
+    return {
+      success: false,
+      error: validationResult
+    };
+  }
+  async validateTransition(toState, options) {
+    const action = options?.action;
+    if (this.getCurrentStatus() === toState)
+      return true;
+    const allowedTransitions = this.config.stateTransitions[this.getCurrentStatus()] || [];
+    if (!allowedTransitions.includes(toState)) {
+      return `Invalid transition from '${this.getCurrentStatus()}' to '${toState}'`;
+    }
+    if (this.config.globalValidator) {
+      const globalResult = await this.config.globalValidator(this.item, this.getCurrentStatus(), toState, action);
+      if (globalResult !== true) {
+        return globalResult;
+      }
+    }
+    const stateValidator = this.config.validators?.[toState];
+    if (stateValidator) {
+      return await stateValidator(this.item, this.getCurrentStatus(), toState, action);
+    }
+    return true;
+  }
+  getStates() {
+    return Object.keys(this.config.stateTransitions);
+  }
+  getInitialState() {
+    return this.getStates()[0];
+  }
+}
+// src/math/linearRegressionTrend.ts
+function linearRegressionTrend(values) {
+  const n = values.length;
+  if (n < 2)
+    return [];
+  for (const v of values) {
+    if (!Number.isFinite(v))
+      return [];
+  }
+  let sumX = 0;
+  let sumY = 0;
+  let sumXY = 0;
+  let sumX2 = 0;
+  for (let i = 0;i < n; i++) {
+    const x = i;
+    const y = values[i];
+    sumX += x;
+    sumY += y;
+    sumXY += x * y;
+    sumX2 += x * x;
+  }
+  const denom = n * sumX2 - sumX * sumX;
+  if (denom === 0)
+    return [];
+  const slope = (n * sumXY - sumX * sumY) / denom;
+  const intercept = (sumY - slope * sumX) / n;
+  const out = [];
+  for (let i = 0;i < n; i++) {
+    out.push(intercept + slope * i);
+  }
+  return out;
+}
+// src/math/metricsSeriesColors.ts
+var METRICS_SERIES_PALETTE_SIZE = 10;
+function hashStringToColorIndex(str) {
+  let hash = 2166136261;
+  for (let i = 0;i < str.length; i++) {
+    hash ^= str.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return Math.abs(hash) % METRICS_SERIES_PALETTE_SIZE;
+}
+function circularHueDistance(a, b, paletteSize) {
+  const diff = Math.abs(a - b);
+  return Math.min(diff, paletteSize - diff);
+}
+function pickHueMaxMinDistance(candidates, used, paletteSize) {
+  let best = candidates[0] ?? 0;
+  let bestScore = -1;
+  for (const cand of candidates) {
+    let minD = paletteSize;
+    for (const u of used) {
+      minD = Math.min(minD, circularHueDistance(cand, u, paletteSize));
+    }
+    if (minD > bestScore || minD === bestScore && cand < best) {
+      bestScore = minD;
+      best = cand;
+    }
+  }
+  return best;
+}
+function seriesColorKey(label, key) {
+  const fromLabel = label?.trim();
+  if (fromLabel)
+    return fromLabel;
+  return key.trim() || key;
+}
+function resolveSeriesColorMap(keys) {
+  const result = new Map;
+  const uniqueKeys = [...new Set(keys)];
+  if (uniqueKeys.length === 0)
+    return result;
+  const paletteSize = METRICS_SERIES_PALETTE_SIZE;
+  if (uniqueKeys.length === 1) {
+    const only = uniqueKeys[0];
+    result.set(only, hashStringToColorIndex(only));
+    return result;
+  }
+  const usedIndices = new Set;
+  const entries = uniqueKeys.map((key) => ({
+    key,
+    preferred: hashStringToColorIndex(key)
+  }));
+  for (const entry of entries) {
+    if (!usedIndices.has(entry.preferred)) {
+      result.set(entry.key, entry.preferred);
+      usedIndices.add(entry.preferred);
+    }
+  }
+  const unassigned = entries.filter((e) => !result.has(e.key));
+  for (const entry of unassigned) {
+    const unused = [];
+    for (let i = 0;i < paletteSize; i++) {
+      if (!usedIndices.has(i))
+        unused.push(i);
+    }
+    const candidates = unused.length > 0 ? unused : Array.from({ length: paletteSize }, (_, i) => i);
+    const idx = pickHueMaxMinDistance(candidates, usedIndices, paletteSize);
+    result.set(entry.key, idx);
+    usedIndices.add(idx);
+  }
+  return result;
+}
+function createResolveColorsByKeys(keys, getSeriesColor, getSeriesHoverColor) {
+  const colorMap = resolveSeriesColorMap(keys);
+  return {
+    getColor: (key) => getSeriesColor(colorMap.get(key) ?? hashStringToColorIndex(key)),
+    getHoverColor: (key) => getSeriesHoverColor(colorMap.get(key) ?? hashStringToColorIndex(key))
+  };
+}
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+function withAlpha(color, alpha) {
+  const trimmed = color.trim();
+  if (trimmed.startsWith("#")) {
+    const hex = trimmed.slice(1);
+    const normalized = hex.length === 3 ? hex.split("").map((c) => c + c).join("") : hex;
+    if (normalized.length === 6) {
+      const r = Number.parseInt(normalized.slice(0, 2), 16);
+      const g = Number.parseInt(normalized.slice(2, 4), 16);
+      const b = Number.parseInt(normalized.slice(4, 6), 16);
+      return `rgba(${r}, ${g}, ${b}, ${alpha})`;
+    }
+  }
+  if (trimmed.startsWith("rgb(")) {
+    return trimmed.replace("rgb(", "rgba(").replace(")", `, ${alpha})`);
+  }
+  if (trimmed.startsWith("rgba(")) {
+    return trimmed.replace(/,\s*[\d.]+\)$/, `, ${alpha})`);
+  }
+  return trimmed;
+}
+function getHeatmapCellStyle(params) {
+  const {
+    value,
+    min,
+    max,
+    baseColor,
+    neutralColor,
+    minAlpha = 0.08,
+    maxAlpha = 0.78
+  } = params;
+  if (value === null || value === undefined || Number.isNaN(value)) {
+    return {};
+  }
+  if (!Number.isFinite(min) || !Number.isFinite(max)) {
+    return {};
+  }
+  if (max <= min) {
+    return {
+      backgroundColor: withAlpha(neutralColor ?? baseColor, 0.32)
+    };
+  }
+  const normalized = clamp((value - min) / (max - min), 0, 1);
+  const alpha = minAlpha + (maxAlpha - minAlpha) * normalized;
+  return {
+    backgroundColor: withAlpha(baseColor, alpha)
+  };
+}
+// src/date/index.ts
+function getPreviousReportPeriod(periodType, referenceDate = new Date) {
+  const month = referenceDate.getMonth();
+  const year = referenceDate.getFullYear();
+  switch (periodType) {
+    case "MONTHLY": {
+      const prevMonth = month === 0 ? 11 : month - 1;
+      const prevYear = month === 0 ? year - 1 : year;
+      return {
+        start: new Date(prevYear, prevMonth, 1),
+        end: new Date(year, month, 0)
+      };
+    }
+    case "QUARTERLY": {
+      const qStart = Math.floor(month / 3) * 3;
+      const prevQStart = qStart === 0 ? 9 : qStart - 3;
+      const prevQYear = qStart === 0 ? year - 1 : year;
+      return {
+        start: new Date(prevQYear, prevQStart, 1),
+        end: new Date(prevQYear, prevQStart + 3, 0)
+      };
+    }
+    case "YEARLY": {
+      return {
+        start: new Date(year - 1, 0, 1),
+        end: new Date(year - 1, 11, 31)
+      };
+    }
+  }
+}
+function formatPeriodLabel(start, end, includeDay = false) {
+  const s = start instanceof Date ? start : new Date(start);
+  const e = end instanceof Date ? end : new Date(end);
+  const opts = {
+    year: "numeric",
+    month: "long",
+    ...includeDay && { day: "numeric" }
+  };
+  return `${s.toLocaleDateString("en-GB", opts)} — ${e.toLocaleDateString("en-GB", opts)}`;
+}
+// src/url/index.ts
+function getDomainFaviconUrl(domain, size = 128) {
+  return `https://www.google.com/s2/favicons?domain=${encodeURIComponent(domain)}&sz=${size}`;
+}
 // src/zod/index.ts
 import { z as z3 } from "zod";
 
@@ -198,252 +923,1115 @@ function normalizeSingleOrArray(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, configError) {
+  if (body === undefined || body === null)
+    return;
+  if (body instanceof FormData || body instanceof Blob)
+    return body;
+  if (hasJsonContentType(headers))
+    return JSON.stringify(body);
+  if (typeof body === "object" && (Object.getPrototypeOf(body) === Object.prototype || Object.getPrototypeOf(body) === null) && configError) {
+    throw configError("Request body is a plain object but Content-Type is not application/json");
+  }
+  return body;
+}
+function getHeadersAsObject(headers) {
+  const result = {};
+  headers.forEach((value, key) => {
+    result[key] = value;
+  });
+  return result;
+}
 
-// src/api-wrapper/index.ts
+// 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 Error {
+class ResponseValidationError extends ApiError {
   zodError;
   rawResponse;
+  issues;
   validationIssues;
-  constructor(zodError, rawResponse) {
-    const issues = zodError.issues.map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`).join("; ");
-    super(`Response validation failed: ${issues}`);
+  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.validationIssues = issues;
+    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 HttpResponseError extends Error {
-  status;
-  body;
-  constructor(status, body) {
-    super(`HTTP error: ${status} - ${body}`);
-    this.name = "HttpResponseError";
-    this.status = status;
-    this.body = body;
+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
+    };
   }
 }
-function createApiClient(apiConfig) {
-  const request = async (endpointKey, input = {}) => {
-    const endpoint = apiConfig.endpoints[endpointKey];
-    if (!endpoint) {
-      throw new Error(`Unknown API endpoint: ${String(endpointKey)}`);
+
+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;
+function isNonRetryableApiError(error) {
+  return error instanceof HttpResponseError || error instanceof ResponseValidationError || error instanceof RequestValidationError || error instanceof ConfigError || error instanceof RequestAbortedError;
+}
+// src/api-wrapper/builders.ts
+import { ZodError as ZodError2 } from "zod";
+function formatQueryString(queryParams, doNotEncode) {
+  if (Object.keys(queryParams).length === 0)
+    return "";
+  return doNotEncode ? Object.entries(queryParams).map(([key, value]) => `${key}=${value}`).join("&") : new URLSearchParams(queryParams).toString();
+}
+function buildUrl(options) {
+  const {
+    endpoint,
+    params,
+    queryParams,
+    baseApiUrls,
+    defaultBaseApiUrl,
+    url,
+    doNotEncodeQueryParams,
+    configError
+  } = options;
+  let finalUrl;
+  if (url) {
+    finalUrl = replacePathParams(url, params, configError);
+  } else {
+    const defaultBaseUrl = defaultBaseApiUrl ?? Object.keys(baseApiUrls)[0];
+    if (!defaultBaseUrl) {
+      throw configError("At least one base API URL is required");
     }
-    const { finalUrl, fullUrl } = buildUrl(endpoint, input.reqParams, input.reqQuery, apiConfig.baseApiUrls, apiConfig.defaultBaseApiUrl, input.url);
-    const endpointName = apiConfig.name ? `${apiConfig.name}.${String(endpointKey)}` : String(endpointKey);
-    const startedAt = Date.now();
-    let retryCount = 0;
-    let httpStatus = 0;
-    apiConfig.onRequestStart?.({ endpoint: endpointName, url: fullUrl });
+    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;
+    finalUrl = `${baseUrl}${replacePathParams(path, params, configError)}`;
+  }
+  const queryString = formatQueryString(queryParams, doNotEncodeQueryParams);
+  return {
+    finalUrl,
+    fullUrl: queryString ? `${finalUrl}?${queryString}` : finalUrl
+  };
+}
+function buildPathParams(endpoint, params, ctx) {
+  if (!endpoint.reqParamsSchema)
+    return params;
+  try {
+    return endpoint.reqParamsSchema.parse(params);
+  } catch (error) {
+    if (error instanceof ZodError2) {
+      throw new RequestValidationError(error, "params", params, ctx());
+    }
+    throw error;
+  }
+}
+function buildQueryParams(endpoint, query, ctx) {
+  const defaultParams = endpoint.reqDefaultQueryParams ?? {};
+  let parsedQuery;
+  if (endpoint.reqQuerySchema) {
     try {
-      const config = {
-        method: endpoint.method,
-        url: finalUrl,
-        queryParams: buildQueryParams(endpoint, input.reqQuery),
-        body: buildRequestBody(endpoint, input.reqBody),
-        headers: buildHeaders(endpoint, input.reqHeaders, apiConfig.defaultHeaders ?? {}),
-        doNotEncodeQueryParams: endpoint.doNotEncodeQueryParams,
-        timeoutMs: apiConfig.timeoutMs,
-        fetchFn: apiConfig.fetch ?? fetch
-      };
-      const result = await makeRequestWithRetry(config, apiConfig.retries ?? 3, apiConfig.retryDelayMs ?? 300, (response) => validateAndTransformResponse(endpoint, response), apiConfig.shouldRetry ?? defaultShouldRetry, apiConfig.logger);
-      retryCount = result.retryCount;
-      httpStatus = result.httpStatus;
-      const responseTimeMs = Date.now() - startedAt;
-      const responseSizeMb = calculateSizeInMb(result.validatedData);
-      const requestSizeMb = calculateSizeInMb({
-        method: config.method,
-        url: fullUrl,
-        body: config.body,
-        headers: config.headers
-      });
-      apiConfig.onRequestEnd?.({
-        endpoint: endpointName,
-        url: fullUrl,
-        status: httpStatus,
-        retryCount,
-        responseTimeMs
-      });
-      return {
-        data: result.validatedData,
-        requestSizeMb,
-        responseSizeMb,
-        requestSizeTotalMb: requestSizeMb + responseSizeMb,
-        responseTimeMs,
-        httpStatus,
-        retryCount
-      };
+      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) {
-      apiConfig.logger?.error?.(error);
+      store.delete(key);
       throw error;
     }
   };
-  return { request };
+  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 (def) => ({
+        ...def,
+        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",
+  "clientsecret",
+  "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 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(config.fullUrl, {
+      method: config.method,
+      headers: config.headers,
+      body: buildFetchBody(config.body, config.headers, (msg) => new ConfigError(msg, ctx())),
+      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);
+    }
+    if (error instanceof ConfigError)
+      throw 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
+  };
 }
-var createApiWrapper = createApiClient;
-async function validateResponse(schema, data) {
-  try {
-    return await schema.parseAsync(data);
-  } catch (error) {
-    if (error instanceof ZodError) {
-      throw new ResponseValidationError(error, data);
+function getRetryDelay(params) {
+  const maxDelay = params.maxRetryDelayMs ?? 30000;
+  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 Math.min(Math.max(0, seconds * 1000), maxDelay);
+      }
+      const dateMs = Date.parse(retryAfter);
+      if (!Number.isNaN(dateMs)) {
+        return Math.min(Math.max(0, dateMs - Date.now()), maxDelay);
+      }
     }
-    throw error;
   }
+  const delayMs = typeof retryDelay === "function" ? retryDelay(attempt) : retryDelay;
+  return Math.min(delayMs, maxDelay);
 }
-async function httpRequest(config) {
-  const queryString = config.doNotEncodeQueryParams ? Object.entries(config.queryParams).map(([key, value]) => `${key}=${value}`).join("&") : new URLSearchParams(config.queryParams).toString();
-  const fullUrl = queryString ? `${config.url}?${queryString}` : config.url;
-  const abortController = new AbortController;
-  const timeout = config.timeoutMs === undefined ? undefined : setTimeout(() => abortController.abort(), config.timeoutMs);
-  try {
-    return await config.fetchFn(fullUrl, {
-      method: config.method,
-      headers: config.headers,
-      body: buildFetchBody(config.body, config.headers),
-      signal: abortController.signal
-    });
-  } finally {
-    if (timeout)
-      clearTimeout(timeout);
-  }
+function shouldAttemptRetryOnError(error) {
+  return !isNonRetryableApiError(error);
+}
+function shouldAttemptRetryOnHttp(retryCtx) {
+  const { error, response } = retryCtx;
+  if (error)
+    return shouldAttemptRetryOnError(error);
+  return response ? response.status >= 500 || response.status === 429 : false;
 }
-async function makeRequestWithRetry(config, maxRetries, retryDelayMs, validateFn, shouldRetry, logger) {
+async function makeRequestWithRetry(args) {
+  const {
+    config,
+    maxRetries,
+    retryDelay,
+    maxRetryDelayMs,
+    validateFn,
+    shouldRetry,
+    logger,
+    ctx,
+    endpointName,
+    method,
+    fullUrl,
+    meta,
+    onResponse,
+    onRetry
+  } = args;
   let retryCount = 0;
   while (true) {
+    let response;
     try {
       logger?.debug?.("API request", config);
-      const response = await httpRequest(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) {
-        if (retryCount < maxRetries && shouldRetry({ response, retryCount, maxRetries })) {
+        const retryCtx = {
+          response,
+          retryCount,
+          maxRetries,
+          endpoint: endpointName,
+          method,
+          url: fullUrl
+        };
+        if (retryCount < maxRetries && shouldRetry(retryCtx)) {
+          const delayMs = getRetryDelay({
+            retryDelay,
+            attempt: retryCount,
+            response,
+            maxRetryDelayMs
+          });
+          await onRetry?.({
+            ...retryCtx,
+            delayMs,
+            nextAttempt: retryCount + 1
+          });
           retryCount++;
-          await delay(retryDelayMs);
+          await delay(delayMs);
           continue;
         }
-        throw new HttpResponseError(response.status, await response.text());
+        const { body, headers: responseHeaders } = await readErrorResponse(response);
+        throw new HttpResponseError(response.status, body, responseHeaders, ctx({ attempt: retryCount }));
       }
       return {
-        validatedData: await validateFn(response),
+        validatedData: await validateFn(response, retryCount),
         retryCount,
         httpStatus: response.status
       };
     } catch (error) {
-      if (error instanceof HttpResponseError)
+      if (isNonRetryableApiError(error)) {
         throw error;
-      if (retryCount >= maxRetries || !shouldRetry({ error, retryCount, maxRetries })) {
+      }
+      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,
+        maxRetryDelayMs
+      });
+      await onRetry?.({
+        ...retryCtx,
+        delayMs,
+        nextAttempt: retryCount + 1
+      });
       retryCount++;
-      await delay(retryDelayMs);
+      await delay(delayMs);
     }
   }
 }
-async function validateAndTransformResponse(endpoint, response) {
+async function validateAndTransformResponse(endpoint, response, ctx) {
   const responseHeaders = getHeadersAsObject(response.headers);
-  const contentType = responseHeaders["content-type"] ?? "";
-  const responseData = contentType.includes("application/json") ? await response.json() : await response.text();
+  const text = await response.text();
+  const responseSizeBytes = new TextEncoder().encode(text).length;
+  let responseData;
+  if (hasJsonContentType(responseHeaders)) {
+    try {
+      responseData = text === "" ? undefined : JSON.parse(text);
+    } catch (error) {
+      throw new ResponseValidationError(makeJsonParseZodError(error, text), text, ctx());
+    }
+  } else {
+    responseData = text;
+  }
   const transformedData = endpoint.resFormatter ? endpoint.resFormatter(responseData, responseHeaders) : responseData;
-  return validateResponse(endpoint.resSchema, transformedData);
+  const data = await validateResponse(endpoint.resSchema, transformedData, ctx);
+  return { data, responseSizeBytes };
 }
-function buildUrl(endpoint, params, reqQuery, baseApiUrls, defaultBaseApiUrl, url) {
-  if (url) {
-    const finalUrl2 = replacePathParams(url, params);
-    const queryString2 = new URLSearchParams(buildQueryParams(endpoint, reqQuery)).toString();
-    return {
-      finalUrl: finalUrl2,
-      fullUrl: queryString2 ? `${finalUrl2}?${queryString2}` : finalUrl2
-    };
+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 resolveActionInvocation(action, actionName, first, second) {
+  if (!action.noRuntimeInput) {
+    return { input: first, options: second ?? {} };
   }
-  const defaultBaseUrl = defaultBaseApiUrl ?? Object.keys(baseApiUrls)[0];
-  if (!defaultBaseUrl) {
-    throw new Error("At least one base API URL is required");
+  if (first === undefined || first === null) {
+    return { input: undefined, options: second ?? {} };
   }
-  const baseUrlKey = endpoint.baseApiUrl ?? defaultBaseUrl;
-  const configBaseUrl = baseApiUrls[baseUrlKey];
-  if (!configBaseUrl) {
-    throw new Error(`Unknown base API URL: ${baseUrlKey}`);
+  if (second !== undefined) {
+    return { input: undefined, options: second };
   }
-  const baseUrl = typeof configBaseUrl === "function" ? configBaseUrl() : configBaseUrl;
-  const path = typeof endpoint.path === "function" ? endpoint.path(baseUrl) : endpoint.path;
-  const finalUrl = replacePathParams(`${baseUrl}${path}`, params);
-  const queryString = new URLSearchParams(buildQueryParams(endpoint, reqQuery)).toString();
-  return {
-    finalUrl,
-    fullUrl: queryString ? `${finalUrl}?${queryString}` : finalUrl
-  };
-}
-function buildQueryParams(endpoint, query) {
-  const defaultParams = endpoint.reqDefaultQueryParams ?? {};
-  const parsedQuery = endpoint.reqQuerySchema ? endpoint.reqQuerySchema.parse(query) : query ?? {};
-  const merged = { ...defaultParams, ...parsedQuery };
-  return Object.fromEntries(Object.entries(merged).filter(([, value]) => value !== undefined).map(([key, value]) => [key, String(value)]));
+  if (isActionInvokeOptionsOnly(first)) {
+    return { input: undefined, options: first };
+  }
+  throw new ConfigError(`Action "${actionName}" does not accept input; pass only optional { signal, meta }`, {
+    endpoint: actionName,
+    method: "GET",
+    url: "",
+    attempt: 0,
+    maxRetries: 0,
+    elapsedMs: 0
+  });
 }
-function buildRequestBody(endpoint, body) {
-  if (!endpoint.reqBodySchema)
-    return body;
-  const parsedBody = endpoint.reqBodySchema.parse(body);
-  if (endpoint.reqBodyFormat !== "form-data") {
-    return parsedBody;
+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 pathParams;
+    let queryParams;
+    let body;
+    let headers;
+    try {
+      pathParams = buildPathParams(endpoint, rawInput.reqParams, ctx);
+      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;
+    }
+    let fullUrl;
+    try {
+      const built = buildUrl({
+        endpoint,
+        params: pathParams,
+        queryParams,
+        baseApiUrls: apiConfig.baseApiUrls,
+        defaultBaseApiUrl: apiConfig.defaultBaseApiUrl,
+        url: input.url,
+        doNotEncodeQueryParams: endpoint.doNotEncodeQueryParams,
+        configError: (msg) => new ConfigError(msg, ctx())
+      });
+      fullUrl = built.fullUrl;
+    } catch (e) {
+      if (e instanceof ApiError)
+        throw await reportApiError(e, apiConfig);
+      throw e;
+    }
+    baseContext.url = fullUrl;
+    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,
+      fullUrl,
+      body,
+      headers,
+      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,
+        maxRetryDelayMs: apiConfig.maxRetryDelayMs,
+        validateFn: (response, attempt) => validateAndTransformResponse(endpoint, response, (over) => ctx({ attempt, ...over })),
+        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 = result.validatedData.responseSizeBytes / (1024 * 1024);
+      const requestBodySizeMb = calculateSizeInMb(config.body);
+      return {
+        data: result.validatedData.data,
+        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 formData = new FormData;
-  for (const [key, value] of Object.entries(parsedBody)) {
-    if (value == null)
-      continue;
-    formData.set(key, value instanceof Blob ? value : String(value));
+  async function dispatchAction(name, first, second) {
+    const action = actions[name];
+    const { input, options } = resolveActionInvocation(action, name, first, second);
+    return invokeAction(name, input, options);
   }
-  return formData;
-}
-function buildHeaders(endpoint, headers, defaultHeaders) {
-  const contentType = endpoint.reqBodyFormat === "json" ? "application/json" : undefined;
-  const parsedHeaders = endpoint.reqHeadersSchema ? endpoint.reqHeadersSchema.parse(headers) : headers ?? {};
-  return {
-    ...defaultHeaders,
-    ...contentType && { "Content-Type": contentType },
-    ...endpoint.defaultHeaders,
-    ...parsedHeaders
+  const request = async (key, input, options) => {
+    if (key in actions) {
+      return dispatchAction(key, input, options);
+    }
+    return invokeEndpoint(key, input ?? {});
   };
-}
-function buildFetchBody(body, headers) {
-  if (body === undefined || body === null)
-    return;
-  if (body instanceof FormData || body instanceof Blob)
-    return body;
-  if (headers["Content-Type"] === "application/json")
-    return JSON.stringify(body);
-  return body;
-}
-function replacePathParams(path, params) {
-  return path.replace(/:(\w+)/g, (_, key) => {
-    const value = params?.[key];
-    if (value === undefined) {
-      throw new Error(`Missing required path parameter: ${key}`);
+  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) {
+        return (first, second) => dispatchAction(prop, first, second);
+      }
+      return;
     }
-    return encodeURIComponent(String(value));
-  });
-}
-function getHeadersAsObject(headers) {
-  const result = {};
-  headers.forEach((value, key) => {
-    result[key] = value;
   });
-  return result;
-}
-function calculateSizeInMb(data) {
-  const sizeInBytes = new TextEncoder().encode(JSON.stringify(data)).length;
-  return sizeInBytes / (1024 * 1024);
-}
-function defaultShouldRetry({ error, response }) {
-  if (error)
-    return true;
-  return response ? response.status >= 500 : false;
-}
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  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) {
@@ -474,7 +2062,7 @@ class PriorityQueue {
     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);
+    const index = this.#queue.findIndex((item) => item.id === id);
     if (index === -1) {
       throw new ReferenceError(`No promise function with the id "${id}" exists in the queue.`);
     }
@@ -664,551 +2252,220 @@ class PQueue {
       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);
+            return;
+          }
+          this.#queue.remove?.(taskOptions.id);
+          reject(taskOptions.signal?.reason);
+          this.emit("next");
+          this.#tryToStartAnother();
         };
-        setAbortListener(listener);
-        options.signal?.addEventListener("abort", listener, { once: true });
-      }));
-    }
-    try {
-      return await Promise.race(races);
-    } finally {
-      if (timeoutId) {
-        clearTimeout(timeoutId);
+        taskOptions.signal.addEventListener("abort", queuedAbortHandler, {
+          once: true
+        });
       }
-    }
+      this.#queue.enqueue(run, taskOptions);
+      this.emit("add");
+      this.#processQueue();
+    });
   }
-  #next() {
-    this.#pending--;
-    if (this.#pending === 0) {
-      this.emit("pendingZero");
+  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();
-    this.emit("next");
-  }
-  #processQueue() {
-    while (this.#tryToStartAnother()) {}
-    this.#updateRateLimitState();
+    return this;
   }
-  #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;
+  pause() {
+    this.#isPaused = 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;
+  clear() {
+    this.#queue = new this.#queueClass;
+    this.#clearIntervalTimer();
+    this.#updateRateLimitState();
+    this.emit("empty");
+    if (this.#pending === 0) {
+      this.emit("idle");
     }
-    this.#scheduleIntervalResume(this.#intervalEnd - now);
-    return false;
+    this.emit("next");
   }
-  #consumeIntervalSlot() {
-    if (this.#intervalCap === Number.POSITIVE_INFINITY || this.#interval === 0) {
-      return;
-    }
-    if (this.#strict) {
-      this.#strictTimestamps.push(Date.now());
+  async onEmpty() {
+    if (this.#queue.size === 0) {
       return;
     }
-    this.#intervalCount++;
+    await this.#onEvent("empty");
   }
-  #scheduleIntervalResume(delay2) {
-    if (this.#intervalTimer) {
+  async onIdle() {
+    if (this.#queue.size === 0 && this.#pending === 0) {
       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");
+    await this.#onEvent("idle");
   }
-  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
+  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);
     });
-    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];
-      }
+  }
+  async onSizeLessThan(limit) {
+    if (this.#queue.size < limit) {
+      return;
     }
-  } catch (error) {
-    console.warn("Could not fetch robots.txt:", error instanceof Error ? error.message : "Unknown error");
+    await this.#onEvent("next", () => this.#queue.size < limit);
   }
-  for (const location of commonLocations) {
+  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 {
-      const response = await fetch(`${normalizedDomain}${location}`, {
-        ...requestOptions,
-        method: "HEAD"
-      });
-      if (response.ok) {
-        return [`${normalizedDomain}${location}`];
+      return await Promise.race(races);
+    } finally {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
       }
-    } 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}`;
+  #next() {
+    this.#pending--;
+    if (this.#pending === 0) {
+      this.emit("pendingZero");
+    }
+    this.#processQueue();
+    this.emit("next");
   }
-  const sitemapUrls = await discoverSitemaps(normalizedDomain);
-  if (sitemapUrls.length === 0) {
-    throw new Error("No sitemaps found for the domain");
+  #processQueue() {
+    while (this.#tryToStartAnother()) {}
+    this.#updateRateLimitState();
   }
-  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;
+  #tryToStartAnother() {
+    if (this.#queue.size === 0) {
+      this.#clearIntervalTimer();
+      this.emit("empty");
+      if (this.#pending === 0) {
+        this.emit("idle");
+      }
+      return false;
     }
-    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);
-        }
+    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;
-      });
-      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");
+      this.#scheduleIntervalResume(this.#interval - (now - this.#strictTimestamps[0]));
+      return false;
     }
-  };
-  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 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 loadInfisicalSecrets({
-  keys,
-  projectId,
-  environment,
-  siteUrl,
-  clientIdEnvKey,
-  clientSecretEnvKey
-}) {
-  const clientId = process.env[clientIdEnvKey];
-  const clientSecret = process.env[clientSecretEnvKey];
-  if (!clientId || !clientSecret) {
-    throw new Error("Missing Infisical credentials");
-  }
-  const infisical = createInfisicalApiClient(siteUrl);
-  const { data: auth } = await infisical.request("login", {
-    reqBody: {
-      clientId,
-      clientSecret
+    if (this.#intervalEnd === 0 || now >= this.#intervalEnd) {
+      this.#intervalCount = this.#carryoverIntervalCount ? this.#pending : 0;
+      this.#intervalEnd = now + this.#interval;
     }
-  });
-  const { data } = await infisical.request("listSecrets", {
-    reqHeaders: {
-      Authorization: `Bearer ${auth.accessToken}`
-    },
-    reqQuery: {
-      environment,
-      projectId,
-      secretPath: "/",
-      viewSecretValue: true,
-      expandSecretReferences: true,
-      includeImports: true
+    if (this.#intervalCount < this.#intervalCap) {
+      return true;
     }
-  });
-  const wantedKeys = new Set(keys);
-  return Object.fromEntries(data.secrets.filter((secret) => wantedKeys.has(secret.secretKey)).map((secret) => [secret.secretKey, secret.secretValue]));
-}
-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
-      }
+    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(delay) {
+    if (this.#intervalTimer) {
+      return;
+    }
+    this.#intervalTimer = setTimeout(() => {
+      this.#intervalTimer = undefined;
+      this.#processQueue();
+    }, Math.max(0, delay));
+  }
+  #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");
     }
-  });
-}
-function getFetch() {
-  return globalThis.fetch ?? defaultFetch;
-}
-
-// 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",
@@ -1313,783 +2570,936 @@ function logBanner(text, color = "cyan", options = {}) {
   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 DEFAULT_INFISICAL_SITE_URL = "https://eu.infisical.com";
-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 loader = options.loader ?? loadInfisicalSecrets;
-  let cachedSecrets = null;
-  const loadSecrets = async (force = false) => {
-    const envSecrets = readEnvSecrets(keySet, force ? cachedSecrets : null);
-    const keysMissingFromEnv = keySet.filter((key) => !envSecrets[key]);
-    const environment = resolveEnvironment(options.environment);
-    logSecretEnvironment(environment, keySet.length);
-    const loadedSecrets = keysMissingFromEnv.length === 0 && !force ? {} : await loader({
-      keys: keySet,
-      projectId: options.projectId,
-      environment,
-      siteUrl: options.siteUrl ?? DEFAULT_INFISICAL_SITE_URL,
-      clientIdEnvKey: options.clientIdEnvKey ?? "INFISICAL_CLIENT_ID",
-      clientSecretEnvKey: options.clientSecretEnvKey ?? "INFISICAL_CLIENT_SECRET"
-    });
-    const missingKeys = keySet.filter((key) => !(envSecrets[key] ?? loadedSecrets[key]));
-    if (missingKeys.length > 0) {
-      throw new Error(`Missing secrets: ${missingKeys.join(", ")}`);
-    }
-    const nextSecrets = Object.fromEntries(keySet.map((key) => [
-      key,
-      envSecrets[key] ?? loadedSecrets[key]
-    ]));
-    for (const [key, value] of Object.entries(nextSecrets)) {
-      process.env[key] = value;
-    }
-    cachedSecrets = nextSecrets;
-    return nextSecrets;
-  };
-  const secretSet = {
-    secret(key) {
-      const value = cachedSecrets?.[key] ?? process.env[key];
-      if (!value) {
-        throw new Error(`Secret ${key} not found`);
-      }
-      return value;
-    },
-    secrets() {
-      if (!cachedSecrets) {
-        throw new Error("Secrets not initialized.");
-      }
-      return cachedSecrets;
-    },
-    async reload() {
-      await loadSecrets(true);
-      return secretSet;
-    }
-  };
-  await loadSecrets();
-  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
+// 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)}`;
 }
-function readEnvSecrets(keys, previousSecrets = null) {
-  return Object.fromEntries(keys.filter((key) => {
-    const value = process.env[key];
-    return value && value !== previousSecrets?.[key];
-  }).map((key) => [key, process.env[key]]));
-}
-
-// src/typedswitch/index.ts
-function runSwitch(value, keyOrCases, casesOrDefault, defaultCase) {
-  let key;
-  let cases;
-  let defaultHandler;
-  let discriminantKey;
-  if (typeof value === "string") {
-    key = value;
-    cases = keyOrCases;
-    defaultHandler = casesOrDefault;
-  } else {
-    if (typeof keyOrCases !== "string") {
-      throw new Error("Invalid typedSwitch call: object mode requires a string discriminant key");
-    }
-    discriminantKey = keyOrCases;
-    const discriminantValue = value[discriminantKey];
-    if (typeof discriminantValue !== "string") {
-      throw new Error(`Invalid discriminant value for key "${discriminantKey}": expected string, received ${typeof discriminantValue}`);
-    }
-    key = discriminantValue;
-    cases = casesOrDefault;
-    defaultHandler = defaultCase;
-  }
-  const handler = cases[key];
-  if (handler) {
-    return handler(value);
-  }
-  if (defaultHandler) {
-    return defaultHandler(value);
-  }
-  const availableCases = Object.keys(cases).join(", ");
-  const availableCasesSuffix = availableCases.length > 0 ? ` Available cases: ${availableCases}` : " Available cases: (none)";
-  const contextSuffix = discriminantKey ? ` (discriminant key: "${discriminantKey}")` : "";
-  throw new Error(`Unhandled case: ${key}${contextSuffix}.${availableCasesSuffix}`);
-}
-function typedSwitch(value, keyOrCases, casesOrDefault, defaultCase) {
-  return runSwitch(value, keyOrCases, casesOrDefault, defaultCase);
-}
-// src/array/index.ts
-function chunkArray(array, chunkSize) {
-  if (!Number.isInteger(chunkSize) || chunkSize <= 0) {
-    throw new Error("Chunk size must be a positive integer");
-  }
-  const chunks = [];
-  for (let index = 0;index < array.length; index += chunkSize) {
-    chunks.push(array.slice(index, index + chunkSize));
-  }
-  return chunks;
-}
-function findArrayDifferenceByKey(current, next, key) {
-  const currentByKey = new Map(current.map((item) => [String(item[key]), item]));
-  const itemsToDelete = [...current];
-  const newItems = [];
-  const upsertItems = [];
-  for (const item of next) {
-    const keyValue = String(item[key]);
-    if (!currentByKey.has(keyValue)) {
-      newItems.push(item);
-      continue;
-    }
-    upsertItems.push(item);
-    const deleteIndex = itemsToDelete.findIndex((currentItem) => String(currentItem[key]) === keyValue);
-    if (deleteIndex >= 0) {
-      itemsToDelete.splice(deleteIndex, 1);
-    }
-  }
-  return {
-    new: newItems,
-    upsert: upsertItems,
-    delete: itemsToDelete
-  };
-}
-function getUniqueValues(array) {
-  const seen = new Map;
-  for (const element of array) {
-    const key = JSON.stringify(element);
-    if (!seen.has(key)) {
-      seen.set(key, element);
-    }
+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;
   }
-  return Array.from(seen.values());
 }
-function compact(array) {
-  return array.filter((item) => item != null);
+async function sign(data, secret) {
+  const key = await getKey(secret, ["sign"]);
+  return await getSubtleCrypto().sign("HMAC", key, encodeText(data));
 }
-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;
+async function verify(data, signature, secret) {
+  const key = await getKey(secret, ["verify"]);
+  return await getSubtleCrypto().verify("HMAC", key, signature, encodeText(data));
 }
-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;
-  }, {});
+async function getKey(secret, usages) {
+  return await getSubtleCrypto().importKey("raw", encodeText(secret), {
+    name: "HMAC",
+    hash: "SHA-256"
+  }, false, usages);
 }
-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 encodeJson(value) {
+  return encodeBase64Url(encodeText(JSON.stringify(value)));
 }
-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 decodeJson(value) {
+  return JSON.parse(textDecoder.decode(decodeBase64Url(value)));
 }
-function pickItemsInArray(array, key, values) {
-  return array.filter((item) => values.includes(item[key]));
+function encodeBase64Url(value) {
+  const bytes = value instanceof ArrayBuffer ? new Uint8Array(value) : value;
+  return btoa(bytesToBinaryString(bytes)).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
 }
-// 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 decodeBase64Url(value) {
+  const base64 = value.replaceAll("-", "+").replaceAll("_", "/");
+  const padded = base64.padEnd(Math.ceil(base64.length / 4) * 4, "=");
+  return binaryStringToBytes(atob(padded)).buffer;
 }
-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 encodeText(value) {
+  return toArrayBuffer(textEncoder.encode(value));
 }
-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 toArrayBuffer(bytes) {
+  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
 }
-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();
+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 JSON.stringify(sortJsonValue(input));
+  return binary;
 }
-function sortJsonValue(value) {
-  if (value === undefined)
-    return null;
-  if (Array.isArray(value)) {
-    return value.map((item) => sortJsonValue(item));
+function binaryStringToBytes(binary) {
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0;index < binary.length; index += 1) {
+    bytes[index] = binary.charCodeAt(index);
   }
-  if (typeof value === "object" && value !== null) {
-    return Object.fromEntries(Object.entries(value).filter(([, itemValue]) => itemValue !== undefined).sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey)).map(([key, itemValue]) => [key, sortJsonValue(itemValue)]));
+  return bytes;
+}
+function getSubtleCrypto() {
+  const subtle = globalThis.crypto?.subtle;
+  if (!subtle) {
+    throw new Error("Web Crypto is not available in this runtime");
   }
-  return value;
+  return subtle;
 }
-// src/promise/index.ts
-function isSuccess(result) {
-  return result.error === null;
+function isJwtHeader(value) {
+  return typeof value === "object" && value !== null && "alg" in value && value.alg === "HS256";
 }
-function isFailure(result) {
-  return result.error !== null;
+function isJwtPayload(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function unwrapResult(result) {
-  if (isSuccess(result))
-    return result.data;
-  throw result.error;
+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;
 }
-function backgroundPromise(promiseFactory, options = {}) {
-  const run = () => {
-    promiseFactory().then(() => options.onSuccess?.()).catch((error) => options.onError?.(error));
+// 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
   };
-  if (options.scheduler) {
-    options.scheduler(run);
-    return;
-  }
-  run();
-}
-function backgroundPromiseSync(promiseFactory, options = {}) {
-  backgroundPromise(promiseFactory, {
-    ...options,
-    scheduler: options.scheduler ?? queueMicrotask
-  });
-}
-function promiseTimeout(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function tryCatch(promise) {
   try {
-    const data = await promise;
-    return { data, error: null };
+    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) {
-    return { data: null, error };
+    console.warn("Could not fetch robots.txt:", error instanceof Error ? error.message : "Unknown error");
   }
-}
-// src/cache/index.ts
-function cacheFunction(options) {
+  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 {
-    name,
-    fn,
-    cacheTimeMs = 10 * 60 * 1000,
-    refreshInBackground = false,
-    cacheKeyArgs,
-    cacheKeyFn,
-    onBackgroundRefreshError
+    filterIndexes,
+    concurrency = 10,
+    maxDepth = 5,
+    timeout = 1e4
   } = options;
-  const cache = new Map;
-  const pendingPromises = new Map;
-  const cleanupInterval = setInterval(() => {
-    const now = Date.now();
-    for (const [key, entry] of cache.entries()) {
-      if (now - entry.timestamp >= cacheTimeMs) {
-        cache.delete(key);
-      }
-    }
-  }, Math.min(cacheTimeMs / 2, 5 * 60 * 1000));
-  const wrappedFn = (...args) => {
-    const keyArgs = cacheKeyFn ? cacheKeyFn(...args) : cacheKeyArgs ? cacheKeyArgs.map((i) => args[i]) : args;
-    const key = `${name}:${JSON.stringify(keyArgs)}`;
-    const now = Date.now();
-    const pending = pendingPromises.get(key);
-    if (pending) {
-      return pending;
+  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;
     }
-    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;
+    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);
         }
-        if (isCacheFresh) {
-          return cached.value;
+        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");
     }
-    const result = fn(...args);
-    if (isPromiseLike(result)) {
-      const promise = result.then((resolvedValue) => {
-        cache.set(key, { value: resolvedValue, timestamp: now });
-        pendingPromises.delete(key);
-        return resolvedValue;
-      }).catch((error) => {
-        pendingPromises.delete(key);
-        throw error;
-      });
-      pendingPromises.set(key, promise);
-      return promise;
-    }
-    cache.set(key, { value: result, timestamp: now });
-    return result;
-  };
-  wrappedFn.clearCache = () => {
-    cache.clear();
-    pendingPromises.clear();
-    clearInterval(cleanupInterval);
   };
-  return wrappedFn;
-}
-function isPromiseLike(value) {
-  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+  await Promise.all(sitemapUrls.map((sitemapUrl) => queue.add(() => processSitemap(sitemapUrl))));
+  await queue.onIdle();
+  return [...result.links];
+};
+// src/secrets/errors.ts
+class SecretLoadError extends Error {
+  code;
+  operation;
+  status;
+  constructor(code, message, details = {}) {
+    super(message);
+    this.name = "SecretLoadError";
+    this.code = code;
+    this.operation = details.operation;
+    this.status = details.status;
+  }
 }
-// src/state/index.ts
-class SimpleStateMachine {
-  config;
-  item;
-  stateKey;
-  constructor(config, item, stateKey) {
-    this.config = config;
-    this.item = item;
-    this.stateKey = stateKey;
+
+// src/secrets/deadline.ts
+async function withSecretDeadline(options, operation) {
+  const timeoutMs = options.timeoutMs ?? 30000;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0 || timeoutMs > 2147483647) {
+    throw new SecretLoadError("CONFIGURATION", "Secret timeoutMs must be a positive finite timer duration.");
   }
-  getCurrentStatus() {
-    return this.item[this.stateKey];
+  const controller = new AbortController;
+  const cancel = () => controller.abort(new SecretLoadError("ABORTED", "Secret loading was cancelled."));
+  if (options.signal?.aborted) {
+    cancel();
+  } else {
+    options.signal?.addEventListener("abort", cancel, { once: true });
   }
-  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;
+  const timer = setTimeout(() => controller.abort(new SecretLoadError("TIMEOUT", `Secret loading timed out after ${timeoutMs}ms.`)), timeoutMs);
+  let rejectOnAbort = () => {};
+  try {
+    const aborted = new Promise((_, reject) => {
+      rejectOnAbort = () => reject(controller.signal.reason);
+      controller.signal.addEventListener("abort", rejectOnAbort, { once: true });
+    });
+    if (controller.signal.aborted) {
+      throw controller.signal.reason;
+    }
+    return await Promise.race([operation(controller.signal), aborted]);
+  } finally {
+    clearTimeout(timer);
+    options.signal?.removeEventListener("abort", cancel);
+    controller.signal.removeEventListener("abort", rejectOnAbort);
+  }
+}
+
+// src/secrets/environment.ts
+function getProcessEnvironment() {
+  return typeof process === "undefined" ? undefined : process.env;
+}
+function resolveSecretEnvironment(option, env) {
+  const explicit = typeof option === "function" ? option() : option;
+  if (typeof explicit === "object" && explicit !== null) {
+    if (typeof explicit.slug !== "string" || !/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(explicit.slug)) {
+      throw new SecretLoadError("CONFIGURATION", "Custom secret environment requires a valid slug.");
+    }
+    return explicit.slug;
+  }
+  const selected = explicit ?? env?.SECRETS_ENV;
+  if (selected !== undefined) {
+    if (selected === "production" || selected === "prod") {
+      return "prod";
+    }
+    if (selected === "development" || selected === "dev") {
+      return "dev";
+    }
+    if (selected === "staging") {
+      return "staging";
     }
-    return result;
+    throw new SecretLoadError("CONFIGURATION", "Invalid secret environment. Use dev, staging, prod, or an explicit { slug } option.");
   }
-  async getPossibleTransitions() {
-    const possibleTransitions = this.config.stateTransitions[this.getCurrentStatus()] || [];
-    const actionsMap = this.config.stateActionMap[this.getCurrentStatus()] || {};
-    const result = {};
-    for (const targetState of possibleTransitions) {
-      const actionsToTarget = Object.entries(actionsMap).filter(([, t]) => t === targetState);
-      if (actionsToTarget.length === 0) {
-        result[targetState] = await this.validateTransition(targetState);
-        continue;
+  if (env?.NODE_ENV === "production" || env?.NODE_ENV === "prod") {
+    return "prod";
+  }
+  if (env?.NODE_ENV === "staging") {
+    return "staging";
+  }
+  return "dev";
+}
+
+// src/secrets/core.ts
+var registryKey = Symbol.for("hanzio.secrets.environmentWrites.v1");
+var shared = globalThis;
+var environmentWrites = shared[registryKey] ?? new WeakMap;
+shared[registryKey] = environmentWrites;
+var defaultLogger = {
+  info: (message, attrs) => console.log(`${message} environment=${attrs.environment} count=${attrs.count} source=${attrs.source} durationMs=${attrs.durationMs}`, { sources: attrs.sources }),
+  error: (message, attrs) => console.error(message, attrs)
+};
+function readOverrides(keys, env) {
+  if (!env) {
+    return {};
+  }
+  const writes = environmentWrites.get(env);
+  return Object.fromEntries(keys.flatMap((key) => {
+    const value = Object.hasOwn(env, key) ? env[key] : undefined;
+    if (writes?.has(key)) {
+      if (writes.get(key) === value) {
+        return [];
       }
-      let lastError = true;
-      let anyOk = false;
-      for (const [actionKey] of actionsToTarget) {
-        const r = await this.validateTransition(targetState, {
-          action: actionKey
+      writes.delete(key);
+    }
+    return value ? [[key, value]] : [];
+  }));
+}
+async function defineSecretSet(keys, options, environmentVariables) {
+  const keySet = [...new Set(keys)];
+  const environment = resolveSecretEnvironment(options.environment, environmentVariables);
+  const logger = options.logger === false ? undefined : options.logger ?? defaultLogger;
+  let cached;
+  let parsed;
+  let sources;
+  let inFlight;
+  const log = (level, message, attributes) => {
+    try {
+      logger?.[level](message, attributes);
+    } catch {}
+  };
+  const loadSnapshot = async (request, signal) => {
+    const local = readOverrides(keySet, environmentVariables);
+    const missing = keySet.filter((key) => !Object.hasOwn(local, key));
+    let loaderSource = options.loader.source ?? "custom loader";
+    let loaded = {};
+    if (missing.length) {
+      try {
+        loaded = await options.loader({
+          keys: missing,
+          environment,
+          signal,
+          timeoutMs: request.timeoutMs ?? options.timeoutMs ?? 30000,
+          reportSource: (source) => {
+            loaderSource = source;
+          }
         });
-        if (r === true) {
-          anyOk = true;
-          break;
+      } catch (error) {
+        if (error instanceof SecretLoadError) {
+          throw error;
         }
-        lastError = r;
+        throw new SecretLoadError("LOADER", "Secret loader failed.");
       }
-      result[targetState] = anyOk ? true : lastError;
     }
-    return result;
-  }
-  async executeAction(action, data) {
-    const actionsMap = this.config.stateActionMap[this.getCurrentStatus()];
-    if (!actionsMap) {
-      return {
-        success: false,
-        error: `No actions defined for state '${this.getCurrentStatus()}'`
-      };
+    const overrides = readOverrides(keySet, environmentVariables);
+    const next = Object.fromEntries(keySet.map((key) => {
+      if (Object.hasOwn(overrides, key)) {
+        return [key, overrides[key]];
+      }
+      if (Object.hasOwn(loaded, key)) {
+        return [key, loaded[key]];
+      }
+      return [key, undefined];
+    }));
+    const missingKeys = keySet.filter((key) => typeof next[key] !== "string" || !next[key]);
+    if (missingKeys.length) {
+      throw new SecretLoadError("MISSING_SECRETS", `Missing secrets: ${missingKeys.join(", ")}`);
     }
-    const targetState = actionsMap[action];
-    if (!targetState) {
-      return {
-        success: false,
-        error: `Action '${action}' not allowed in state '${this.getCurrentStatus()}'`
-      };
+    let nextParsed;
+    try {
+      nextParsed = options.schema ? await options.schema.parseAsync({ ...next }) : { ...next };
+      nextParsed = structuredClone(nextParsed);
+    } catch {
+      throw new SecretLoadError("VALIDATION", "Secret schema validation failed. Check the configured schema; values are omitted.");
     }
-    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)
-          };
+    signal.throwIfAborted();
+    const nextSources = Object.fromEntries(keySet.map((key) => [
+      key,
+      Object.hasOwn(overrides, key) ? "process.env" : loaderSource
+    ]));
+    if (options.writeToProcessEnv !== false && environmentVariables) {
+      let writes = environmentWrites.get(environmentVariables);
+      if (!writes) {
+        writes = new Map;
+        environmentWrites.set(environmentVariables, writes);
+      }
+      for (const key of keySet) {
+        if (Object.hasOwn(overrides, key)) {
+          continue;
         }
+        environmentVariables[key] = next[key];
+        writes.set(key, next[key]);
       }
-      return {
-        success: true,
-        newState: targetState
-      };
     }
-    return {
-      success: false,
-      error: validationResult
-    };
-  }
-  async validateTransition(toState, options) {
-    const action = options?.action;
-    if (this.getCurrentStatus() === toState)
-      return true;
-    const allowedTransitions = this.config.stateTransitions[this.getCurrentStatus()] || [];
-    if (!allowedTransitions.includes(toState)) {
-      return `Invalid transition from '${this.getCurrentStatus()}' to '${toState}'`;
-    }
-    if (this.config.globalValidator) {
-      const globalResult = await this.config.globalValidator(this.item, this.getCurrentStatus(), toState, action);
-      if (globalResult !== true) {
-        return globalResult;
+    cached = next;
+    parsed = nextParsed;
+    sources = nextSources;
+  };
+  const load = (request = {}) => {
+    if (inFlight) {
+      return inFlight;
+    }
+    inFlight = (async () => {
+      const start = Date.now();
+      try {
+        await withSecretDeadline({
+          timeoutMs: request.timeoutMs ?? options.timeoutMs,
+          signal: request.signal ?? options.signal
+        }, (signal) => loadSnapshot(request, signal));
+        const sourceCounts = new Map;
+        for (const key of keySet) {
+          const source = sources[key];
+          sourceCounts.set(source, (sourceCounts.get(source) ?? 0) + 1);
+        }
+        const counts = Object.fromEntries(sourceCounts);
+        log("info", "Loaded secrets", {
+          environment,
+          count: keySet.length,
+          durationMs: Date.now() - start,
+          source: Object.keys(counts).join(" + ") || "none",
+          sources: counts
+        });
+      } catch (error) {
+        const safe = error instanceof SecretLoadError ? error : new SecretLoadError("LOADER", "Secret loading failed.");
+        log("error", "Secret loading failed", {
+          environment,
+          count: keySet.length,
+          durationMs: Date.now() - start,
+          code: safe.code
+        });
+        throw safe;
+      }
+    })().finally(() => {
+      inFlight = undefined;
+    });
+    return inFlight;
+  };
+  const secretSet = {
+    secret(key) {
+      if (!Object.hasOwn(cached, key)) {
+        throw new SecretLoadError("MISSING_SECRETS", `Secret ${key} not found`);
       }
+      return cached[key];
+    },
+    secrets: () => ({ ...cached }),
+    parsed: () => structuredClone(parsed),
+    sources: () => ({ ...sources }),
+    async reload(request) {
+      await load(request);
+      return secretSet;
     }
-    const stateValidator = this.config.validators?.[toState];
-    if (stateValidator) {
-      return await stateValidator(this.item, this.getCurrentStatus(), toState, action);
+  };
+  await load();
+  return secretSet;
+}
+
+// src/secrets/infisical.ts
+import { z as z5 } from "zod";
+
+// src/secrets/infisical-cli.ts
+async function readInfisicalCliToken(options) {
+  const { execFile } = await import("node:child_process").catch(() => {
+    throw new SecretLoadError("CLI", "Infisical CLI fallback requires a runtime with subprocess support. Provide Infisical client credentials or a custom secret loader.");
+  });
+  options.signal.throwIfAborted();
+  const env = {
+    ...getProcessEnvironment(),
+    INFISICAL_DISABLE_UPDATE_CHECK: "true"
+  };
+  delete env.INFISICAL_TOKEN;
+  delete env.INFISICAL_UNIVERSAL_AUTH_ACCESS_TOKEN;
+  delete env.TOKEN;
+  try {
+    const stdout = await new Promise((resolve, reject) => {
+      const child = execFile("infisical", [
+        "user",
+        "get",
+        "token",
+        "--plain",
+        `--domain=${options.siteUrl}`,
+        "--silent"
+      ], {
+        env,
+        encoding: "utf8",
+        shell: false,
+        timeout: options.timeoutMs ?? 30000,
+        signal: options.signal,
+        killSignal: "SIGKILL",
+        maxBuffer: 10485760,
+        windowsHide: true
+      }, (error, output) => {
+        if (error) {
+          reject(error);
+        } else {
+          resolve(output);
+        }
+      });
+      child.stdin?.end();
+    });
+    return stdout.trim();
+  } catch (error) {
+    if (options.signal.aborted) {
+      throw options.signal.reason;
     }
-    return true;
-  }
-  getStates() {
-    return Object.keys(this.config.stateTransitions);
-  }
-  getInitialState() {
-    return this.getStates()[0];
+    const failure = error;
+    if (failure?.code === "ENOENT") {
+      throw new SecretLoadError("CLI", "Infisical CLI not found. Install infisical and ensure it is on PATH, or provide Infisical client credentials.");
+    }
+    if (failure?.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER") {
+      throw new SecretLoadError("CLI", "Infisical CLI output exceeded the 10 MiB limit.");
+    }
+    if (failure?.killed) {
+      throw new SecretLoadError("TIMEOUT", `Infisical CLI timed out after ${(options.timeoutMs ?? 30000) / 1000} seconds or was terminated.`);
+    }
+    throw new SecretLoadError("CLI", `Infisical CLI session token failed. Run infisical login --domain=${options.siteUrl} and verify access to the configured organization, project, and environment.`);
   }
 }
-// src/math/linearRegressionTrend.ts
-function linearRegressionTrend(values) {
-  const n = values.length;
-  if (n < 2)
-    return [];
-  for (const v of values) {
-    if (!Number.isFinite(v))
-      return [];
+
+// src/secrets/infisical-config.ts
+function validateInfisicalScope(options) {
+  validateInfisicalOrganizationId(options.organizationId);
+  let url;
+  try {
+    url = new URL(options.siteUrl);
+  } catch {
+    throw new SecretLoadError("CONFIGURATION", "Invalid Infisical siteUrl.");
   }
-  let sumX = 0;
-  let sumY = 0;
-  let sumXY = 0;
-  let sumX2 = 0;
-  for (let i = 0;i < n; i++) {
-    const x = i;
-    const y = values[i];
-    sumX += x;
-    sumY += y;
-    sumXY += x * y;
-    sumX2 += x * x;
+  if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash) {
+    throw new SecretLoadError("CONFIGURATION", "Infisical siteUrl must be an HTTP(S) URL without credentials, query, or fragment.");
   }
-  const denom = n * sumX2 - sumX * sumX;
-  if (denom === 0)
-    return [];
-  const slope = (n * sumXY - sumX * sumY) / denom;
-  const intercept = (sumY - slope * sumX) / n;
-  const out = [];
-  for (let i = 0;i < n; i++) {
-    out.push(intercept + slope * i);
+  if (!options.projectId.trim() || !options.environment.trim() || !(options.secretPath ?? "/").startsWith("/")) {
+    throw new SecretLoadError("CONFIGURATION", "Infisical requires a projectId, environment, and absolute secretPath.");
   }
-  return out;
 }
-// src/math/metricsSeriesColors.ts
-var METRICS_SERIES_PALETTE_SIZE = 10;
-function hashStringToColorIndex(str) {
-  let hash = 2166136261;
-  for (let i = 0;i < str.length; i++) {
-    hash ^= str.charCodeAt(i);
-    hash = Math.imul(hash, 16777619);
+function validateInfisicalOrganizationId(organizationId) {
+  if (typeof organizationId !== "string" || !organizationId.trim() || /\s/.test(organizationId)) {
+    throw new SecretLoadError("CONFIGURATION", "Infisical organizationId is required and must be a nonempty ID without whitespace.");
   }
-  return Math.abs(hash) % METRICS_SERIES_PALETTE_SIZE;
-}
-function circularHueDistance(a, b, paletteSize) {
-  const diff = Math.abs(a - b);
-  return Math.min(diff, paletteSize - diff);
 }
-function pickHueMaxMinDistance(candidates, used, paletteSize) {
-  let best = candidates[0] ?? 0;
-  let bestScore = -1;
-  for (const cand of candidates) {
-    let minD = paletteSize;
-    for (const u of used) {
-      minD = Math.min(minD, circularHueDistance(cand, u, paletteSize));
-    }
-    if (minD > bestScore || minD === bestScore && cand < best) {
-      bestScore = minD;
-      best = cand;
+
+// src/secrets/infisical-session.ts
+import { z as z4 } from "zod";
+var sessionClaimsSchema = z4.object({
+  organizationId: z4.string().optional(),
+  subOrganizationId: z4.string().optional(),
+  exp: z4.number().finite().optional()
+});
+function parseInfisicalSessionToken(token) {
+  let claims;
+  try {
+    if (!/^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/.test(token)) {
+      throw new Error("Invalid token format");
     }
+    const payload = token.split(".")[1];
+    const json = atob(payload.replace(/-/g, "+").replace(/_/g, "/"));
+    claims = sessionClaimsSchema.parse(JSON.parse(json));
+  } catch {
+    throw new SecretLoadError("AUTHENTICATION", "Infisical returned an invalid user session token. Run infisical login for the configured domain.");
   }
-  return best;
+  if (claims.exp !== undefined && claims.exp <= Date.now() / 1000) {
+    throw new SecretLoadError("AUTHENTICATION", "Infisical user session has expired. Run infisical login for the configured domain.");
+  }
+  return { organizationId: claims.subOrganizationId ?? claims.organizationId };
 }
-function seriesColorKey(label, key) {
-  const fromLabel = label?.trim();
-  if (fromLabel)
-    return fromLabel;
-  return key.trim() || key;
+
+// src/secrets/infisical.ts
+var DEFAULT_INFISICAL_SITE_URL = "https://eu.infisical.com";
+var defaultFetch = globalThis.fetch;
+var infisicalAuthResponseSchema = z5.object({ accessToken: z5.string() });
+var infisicalSecretSchema = z5.object({
+  secretKey: z5.string(),
+  secretValue: z5.string()
+});
+var infisicalSecretsResponseSchema = z5.object({
+  secrets: z5.array(infisicalSecretSchema)
+});
+async function fetchInfisicalSecrets(options) {
+  validateInfisicalScope(options);
+  return withSecretDeadline(options, async (signal) => {
+    let operation = "login";
+    try {
+      const infisical = createInfisicalApiClient(options.siteUrl);
+      const { data: auth } = await infisical.request("login", {
+        signal,
+        reqBody: {
+          clientId: options.clientId,
+          clientSecret: options.clientSecret
+        }
+      });
+      signal.throwIfAborted();
+      operation = "listSecrets";
+      return await listInfisicalSecrets(infisical, auth.accessToken, {
+        ...options,
+        signal
+      });
+    } catch (error) {
+      throwInfisicalHttpError(error, operation, signal);
+    }
+  });
 }
-function resolveSeriesColorMap(keys) {
-  const result = new Map;
-  const uniqueKeys = [...new Set(keys)];
-  if (uniqueKeys.length === 0)
-    return result;
-  const paletteSize = METRICS_SERIES_PALETTE_SIZE;
-  if (uniqueKeys.length === 1) {
-    const only = uniqueKeys[0];
-    result.set(only, hashStringToColorIndex(only));
-    return result;
-  }
-  const usedIndices = new Set;
-  const entries = uniqueKeys.map((key) => ({
-    key,
-    preferred: hashStringToColorIndex(key)
-  }));
-  for (const entry of entries) {
-    if (!usedIndices.has(entry.preferred)) {
-      result.set(entry.key, entry.preferred);
-      usedIndices.add(entry.preferred);
+async function loadInfisicalSecrets(options) {
+  validateInfisicalScope(options);
+  const env = getProcessEnvironment();
+  const clientId = env?.[options.clientIdEnvKey];
+  const clientSecret = env?.[options.clientSecretEnvKey];
+  const mode = options.auth ?? "auto";
+  if (!["auto", "http", "cli"].includes(mode)) {
+    throw new SecretLoadError("CONFIGURATION", "Invalid Infisical auth mode.");
+  }
+  const useHttp = mode === "http" || mode === "auto" && Boolean(clientId && clientSecret);
+  if (useHttp) {
+    if (!clientId || !clientSecret) {
+      throw new SecretLoadError("AUTHENTICATION", "Infisical HTTP authentication requires both client credentials.");
+    }
+    options.reportSource?.("Infisical HTTP");
+    return fetchInfisicalSecrets({ ...options, clientId, clientSecret });
+  }
+  options.reportSource?.(`Infisical CLI session (organization=${options.organizationId} project=${options.projectId} environment=${options.environment})`);
+  return withSecretDeadline(options, (signal) => fetchInfisicalSessionSecrets({ ...options, signal }));
+}
+async function fetchInfisicalSessionSecrets(options) {
+  const { signal } = options;
+  let token = await readInfisicalCliToken(options);
+  signal.throwIfAborted();
+  const session = parseInfisicalSessionToken(token);
+  const infisical = createInfisicalApiClient(options.siteUrl);
+  let operation = "selectOrganization";
+  try {
+    if (session.organizationId !== options.organizationId) {
+      const { data } = await infisical.request("selectOrganization", {
+        signal,
+        reqHeaders: {
+          Authorization: `Bearer ${token}`,
+          "User-Agent": "hanzio/secrets"
+        },
+        reqBody: { organizationId: options.organizationId }
+      });
+      signal.throwIfAborted();
+      if (data.isMfaEnabled) {
+        throw new SecretLoadError("AUTHENTICATION", "Infisical requires MFA for this organization. Complete infisical login for the target organization and configured domain before loading secrets.", { operation });
+      }
+      const scopedSession = parseInfisicalSessionToken(data.token);
+      if (scopedSession.organizationId !== options.organizationId) {
+        throw new SecretLoadError("AUTHENTICATION", "Infisical returned a session for a different organization.", { operation });
+      }
+      token = data.token;
     }
+    signal.throwIfAborted();
+    operation = "listSecrets";
+    return await listInfisicalSecrets(infisical, token, options);
+  } catch (error) {
+    throwInfisicalHttpError(error, operation, signal);
   }
-  const unassigned = entries.filter((e) => !result.has(e.key));
-  for (const entry of unassigned) {
-    const unused = [];
-    for (let i = 0;i < paletteSize; i++) {
-      if (!usedIndices.has(i))
-        unused.push(i);
-    }
-    const candidates = unused.length > 0 ? unused : Array.from({ length: paletteSize }, (_, i) => i);
-    const idx = pickHueMaxMinDistance(candidates, usedIndices, paletteSize);
-    result.set(entry.key, idx);
-    usedIndices.add(idx);
+}
+async function listInfisicalSecrets(infisical, token, options) {
+  const { data } = await infisical.request("listSecrets", {
+    signal: options.signal,
+    reqHeaders: { Authorization: `Bearer ${token}` },
+    reqQuery: {
+      environment: options.environment,
+      projectId: options.projectId,
+      secretPath: options.secretPath ?? "/",
+      viewSecretValue: true,
+      expandSecretReferences: true,
+      includeImports: true
+    }
+  });
+  const wantedKeys = new Set(options.keys);
+  return Object.fromEntries(data.secrets.filter((secret) => wantedKeys.has(secret.secretKey)).map((secret) => [secret.secretKey, secret.secretValue]));
+}
+function throwInfisicalHttpError(error, operation, signal) {
+  if (signal.aborted) {
+    throw signal.reason;
   }
-  return result;
+  if (error instanceof SecretLoadError) {
+    throw error;
+  }
+  const status = error instanceof HttpResponseError ? error.status : undefined;
+  const guidance = operation === "selectOrganization" && (status === 401 || status === 403) ? " Run infisical login for the target organization and configured domain, then verify your access." : "";
+  throw new SecretLoadError("HTTP", `Infisical HTTP ${operation} failed${status ? ` (status ${status})` : ""}.${guidance}`, { operation, status });
 }
-function createResolveColorsByKeys(keys, getSeriesColor, getSeriesHoverColor) {
-  const colorMap = resolveSeriesColorMap(keys);
-  return {
-    getColor: (key) => getSeriesColor(colorMap.get(key) ?? hashStringToColorIndex(key)),
-    getHoverColor: (key) => getSeriesHoverColor(colorMap.get(key) ?? hashStringToColorIndex(key))
-  };
+function createInfisicalApiClient(siteUrl) {
+  return createApiClient({
+    name: "infisical",
+    baseApiUrls: {
+      infisical: siteUrl
+    },
+    defaultBaseApiUrl: "infisical",
+    fetch: getFetch(),
+    retries: 1,
+    endpoints: {
+      selectOrganization: {
+        method: "POST",
+        path: "/api/v3/auth/select-organization",
+        reqHeadersSchema: z5.object({
+          Authorization: z5.string(),
+          "User-Agent": z5.string()
+        }),
+        reqBodySchema: z5.object({ organizationId: z5.string() }),
+        resSchema: z5.object({
+          token: z5.string().min(1),
+          isMfaEnabled: z5.boolean().optional()
+        }),
+        reqBodyFormat: "json"
+      },
+      login: {
+        method: "POST",
+        path: "/api/v1/auth/universal-auth/login",
+        reqBodySchema: z5.object({
+          clientId: z5.string(),
+          clientSecret: z5.string()
+        }),
+        resSchema: infisicalAuthResponseSchema,
+        reqBodyFormat: "json"
+      },
+      listSecrets: {
+        method: "GET",
+        path: "/api/v4/secrets",
+        reqHeadersSchema: z5.object({
+          Authorization: z5.string()
+        }),
+        reqQuerySchema: z5.object({
+          projectId: z5.string(),
+          environment: z5.string(),
+          secretPath: z5.string(),
+          viewSecretValue: z5.boolean(),
+          expandSecretReferences: z5.boolean(),
+          includeImports: z5.boolean()
+        }),
+        resSchema: infisicalSecretsResponseSchema
+      }
+    }
+  });
 }
-function clamp(value, min, max) {
-  return Math.min(max, Math.max(min, value));
+function getFetch() {
+  const fetchFn = globalThis.fetch ?? defaultFetch;
+  return (input, init) => {
+    init?.signal?.throwIfAborted();
+    return fetchFn(input, init);
+  };
 }
-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})`;
+// src/secrets/worker-loader.ts
+function cloudflareWorkerEnvLoader(workerEnv) {
+  const loader = async (ctx) => {
+    const out = Object.create(null);
+    for (const key of ctx.keys) {
+      const str = workerBindingToString(Object.hasOwn(workerEnv, key) ? workerEnv[key] : undefined);
+      if (str !== undefined) {
+        out[key] = str;
+      }
     }
-  }
-  if (trimmed.startsWith("rgb(")) {
-    return trimmed.replace("rgb(", "rgba(").replace(")", `, ${alpha})`);
-  }
-  if (trimmed.startsWith("rgba(")) {
-    return trimmed.replace(/,\s*[\d.]+\)$/, `, ${alpha})`);
-  }
-  return trimmed;
+    return out;
+  };
+  return Object.assign(loader, { source: "Cloudflare Worker bindings" });
 }
-function getHeatmapCellStyle(params) {
-  const {
-    value,
-    min,
-    max,
-    baseColor,
-    neutralColor,
-    minAlpha = 0.08,
-    maxAlpha = 0.78
-  } = params;
-  if (value === null || value === undefined || Number.isNaN(value)) {
-    return {};
+function workerBindingToString(value) {
+  if (value === undefined || value === null) {
+    return;
   }
-  if (!Number.isFinite(min) || !Number.isFinite(max)) {
-    return {};
+  if (typeof value === "string") {
+    return value === "" ? undefined : value;
   }
-  if (max <= min) {
-    return {
-      backgroundColor: withAlpha(neutralColor ?? baseColor, 0.32)
-    };
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
   }
-  const normalized = clamp((value - min) / (max - min), 0, 1);
-  const alpha = minAlpha + (maxAlpha - minAlpha) * normalized;
-  return {
-    backgroundColor: withAlpha(baseColor, alpha)
-  };
+  if (typeof value === "object") {
+    return JSON.stringify(value);
+  }
+  return String(value);
 }
-// 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)
-      };
+
+// src/secrets/loaders.ts
+function infisicalLoader(config) {
+  validateInfisicalOrganizationId(config.organizationId);
+  const loader = async (ctx) => fetchInfisicalSecrets({
+    keys: ctx.keys,
+    projectId: config.projectId,
+    organizationId: config.organizationId,
+    environment: ctx.environment,
+    siteUrl: config.siteUrl ?? DEFAULT_INFISICAL_SITE_URL,
+    clientId: config.clientId,
+    clientSecret: config.clientSecret,
+    secretPath: config.secretPath,
+    timeoutMs: config.timeoutMs ?? ctx.timeoutMs,
+    signal: ctx.signal
+  });
+  return Object.assign(loader, { source: "Infisical HTTP" });
+}
+async function processEnvLoader(_ctx) {
+  return {};
+}
+Object.assign(processEnvLoader, { source: "process.env" });
+// src/secrets/vite.ts
+function getViteDefine(secretSet, options = {}) {
+  const values = secretSet.secrets();
+  const keys = options.publicKeys ?? Object.keys(values);
+  if (!options.publicKeys && keys.some((key) => !key.startsWith("VITE_"))) {
+    throw new SecretLoadError("CONFIGURATION", "Vite secret sets must contain only VITE_ keys, or provide an explicit publicKeys list.");
+  }
+  for (const key of keys) {
+    if (!Object.hasOwn(values, key) || !/^[A-Za-z_$][\w$]*$/.test(key)) {
+      throw new SecretLoadError("CONFIGURATION", "Vite publicKeys must reference configured keys with valid JavaScript identifiers.");
     }
-    case "YEARLY": {
-      return {
-        start: new Date(year - 1, 0, 1),
-        end: new Date(year - 1, 11, 31)
-      };
+    if (["MODE", "BASE_URL", "PROD", "DEV", "SSR"].includes(key)) {
+      throw new SecretLoadError("CONFIGURATION", "Vite built-in environment constants cannot be overridden by secrets.");
     }
   }
+  return Object.fromEntries(keys.map((key) => [`import.meta.env.${key}`, JSON.stringify(values[key])]));
 }
-function formatPeriodLabel(start, end, includeDay = false) {
-  const s = start instanceof Date ? start : new Date(start);
-  const e = end instanceof Date ? end : new Date(end);
-  const opts = {
-    year: "numeric",
-    month: "long",
-    ...includeDay && { day: "numeric" }
+function viteSecretSetPlugin(secretSet, options = {}) {
+  return {
+    name: "hanzio-secret-set",
+    config: () => ({ define: getViteDefine(secretSet, options) })
   };
-  return `${s.toLocaleDateString("en-GB", opts)} — ${e.toLocaleDateString("en-GB", opts)}`;
 }
-// src/url/index.ts
-function getDomainFaviconUrl(domain, size = 128) {
-  return `https://www.google.com/s2/favicons?domain=${encodeURIComponent(domain)}&sz=${size}`;
+
+// src/secrets/index.ts
+function getSecretEnvironment() {
+  return resolveSecretEnvironment(undefined, getProcessEnvironment());
+}
+async function defineSecretSet2(keys, options) {
+  let loader;
+  if (!options.loader) {
+    validateInfisicalOrganizationId(options.organizationId);
+    loader = createDefaultInfisicalLoader(options);
+  } else {
+    loader = options.loader;
+  }
+  return defineSecretSet(keys, { ...options, loader }, getProcessEnvironment());
+}
+function createDefaultInfisicalLoader(options) {
+  return (context) => loadInfisicalSecrets({
+    ...context,
+    projectId: options.projectId,
+    organizationId: options.organizationId,
+    siteUrl: options.siteUrl ?? DEFAULT_INFISICAL_SITE_URL,
+    secretPath: options.secretPath,
+    auth: options.auth,
+    clientIdEnvKey: options.clientIdEnvKey ?? "INFISICAL_CLIENT_ID",
+    clientSecretEnvKey: options.clientSecretEnvKey ?? "INFISICAL_CLIENT_SECRET"
+  });
 }
 export {
-  zodToTypeString,
-  zodToExample,
-  zodMinMaxFilter,
-  zSingleOrArray,
-  withAlpha,
-  viteSecretSetPlugin,
-  unwrapResult,
-  typedSwitch,
-  tryCatch,
-  toGteLteFilter,
-  terminalColors,
-  slugify,
-  seriesColorKey,
-  resolveSeriesColorMap,
-  promiseTimeout,
-  pickItemsInArray,
-  partition,
-  normalizeSingleOrArray,
-  logOperationSummary,
-  logBanner,
-  loadInfisicalSecrets,
-  linearRegressionTrend,
-  keyBy,
-  jwtVerify,
-  jwtSign,
-  jsonToZodSchemaMapper,
-  isSuccess,
-  isFailure,
-  hashStringToColorIndex,
-  groupBy,
-  getViteDefine,
-  getUniqueValuesByKey,
-  getUniqueValues,
-  getSecretEnvironment,
-  getPreviousReportPeriod,
-  getHeatmapCellStyle,
-  getDomainSitemap,
-  getDomainFaviconUrl,
-  generateId,
-  formatPeriodLabel,
-  findArrayDifferenceByKey,
-  extractNumber,
-  defineSecretSet,
-  createZId,
-  createResolveColorsByKeys,
-  createCoolLogger,
-  createApiWrapper,
-  createApiClient,
-  compact,
-  colorize,
-  chunkArray,
-  cacheFunction,
-  backgroundPromiseSync,
-  backgroundPromise,
-  TimeoutError,
-  SimpleStateMachine,
-  ResponseValidationError,
-  PriorityQueue,
+  ActionError,
+  ApiError,
+  ConfigError,
+  DEFAULT_INFISICAL_SITE_URL,
+  HttpResponseError,
   METRICS_SERIES_PALETTE_SIZE,
-  HttpResponseError
+  NetworkError,
+  PriorityQueue,
+  RequestAbortedError,
+  RequestTimeoutError,
+  RequestValidationError,
+  ResponseValidationError,
+  SecretLoadError,
+  SimpleStateMachine,
+  TimeoutError,
+  backgroundPromise,
+  backgroundPromiseSync,
+  cacheFunction,
+  chunkArray,
+  cloudflareWorkerEnvLoader,
+  colorize,
+  compact,
+  createApiClient,
+  createCoolLogger,
+  createResolveColorsByKeys,
+  createZId,
+  defineAction,
+  defineSecretSet2 as defineSecretSet,
+  extractNumber,
+  fetchInfisicalSecrets,
+  findArrayDifferenceByKey,
+  formatPeriodLabel,
+  generateId,
+  getDomainFaviconUrl,
+  getDomainSitemap,
+  getHeatmapCellStyle,
+  getPreviousReportPeriod,
+  getSecretEnvironment,
+  getUniqueValues,
+  getUniqueValuesByKey,
+  getViteDefine,
+  groupBy,
+  hashStringToColorIndex,
+  infisicalLoader,
+  isActionError,
+  isApiError,
+  isConfigError,
+  isFailure,
+  isHttpResponseError,
+  isNetworkError,
+  isNonRetryableApiError,
+  isRequestAbortedError,
+  isRequestTimeoutError,
+  isRequestValidationError,
+  isResponseValidationError,
+  isSuccess,
+  jsonToZodSchemaMapper,
+  jwtSign,
+  jwtVerify,
+  keyBy,
+  linearRegressionTrend,
+  loadInfisicalSecrets,
+  logBanner,
+  logOperationSummary,
+  normalizeSingleOrArray,
+  partition,
+  pickItemsInArray,
+  processEnvLoader,
+  promiseTimeout,
+  resolveSeriesColorMap,
+  seriesColorKey,
+  slugify,
+  terminalColors,
+  toGteLteFilter,
+  tryCatch,
+  typedSwitch,
+  unwrapResult,
+  viteSecretSetPlugin,
+  withAlpha,
+  zSingleOrArray,
+  zodMinMaxFilter,
+  zodToExample,
+  zodToTypeString
 };