hanzio 1.2.0 → 2.1.0

package/dist/src/index.js

@@ -1,3 +1,89 @@
+import {
+  chunkArray2,
+  findArrayDifferenceByKey2,
+  getUniqueValues2,
+  compact2,
+  getUniqueValuesByKey2,
+  groupBy2,
+  countBy2,
+  keyBy2,
+  partition2,
+  pickItemsInArray2,
+  toArray2,
+  sumBy2,
+  sortBy2,
+  range2
+} from "../index-hy7kbb99.js";
+import {
+  createCache2
+} from "../index-k9yx6bne.js";
+import {
+  ok2,
+  err2,
+  isSuccess2,
+  isFailure2,
+  unwrapResult2,
+  backgroundPromise2,
+  backgroundPromiseSync2,
+  promiseTimeout2,
+  tryCatch2,
+  PromiseTimeoutError2,
+  withTimeout2,
+  exponentialBackoff2,
+  retry2,
+  pMap2,
+  startTimer2,
+  timed2,
+  anySignal2,
+  timeoutSignal2,
+  raceAbort2,
+  createLatestGuard2
+} from "../index-0zvtcbzy.js";
+import {
+  InvariantError2,
+  getErrorMessage2,
+  toError2,
+  must2,
+  invariant2,
+  isRecord2,
+  isPlainObject2,
+  isDefined2,
+  isTruthy2,
+  isString2,
+  isNumber2,
+  isBoolean2,
+  isFunction2,
+  isOneOf2,
+  hasKey2,
+  isNonEmpty2,
+  nonEmpty2
+} from "../index-8r2vdzjg.js";
+import {
+  extractNumber2,
+  generateId2,
+  sha256Id2,
+  slugify2,
+  stableStringify2,
+  truncate2,
+  normalizeWhitespace2,
+  escapeRegExp2,
+  foldForSearch2,
+  matchesSearch2,
+  initials2,
+  safeJsonParse2
+} from "../index-kj1phgrx.js";
+import {
+  buildQueryString2,
+  replacePathParams2,
+  buildUrl2,
+  normalizeDomain2,
+  getDomainFaviconUrl2,
+  trimTrailingSlash2,
+  ensureLeadingSlash2,
+  buildMailto2,
+  parseRetryAfter2
+} from "../index-mnkcfyx8.js";
+
 // src/typedswitch/index.ts
 function typedSwitch(value, keyOrCases, casesOrDefault, defaultCase) {
   let key;
@@ -14,10 +100,10 @@ function typedSwitch(value, keyOrCases, casesOrDefault, defaultCase) {
     }
     discriminantKey = keyOrCases;
     const discriminantValue = value[discriminantKey];
-    if (typeof discriminantValue !== "string") {
-      throw new Error(`Invalid discriminant value for key "${discriminantKey}": expected string, received ${typeof discriminantValue}`);
+    if (typeof discriminantValue !== "string" && typeof discriminantValue !== "number" && typeof discriminantValue !== "boolean") {
+      throw new Error(`Invalid discriminant value for key "${discriminantKey}": expected string, number or boolean, received ${typeof discriminantValue}`);
     }
-    key = discriminantValue;
+    key = String(discriminantValue);
     cases = casesOrDefault;
     defaultHandler = defaultCase;
   }
@@ -33,184 +119,8 @@ function typedSwitch(value, keyOrCases, casesOrDefault, defaultCase) {
   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 };
-  }
+function assertNever(value, message) {
+  throw new Error(message ?? `Unexpected value: ${String(value)}`);
 }
 // src/cache/index.ts
 function cacheFunction(options) {
@@ -223,7 +133,8 @@ function cacheFunction(options) {
     cacheKeyFn,
     onBackgroundRefreshError,
     store,
-    onStoreError
+    onStoreError,
+    maxEntries
   } = options;
   const externalStore = store;
   const cache = new Map;
@@ -255,143 +166,116 @@ function cacheFunction(options) {
   };
   const buildKey = (args) => {
     const keyArgs = cacheKeyFn ? cacheKeyFn(...args) : cacheKeyArgs ? cacheKeyArgs.map((i) => args[i]) : args;
-    return `${name}:${JSON.stringify(keyArgs)}`;
+    return `${name}:${stableStringify2(keyArgs)}`;
   };
-  const saveEntry = (key, value) => {
-    cache.set(key, { value, timestamp: Date.now() });
-    ensureCleanup();
+  const isFresh = (entry) => Date.now() - entry.timestamp < cacheTimeMs;
+  const servable = (entry) => entry && (refreshInBackground || isFresh(entry)) ? entry : undefined;
+  const touch = (key, entry) => {
+    cache.delete(key);
+    cache.set(key, entry);
+    if (maxEntries !== undefined && cache.size > maxEntries) {
+      cache.delete(cache.keys().next().value);
+    }
   };
-  const fetchAndPopulate = (key, args) => {
-    const result = fn(...args);
-    if (!isPromiseLike(result)) {
-      saveEntry(key, result);
-      return result;
+  const guardStore = async (operation) => {
+    try {
+      return await operation();
+    } catch (error) {
+      onStoreError?.(error, { name });
+      return;
     }
-    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 save = (key, value) => {
+    const entry = { value, timestamp: Date.now() };
+    if (externalStore) {
+      return guardStore(() => externalStore.set(key, entry, entryLifetimeMs));
+    }
+    touch(key, entry);
+    ensureCleanup();
+  };
+  const run = (key, args, stale) => {
     const result = fn(...args);
     if (!isPromiseLike(result)) {
-      saveEntry(key, result);
-      return;
+      save(key, result);
+      return result;
     }
-    const promise = result.then((value) => {
-      saveEntry(key, value);
-      pendingPromises.delete(key);
+    const promise = Promise.resolve(result).then(async (value) => {
+      if (pendingPromises.get(key) === promise) {
+        await save(key, value);
+      }
       return value;
-    }).catch((error) => {
-      pendingPromises.delete(key);
+    }, (error) => {
+      if (!stale)
+        throw error;
       onBackgroundRefreshError?.(error, { name });
-      return staleValue;
+      return stale.value;
+    }).finally(() => {
+      if (pendingPromises.get(key) === promise) {
+        pendingPromises.delete(key);
+      }
     });
     pendingPromises.set(key, promise);
+    return promise;
   };
-  const saveToStore = async (cacheStore, key, value) => {
-    try {
-      await cacheStore.set(key, { value, timestamp: Date.now() }, entryLifetimeMs);
-    } catch (error) {
-      onStoreError?.(error, { name });
+  const serve = (key, args, entry) => {
+    if (!isFresh(entry) && !pendingPromises.has(key)) {
+      run(key, args, entry);
     }
+    return entry.value;
   };
-  const callWithStore = (cacheStore, args) => {
-    const key = buildKey(args);
+  const callWithStore = (cacheStore, key, 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 });
+      const entry = await guardStore(() => cacheStore.get(key));
+      const cached = servable(entry);
+      if (cached) {
+        return serve(key, args, cached);
       }
       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;
+        await guardStore(() => cacheStore.delete(key));
       }
-      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;
+      return pendingPromises.get(key) ?? run(key, args);
     })();
   };
   const wrappedFn = (...args) => {
+    const key = buildKey(args);
     if (externalStore) {
-      return callWithStore(externalStore, args);
+      return callWithStore(externalStore, key, args);
     }
-    const key = buildKey(args);
-    const cached = cache.get(key);
+    const cached = servable(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;
+      touch(key, cached);
+      return serve(key, args, cached);
     }
-    return fetchAndPopulate(key, args);
+    cache.delete(key);
+    return pendingPromises.get(key) ?? run(key, args);
   };
   wrappedFn.clearCache = () => {
     cache.clear();
     pendingPromises.clear();
     stopCleanup();
-    if (externalStore?.clear) {
-      externalStore.clear().catch((error) => {
-        onStoreError?.(error, { name });
-      });
+    const clearStore = externalStore?.clear?.bind(externalStore);
+    if (clearStore) {
+      guardStore(clearStore);
+    }
+  };
+  wrappedFn.invalidate = (...args) => {
+    const key = buildKey(args);
+    cache.delete(key);
+    pendingPromises.delete(key);
+    if (externalStore) {
+      guardStore(() => externalStore.delete(key));
+    }
+  };
+  wrappedFn.peek = (...args) => {
+    const key = buildKey(args);
+    if (externalStore) {
+      return guardStore(() => externalStore.get(key)).then((entry) => servable(entry)?.value);
     }
+    return servable(cache.get(key))?.value;
   };
   return wrappedFn;
 }
@@ -413,84 +297,54 @@ class SimpleStateMachine {
   }
   async getAvailableActions() {
     const actionsMap = this.config.stateActionMap[this.getCurrentStatus()] || {};
-    const result = {};
-    for (const [action, targetState] of Object.entries(actionsMap)) {
-      if (!targetState)
-        continue;
-      const validationResult = await this.validateTransition(targetState, { action });
-      result[action] = validationResult;
-    }
-    return result;
+    const entries = Object.entries(actionsMap).filter((entry) => !!entry[1]);
+    const results = await Promise.all(entries.map(([action, targetState]) => this.validateTransition(targetState, { action })));
+    return Object.fromEntries(entries.map(([action], i) => [action, results[i]]));
   }
   async getPossibleTransitions() {
     const possibleTransitions = this.config.stateTransitions[this.getCurrentStatus()] || [];
     const actionsMap = this.config.stateActionMap[this.getCurrentStatus()] || {};
-    const result = {};
-    for (const targetState of possibleTransitions) {
+    const results = await Promise.all(possibleTransitions.map(async (targetState) => {
       const actionsToTarget = Object.entries(actionsMap).filter(([, t]) => t === targetState);
       if (actionsToTarget.length === 0) {
-        result[targetState] = await this.validateTransition(targetState);
-        continue;
-      }
-      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;
+        return this.validateTransition(targetState);
       }
-      result[targetState] = anyOk ? true : lastError;
-    }
-    return result;
+      const rs = await Promise.all(actionsToTarget.map(([action]) => this.validateTransition(targetState, { action })));
+      return rs.includes(true) ? true : rs[rs.length - 1];
+    }));
+    return Object.fromEntries(possibleTransitions.map((targetState, i) => [targetState, results[i]]));
   }
-  async executeAction(action, data) {
+  async canExecute(action) {
     const actionsMap = this.config.stateActionMap[this.getCurrentStatus()];
     if (!actionsMap) {
-      return {
-        success: false,
-        error: `No actions defined for state '${this.getCurrentStatus()}'`
-      };
+      return `No actions defined for state '${this.getCurrentStatus()}'`;
     }
     const targetState = actionsMap[action];
     if (!targetState) {
-      return {
-        success: false,
-        error: `Action '${action}' not allowed in state '${this.getCurrentStatus()}'`
-      };
+      return `Action '${action}' not allowed in state '${this.getCurrentStatus()}'`;
     }
-    const validationResult = await this.validateTransition(targetState, {
-      action
-    });
-    if (validationResult === true) {
-      if (this.config.actions?.[action]) {
-        try {
-          const result = await this.config.actions[action](this.item, data);
-          return {
-            success: true,
-            newState: targetState,
-            result
-          };
-        } catch (error) {
-          return {
-            success: false,
-            error: error instanceof Error ? error.message : String(error)
-          };
-        }
+    return this.validateTransition(targetState, { action });
+  }
+  async executeAction(action, data) {
+    const fromState = this.getCurrentStatus();
+    const validationResult = await this.canExecute(action);
+    if (validationResult !== true) {
+      return { success: false, error: validationResult };
+    }
+    const targetState = this.config.stateActionMap[fromState][action];
+    try {
+      const result = await this.config.actions?.[action]?.(this.item, data);
+      await this.config.onTransition?.(this.item, fromState, targetState, action);
+      if (this.config.applyTransition) {
+        this.item[this.stateKey] = targetState;
       }
+      return { success: true, newState: targetState, result };
+    } catch (error) {
       return {
-        success: true,
-        newState: targetState
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
       };
     }
-    return {
-      success: false,
-      error: validationResult
-    };
   }
   async validateTransition(toState, options) {
     const action = options?.action;
@@ -508,7 +362,14 @@ class SimpleStateMachine {
     }
     const stateValidator = this.config.validators?.[toState];
     if (stateValidator) {
-      return await stateValidator(this.item, this.getCurrentStatus(), toState, action);
+      const stateResult = await stateValidator(this.item, this.getCurrentStatus(), toState, action);
+      if (stateResult !== true) {
+        return stateResult;
+      }
+    }
+    const actionValidator = action && this.config.actionValidators?.[action];
+    if (actionValidator) {
+      return await actionValidator(this.item, this.getCurrentStatus(), toState, action);
     }
     return true;
   }
@@ -516,17 +377,23 @@ class SimpleStateMachine {
     return Object.keys(this.config.stateTransitions);
   }
   getInitialState() {
-    return this.getStates()[0];
+    return this.config.initialState ?? this.getStates()[0];
   }
 }
+function createStateMachine(config) {
+  return {
+    config,
+    for: (item, stateKey) => new SimpleStateMachine(config, item, stateKey)
+  };
+}
 // src/math/linearRegressionTrend.ts
-function linearRegressionTrend(values) {
+function linearRegression(values) {
   const n = values.length;
   if (n < 2)
-    return [];
+    return null;
   for (const v of values) {
     if (!Number.isFinite(v))
-      return [];
+      return null;
   }
   let sumX = 0;
   let sumY = 0;
@@ -542,24 +409,155 @@ function linearRegressionTrend(values) {
   }
   const denom = n * sumX2 - sumX * sumX;
   if (denom === 0)
-    return [];
+    return null;
   const slope = (n * sumXY - sumX * sumY) / denom;
   const intercept = (sumY - slope * sumX) / n;
-  const out = [];
+  const mean = sumY / n;
+  const fitted = [];
+  let ssRes = 0;
+  let ssTot = 0;
   for (let i = 0;i < n; i++) {
-    out.push(intercept + slope * i);
+    const y = values[i];
+    const f = intercept + slope * i;
+    fitted.push(f);
+    ssRes += (y - f) ** 2;
+    ssTot += (y - mean) ** 2;
   }
-  return out;
+  return { slope, intercept, r2: ssTot === 0 ? 1 : 1 - ssRes / ssTot, fitted };
+}
+function linearRegressionTrend(values) {
+  return linearRegression(values)?.fitted ?? [];
+}
+// src/math/scale.ts
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+function lerp(start, end, t) {
+  return start + (end - start) * t;
+}
+function normalize(value, min, max) {
+  if (max <= min)
+    return 0;
+  return clamp((value - min) / (max - min), 0, 1);
+}
+// src/color/contrast.ts
+function colorFunctionArgs(color) {
+  const match = /^(rgb|hsl)a?\(([^()]*)\)$/i.exec(color.trim());
+  const args = match?.[2]?.trim().split(/[\s,/]+/);
+  if (!match || !args || args.length !== 3 && args.length !== 4) {
+    return;
+  }
+  return { name: match[1].toLowerCase(), args };
+}
+function parseChannel(raw, percentOf) {
+  const isPercent = raw.endsWith("%");
+  const text = isPercent ? raw.slice(0, -1) : raw;
+  const n = text === "" ? Number.NaN : Number(text);
+  if (!Number.isFinite(n))
+    return;
+  return isPercent ? n / 100 * percentOf : n;
+}
+function hslToRgb(h, s, l) {
+  const a = s * Math.min(l, 1 - l);
+  const f = (n) => {
+    const k = (n + h / 30) % 12;
+    return (l - a * Math.max(-1, Math.min(k - 3, 9 - k, 1))) * 255;
+  };
+  return [f(0), f(8), f(4)];
+}
+function parseColor(color) {
+  const trimmed = color.trim();
+  const hex = /^#([\da-f]{3,4}|[\da-f]{6}|[\da-f]{8})$/i.exec(trimmed)?.[1];
+  if (hex) {
+    const full = hex.length <= 4 ? hex.replace(/./g, "$&$&") : hex;
+    const [r = 0, g = 0, b = 0, a = 255] = [0, 2, 4, 6].map((i) => i < full.length ? Number.parseInt(full.slice(i, i + 2), 16) : undefined);
+    return { r, g, b, a: a / 255 };
+  }
+  const fn = colorFunctionArgs(trimmed);
+  if (!fn)
+    return;
+  const [x = "", y = "", z = "", alpha = "1"] = fn.args;
+  const isRgb = fn.name === "rgb";
+  const c1 = parseChannel(isRgb ? x : x.replace(/deg$/i, ""), isRgb ? 255 : 360);
+  const c2 = parseChannel(y, isRgb ? 255 : 100);
+  const c3 = parseChannel(z, isRgb ? 255 : 100);
+  const a = parseChannel(alpha, 1);
+  if (c1 === undefined || c2 === undefined || c3 === undefined)
+    return;
+  if (a === undefined)
+    return;
+  const [r, g, b] = isRgb ? [c1, c2, c3] : hslToRgb((c1 % 360 + 360) % 360, clamp(c2 / 100, 0, 1), clamp(c3 / 100, 0, 1));
+  const channel = (v) => Math.round(clamp(v, 0, 255));
+  return { r: channel(r), g: channel(g), b: channel(b), a: clamp(a, 0, 1) };
+}
+function toRgba(color) {
+  if (typeof color !== "string")
+    return color;
+  const parsed = parseColor(color);
+  if (!parsed)
+    throw new TypeError(`Unsupported color: ${color}`);
+  return parsed;
+}
+function toHex(color, options = {}) {
+  const { r, g, b, a } = toRgba(color);
+  const channels = options.alpha ? [r, g, b, a * 255] : [r, g, b];
+  return `#${channels.map((v) => Math.round(clamp(v, 0, 255)).toString(16).padStart(2, "0")).join("")}`;
+}
+function toRgbString(color) {
+  const { r, g, b, a } = toRgba(color);
+  const [rr, gg, bb] = [r, g, b].map((v) => Math.round(clamp(v, 0, 255)));
+  return a < 1 ? `rgba(${rr}, ${gg}, ${bb}, ${a})` : `rgb(${rr}, ${gg}, ${bb})`;
+}
+function relativeLuminance(color) {
+  const { r, g, b } = toRgba(color);
+  const [lr, lg, lb] = [r, g, b].map((v) => {
+    const c = clamp(v, 0, 255) / 255;
+    return c <= 0.03928 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+  });
+  return 0.2126 * lr + 0.7152 * lg + 0.0722 * lb;
+}
+function contrastRatio(a, b) {
+  const la = relativeLuminance(a);
+  const lb = relativeLuminance(b);
+  return (Math.max(la, lb) + 0.05) / (Math.min(la, lb) + 0.05);
+}
+function contrastText(background, options = {}) {
+  const { light = "#ffffff", dark = "#000000" } = options;
+  return contrastRatio(background, light) >= contrastRatio(background, dark) ? light : dark;
+}
+function mix(a, b, weight) {
+  const t = clamp(weight, 0, 1);
+  const at = (x, y) => x + (y - x) * t;
+  return {
+    r: at(a.r, b.r),
+    g: at(a.g, b.g),
+    b: at(a.b, b.b),
+    a: at(a.a, b.a)
+  };
 }
-// src/math/metricsSeriesColors.ts
+var hexOf = (color) => toHex(color, { alpha: color.a < 1 });
+function mixColors(a, b, weight) {
+  return hexOf(mix(toRgba(a), toRgba(b), weight));
+}
+function shade(color, amount) {
+  const base = toRgba(color);
+  const v = amount < 0 ? 0 : 255;
+  return hexOf(mix(base, { r: v, g: v, b: v, a: base.a }, Math.abs(amount)));
+}
+// src/color/metricsSeriesColors.ts
 var METRICS_SERIES_PALETTE_SIZE = 10;
-function hashStringToColorIndex(str) {
+function hashStringToColorIndex(str, paletteSize = METRICS_SERIES_PALETTE_SIZE) {
   let hash = 2166136261;
   for (let i = 0;i < str.length; i++) {
     hash ^= str.charCodeAt(i);
     hash = Math.imul(hash, 16777619);
   }
-  return Math.abs(hash) % METRICS_SERIES_PALETTE_SIZE;
+  return Math.abs(hash) % paletteSize;
+}
+function pickFromPalette(seed, palette) {
+  if (palette.length === 0)
+    throw new RangeError("palette is empty");
+  return palette[hashStringToColorIndex(seed, palette.length)];
 }
 function circularHueDistance(a, b, paletteSize) {
   const diff = Math.abs(a - b);
@@ -586,21 +584,20 @@ function seriesColorKey(label, key) {
     return fromLabel;
   return key.trim() || key;
 }
-function resolveSeriesColorMap(keys) {
+function resolveSeriesColorMap(keys, paletteSize = METRICS_SERIES_PALETTE_SIZE) {
   const result = new Map;
   const uniqueKeys = [...new Set(keys)];
   if (uniqueKeys.length === 0)
     return result;
-  const paletteSize = METRICS_SERIES_PALETTE_SIZE;
   if (uniqueKeys.length === 1) {
     const only = uniqueKeys[0];
-    result.set(only, hashStringToColorIndex(only));
+    result.set(only, hashStringToColorIndex(only, paletteSize));
     return result;
   }
   const usedIndices = new Set;
   const entries = uniqueKeys.map((key) => ({
     key,
-    preferred: hashStringToColorIndex(key)
+    preferred: hashStringToColorIndex(key, paletteSize)
   }));
   for (const entry of entries) {
     if (!usedIndices.has(entry.preferred)) {
@@ -622,35 +619,25 @@ function resolveSeriesColorMap(keys) {
   }
   return result;
 }
-function createResolveColorsByKeys(keys, getSeriesColor, getSeriesHoverColor) {
-  const colorMap = resolveSeriesColorMap(keys);
+function createResolveColorsByKeys(keys, getSeriesColor, getSeriesHoverColor, paletteSize = METRICS_SERIES_PALETTE_SIZE) {
+  const colorMap = resolveSeriesColorMap(keys, paletteSize);
+  const indexOf = (key) => colorMap.get(key) ?? hashStringToColorIndex(key, paletteSize);
   return {
-    getColor: (key) => getSeriesColor(colorMap.get(key) ?? hashStringToColorIndex(key)),
-    getHoverColor: (key) => getSeriesHoverColor(colorMap.get(key) ?? hashStringToColorIndex(key))
+    getColor: (key) => getSeriesColor(indexOf(key)),
+    getHoverColor: (key) => getSeriesHoverColor(indexOf(key))
   };
 }
-function clamp(value, min, max) {
-  return Math.min(max, Math.max(min, value));
-}
 function withAlpha(color, alpha) {
   const trimmed = color.trim();
-  if (trimmed.startsWith("#")) {
-    const hex = trimmed.slice(1);
-    const normalized = hex.length === 3 ? hex.split("").map((c) => c + c).join("") : hex;
-    if (normalized.length === 6) {
-      const r = Number.parseInt(normalized.slice(0, 2), 16);
-      const g = Number.parseInt(normalized.slice(2, 4), 16);
-      const b = Number.parseInt(normalized.slice(4, 6), 16);
-      return `rgba(${r}, ${g}, ${b}, ${alpha})`;
-    }
-  }
-  if (trimmed.startsWith("rgb(")) {
-    return trimmed.replace("rgb(", "rgba(").replace(")", `, ${alpha})`);
+  const rgba = parseColor(trimmed);
+  const fn = rgba && colorFunctionArgs(trimmed);
+  if (fn?.name === "hsl") {
+    const [h, s, l] = fn.args;
+    return `hsla(${h}, ${s}, ${l}, ${alpha})`;
   }
-  if (trimmed.startsWith("rgba(")) {
-    return trimmed.replace(/,\s*[\d.]+\)$/, `, ${alpha})`);
-  }
-  return trimmed;
+  if (rgba)
+    return `rgba(${rgba.r}, ${rgba.g}, ${rgba.b}, ${alpha})`;
+  return `color-mix(in srgb, ${trimmed} ${alpha * 100}%, transparent)`;
 }
 function getHeatmapCellStyle(params) {
   const {
@@ -673,2833 +660,440 @@ function getHeatmapCellStyle(params) {
       backgroundColor: withAlpha(neutralColor ?? baseColor, 0.32)
     };
   }
-  const normalized = clamp((value - min) / (max - min), 0, 1);
-  const alpha = minAlpha + (maxAlpha - minAlpha) * normalized;
   return {
-    backgroundColor: withAlpha(baseColor, alpha)
+    backgroundColor: withAlpha(baseColor, lerp(minAlpha, maxAlpha, normalize(value, min, max)))
   };
 }
 // src/date/index.ts
-function getPreviousReportPeriod(periodType, referenceDate = new Date) {
-  const month = referenceDate.getMonth();
-  const year = referenceDate.getFullYear();
-  switch (periodType) {
-    case "MONTHLY": {
-      const prevMonth = month === 0 ? 11 : month - 1;
-      const prevYear = month === 0 ? year - 1 : year;
-      return {
-        start: new Date(prevYear, prevMonth, 1),
-        end: new Date(year, month, 0)
-      };
-    }
-    case "QUARTERLY": {
-      const qStart = Math.floor(month / 3) * 3;
-      const prevQStart = qStart === 0 ? 9 : qStart - 3;
-      const prevQYear = qStart === 0 ? year - 1 : year;
-      return {
-        start: new Date(prevQYear, prevQStart, 1),
-        end: new Date(prevQYear, prevQStart + 3, 0)
-      };
-    }
-    case "YEARLY": {
-      return {
-        start: new Date(year - 1, 0, 1),
-        end: new Date(year - 1, 11, 31)
-      };
-    }
+var MONTHS_PER_PERIOD = { MONTHLY: 1, QUARTERLY: 3, YEARLY: 12 };
+function ymd(date, utc = false) {
+  return utc ? [date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()] : [date.getFullYear(), date.getMonth(), date.getDate()];
+}
+function startOfDay(y, m, d, utc = false) {
+  return utc ? new Date(Date.UTC(y, m, d)) : new Date(y, m, d);
+}
+function addPeriod(date, type, n, options = {}) {
+  const { utc = false } = options;
+  let [y, m, d] = ymd(date, utc);
+  if (type === "DAILY" || type === "WEEKLY") {
+    d += n * (type === "WEEKLY" ? 7 : 1);
+  } else {
+    m += n * MONTHS_PER_PERIOD[type];
+    d = Math.min(d, new Date(Date.UTC(y, m + 1, 0)).getUTCDate());
   }
+  const out = new Date(date);
+  if (utc)
+    out.setUTCFullYear(y, m, d);
+  else
+    out.setFullYear(y, m, d);
+  return out;
+}
+function getPeriod(type, referenceDate = new Date, offset = 0, options = {}) {
+  const { utc = false, weekStartsOn = 1 } = options;
+  const [y, m, d] = ymd(referenceDate, utc);
+  const weekday = utc ? referenceDate.getUTCDay() : referenceDate.getDay();
+  const anchor = {
+    DAILY: () => startOfDay(y, m, d, utc),
+    WEEKLY: () => startOfDay(y, m, d - (weekday - weekStartsOn + 7) % 7, utc),
+    MONTHLY: () => startOfDay(y, m, 1, utc),
+    QUARTERLY: () => startOfDay(y, m - m % 3, 1, utc),
+    YEARLY: () => startOfDay(y, 0, 1, utc)
+  }[type]();
+  const [ey, em, ed] = ymd(addPeriod(anchor, type, offset + 1, { utc }), utc);
+  return {
+    start: addPeriod(anchor, type, offset, { utc }),
+    end: startOfDay(ey, em, ed - 1, utc)
+  };
+}
+function getPreviousReportPeriod(periodType, referenceDate = new Date) {
+  return getPeriod(periodType, referenceDate, -1);
 }
-function formatPeriodLabel(start, end, includeDay = false) {
+function formatPeriodLabel(start, end, options = false) {
+  const {
+    includeDay = false,
+    locale = "en-GB",
+    separator = " — ",
+    collapse = false,
+    timeZone
+  } = typeof options === "boolean" ? { includeDay: options } : options;
   const s = start instanceof Date ? start : new Date(start);
   const e = end instanceof Date ? end : new Date(end);
-  const opts = {
+  const format = new Intl.DateTimeFormat(locale, {
     year: "numeric",
     month: "long",
-    ...includeDay && { day: "numeric" }
-  };
-  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";
-
-// src/zod/jsonToZodSchemaMapper.ts
-import { z } from "zod";
-function jsonToZodSchemaMapper(jsonObject, zodSchema, config) {
-  const result = {};
-  const shape = zodSchema instanceof z.ZodObject ? zodSchema.shape : {};
-  for (const key of Object.keys(shape)) {
-    const fieldConfig = config[key];
-    let value = jsonObject[key];
-    if (fieldConfig) {
-      value = fieldConfig(jsonObject);
-    }
-    if (shape[key] instanceof z.ZodObject && value && typeof value === "object") {
-      result[key] = jsonToZodSchemaMapper(value, shape[key], config[key] || {});
-    } else {
-      result[key] = value;
-    }
-  }
-  return zodSchema.parse(result);
-}
-// src/zod/zodMinMaxFilter.ts
-import { z as z2 } from "zod";
-var zodMinMaxFilter = z2.object({
-  min: z2.number().optional(),
-  max: z2.number().optional()
-});
-function toGteLteFilter(filter) {
-  if (!filter)
-    return;
-  const hasMin = filter.min !== undefined;
-  const hasMax = filter.max !== undefined;
-  if (!hasMin && !hasMax)
-    return;
-  return {
-    ...hasMin && { gte: filter.min },
-    ...hasMax && { lte: filter.max }
-  };
-}
-// src/zod/zodToTypeString.ts
-function getDefProp(def, prop) {
-  return def?.[prop];
+    ...includeDay && { day: "numeric" },
+    timeZone
+  });
+  return collapse ? format.formatRange(s, e) : `${format.format(s)}${separator}${format.format(e)}`;
 }
-function zodToTypeString(schema, indent = 0) {
-  const pad = "  ".repeat(indent);
-  const innerPad = "  ".repeat(indent + 1);
-  const def = schema._zod?.def ?? schema._def;
-  if (!def)
-    return "unknown";
-  const schemaType = getDefProp(def, "type") ?? getDefProp(def, "typeName");
-  switch (schemaType) {
-    case "object": {
-      const shape = getDefProp(def, "shape");
-      if (!shape || Object.keys(shape).length === 0)
-        return "{}";
-      const fields = Object.entries(shape).map(([key, value]) => {
-        const valueType = getDefProp(value._zod?.def ?? value._def, "type");
-        const isOptional = valueType === "optional";
-        const innerSchema = isOptional ? getDefProp(value._zod?.def ?? value._def, "innerType") ?? value : value;
-        const typeStr = zodToTypeString(innerSchema, indent + 1);
-        return `${innerPad}${key}${isOptional ? "?" : ""}: ${typeStr}`;
-      });
-      return `{
-${fields.join(`
-`)}
-${pad}}`;
-    }
-    case "array": {
-      const itemType = getDefProp(def, "element") ?? getDefProp(def, "type");
-      return itemType ? `${zodToTypeString(itemType, indent)}[]` : "unknown[]";
-    }
-    case "string":
-      return "string";
-    case "number":
-      return "number";
-    case "boolean":
-      return "boolean";
-    case "date":
-      return "Date";
-    case "null":
-      return "null";
-    case "undefined":
-      return "undefined";
-    case "any":
-      return "any";
-    case "unknown":
-      return "unknown";
-    case "record": {
-      const valueType = getDefProp(def, "valueType");
-      return valueType ? `Record<string, ${zodToTypeString(valueType, indent)}>` : "Record<string, unknown>";
-    }
-    case "enum": {
-      const values = getDefProp(def, "values");
-      return values ? values.map((v) => `"${v}"`).join(" | ") : "string";
-    }
-    case "literal": {
-      const value = getDefProp(def, "value");
-      return typeof value === "string" ? `"${value}"` : String(value);
-    }
-    case "union": {
-      const options = getDefProp(def, "options");
-      return options ? options.map((o) => zodToTypeString(o, indent)).join(" | ") : "unknown";
-    }
-    case "optional": {
-      const inner = getDefProp(def, "innerType");
-      return inner ? `${zodToTypeString(inner, indent)} | undefined` : "unknown";
-    }
-    case "nullable": {
-      const inner = getDefProp(def, "innerType");
-      return inner ? `${zodToTypeString(inner, indent)} | null` : "unknown";
-    }
-    case "default": {
-      const inner = getDefProp(def, "innerType");
-      return inner ? zodToTypeString(inner, indent) : "unknown";
-    }
-    case "ZodObject":
-    case "ZodArray":
-    case "ZodString":
-    case "ZodNumber":
-    case "ZodBoolean":
-    case "ZodDate":
-    case "ZodNull":
-    case "ZodUndefined":
-    case "ZodAny":
-    case "ZodUnknown":
-    case "ZodRecord":
-    case "ZodEnum":
-    case "ZodLiteral":
-    case "ZodUnion":
-    case "ZodOptional":
-    case "ZodNullable":
-    case "ZodDefault":
-      return zodToTypeString(schema, indent);
-    default:
-      return "unknown";
-  }
+// src/object/index.ts
+function typedKeys(object) {
+  return Object.keys(object);
 }
-function zodToExample(schema) {
-  const def = schema._zod?.def ?? schema._def;
-  if (!def)
-    return null;
-  const schemaType = getDefProp(def, "type") ?? getDefProp(def, "typeName");
-  switch (schemaType) {
-    case "object": {
-      const shape = getDefProp(def, "shape");
-      if (!shape)
-        return {};
-      const result = {};
-      for (const [key, value] of Object.entries(shape)) {
-        const valueType = getDefProp(value._zod?.def ?? value._def, "type");
-        const isOptional = valueType === "optional";
-        if (!isOptional) {
-          result[key] = zodToExample(value);
-        }
-      }
-      return result;
-    }
-    case "array": {
-      const itemType = getDefProp(def, "element") ?? getDefProp(def, "type");
-      return itemType ? [zodToExample(itemType)] : [];
-    }
-    case "string":
-      return "";
-    case "number":
-      return 0;
-    case "boolean":
-      return false;
-    case "enum": {
-      const values = getDefProp(def, "values");
-      return values?.[0] ?? "";
-    }
-    case "literal":
-      return getDefProp(def, "value");
-    case "optional":
-    case "default": {
-      const inner = getDefProp(def, "innerType");
-      return inner ? zodToExample(inner) : null;
-    }
-    case "record":
-      return {};
-    default:
-      return null;
-  }
+function typedEntries(object) {
+  return Object.entries(object);
 }
-
-// src/zod/index.ts
-function createZId(typeName) {
-  return z3.string().min(1, `${typeName} ID is required`).brand();
+function typedFromEntries(entries) {
+  return Object.fromEntries(entries);
 }
-function zSingleOrArray(schema) {
-  return z3.union([z3.array(schema), schema]);
+function recordFromKeys(keys, fn) {
+  return typedFromEntries(keys.map((key) => [key, fn(key)]));
 }
-function normalizeSingleOrArray(value) {
-  if (value == null)
-    return [];
-  if (Array.isArray(value))
-    return [...value];
-  return [value];
+function mapValues(object, fn) {
+  return typedFromEntries(typedEntries(object).map(([key, value]) => [key, fn(value, key)]));
 }
-// 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) {
+function pick(object, keys) {
   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;
+  for (const key of keys) {
+    if (key in object)
+      result[key] = object[key];
   }
   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 omit(object, keys) {
+  const result = { ...object };
+  for (const key of keys)
+    delete result[key];
+  return result;
 }
-function hasJsonContentType(headers) {
-  const ct = getHeader(headers, "content-type") ?? "";
-  return ct.includes("application/json");
+var UNSAFE_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+function toPath(path) {
+  if (typeof path !== "string")
+    return path;
+  return path === "" ? [] : path.split(".");
 }
-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");
+function getAtPath(object, path) {
+  let current = object;
+  for (const key of toPath(path)) {
+    if (current === null || typeof current !== "object")
+      return;
+    current = current[key];
   }
-  return body;
-}
-function getHeadersAsObject(headers) {
-  const result = {};
-  headers.forEach((value, key) => {
-    result[key] = value;
-  });
-  return result;
-}
-
-// src/api-wrapper/zod-issues.ts
-import { ZodError } from "zod";
-function formatZodIssues(error, rawData) {
-  return error.issues.map((issue) => {
-    const pathArray = [...issue.path];
-    const path = formatIssuePath(pathArray);
-    const value = getValueAtPath(rawData, pathArray);
-    const valuePreview = value === undefined ? undefined : previewValue(value);
-    const raw = issue;
-    const expected = typeof raw.expected === "string" ? raw.expected : undefined;
-    const received = typeof raw.received === "string" ? raw.received : value !== undefined ? typeofVerbose(value) : undefined;
-    const known = new Set([
-      "code",
-      "path",
-      "message",
-      "expected",
-      "received",
-      "fatal"
-    ]);
-    const extra = {};
-    for (const [k, v] of Object.entries(raw)) {
-      if (!known.has(k) && v !== undefined)
-        extra[k] = v;
-    }
-    return {
-      path,
-      pathArray,
-      code: issue.code,
-      message: issue.message,
-      expected,
-      received,
-      value,
-      valuePreview,
-      extra: Object.keys(extra).length > 0 ? extra : undefined
-    };
-  });
+  return current;
 }
-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)}`);
-      }
+function setAtPath(object, path, value) {
+  const keys = toPath(path);
+  if (keys.length === 0)
+    throw new Error("Path must not be empty");
+  for (const key of keys) {
+    if (UNSAFE_KEYS.has(String(key))) {
+      throw new Error(`Unsafe path segment: ${key}`);
     }
-    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)}]`;
+  }
+  let current = object;
+  for (let index = 0;index < keys.length - 1; index++) {
+    const key = keys[index];
+    let next = current[key];
+    if (next === null || typeof next !== "object") {
+      next = /^\d+$/.test(String(keys[index + 1])) ? [] : {};
+      current[key] = next;
     }
+    current = next;
   }
-  return out;
-}
-function getValueAtPath(data, pathArray) {
-  let current = data;
-  for (const segment of pathArray) {
-    if (current === null || current === undefined)
-      return;
-    if (typeof current !== "object")
-      return;
-    current = current[segment];
-  }
-  return current;
-}
-function typeofVerbose(value) {
-  if (value === null)
-    return "null";
-  if (Array.isArray(value))
-    return "array";
-  return typeof value;
-}
-function previewValue(value, maxLen = 200) {
-  let str;
-  try {
-    if (value === undefined)
-      str = "undefined";
-    else if (typeof value === "string")
-      str = JSON.stringify(value);
-    else
-      str = JSON.stringify(value);
-  } catch {
-    str = String(value);
-  }
-  if (str === undefined)
-    str = String(value);
-  if (str.length > maxLen)
-    str = `${str.slice(0, maxLen)}…`;
-  return str;
-}
-function makeJsonParseZodError(error, text) {
-  const message = error instanceof Error ? `Response body was not valid JSON: ${error.message}` : "Response body was not valid JSON";
-  const preview = text.length > 200 ? `${text.slice(0, 200)}…` : text;
-  return new ZodError([
-    {
-      code: "custom",
-      path: [],
-      message: `${message} (body preview: ${JSON.stringify(preview)})`,
-      input: text
-    }
-  ]);
-}
-function tryParseJson(body) {
-  if (!body)
-    return;
-  try {
-    return JSON.parse(body);
-  } catch {
-    return;
-  }
-}
-
-// src/api-wrapper/errors.ts
-var MAX_BODY_PREVIEW = 500;
-
-class ApiError extends Error {
-  context;
-  cause;
-  constructor(message, context, options) {
-    super(message);
-    this.name = "ApiError";
-    this.context = context;
-    this.cause = options?.cause;
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      message: this.message,
-      context: this.context
-    };
-  }
-}
-
-class HttpResponseError extends ApiError {
-  status;
-  body;
-  bodyJson;
-  responseHeaders;
-  requestId;
-  constructor(status, body, responseHeaders, context) {
-    const preview = body.length > MAX_BODY_PREVIEW ? `${body.slice(0, MAX_BODY_PREVIEW)}…` : body;
-    super(`HTTP ${status} ${context.method} ${context.url} - ${preview}`, context);
-    this.name = "HttpResponseError";
-    this.status = status;
-    this.body = body;
-    this.responseHeaders = responseHeaders;
-    this.requestId = getHeader(responseHeaders, "x-request-id") ?? getHeader(responseHeaders, "x-correlation-id");
-    this.bodyJson = tryParseJson(body);
-  }
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      status: this.status,
-      body: this.body,
-      bodyJson: this.bodyJson,
-      requestId: this.requestId,
-      responseHeaders: this.responseHeaders
-    };
-  }
-}
-
-class ResponseValidationError extends ApiError {
-  zodError;
-  rawResponse;
-  issues;
-  validationIssues;
-  constructor(zodError, rawResponse, context) {
-    const issues = formatZodIssues(zodError, rawResponse);
-    const summary = renderIssueSummary(issues);
-    super(`Response validation failed (${context.method} ${context.url}):
-${summary}`, context, { cause: zodError });
-    this.name = "ResponseValidationError";
-    this.zodError = zodError;
-    this.rawResponse = rawResponse;
-    this.issues = issues;
-    this.validationIssues = issues.map((i) => `${i.path}: ${i.message}`).join("; ");
-  }
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      issues: this.issues,
-      validationIssues: this.validationIssues,
-      rawResponsePreview: previewValue(this.rawResponse, 1000)
-    };
-  }
-}
-
-class RequestValidationError extends ApiError {
-  zodError;
-  target;
-  rawInput;
-  issues;
-  validationIssues;
-  constructor(zodError, target, rawInput, context) {
-    const issues = formatZodIssues(zodError, rawInput);
-    const summary = renderIssueSummary(issues);
-    super(`Request ${target} validation failed (${context.method} ${context.url}):
-${summary}`, context, { cause: zodError });
-    this.name = "RequestValidationError";
-    this.zodError = zodError;
-    this.target = target;
-    this.rawInput = rawInput;
-    this.issues = issues;
-    this.validationIssues = issues.map((i) => `${i.path}: ${i.message}`).join("; ");
-  }
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      target: this.target,
-      issues: this.issues,
-      validationIssues: this.validationIssues
-    };
-  }
-}
-
-class RequestTimeoutError extends ApiError {
-  timeoutMs;
-  constructor(timeoutMs, context) {
-    super(`Request timed out after ${timeoutMs}ms: ${context.method} ${context.url}`, context);
-    this.name = "RequestTimeoutError";
-    this.timeoutMs = timeoutMs;
-  }
-}
-
-class NetworkError extends ApiError {
-  constructor(message, context, cause) {
-    super(message, context, { cause });
-    this.name = "NetworkError";
-  }
-}
-
-class RequestAbortedError extends ApiError {
-  constructor(context, cause) {
-    super(`Request aborted: ${context.method} ${context.url}`, context, {
-      cause
-    });
-    this.name = "RequestAbortedError";
-  }
-}
-
-class ConfigError extends ApiError {
-  constructor(message, context) {
-    super(message, context);
-    this.name = "ConfigError";
-  }
-}
-
-class ActionError extends ApiError {
-  constructor(message, context, cause) {
-    super(message, context, { cause });
-    this.name = "ActionError";
-  }
-}
-var isApiError = (e) => e instanceof ApiError;
-var isHttpResponseError = (e) => e instanceof HttpResponseError;
-var isResponseValidationError = (e) => e instanceof ResponseValidationError;
-var isRequestValidationError = (e) => e instanceof RequestValidationError;
-var isRequestTimeoutError = (e) => e instanceof RequestTimeoutError;
-var isNetworkError = (e) => e instanceof NetworkError;
-var isRequestAbortedError = (e) => e instanceof RequestAbortedError;
-var isConfigError = (e) => e instanceof ConfigError;
-var isActionError = (e) => e instanceof ActionError;
-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 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 {
-      parsedQuery = endpoint.reqQuerySchema.parse(query);
-    } catch (error) {
-      if (error instanceof ZodError2) {
-        throw new RequestValidationError(error, "query", query, ctx());
-      }
-      throw error;
-    }
-  } else {
-    parsedQuery = query ?? {};
-  }
-  const merged = { ...defaultParams, ...parsedQuery };
-  return Object.fromEntries(Object.entries(merged).filter(([, value]) => value !== undefined).map(([key, value]) => [key, String(value)]));
-}
-function buildRequestBody(endpoint, body, ctx) {
-  if (!endpoint.reqBodySchema)
-    return body;
-  let parsedBody;
-  try {
-    parsedBody = endpoint.reqBodySchema.parse(body);
-  } catch (error) {
-    if (error instanceof ZodError2) {
-      throw new RequestValidationError(error, "body", body, ctx());
-    }
-    throw error;
-  }
-  if (endpoint.reqBodyFormat !== "form-data") {
-    return parsedBody;
-  }
-  const formData = new FormData;
-  for (const [key, value] of Object.entries(parsedBody)) {
-    if (value == null)
-      continue;
-    formData.set(key, value instanceof Blob ? value : String(value));
-  }
-  return formData;
-}
-function buildHeaders(endpoint, headers, defaultHeaders, ctx) {
-  const contentType = endpoint.reqBodyFormat === "json" ? "application/json" : undefined;
-  let parsedHeaders;
-  if (endpoint.reqHeadersSchema) {
-    try {
-      parsedHeaders = endpoint.reqHeadersSchema.parse(headers);
-    } catch (error) {
-      if (error instanceof ZodError2) {
-        throw new RequestValidationError(error, "headers", headers, ctx());
-      }
-      throw error;
-    }
-  } else {
-    parsedHeaders = headers ?? {};
-  }
-  return normalizeHeaders({
-    ...defaultHeaders,
-    ...contentType && { "Content-Type": contentType },
-    ...endpoint.defaultHeaders,
-    ...parsedHeaders
-  });
-}
-function replacePathParams(path, params, configError) {
-  return path.replace(/:(\w+)/g, (_, key) => {
-    const value = params?.[key];
-    if (value === undefined) {
-      throw configError(`Missing required path parameter: ${key}`);
-    }
-    return encodeURIComponent(String(value));
-  });
-}
-
-// src/api-wrapper/actions-impl.ts
-function createActionCache() {
-  const store = new Map;
-  const isExpired = (entry) => entry.expiresAt !== undefined && entry.expiresAt <= Date.now();
-  const cache = async (key, fn, options) => {
-    const existing = store.get(key);
-    if (existing && !isExpired(existing)) {
-      if (existing.inflight)
-        return existing.inflight;
-      if (existing.hasValue)
-        return existing.value;
-    }
-    const promise = (async () => fn())();
-    const entry = {
-      hasValue: false,
-      inflight: promise,
-      expiresAt: options?.ttlMs !== undefined ? Date.now() + options.ttlMs : undefined
-    };
-    store.set(key, entry);
-    try {
-      const value = await promise;
-      entry.value = value;
-      entry.hasValue = true;
-      entry.inflight = undefined;
-      return value;
-    } catch (error) {
-      store.delete(key);
-      throw error;
-    }
-  };
-  cache.get = (key) => {
-    const entry = store.get(key);
-    if (!entry || !entry.hasValue)
-      return;
-    if (isExpired(entry)) {
-      store.delete(key);
-      return;
-    }
-    return entry.value;
-  };
-  cache.set = (key, value, options) => {
-    store.set(key, {
-      value,
-      hasValue: true,
-      expiresAt: options?.ttlMs !== undefined ? Date.now() + options.ttlMs : undefined
-    });
-  };
-  cache.invalidate = (key) => {
-    store.delete(key);
-  };
-  cache.clear = () => {
-    store.clear();
-  };
-  return cache;
-}
-function makeDefineAction() {
-  function defineAction(...args) {
-    if (args.length === 0) {
-      return (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
-  };
-}
-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);
-      }
-    }
-  }
-  const delayMs = typeof retryDelay === "function" ? retryDelay(attempt) : retryDelay;
-  return Math.min(delayMs, maxDelay);
-}
-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(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);
-      response = await httpRequest(config, (over) => ctx({ attempt: retryCount, ...over }));
-      await onResponse?.({
-        endpoint: endpointName,
-        method,
-        url: fullUrl,
-        response: response.clone(),
-        attempt: retryCount,
-        meta
-      });
-      if (response.status >= 400) {
-        const retryCtx = {
-          response,
-          retryCount,
-          maxRetries,
-          endpoint: endpointName,
-          method,
-          url: fullUrl
-        };
-        if (retryCount < maxRetries && shouldRetry(retryCtx)) {
-          const delayMs = getRetryDelay({
-            retryDelay,
-            attempt: retryCount,
-            response,
-            maxRetryDelayMs
-          });
-          await onRetry?.({
-            ...retryCtx,
-            delayMs,
-            nextAttempt: retryCount + 1
-          });
-          retryCount++;
-          await delay(delayMs);
-          continue;
-        }
-        const { body, headers: responseHeaders } = await readErrorResponse(response);
-        throw new HttpResponseError(response.status, body, responseHeaders, ctx({ attempt: retryCount }));
-      }
-      return {
-        validatedData: await validateFn(response, retryCount),
-        retryCount,
-        httpStatus: response.status
-      };
-    } catch (error) {
-      if (isNonRetryableApiError(error)) {
-        throw error;
-      }
-      const retryCtx = {
-        error,
-        retryCount,
-        maxRetries,
-        endpoint: endpointName,
-        method,
-        url: fullUrl
-      };
-      if (retryCount >= maxRetries || !shouldRetry(retryCtx)) {
-        throw error;
-      }
-      const delayMs = getRetryDelay({
-        retryDelay,
-        attempt: retryCount,
-        response: undefined,
-        maxRetryDelayMs
-      });
-      await onRetry?.({
-        ...retryCtx,
-        delayMs,
-        nextAttempt: retryCount + 1
-      });
-      retryCount++;
-      await delay(delayMs);
-    }
-  }
-}
-async function validateAndTransformResponse(endpoint, response, ctx) {
-  const responseHeaders = getHeadersAsObject(response.headers);
-  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;
-  const data = await validateResponse(endpoint.resSchema, transformedData, ctx);
-  return { data, responseSizeBytes };
-}
-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 ?? {} };
-  }
-  if (first === undefined || first === null) {
-    return { input: undefined, options: second ?? {} };
-  }
-  if (second !== undefined) {
-    return { input: undefined, options: second };
-  }
-  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 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);
-    }
-  }
-  async function dispatchAction(name, first, second) {
-    const action = actions[name];
-    const { input, options } = resolveActionInvocation(action, name, first, second);
-    return invokeAction(name, input, options);
-  }
-  const request = async (key, input, options) => {
-    if (key in actions) {
-      return dispatchAction(key, input, options);
-    }
-    return invokeEndpoint(key, input ?? {});
-  };
-  const client = { request, cache };
-  const proxy = new Proxy(client, {
-    get(target, prop, receiver) {
-      if (prop in target || typeof prop !== "string") {
-        return Reflect.get(target, prop, receiver);
-      }
-      if (prop in apiConfig.endpoints) {
-        return (input) => invokeEndpoint(prop, input ?? {});
-      }
-      if (prop in actions) {
-        return (first, second) => dispatchAction(prop, first, second);
-      }
-      return;
-    }
-  });
-  const rawActions = apiConfig.actions;
-  if (typeof rawActions === "function") {
-    actions = rawActions({
-      api: proxy,
-      defineAction: makeDefineAction()
-    });
-  } else if (rawActions) {
-    actions = rawActions;
-  }
-  const collisions = Object.keys(actions).filter((key) => (key in apiConfig.endpoints));
-  if (collisions.length > 0) {
-    throw new ConfigError(`Action name(s) collide with endpoint name(s): ${collisions.join(", ")}`, {
-      endpoint: collisions[0],
-      method: "GET",
-      url: "",
-      attempt: 0,
-      maxRetries: 0,
-      elapsedMs: 0
-    });
-  }
-  return proxy;
-}
-var createApiClient = (apiConfig) => createApiClientImpl(apiConfig);
-// src/p-queue/index.ts
-class TimeoutError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "TimeoutError";
-  }
-}
-
-class PriorityQueue {
-  #queue = [];
-  enqueue(run, options = {}) {
-    const element = {
-      priority: options.priority ?? 0,
-      id: options.id,
-      run
-    };
-    const index = this.#queue.findIndex((item) => item.priority < element.priority);
-    if (index === -1) {
-      this.#queue.push(element);
-      return;
-    }
-    this.#queue.splice(index, 0, element);
-  }
-  dequeue() {
-    return this.#queue.shift()?.run;
-  }
-  filter(options) {
-    return this.#queue.filter((item) => Object.entries(options).every(([key, value]) => item[key] === value)).map((item) => item.run);
-  }
-  setPriority(id, priority) {
-    const index = this.#queue.findIndex((item) => item.id === id);
-    if (index === -1) {
-      throw new ReferenceError(`No promise function with the id "${id}" exists in the queue.`);
-    }
-    const [item] = this.#queue.splice(index, 1);
-    this.enqueue(item.run, { ...item, priority });
-  }
-  remove(id) {
-    const index = this.#queue.findIndex((item) => item.id === id);
-    if (index !== -1) {
-      this.#queue.splice(index, 1);
-    }
-  }
-  get size() {
-    return this.#queue.length;
-  }
-}
-
-class PQueue {
-  #listeners = new Map;
-  #queue;
-  #queueClass;
-  #pending = 0;
-  #concurrency;
-  #isPaused;
-  #intervalCap;
-  #interval;
-  #carryoverIntervalCount;
-  #strict;
-  #intervalCount = 0;
-  #intervalEnd = 0;
-  #intervalTimer;
-  #strictTimestamps = [];
-  #rateLimited = false;
-  #idCounter = 1n;
-  #runningTasks = new Map;
-  timeout;
-  constructor(options = {}) {
-    const {
-      concurrency = Number.POSITIVE_INFINITY,
-      autoStart = true,
-      queueClass = PriorityQueue,
-      intervalCap = Number.POSITIVE_INFINITY,
-      interval = 0,
-      carryoverIntervalCount,
-      carryoverConcurrencyCount,
-      strict = false,
-      timeout
-    } = options;
-    if (!(typeof concurrency === "number" && concurrency >= 1)) {
-      throw new TypeError("Expected `concurrency` to be a number from 1 and up");
-    }
-    if (!(typeof intervalCap === "number" && intervalCap >= 1)) {
-      throw new TypeError("Expected `intervalCap` to be a number from 1 and up");
-    }
-    if (!(typeof interval === "number" && Number.isFinite(interval) && interval >= 0)) {
-      throw new TypeError("Expected `interval` to be a finite number >= 0");
-    }
-    if (strict && interval === 0) {
-      throw new TypeError("The `strict` option requires a non-zero `interval`");
-    }
-    if (strict && intervalCap === Number.POSITIVE_INFINITY) {
-      throw new TypeError("The `strict` option requires a finite `intervalCap`");
-    }
-    if (timeout !== undefined && !(Number.isFinite(timeout) && timeout > 0)) {
-      throw new TypeError("Expected `timeout` to be a positive finite number");
-    }
-    this.#queueClass = queueClass;
-    this.#queue = new queueClass;
-    this.#concurrency = concurrency;
-    this.#isPaused = !autoStart;
-    this.#intervalCap = intervalCap;
-    this.#interval = interval;
-    this.#carryoverIntervalCount = carryoverIntervalCount ?? carryoverConcurrencyCount ?? false;
-    this.#strict = strict;
-    this.timeout = timeout;
-  }
-  on(event, listener) {
-    const listeners = this.#listeners.get(event) ?? new Set;
-    listeners.add(listener);
-    this.#listeners.set(event, listeners);
-    return this;
-  }
-  off(event, listener) {
-    this.#listeners.get(event)?.delete(listener);
-    return this;
-  }
-  emit(event, ...arguments_) {
-    const listeners = this.#listeners.get(event);
-    if (!listeners || listeners.size === 0) {
-      return false;
-    }
-    for (const listener of [...listeners]) {
-      listener(...arguments_);
-    }
-    return true;
-  }
-  get concurrency() {
-    return this.#concurrency;
-  }
-  set concurrency(newConcurrency) {
-    if (!(typeof newConcurrency === "number" && newConcurrency >= 1)) {
-      throw new TypeError("Expected `concurrency` to be a number from 1 and up");
-    }
-    this.#concurrency = newConcurrency;
-    this.#processQueue();
-  }
-  get size() {
-    return this.#queue.size;
-  }
-  sizeBy(options) {
-    return this.#queue.filter(options).length;
-  }
-  get pending() {
-    return this.#pending;
-  }
-  get isPaused() {
-    return this.#isPaused;
-  }
-  get isRateLimited() {
-    this.#updateRateLimitState();
-    return this.#rateLimited;
-  }
-  get isSaturated() {
-    return this.#pending >= this.#concurrency && this.#queue.size > 0 || this.isRateLimited && this.#queue.size > 0;
-  }
-  get runningTasks() {
-    return [...this.#runningTasks.values()].map((task) => ({ ...task }));
-  }
-  setPriority(id, priority) {
-    if (typeof priority !== "number" || !Number.isFinite(priority)) {
-      throw new TypeError("Expected `priority` to be a finite number");
-    }
-    this.#queue.setPriority(id, priority);
-  }
-  async add(function_, options = {}) {
-    const taskOptions = {
-      timeout: this.timeout,
-      ...options,
-      id: options.id ?? (this.#idCounter++).toString()
-    };
-    return new Promise((resolve, reject) => {
-      const taskSymbol = Symbol(taskOptions.id);
-      let didRun = false;
-      let queuedAbortHandler;
-      let runningAbortHandler;
-      const cleanupQueuedAbort = () => {
-        if (queuedAbortHandler) {
-          taskOptions.signal?.removeEventListener("abort", queuedAbortHandler);
-          queuedAbortHandler = undefined;
-        }
-      };
-      const run = async () => {
-        didRun = true;
-        cleanupQueuedAbort();
-        this.#pending++;
-        this.#runningTasks.set(taskSymbol, {
-          id: taskOptions.id,
-          priority: taskOptions.priority ?? 0,
-          startTime: Date.now(),
-          timeout: taskOptions.timeout
-        });
-        try {
-          taskOptions.signal?.throwIfAborted();
-          const operation = Promise.resolve(function_({ signal: taskOptions.signal }));
-          const result = await this.#withTimeoutAndAbort(operation, taskOptions, (listener) => {
-            runningAbortHandler = listener;
-          });
-          resolve(result);
-          this.emit("completed", result);
-        } catch (error) {
-          reject(error);
-          this.emit("error", error);
-        } finally {
-          if (runningAbortHandler) {
-            taskOptions.signal?.removeEventListener("abort", runningAbortHandler);
-          }
-          this.#runningTasks.delete(taskSymbol);
-          queueMicrotask(() => {
-            this.#next();
-          });
-        }
-      };
-      if (taskOptions.signal?.aborted) {
-        reject(taskOptions.signal.reason);
-        return;
-      }
-      if (taskOptions.signal) {
-        queuedAbortHandler = () => {
-          if (didRun) {
-            return;
-          }
-          this.#queue.remove?.(taskOptions.id);
-          reject(taskOptions.signal?.reason);
-          this.emit("next");
-          this.#tryToStartAnother();
-        };
-        taskOptions.signal.addEventListener("abort", queuedAbortHandler, {
-          once: true
-        });
-      }
-      this.#queue.enqueue(run, taskOptions);
-      this.emit("add");
-      this.#processQueue();
-    });
-  }
-  async addAll(functions, options) {
-    return Promise.all(functions.map(async (function_) => this.add(function_, options)));
-  }
-  start() {
-    if (!this.#isPaused) {
-      return this;
-    }
-    this.#isPaused = false;
-    this.#processQueue();
-    return this;
-  }
-  pause() {
-    this.#isPaused = true;
-  }
-  clear() {
-    this.#queue = new this.#queueClass;
-    this.#clearIntervalTimer();
-    this.#updateRateLimitState();
-    this.emit("empty");
-    if (this.#pending === 0) {
-      this.emit("idle");
-    }
-    this.emit("next");
-  }
-  async onEmpty() {
-    if (this.#queue.size === 0) {
-      return;
-    }
-    await this.#onEvent("empty");
-  }
-  async onIdle() {
-    if (this.#queue.size === 0 && this.#pending === 0) {
-      return;
-    }
-    await this.#onEvent("idle");
-  }
-  async onPendingZero() {
-    if (this.#pending === 0) {
-      return;
-    }
-    await this.#onEvent("pendingZero");
-  }
-  async onRateLimit() {
-    if (this.isRateLimited) {
-      return;
-    }
-    await this.#onEvent("rateLimit");
-  }
-  async onRateLimitCleared() {
-    if (!this.isRateLimited) {
-      return;
-    }
-    await this.#onEvent("rateLimitCleared");
-  }
-  onError() {
-    return new Promise((_resolve, reject) => {
-      const listener = (error) => {
-        this.off("error", listener);
-        reject(error);
-      };
-      this.on("error", listener);
-    });
-  }
-  async onSizeLessThan(limit) {
-    if (this.#queue.size < limit) {
-      return;
-    }
-    await this.#onEvent("next", () => this.#queue.size < limit);
-  }
-  async#onEvent(event, filter) {
-    return new Promise((resolve) => {
-      const listener = () => {
-        if (filter && !filter()) {
-          return;
-        }
-        this.off(event, listener);
-        resolve();
-      };
-      this.on(event, listener);
-    });
-  }
-  async#withTimeoutAndAbort(operation, options, setAbortListener) {
-    const races = [operation];
-    let timeoutId;
-    if (options.timeout) {
-      races.push(new Promise((_resolve, reject) => {
-        timeoutId = setTimeout(() => {
-          reject(new TimeoutError(`Task timed out after ${options.timeout}ms`));
-        }, options.timeout);
-      }));
-    }
-    if (options.signal) {
-      races.push(new Promise((_resolve, reject) => {
-        const listener = () => {
-          reject(options.signal?.reason);
-        };
-        setAbortListener(listener);
-        options.signal?.addEventListener("abort", listener, { once: true });
-      }));
-    }
-    try {
-      return await Promise.race(races);
-    } finally {
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-      }
-    }
-  }
-  #next() {
-    this.#pending--;
-    if (this.#pending === 0) {
-      this.emit("pendingZero");
-    }
-    this.#processQueue();
-    this.emit("next");
-  }
-  #processQueue() {
-    while (this.#tryToStartAnother()) {}
-    this.#updateRateLimitState();
-  }
-  #tryToStartAnother() {
-    if (this.#queue.size === 0) {
-      this.#clearIntervalTimer();
-      this.emit("empty");
-      if (this.#pending === 0) {
-        this.emit("idle");
-      }
-      return false;
-    }
-    if (this.#isPaused || this.#pending >= this.#concurrency || !this.#doesIntervalAllowAnother()) {
-      return false;
-    }
-    const job = this.#queue.dequeue();
-    if (!job) {
-      return false;
-    }
-    this.#consumeIntervalSlot();
-    this.emit("active");
-    job();
-    return true;
-  }
-  #doesIntervalAllowAnother() {
-    if (this.#intervalCap === Number.POSITIVE_INFINITY || this.#interval === 0) {
-      return true;
-    }
-    const now = Date.now();
-    if (this.#strict) {
-      this.#strictTimestamps = this.#strictTimestamps.filter((timestamp) => now - timestamp < this.#interval);
-      if (this.#strictTimestamps.length < this.#intervalCap) {
-        return true;
-      }
-      this.#scheduleIntervalResume(this.#interval - (now - this.#strictTimestamps[0]));
-      return false;
-    }
-    if (this.#intervalEnd === 0 || now >= this.#intervalEnd) {
-      this.#intervalCount = this.#carryoverIntervalCount ? this.#pending : 0;
-      this.#intervalEnd = now + this.#interval;
-    }
-    if (this.#intervalCount < this.#intervalCap) {
-      return true;
-    }
-    this.#scheduleIntervalResume(this.#intervalEnd - now);
-    return false;
-  }
-  #consumeIntervalSlot() {
-    if (this.#intervalCap === Number.POSITIVE_INFINITY || this.#interval === 0) {
-      return;
-    }
-    if (this.#strict) {
-      this.#strictTimestamps.push(Date.now());
-      return;
-    }
-    this.#intervalCount++;
-  }
-  #scheduleIntervalResume(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");
-    }
-  }
-}
-// src/cool-console-log/index.ts
-var terminalColors = {
-  reset: "\x1B[0m",
-  bold: "\x1B[1m",
-  dim: "\x1B[2m",
-  italic: "\x1B[3m",
-  underline: "\x1B[4m",
-  black: "\x1B[30m",
-  red: "\x1B[31m",
-  green: "\x1B[32m",
-  yellow: "\x1B[33m",
-  blue: "\x1B[34m",
-  magenta: "\x1B[35m",
-  cyan: "\x1B[36m",
-  white: "\x1B[37m",
-  gray: "\x1B[90m",
-  brightRed: "\x1B[91m",
-  brightGreen: "\x1B[92m",
-  brightYellow: "\x1B[93m",
-  brightBlue: "\x1B[94m",
-  brightMagenta: "\x1B[95m",
-  brightCyan: "\x1B[96m",
-  brightWhite: "\x1B[97m",
-  bgBlack: "\x1B[40m",
-  bgRed: "\x1B[41m",
-  bgGreen: "\x1B[42m",
-  bgYellow: "\x1B[43m",
-  bgBlue: "\x1B[44m",
-  bgMagenta: "\x1B[45m",
-  bgCyan: "\x1B[46m",
-  bgWhite: "\x1B[47m"
-};
-var levelColors = {
-  debug: { badge: terminalColors.gray, text: terminalColors.dim },
-  info: { badge: terminalColors.cyan, text: terminalColors.reset },
-  warn: { badge: terminalColors.yellow, text: terminalColors.yellow },
-  error: { badge: terminalColors.red, text: terminalColors.brightRed }
-};
-function formatAttributes(attrs) {
-  if (!attrs || Object.keys(attrs).length === 0)
-    return "";
-  const formatted = Object.entries(attrs).map(([k, v]) => `${terminalColors.dim}${k}=${terminalColors.reset}${v}`).join(" ");
-  return ` ${formatted}`;
-}
-function createCoolLogger(options = {}) {
-  const { colorsInDevOnly = true, onLog } = options;
-  const isDev = true;
-  const useColors = colorsInDevOnly ? isDev : true;
-  const createLogMethod = (level) => (message, attributes) => {
-    onLog?.(level, message, attributes);
-    if (level === "debug" && !isDev)
-      return;
-    if (useColors) {
-      const { badge, text } = levelColors[level];
-      const label = level.toUpperCase().padEnd(5);
-      const attrStr = formatAttributes(attributes);
-      console.log(`${badge}[${label}]${terminalColors.reset} ${text}${message}${terminalColors.reset}${attrStr}`);
-    } else {
-      console[level](`[${level.toUpperCase()}]`, message, attributes ?? "");
-    }
-  };
-  return {
-    debug: createLogMethod("debug"),
-    info: createLogMethod("info"),
-    warn: createLogMethod("warn"),
-    error: createLogMethod("error")
-  };
-}
-function logOperationSummary(operationName, durationMs, success, options = {}) {
-  const { devOnly = true, error } = options;
-  const isDev = true;
-  if (devOnly && !isDev)
-    return;
-  const c = terminalColors;
-  const statusIcon = success ? `${c.brightGreen}✓${c.reset}` : `${c.brightRed}✗${c.reset}`;
-  const statusColor = success ? c.green : c.red;
-  const durationStr = `${c.dim}${durationMs.toFixed(1)}ms${c.reset}`;
-  const errorMessage = error ? ` ${c.dim}·${c.reset} ${c.red}${error instanceof Error ? error.message : String(error)}${c.reset}` : "";
-  console.log(`${statusColor}${c.bold}${operationName}${c.reset} ${statusIcon} ${c.dim}·${c.reset} ${durationStr}${errorMessage}`);
-}
-function colorize(text, color, ...modifiers) {
-  const isDev = true;
-  if (!isDev)
-    return text;
-  const colorCodes = [
-    terminalColors[color],
-    ...modifiers.map((m) => terminalColors[m])
-  ].join("");
-  return `${colorCodes}${text}${terminalColors.reset}`;
-}
-function logBanner(text, color = "cyan", options = {}) {
-  const { devOnly = true } = options;
-  const isDev = true;
-  if (devOnly && !isDev) {
-    console.log(`=== ${text} ===`);
-    return;
-  }
-  const c = terminalColors;
-  const padding = 2;
-  const line = "═".repeat(text.length + padding * 2);
-  console.log(`${c[color]}╔${line}╗${c.reset}`);
-  console.log(`${c[color]}║${" ".repeat(padding)}${c.bold}${text}${c.reset}${c[color]}${" ".repeat(padding)}║${c.reset}`);
-  console.log(`${c[color]}╚${line}╝${c.reset}`);
-}
-// src/jwt/index.ts
-var BYTE_CHUNK_SIZE = 32768;
-var textEncoder = new TextEncoder;
-var textDecoder = new TextDecoder;
-async function jwtSign(payload, secret) {
-  const header = encodeJson({ alg: "HS256" });
-  const body = encodeJson({
-    ...payload,
-    iat: Math.floor(Date.now() / 1000)
-  });
-  const data = `${header}.${body}`;
-  const signature = await sign(data, secret);
-  return `${data}.${encodeBase64Url(signature)}`;
-}
-async function jwtVerify(token, secret) {
-  try {
-    const parts = token.split(".");
-    if (parts.length !== 3)
-      return null;
-    const [encodedHeader, encodedPayload, encodedSignature] = parts;
-    const header = decodeJson(encodedHeader);
-    if (!isJwtHeader(header))
-      return null;
-    const data = `${encodedHeader}.${encodedPayload}`;
-    const signature = decodeBase64Url(encodedSignature);
-    const isValid = await verify(data, signature, secret);
-    if (!isValid)
-      return null;
-    const payload = decodeJson(encodedPayload);
-    if (!isJwtPayload(payload) || !isTimeValid(payload))
-      return null;
-    return payload;
-  } catch (_error) {
-    return null;
-  }
-}
-async function sign(data, secret) {
-  const key = await getKey(secret, ["sign"]);
-  return await getSubtleCrypto().sign("HMAC", key, encodeText(data));
-}
-async function verify(data, signature, secret) {
-  const key = await getKey(secret, ["verify"]);
-  return await getSubtleCrypto().verify("HMAC", key, signature, encodeText(data));
-}
-async function getKey(secret, usages) {
-  return await getSubtleCrypto().importKey("raw", encodeText(secret), {
-    name: "HMAC",
-    hash: "SHA-256"
-  }, false, usages);
-}
-function encodeJson(value) {
-  return encodeBase64Url(encodeText(JSON.stringify(value)));
-}
-function decodeJson(value) {
-  return JSON.parse(textDecoder.decode(decodeBase64Url(value)));
-}
-function encodeBase64Url(value) {
-  const bytes = value instanceof ArrayBuffer ? new Uint8Array(value) : value;
-  return btoa(bytesToBinaryString(bytes)).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
-}
-function decodeBase64Url(value) {
-  const base64 = value.replaceAll("-", "+").replaceAll("_", "/");
-  const padded = base64.padEnd(Math.ceil(base64.length / 4) * 4, "=");
-  return binaryStringToBytes(atob(padded)).buffer;
-}
-function encodeText(value) {
-  return toArrayBuffer(textEncoder.encode(value));
-}
-function toArrayBuffer(bytes) {
-  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
-}
-function bytesToBinaryString(bytes) {
-  let binary = "";
-  for (let offset = 0;offset < bytes.length; offset += BYTE_CHUNK_SIZE) {
-    binary += String.fromCharCode(...bytes.subarray(offset, offset + BYTE_CHUNK_SIZE));
-  }
-  return binary;
-}
-function binaryStringToBytes(binary) {
-  const bytes = new Uint8Array(binary.length);
-  for (let index = 0;index < binary.length; index += 1) {
-    bytes[index] = binary.charCodeAt(index);
-  }
-  return bytes;
-}
-function getSubtleCrypto() {
-  const subtle = globalThis.crypto?.subtle;
-  if (!subtle) {
-    throw new Error("Web Crypto is not available in this runtime");
-  }
-  return subtle;
-}
-function isJwtHeader(value) {
-  return typeof value === "object" && value !== null && "alg" in value && value.alg === "HS256";
-}
-function isJwtPayload(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isTimeValid(payload) {
-  const now = Math.floor(Date.now() / 1000);
-  if (typeof payload.exp === "number" && now >= payload.exp)
-    return false;
-  if (typeof payload.nbf === "number" && now < payload.nbf)
-    return false;
-  return true;
+  current[keys.at(-1)] = value;
 }
-// src/sitemap/index.ts
-var createTimeoutController = (timeout) => {
-  const controller = new AbortController;
-  setTimeout(() => controller.abort(), timeout);
-  return controller;
-};
-var discoverSitemaps = async (domain) => {
-  const normalizedDomain = domain.replace(/\/$/, "");
-  const commonLocations = [
-    "/sitemap.xml",
-    "/sitemap_index.xml",
-    "/sitemap/",
-    "/sitemaps.xml",
-    "/sitemap/sitemap.xml"
-  ];
-  const sitemaps = new Set;
-  const requestOptions = {
-    headers: {
-      "User-Agent": "SitemapCrawler/1.0"
-    },
-    signal: createTimeoutController(5000).signal
-  };
-  try {
-    const robotsTxt = await fetch(`${normalizedDomain}/robots.txt`, {
-      ...requestOptions
-    });
-    if (robotsTxt.ok) {
-      const text = await robotsTxt.text();
-      const sitemapMatches = text.match(/Sitemap: (.*)/gi);
-      if (sitemapMatches) {
-        sitemapMatches.forEach((match) => {
-          const url = match.replace("Sitemap:", "").trim();
-          sitemaps.add(url);
-        });
-      }
-      if (sitemaps.size > 0) {
-        return [...sitemaps];
-      }
-    }
-  } catch (error) {
-    console.warn("Could not fetch robots.txt:", error instanceof Error ? error.message : "Unknown error");
-  }
-  for (const location of commonLocations) {
-    try {
-      const response = await fetch(`${normalizedDomain}${location}`, {
-        ...requestOptions,
-        method: "HEAD"
-      });
-      if (response.ok) {
-        return [`${normalizedDomain}${location}`];
-      }
-    } catch (_error) {}
-  }
-  return [];
-};
-var getDomainSitemap = async (domain, options = {}) => {
-  const {
-    filterIndexes,
-    concurrency = 10,
-    maxDepth = 5,
-    timeout = 1e4
-  } = options;
-  let normalizedDomain = domain.replace(/\/$/, "");
-  if (!normalizedDomain.startsWith("http")) {
-    normalizedDomain = `https://${normalizedDomain}`;
-  }
-  const sitemapUrls = await discoverSitemaps(normalizedDomain);
-  if (sitemapUrls.length === 0) {
-    throw new Error("No sitemaps found for the domain");
-  }
-  const queue = new PQueue({ concurrency });
-  const result = {
-    links: new Set,
-    visited: new Set
-  };
-  const locRegex = /<loc>([^<]+)<\/loc>/g;
-  const isXmlSitemap = (url) => url.endsWith(".xml") || url.toLowerCase().includes("sitemap");
-  const processSitemap = async (sitemapUrl, depth = 0) => {
-    if (depth > maxDepth || result.visited.has(sitemapUrl)) {
-      return;
-    }
-    result.visited.add(sitemapUrl);
-    try {
-      const controller = createTimeoutController(timeout);
-      const response = await fetch(sitemapUrl, {
-        headers: {
-          "User-Agent": "SitemapCrawler/1.0"
-        },
-        signal: controller.signal
-      });
-      if (!response.ok)
-        throw new Error(`HTTP error! status: ${response.status}`);
-      const data = await response.text();
-      const matches = [...data.matchAll(locRegex)].map((match) => match[1].trim()).filter((link) => {
-        if (filterIndexes && isXmlSitemap(link)) {
-          return link.includes(filterIndexes);
-        }
-        return true;
-      });
-      for (const link of matches) {
-        if (isXmlSitemap(link)) {
-          queue.add(() => processSitemap(link, depth + 1));
-        } else {
-          result.links.add(link);
-        }
-      }
-    } catch (error) {
-      console.warn(`Failed to process sitemap ${sitemapUrl}:`, error instanceof Error ? error.message : "Unknown error");
-    }
+// src/function/index.ts
+function debounce(fn, waitMs, options = {}) {
+  let timer;
+  let maxTimer;
+  let lastArgs;
+  const cancel = () => {
+    clearTimeout(timer);
+    clearTimeout(maxTimer);
+    timer = maxTimer = lastArgs = undefined;
   };
-  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/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.");
-  }
-  const controller = new AbortController;
-  const cancel = () => controller.abort(new SecretLoadError("ABORTED", "Secret loading was cancelled."));
-  if (options.signal?.aborted) {
+  const flush = () => {
+    const args = lastArgs;
     cancel();
-  } else {
-    options.signal?.addEventListener("abort", cancel, { once: true });
-  }
-  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";
-    }
-    throw new SecretLoadError("CONFIGURATION", "Invalid secret environment. Use dev, staging, prod, or an explicit { slug } option.");
-  }
-  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 [];
-      }
-      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 {}
+    if (args)
+      fn(...args);
   };
