zevairouter 1.0.150 → 1.0.152

package/cli/app/CHANGELOG.md

@@ -1,3 +1,16 @@
+# v1.0.152 (2026-07-27)
+
+## Fixes
+- **Accurate Codex quota recovery**: a newer quota snapshot that explicitly reports capacity can now supersede a stale per-model lock instead of returning a false long-lived 429 while quota remains available.
+- **Bounded recovery probes**: recovered accounts are retried once only when the quota snapshot is newer than the locking error; a fresh upstream failure immediately restores the lock and prevents retry loops.
+
+# v1.0.151 (2026-07-27)
+
+## Fixes
+- **Deterministic DataImpulse sticky sessions**: CodeBuddy CN now initializes pasted proxies with sequential CN-accessible exit checks, preventing parallel first requests from racing sticky-port assignment and falsely reporting an immediate rotation.
+- **Exit-aligned CloakBrowser identity**: the verified residential exit is applied directly to WebRTC, timezone, and locale flags instead of allowing failed foreign echo services to substitute the proxy gateway address.
+- **Safe pre-purchase verification**: browser-context checks use the same sequential fallback order and compare the initial exit with the exit immediately before the 5sim purchase, without modifying pasted credentials or Proxy Pool data.
+
 # v1.0.150 (2026-07-27)
 
 ## Fixes