-  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;
-          }
-        });
-      } catch (error) {
-        if (error instanceof SecretLoadError) {
-          throw error;
-        }
-        throw new SecretLoadError("LOADER", "Secret loader failed.");
-      }
-    }
-    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(", ")}`);
-    }
-    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.");
-    }
-    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]);
-      }
+  const debounced = (...args) => {
+    const idle = timer === undefined;
+    clearTimeout(timer);
+    timer = setTimeout(flush, waitMs);
+    if (options.maxWaitMs !== undefined && maxTimer === undefined) {
+      maxTimer = setTimeout(flush, options.maxWaitMs);
     }
-    cached = next;
-    parsed = nextParsed;
-    sources = nextSources;
+    if (idle && options.leading)
+      fn(...args);
+    else
+      lastArgs = args;
   };
-  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;
+  return Object.assign(debounced, {
+    cancel,
+    flush,
+    pending: () => lastArgs !== undefined
+  });
+}
+function keyedDebounce(fn, waitMs) {
+  const byKey = new Map;
+  const each = (key, action) => {
+    const targets = key === undefined ? [...byKey.values()] : [byKey.get(key)];
+    for (const debounced of targets)
+      if (debounced)
+        action(debounced);
   };
-  const secretSet = {
-    secret(key) {
-      if (!Object.hasOwn(cached, key)) {
-        throw new SecretLoadError("MISSING_SECRETS", `Secret ${key} not found`);
+  return {
+    call(key, ...args) {
+      let debounced = byKey.get(key);
+      if (!debounced) {
+        debounced = debounce((...latest) => {
+          byKey.delete(key);
+          fn(key, ...latest);
+        }, waitMs);
+        byKey.set(key, debounced);
       }
-      return cached[key];
+      debounced(...args);
     },
-    secrets: () => ({ ...cached }),
-    parsed: () => structuredClone(parsed),
-    sources: () => ({ ...sources }),
-    async reload(request) {
-      await load(request);
-      return secretSet;
+    cancel(key) {
+      each(key, (debounced) => debounced.cancel());
+      if (key === undefined)
+        byKey.clear();
+      else
+        byKey.delete(key);
+    },
+    flush(key) {
+      each(key, (debounced) => debounced.flush());
     }
   };
-  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"
+function throttle(fn, intervalMs, options = {}) {
+  const { trailing = true } = options;
+  let timer;
+  let trailingArgs;
+  const invoke = (args) => {
+    timer = setTimeout(() => {
+      timer = undefined;
+      const next = trailingArgs;
+      trailingArgs = undefined;
+      if (next)
+        invoke(next);
+    }, intervalMs);
+    fn(...args);
   };
-  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;
-    }
-    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/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.");
-  }
-  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.");
-  }
-  if (!options.projectId.trim() || !options.environment.trim() || !(options.secretPath ?? "/").startsWith("/")) {
-    throw new SecretLoadError("CONFIGURATION", "Infisical requires a projectId, environment, and absolute secretPath.");
-  }
-}
-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.");
-  }
-}
-
-// 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.");
-  }
-  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 };
-}
-
-// 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);
+  const throttled = (...args) => {
+    if (timer === undefined)
+      invoke(args);
+    else if (trailing)
+      trailingArgs = args;
+  };
+  return Object.assign(throttled, {
+    cancel: () => {
+      clearTimeout(timer);
+      timer = trailingArgs = undefined;
     }
   });
 }
-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.");
+function once(fn) {
+  let called = false;
+  let result;
+  return (...args) => {
+    if (!called) {
+      called = true;
+      result = fn(...args);
     }
-    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 }));
+    return result;
+  };
 }
-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 });
+function createHeartbeat(options) {
+  const {
+    now = Date.now,
+    setTimeout: schedule = (callback, ms) => setTimeout(callback, ms),
+    clearTimeout: unschedule = (timer) => clearTimeout(timer)
+  } = options;
+  let active = false;
+  let lastSentAt = 0;
+  let idleTimer;
+  const stop = () => {
+    if (idleTimer !== undefined)
+      unschedule(idleTimer);
+    idleTimer = undefined;
+    if (!active)
+      return;
+    active = false;
+    options.onStop?.();
+  };
+  return {
+    activity() {
+      const time = now();
+      if (!active || time - lastSentAt >= options.intervalMs) {
+        active = true;
+        lastSentAt = time;
+        options.send();
       }
-      token = data.token;
-    }
-    signal.throwIfAborted();
-    operation = "listSecrets";
-    return await listInfisicalSecrets(infisical, token, options);
-  } catch (error) {
-    throwInfisicalHttpError(error, operation, signal);
-  }
-}
-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;
-  }
-  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 createInfisicalApiClient(siteUrl) {
-  return createApiClient({
-    name: "infisical",
-    baseApiUrls: {
-      infisical: siteUrl
+      if (idleTimer !== undefined)
+        unschedule(idleTimer);
+      idleTimer = schedule(stop, options.idleMs);
     },
-    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 getFetch() {
-  const fetchFn = globalThis.fetch ?? defaultFetch;
-  return (input, init) => {
-    init?.signal?.throwIfAborted();
-    return fetchFn(input, init);
+    stop
   };
 }
-// 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;
-      }
-    }
-    return out;
+// src/emitter/index.ts
+function createEmitter() {
+  const listeners = new Map;
+  const add = (event, listener, once) => {
+    const map = listeners.get(event) ?? new Map;
+    listeners.set(event, map);
+    map.set(listener, once);
+    return () => {
+      map.delete(listener);
+    };
   };
-  return Object.assign(loader, { source: "Cloudflare Worker bindings" });
-}
-function workerBindingToString(value) {
-  if (value === undefined || value === null) {
-    return;
-  }
-  if (typeof value === "string") {
-    return value === "" ? undefined : value;
-  }
-  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
-    return String(value);
-  }
-  if (typeof value === "object") {
-    return JSON.stringify(value);
-  }
-  return String(value);
-}
-
-// 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.");
-    }
-    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 viteSecretSetPlugin(secretSet, options = {}) {
   return {
-    name: "hanzio-secret-set",
-    config: () => ({ define: getViteDefine(secretSet, options) })
+    on: (event, listener) => add(event, listener, false),
+    once: (event, listener) => add(event, listener, true),
+    off(event, listener) {
+      listeners.get(event)?.delete(listener);
+    },
+    emit(event, ...[payload]) {
+      const map = listeners.get(event);
+      if (!map)
+        return;
+      const errors = [];
+      for (const [listener, once] of [...map]) {
+        if (!map.has(listener))
+          continue;
+        if (once)
+          map.delete(listener);
+        try {
+          listener(payload);
+        } catch (error) {
+          errors.push(error);
+        }
+      }
+      if (errors.length === 1)
+        throw errors[0];
+      if (errors.length > 1) {
+        throw new AggregateError(errors, `${errors.length} listeners threw for "${String(event)}"`);
+      }
+    },
+    clear(event) {
+      if (event === undefined)
+        listeners.clear();
+      else
+        listeners.delete(event);
+    },
+    listenerCount: (event) => listeners.get(event)?.size ?? 0
   };
 }
-
-// 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 {
-  ActionError,
-  ApiError,
-  ConfigError,
-  DEFAULT_INFISICAL_SITE_URL,
-  HttpResponseError,
+  InvariantError2 as InvariantError,
   METRICS_SERIES_PALETTE_SIZE,
-  NetworkError,
-  PriorityQueue,
-  RequestAbortedError,
-  RequestTimeoutError,
-  RequestValidationError,
-  ResponseValidationError,
-  SecretLoadError,
+  PromiseTimeoutError2 as PromiseTimeoutError,
   SimpleStateMachine,
-  TimeoutError,
-  backgroundPromise,
-  backgroundPromiseSync,
+  addPeriod,
+  anySignal2 as anySignal,
+  assertNever,
+  backgroundPromise2 as backgroundPromise,
+  backgroundPromiseSync2 as backgroundPromiseSync,
+  buildMailto2 as buildMailto,
+  buildQueryString2 as buildQueryString,
+  buildUrl2 as buildUrl,
   cacheFunction,
-  chunkArray,
-  cloudflareWorkerEnvLoader,
-  colorize,
-  compact,
-  createApiClient,
-  createCoolLogger,
+  chunkArray2 as chunkArray,
+  clamp,
+  compact2 as compact,
+  contrastRatio,
+  contrastText,
+  countBy2 as countBy,
+  createCache2 as createCache,
+  createEmitter,
+  createHeartbeat,
+  createLatestGuard2 as createLatestGuard,
   createResolveColorsByKeys,
-  createZId,
-  defineAction,
-  defineSecretSet2 as defineSecretSet,
-  extractNumber,
-  fetchInfisicalSecrets,
-  findArrayDifferenceByKey,
+  createStateMachine,
+  debounce,
+  ensureLeadingSlash2 as ensureLeadingSlash,
+  err2 as err,
+  escapeRegExp2 as escapeRegExp,
+  exponentialBackoff2 as exponentialBackoff,
+  extractNumber2 as extractNumber,
+  findArrayDifferenceByKey2 as findArrayDifferenceByKey,
+  foldForSearch2 as foldForSearch,
   formatPeriodLabel,
-  generateId,
-  getDomainFaviconUrl,
-  getDomainSitemap,
+  generateId2 as generateId,
+  getAtPath,
+  getDomainFaviconUrl2 as getDomainFaviconUrl,
+  getErrorMessage2 as getErrorMessage,
   getHeatmapCellStyle,
+  getPeriod,
   getPreviousReportPeriod,
-  getSecretEnvironment,
-  getUniqueValues,
-  getUniqueValuesByKey,
-  getViteDefine,
-  groupBy,
+  getUniqueValues2 as getUniqueValues,
+  getUniqueValuesByKey2 as getUniqueValuesByKey,
+  groupBy2 as groupBy,
+  hasKey2 as hasKey,
   hashStringToColorIndex,
-  infisicalLoader,
-  isActionError,
-  isApiError,
-  isConfigError,
-  isFailure,
-  isHttpResponseError,
-  isNetworkError,
-  isNonRetryableApiError,
-  isRequestAbortedError,
-  isRequestTimeoutError,
-  isRequestValidationError,
-  isResponseValidationError,
-  isSuccess,
-  jsonToZodSchemaMapper,
-  jwtSign,
-  jwtVerify,
-  keyBy,
+  initials2 as initials,
+  invariant2 as invariant,
+  isBoolean2 as isBoolean,
+  isDefined2 as isDefined,
+  isFailure2 as isFailure,
+  isFunction2 as isFunction,
+  isNonEmpty2 as isNonEmpty,
+  isNumber2 as isNumber,
+  isOneOf2 as isOneOf,
+  isPlainObject2 as isPlainObject,
+  isRecord2 as isRecord,
+  isString2 as isString,
+  isSuccess2 as isSuccess,
+  isTruthy2 as isTruthy,
+  keyBy2 as keyBy,
+  keyedDebounce,
+  lerp,
+  linearRegression,
   linearRegressionTrend,
-  loadInfisicalSecrets,
-  logBanner,
-  logOperationSummary,
-  normalizeSingleOrArray,
-  partition,
-  pickItemsInArray,
-  processEnvLoader,
-  promiseTimeout,
+  mapValues,
+  matchesSearch2 as matchesSearch,
+  mixColors,
+  must2 as must,
+  nonEmpty2 as nonEmpty,
+  normalize,
+  normalizeDomain2 as normalizeDomain,
+  normalizeWhitespace2 as normalizeWhitespace,
+  ok2 as ok,
+  omit,
+  once,
+  pMap2 as pMap,
+  parseColor,
+  parseRetryAfter2 as parseRetryAfter,
+  partition2 as partition,
+  pick,
+  pickFromPalette,
+  pickItemsInArray2 as pickItemsInArray,
+  promiseTimeout2 as promiseTimeout,
+  raceAbort2 as raceAbort,
+  range2 as range,
+  recordFromKeys,
+  relativeLuminance,
+  replacePathParams2 as replacePathParams,
   resolveSeriesColorMap,
+  retry2 as retry,
+  safeJsonParse2 as safeJsonParse,
   seriesColorKey,
-  slugify,
-  terminalColors,
-  toGteLteFilter,
-  tryCatch,
+  setAtPath,
+  sha256Id2 as sha256Id,
+  shade,
+  slugify2 as slugify,
+  sortBy2 as sortBy,
+  stableStringify2 as stableStringify,
+  startTimer2 as startTimer,
+  sumBy2 as sumBy,
+  throttle,
+  timed2 as timed,
+  timeoutSignal2 as timeoutSignal,
+  toArray2 as toArray,
+  toError2 as toError,
+  toHex,
+  toRgbString,
+  trimTrailingSlash2 as trimTrailingSlash,
+  truncate2 as truncate,
+  tryCatch2 as tryCatch,
+  typedEntries,
+  typedFromEntries,
+  typedKeys,
   typedSwitch,
-  unwrapResult,
-  viteSecretSetPlugin,
+  unwrapResult2 as unwrapResult,
   withAlpha,
-  zSingleOrArray,
-  zodMinMaxFilter,
-  zodToExample,
-  zodToTypeString
+  withTimeout2 as withTimeout
 };