package/cli/app/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zevairouter",
-  "version": "1.0.150",
+  "version": "1.0.152",
   "description": "Self-hosted AI router: many providers, one OpenAI-compatible /v1 endpoint and dashboard",
   "bin": {
     "zevai": "./cli/cli.js"

package/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zevairouter-cli",
-  "version": "1.0.150",
+  "version": "1.0.152",
   "description": "ZevaiRouter CLI - Start and manage ZevaiRouter server",
   "bin": {
     "zevai": "./cli.js"

package/open-sse/services/accountFallback.js

@@ -53,6 +53,43 @@ export function getQuotaExhaustedUntil(usage) {
   return getQuotaResetAt(usage);
 }
 
+/**
+ * Return true only when a quota snapshot explicitly says every known window
+ * still has capacity. Requiring all windows avoids treating an account with an
+ * exhausted weekly window as recovered just because its short window is open.
+ */
+export function hasAvailableQuota(usage) {
+  if (!usage || usage.limitReached === true) return false;
+  const quotas = Object.values(usage.quotas || {});
+  const remaining = quotas.map((quota) => {
+    if (Number.isFinite(quota?.remaining)) return quota.remaining;
+    if (Number.isFinite(quota?.remainingPercentage)) return quota.remainingPercentage;
+    return null;
+  }).filter((value) => value !== null);
+
+  return remaining.length > 0
+    && remaining.length === quotas.length
+    && remaining.every((value) => value > 0);
+}
+
+/**
+ * A successful quota poll newer than the error which created a model lock is
+ * authoritative evidence that a Codex account recovered. The caller may probe
+ * the account once; a fresh upstream failure updates lastErrorAt and makes the
+ * same snapshot too old to bypass the replacement lock.
+ */
+export function isModelLockRecoveredByQuota(connection, model, snapshot) {
+  if (!isModelLockActive(connection, model) || !hasAvailableQuota(snapshot?.usage)) {
+    return false;
+  }
+
+  const fetchedAt = Date.parse(snapshot?.fetchedAt);
+  const errorAt = Date.parse(connection?.lastErrorAt);
+  return Number.isFinite(fetchedAt)
+    && Number.isFinite(errorAt)
+    && fetchedAt > errorAt;
+}
+
 /**
  * Calculate exponential backoff cooldown for rate limits (429)
  * Level 1: 1s, Level 2: 2s, Level 3: 4s... → max 4 min

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zevairouter",
-  "version": "1.0.150",
+  "version": "1.0.152",
   "description": "Self-hosted AI router: many providers, one OpenAI-compatible /v1 endpoint and dashboard",
   "bin": {
     "zevai": "./cli/cli.js"

package/src/lib/oauth/services/bulkImportBrowserEngine.js

@@ -1,5 +1,7 @@
 import { createHash } from "node:crypto";
 import { createRequire } from "node:module";
+import net from "node:net";
+import { ProxyAgent, fetch as undiciFetch } from "undici";
 
 const requireFromHere = createRequire(import.meta.url);
 
@@ -14,6 +16,27 @@ export const DEFAULT_BULK_IMPORT_ENGINE = "cloakbrowser";
 const SUPPORTED_ENGINES = new Set(["cloakbrowser"]);
 const CLOAK_PROXY_PROFILES = new WeakMap();
 
+export const PROXY_EGRESS_ECHO_URLS = Object.freeze([
+  "https://myip.ipip.net",
+  "https://ip.3322.net",
+  "https://cip.cc",
+]);
+
+const PROXY_GEO_PROFILES = Object.freeze({
+  CN: { timezone: "Asia/Shanghai", locale: "zh-CN" },
+  HK: { timezone: "Asia/Hong_Kong", locale: "zh-HK" },
+  MO: { timezone: "Asia/Macau", locale: "zh-MO" },
+  TW: { timezone: "Asia/Taipei", locale: "zh-TW" },
+  SG: { timezone: "Asia/Singapore", locale: "en-SG" },
+  JP: { timezone: "Asia/Tokyo", locale: "ja-JP" },
+  KR: { timezone: "Asia/Seoul", locale: "ko-KR" },
+  US: { locale: "en-US" },
+  GB: { locale: "en-GB" },
+});
+
+const DEFAULT_PROXY_PROBE_TIMEOUT_MS = 8_000;
+const DEFAULT_PROXY_GEO_TIMEOUT_MS = 5_000;
+
 export function normalizeBulkImportEngine(value) {
   if (typeof value !== "string" || !value.trim()) return DEFAULT_BULK_IMPORT_ENGINE;
   const lower = value.trim().toLowerCase();
@@ -208,6 +231,220 @@ export async function newStealthContext(browser, options = {}) {
   return context;
 }
 
+export function parseProxyEgressIp(value) {
+  const raw = String(value || "").trim();
+  if (!raw) return null;
+  if (net.isIP(raw)) return raw;
+
+  try {
+    const parsed = JSON.parse(raw);
+    for (const key of ["ip", "query", "address", "origin"]) {
+      const candidate = String(parsed?.[key] || "").trim();
+      if (net.isIP(candidate)) return candidate;
+    }
+  } catch {
+    // Plain-text echo services are expected here.
+  }
+
+  for (const match of raw.matchAll(/(?:\d{1,3}\.){3}\d{1,3}/g)) {
+    if (net.isIP(match[0])) return match[0];
+  }
+
+  const tokens = raw.split(/[\s,;()[\]{}<>"'=\uFF1A]+/);
+  for (const token of tokens) {
+    const candidate = token.replace(/^[^0-9a-f:]+|[^0-9a-f:]+$/gi, "");
+    if (candidate.includes(":") && net.isIP(candidate)) return candidate;
+  }
+  return null;
+}
+
+function inferProxyRegionalProfile(proxyUrl) {
+  try {
+    const parsed = new URL(String(proxyUrl || "").trim());
+    const username = decodeURIComponent(parsed.username || "");
+    const matches = [...username.matchAll(/(?:^|__)cr\.([a-z]{2})(?=__|$)/gi)];
+    const countryCode = matches.at(-1)?.[1]?.toUpperCase() || null;
+    const regional = countryCode ? PROXY_GEO_PROFILES[countryCode] : null;
+    return regional?.timezone && regional?.locale
+      ? { countryCode, ...regional, source: "proxy-country" }
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+async function closeProxyAgent(agent) {
+  if (!agent) return;
+  if (typeof agent.close === "function") {
+    await Promise.resolve(agent.close()).catch(() => null);
+    return;
+  }
+  if (typeof agent.destroy === "function") {
+    await Promise.resolve(agent.destroy()).catch(() => null);
+  }
+}
+
+/**
+ * Pin a fresh sticky proxy with one request at a time. Parallel first-use
+ * requests can race session assignment on providers such as DataImpulse.
+ */
+export async function probeProxyEgressBeforeLaunch(
+  proxyUrl,
+  {
+    timeoutMs = DEFAULT_PROXY_PROBE_TIMEOUT_MS,
+    urls = PROXY_EGRESS_ECHO_URLS,
+    fetchImpl = undiciFetch,
+    createProxyAgent = (url) => new ProxyAgent(url),
+  } = {},
+) {
+  let agent = null;
+  const attemptedUrls = [];
+  let lastError = null;
+
+  try {
+    try {
+      agent = createProxyAgent(proxyUrl);
+    } catch {
+      return {
+        ok: false,
+        ip: null,
+        url: null,
+        attempts: 0,
+        attemptedUrls,
+        error: "proxy agent setup failed",
+      };
+    }
+
+    for (const url of urls) {
+      attemptedUrls.push(url);
+      try {
+        const response = await fetchImpl(url, {
+          dispatcher: agent,
+          redirect: "follow",
+          signal: AbortSignal.timeout(timeoutMs),
+          headers: {
+            Accept: "text/plain, application/json;q=0.9, */*;q=0.1",
+            "Cache-Control": "no-cache",
+          },
+        });
+        if (!response?.ok) {
+          lastError = `HTTP ${response?.status || 0}`;
+          continue;
+        }
+        const ip = parseProxyEgressIp(await response.text());
+        if (!ip) {
+          lastError = "exit-IP response was not recognized";
+          continue;
+        }
+        return {
+          ok: true,
+          ip,
+          url,
+          attempts: attemptedUrls.length,
+          attemptedUrls,
+          error: null,
+        };
+      } catch (error) {
+        lastError = error?.name === "TimeoutError"
+          ? `timed out after ${timeoutMs}ms`
+          : "request failed";
+      }
+    }
+
+    return {
+      ok: false,
+      ip: null,
+      url: null,
+      attempts: attemptedUrls.length,
+      attemptedUrls,
+      error: lastError || "all exit-IP services failed",
+    };
+  } finally {
+    await closeProxyAgent(agent);
+  }
+}
+
+async function lookupProxyGeoProfile(
+  egressIp,
+  { timeoutMs = DEFAULT_PROXY_GEO_TIMEOUT_MS, fetchImpl = undiciFetch } = {},
+) {
+  try {
+    const response = await fetchImpl(`https://ipwho.is/${encodeURIComponent(egressIp)}`, {
+      redirect: "follow",
+      signal: AbortSignal.timeout(timeoutMs),
+      headers: { Accept: "application/json" },
+    });
+    if (!response?.ok) return null;
+    const data = await response.json();
+    if (data?.success === false) return null;
+    const countryCode = String(data?.country_code || "").trim().toUpperCase();
+    const timezone = String(data?.timezone?.id || "").trim();
+    const locale = PROXY_GEO_PROFILES[countryCode]?.locale
+      || (countryCode ? `en-${countryCode}` : "");
+    return timezone && locale
+      ? { countryCode: countryCode || null, timezone, locale, source: "ip-geo" }
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+export async function resolveProxyLaunchProfile(proxyUrl, options = {}) {
+  const probe = await probeProxyEgressBeforeLaunch(proxyUrl, options);
+  if (!probe.ok || !probe.ip) {
+    const error = new Error(
+      `Manual proxy exit IP could not be verified before browser launch (${probe.error || "no response"}); no phone number was purchased`,
+    );
+    error.code = "CLOAKBROWSER_PROXY_EGRESS_UNAVAILABLE";
+    throw error;
+  }
+
+  const regional = inferProxyRegionalProfile(proxyUrl)
+    || await lookupProxyGeoProfile(probe.ip, options);
+  if (!regional?.timezone || !regional?.locale) {
+    const error = new Error(
+      "Manual proxy region could not be aligned with CloakBrowser; no phone number was purchased",
+    );
+    error.code = "CLOAKBROWSER_PROXY_GEOIP_UNAVAILABLE";
+    throw error;
+  }
+
+  return Object.freeze({
+    egressIp: probe.ip,
+    timezone: regional.timezone,
+    locale: regional.locale,
+    countryCode: regional.countryCode || null,
+    source: regional.source,
+    probeUrl: probe.url,
+    probeAttempts: probe.attempts,
+  });
+}
+
+export function buildVerifiedProxyLaunchOptions(launchOpts, proxyProfile) {
+  const managedPrefixes = [
+    "--fingerprint-webrtc-ip=",
+    "--fingerprint-timezone=",
+    "--fingerprint-locale=",
+    "--lang=",
+  ];
+  const args = (launchOpts?.args || []).filter(
+    (arg) => !managedPrefixes.some((prefix) => String(arg).startsWith(prefix)),
+  );
+  args.push(
+    `--fingerprint-webrtc-ip=${proxyProfile.egressIp}`,
+    `--fingerprint-timezone=${proxyProfile.timezone}`,
+    `--lang=${proxyProfile.locale}`,
+    `--fingerprint-locale=${proxyProfile.locale}`,
+  );
+  return {
+    ...launchOpts,
+    args,
+    timezone: proxyProfile.timezone,
+    locale: proxyProfile.locale,
+    geoip: false,
+  };
+}
+
 /**
  * CloakBrowser — sole bulk-import engine (patched stealth Chromium).
  * Prefer headed (headless=false); Turnstile / Google bot checks often fail headless.
@@ -292,38 +529,10 @@ async function launchCloakbrowser({
   let effectiveLaunchOpts = launchOpts;
   let proxyProfile = null;
   if (proxyUrl && requireProxyGeoip) {
-    if (typeof cloak.buildLaunchOptions !== "function") {
-      const error = new Error("CloakBrowser runtime cannot verify proxy GeoIP before launch");
-      error.code = "CLOAKBROWSER_PROXY_GEOIP_UNSUPPORTED";
-      throw error;
-    }
-    // Slow residential CONNECT handshakes regularly exceed CloakBrowser's 5s
-    // default. Resolve once with a bounded 12s budget, then reuse those flags.
-    const previousGeoipTimeout = process.env.CLOAKBROWSER_GEOIP_TIMEOUT_SECONDS;
-    if (!previousGeoipTimeout) process.env.CLOAKBROWSER_GEOIP_TIMEOUT_SECONDS = "12";
-    let resolved;
-    try {
-      resolved = await cloak.buildLaunchOptions(launchOpts);
-    } finally {
-      if (previousGeoipTimeout === undefined) {
-        delete process.env.CLOAKBROWSER_GEOIP_TIMEOUT_SECONDS;
-      } else {
-        process.env.CLOAKBROWSER_GEOIP_TIMEOUT_SECONDS = previousGeoipTimeout;
-      }
-    }
-    proxyProfile = extractCloakProxyProfile(resolved?.args || []);
-    if (!proxyProfile.egressIp || !proxyProfile.timezone || !proxyProfile.locale) {
-      const error = new Error(
-        "Manual proxy exit GeoIP could not be verified; no phone number was purchased",
-      );
-      error.code = "CLOAKBROWSER_PROXY_GEOIP_UNAVAILABLE";
-      throw error;
-    }
-    effectiveLaunchOpts = {
-      ...launchOpts,
-      args: resolved.args || launchOpts.args,
-      geoip: false,
-    };
+    // Resolve the exit ourselves through CN-accessible endpoints. CloakBrowser's
+    // foreign echo fallbacks can time out and mistake the gateway IP for the exit.
+    proxyProfile = await resolveProxyLaunchProfile(proxyUrl);
+    effectiveLaunchOpts = buildVerifiedProxyLaunchOptions(launchOpts, proxyProfile);
   }
 
   try {

package/src/lib/oauth/services/codebuddyCnBulkImportManager.js

@@ -18,7 +18,6 @@
  */
 
 import { randomUUID } from "crypto";
-import net from "node:net";
 import {
   KiroBulkImportManager,
   buildLookupResponse,
@@ -44,6 +43,8 @@ import {
 import {
   forceCloseBrowser,
   getCloakProxyProfile,
+  parseProxyEgressIp,
+  PROXY_EGRESS_ECHO_URLS,
 } from "./bulkImportBrowserEngine.js";
 
 const CODEBUDDY_CN_PROVIDER_ID = "codebuddy-cn";
@@ -89,11 +90,6 @@ const CODEBUDDY_CN_FIVESIM_SETTLE_TIMEOUT_MS = 12_000;
 const CODEBUDDY_CN_EGRESS_PROBE_TIMEOUT_MS = 6_000;
 const CODEBUDDY_CN_API_KEY_OUTCOME_UNKNOWN = "CN_API_KEY_OUTCOME_UNKNOWN";
 const CODEBUDDY_CN_ACCOUNT_RESTRICTED = "CN_ACCOUNT_RESTRICTED";
-const CODEBUDDY_CN_EGRESS_ECHO_URLS = [
-  "https://api.ipify.org",
-  "https://checkip.amazonaws.com",
-  "https://ifconfig.me/ip",
-];
 
 // Supported 5sim regions
 const SUPPORTED_REGIONS = new Set(["hongkong", "china", "any"]);
@@ -142,15 +138,7 @@ function resolveCnJobConcurrency(value, { manualProxy = false } = {}) {
 }
 
 function parseEgressIp(value) {
-  const raw = String(value || "").trim();
-  if (net.isIP(raw)) return raw;
-  try {
-    const parsed = JSON.parse(raw);
-    const ip = String(parsed?.ip || parsed?.query || "").trim();
-    return net.isIP(ip) ? ip : null;
-  } catch {
-    return null;
-  }
+  return parseProxyEgressIp(value);
 }
 
 async function probeCodeBuddyProxyEgress(
@@ -167,7 +155,10 @@ async function probeCodeBuddyProxyEgress(
     return { ok: false, ip: null, ips: [], samples: 0, error: "context request unavailable" };
   }
 
-  const results = await Promise.all(CODEBUDDY_CN_EGRESS_ECHO_URLS.map(async (url) => {
+  const attemptedUrls = [];
+  let lastError = null;
+  for (const url of PROXY_EGRESS_ECHO_URLS) {
+    attemptedUrls.push(url);
     let response = null;
     try {
       response = await requestContext.get(url, {
@@ -178,30 +169,44 @@ async function probeCodeBuddyProxyEgress(
           "Cache-Control": "no-cache",
         },
       });
-      if (response.status() < 200 || response.status() >= 300) return null;
-      return parseEgressIp(await response.text().catch(() => ""));
-    } catch {
-      return null;
+      if (response.status() < 200 || response.status() >= 300) {
+        lastError = `HTTP ${response.status()}`;
+        continue;
+      }
+      const ip = parseEgressIp(await response.text().catch(() => ""));
+      if (!ip) {
+        lastError = "exit-IP response was not recognized";
+        continue;
+      }
+      return {
+        ok: true,
+        ip,
+        ips: [ip],
+        samples: 1,
+        attempts: attemptedUrls.length,
+        attemptedUrls,
+        unstable: false,
+        error: null,
+      };
+    } catch (error) {
+      lastError = error?.name === "TimeoutError"
+        ? `timed out after ${timeoutMs}ms`
+        : "request failed";
     } finally {
       if (typeof response?.dispose === "function") {
         await Promise.resolve(response.dispose()).catch(() => null);
       }
     }
-  }));
-
-  const successful = results.filter(Boolean);
-  const ips = [...new Set(successful)];
+  }
   return {
-    ok: ips.length === 1,
-    ip: ips.length === 1 ? ips[0] : null,
-    ips,
-    samples: successful.length,
-    unstable: ips.length > 1,
-    error: ips.length === 0
-      ? "all exit-IP services failed"
-      : ips.length > 1
-        ? `proxy returned ${ips.length} exit IPs in one probe`
-        : null,
+    ok: false,
+    ip: null,
+    ips: [],
+    samples: 0,
+    attempts: attemptedUrls.length,
+    attemptedUrls,
+    unstable: false,
+    error: lastError || "all exit-IP services failed",
   };
 }
 

package/src/sse/services/auth.js

@@ -1,6 +1,6 @@
 import { getProviderConnections, validateApiKey, updateProviderConnection, getSettings, getQuotaSnapshot, getAllQuotaSnapshots, getProxyPools } from "@/lib/localDb";
 import { resolveConnectionProxyConfig, pickProxyPoolId } from "@/lib/network/connectionProxy";
-import { formatRetryAfter, checkFallbackError, isModelLockActive, buildModelLockUpdate, getEarliestModelLockUntil, isNonAccountError, extractProviderErrorCode, getQuotaResetAt, getQuotaExhaustedUntil } from "open-sse/services/accountFallback.js";
+import { formatRetryAfter, checkFallbackError, isModelLockActive, isModelLockRecoveredByQuota, buildModelLockUpdate, getEarliestModelLockUntil, isNonAccountError, extractProviderErrorCode, getQuotaResetAt, getQuotaExhaustedUntil } from "open-sse/services/accountFallback.js";
 import { MAX_RATE_LIMIT_COOLDOWN_MS } from "open-sse/config/errorConfig.js";
 import { resolveProviderId, FREE_PROVIDERS } from "@/shared/constants/providers.js";
 import * as log from "../utils/logger.js";
@@ -77,9 +77,29 @@ export async function getProviderCredentials(provider, excludeConnectionIds = nu
       }
     }
 
+    // Codex can return a precise usage-limit reset which creates a long-lived
+    // model lock. If a newer quota poll explicitly reports capacity again, let
+    // that account be probed once instead of serving a stale all-rate-limited
+    // response until the old reset timestamp. A new failure is newer than the
+    // snapshot, so it immediately restores the lock without a retry loop.
+    const recoveredModelLocks = new Set();
+    if (providerId === "codex" && model) {
+      const snapshots = await getAllQuotaSnapshots(providerId);
+      const byConnection = new Map(snapshots.map((snapshot) => [snapshot.connectionId, snapshot]));
+      for (const connection of connections) {
+        if (isModelLockRecoveredByQuota(connection, model, byConnection.get(connection.id))) {
+          recoveredModelLocks.add(connection.id);
+        }
+      }
+    }
+
+    const hasBlockingModelLock = (connection) => (
+      isModelLockActive(connection, model) && !recoveredModelLocks.has(connection.id)
+    );
+
     const baseAvailableConnections = connections.filter(c => {
       if (excludeSet.has(c.id)) return false;
-      if (isModelLockActive(c, model)) return false;
+      if (hasBlockingModelLock(c)) return false;
       if (quotaExhausted.has(c.id)) return false;
       return true;
     });
@@ -98,7 +118,7 @@ export async function getProviderCredentials(provider, excludeConnectionIds = nu
         log.warn("AUTH", `${provider} | pinned account excluded after failure: ${preferred.id?.slice(0, 8)}`);
         return null;
       }
-      if (isModelLockActive(preferred, model) || quotaExhausted.has(preferred.id)) {
+      if (hasBlockingModelLock(preferred) || quotaExhausted.has(preferred.id)) {
         const retryAfter = [
           getEarliestModelLockUntil(preferred),
           quotaExhausted.has(preferred.id)
@@ -119,17 +139,18 @@ export async function getProviderCredentials(provider, excludeConnectionIds = nu
     log.debug("AUTH", `${provider} | available: ${availableConnections.length}/${connections.length}`);
     connections.forEach(c => {
       const excluded = excludeSet.has(c.id);
-      const locked = isModelLockActive(c, model);
+      const locked = hasBlockingModelLock(c);
+      const recovered = recoveredModelLocks.has(c.id);
       const exhaustedUntil = quotaExhausted.get(c.id);
-      if (excluded || locked || exhaustedUntil) {
+      if (excluded || locked || exhaustedUntil || recovered) {
         const lockUntil = getEarliestModelLockUntil(c);
-        log.debug("AUTH", `  \u2192 ${c.id?.slice(0, 8)} | ${excluded ? "excluded" : ""} ${locked ? `modelLocked(${model}) until ${lockUntil}` : ""} ${exhaustedUntil ? `quotaExhausted until ${new Date(exhaustedUntil).toISOString()}` : ""}`);
+        log.debug("AUTH", `  \u2192 ${c.id?.slice(0, 8)} | ${excluded ? "excluded" : ""} ${locked ? `modelLocked(${model}) until ${lockUntil}` : ""} ${recovered ? `staleLockRecovered(${model})` : ""} ${exhaustedUntil ? `quotaExhausted until ${new Date(exhaustedUntil).toISOString()}` : ""}`);
       }
     });
 
     if (availableConnections.length === 0) {
       // Find earliest lock expiry across all connections for retry timing
-      const lockedConns = connections.filter(c => isModelLockActive(c, model));
+      const lockedConns = connections.filter(c => hasBlockingModelLock(c));
       const expiries = [
         ...lockedConns.map(c => getEarliestModelLockUntil(c)).filter(Boolean),
         ...quotaExhausted.values().map(timestamp => new Date(timestamp).toISOString()),