@ckirg/corelib 0.1.22

package/dist/chunk-PESRDNPD.js

@@ -0,0 +1,876 @@
+import {
+  existsSync,
+  getAllEnv,
+  getCwd,
+  getDirname,
+  getMode,
+  getPlatform,
+  getRequire,
+  loggers_default,
+  readTextFileSync
+} from "./chunk-BAVE2JXI.js";
+import {
+  nextCid
+} from "./chunk-2DF4ADYX.js";
+import {
+  detectRuntime
+} from "./chunk-HPE2XSTW.js";
+
+// src/retrieve/RequestUnlimited.ts
+import { deepmergeCustom as deepmergeCustom2 } from "deepmerge-ts";
+import ky, { HTTPError } from "ky";
+import { serializeError as serializeError3 } from "serialize-error";
+
+// src/configs/ConfigManager.ts
+import { EventEmitter } from "events";
+import { deepmergeCustom } from "deepmerge-ts";
+import { serializeError } from "serialize-error";
+
+// src/configs/ConfigManager.json
+var ConfigManager_default = {
+  markets: {
+    chromeVersion: "146",
+    nasdaq: {
+      statusEndpoint: "https://api.nasdaq.com/api/market-info",
+      monitor: {
+        liveIntervalSec: 10,
+        closedIntervalSec: 3600,
+        warnIntervalSec: 60
+      },
+      symbols: {
+        nasdaqListedUrl: "https://www.nasdaqtrader.com/dynamic/symdir/nasdaqlisted.txt",
+        otherListedUrl: "https://www.nasdaqtrader.com/dynamic/symdir/otherlisted.txt",
+        initialBackoffMs: 1e3,
+        maxRetryBackoffMs: 36e5,
+        maxFetchRetries: 10
+      },
+      quotes: {
+        concurrencyLimit: 5
+      }
+    }
+  },
+  retrieve: {
+    timeout: 5e4,
+    retry: {
+      limit: 5,
+      backoffLimit: 3e3
+    }
+  }
+};
+
+// src/configs/ConfigUtils.ts
+async function decryptConfig(encryptedData) {
+  const { getEnv } = await import("./utils-Q4C2EEPD.js");
+  const crypto = (await import("crypto")).default;
+  const password = getEnv("CORELIB_AES_PASSWORD");
+  if (!password) {
+    throw new Error(
+      "Decryption failed: CORELIB_AES_PASSWORD environment variable is not set."
+    );
+  }
+  const lines = encryptedData.split("\n").map((l) => l.trim()).filter(Boolean);
+  if (lines.length < 2) {
+    throw new Error(
+      "Invalid .enc file format. Expected IV on line 1 and Ciphertext on line 2."
+    );
+  }
+  const iv = Buffer.from(lines[0], "base64");
+  const ciphertext = Buffer.from(lines[1], "base64");
+  const key = Buffer.from(password, "hex");
+  const decipher = crypto.createDecipheriv("aes-256-cbc", key, iv);
+  let decrypted = decipher.update(ciphertext);
+  decrypted = Buffer.concat([decrypted, decipher.final()]);
+  return JSON.parse(decrypted.toString("utf8"));
+}
+
+// src/configs/ConfigManager.ts
+var leafMerger = deepmergeCustom({
+  mergeArrays: false
+});
+var isSafeKey = (key) => !key.split(/[.-]/).some((p) => p === "__proto__" || p === "constructor" || p === "prototype");
+function clearAndFill(target, source) {
+  for (const key of Object.keys(target)) {
+    if (!(key in source)) delete target[key];
+  }
+  for (const key of Object.keys(source)) {
+    const val = source[key];
+    if (val && typeof val === "object" && !Array.isArray(val)) {
+      if (!target[key] || typeof target[key] !== "object" || Array.isArray(target[key])) {
+        target[key] = {};
+      }
+      clearAndFill(
+        target[key],
+        val
+      );
+    } else {
+      target[key] = val;
+    }
+  }
+}
+function resolveAppName(cwd, pathMod, fileExists, readFile) {
+  let dir = cwd;
+  for (; ; ) {
+    if (fileExists(pathMod.join(dir, "pnpm-workspace.yaml")))
+      return pathMod.basename(dir);
+    const pkgPath = pathMod.join(dir, "package.json");
+    if (fileExists(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFile(pkgPath));
+        if (pkg.workspaces) return pathMod.basename(dir);
+      } catch {
+      }
+    }
+    const parent = pathMod.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return pathMod.basename(cwd);
+}
+var ConfigManager = class _ConfigManager extends EventEmitter {
+  static instance;
+  _config = {};
+  _defaultsPath;
+  static _logger = loggers_default.child({ section: "ConfigManager" });
+  /** Single-flight guard for initialize(); null until first call, evicted on failure. */
+  _initPromise = null;
+  _isInitialized = false;
+  /** Async mutex: every async mutator chains onto this so they never interleave. */
+  _mutationChain = Promise.resolve();
+  /** The staging object of an in-flight staged build, or null. Lets a synchronous
+   *  updateValue() between awaits survive the final clearAndFill swap. */
+  _inFlightTempConfig = null;
+  /** Throttle: emit the premature-read warning at most once per process (get()
+   *  is called pervasively, so a per-call warn would flood dev logs). */
+  static _prematureWarnEmitted = false;
+  constructor() {
+    super();
+    const __dirname = getDirname();
+    let defaultsPath = __dirname;
+    try {
+      const { join } = getRequire()("node:path");
+      defaultsPath = join(__dirname, "ConfigManager.json");
+    } catch (_e) {
+      defaultsPath = `${__dirname}/ConfigManager.json`;
+    }
+    this._defaultsPath = defaultsPath;
+    clearAndFill(
+      this._config,
+      ConfigManager_default
+    );
+    globalThis.sysconfig = this._config;
+  }
+  /**
+   * Singleton accessor for the ConfigManager
+   */
+  static getInstance() {
+    if (!_ConfigManager.instance) {
+      _ConfigManager.instance = new _ConfigManager();
+    }
+    return _ConfigManager.instance;
+  }
+  /**
+   * Retrieves a nested configuration value by string path (e.g., "db.mysql.port").
+   * @param {string} path - The dot-notation path to the configuration value.
+   * @returns The value at the specified path, or undefined if not found.
+   */
+  get(path) {
+    if (!this._isInitialized && !_ConfigManager._prematureWarnEmitted && getMode() !== "production") {
+      _ConfigManager._prematureWarnEmitted = true;
+      _ConfigManager._logger.warn(
+        `ConfigManager.get("${path}") called before initialize() resolved; returning seeded default`
+      );
+    }
+    const keys = path.split(".");
+    let current = this._config;
+    for (const key of keys) {
+      if (current === null || typeof current !== "object" || !(key in current)) {
+        return void 0;
+      }
+      current = current[key];
+    }
+    return current;
+  }
+  /**
+   * Static helper to retrieve a configuration value from the singleton instance.
+   */
+  static get(path) {
+    return _ConfigManager.getInstance().get(path);
+  }
+  /**
+   * Idempotent under concurrency: simultaneous calls share one in-flight
+   * promise (-01). On failure the promise is evicted so a transient error can
+   * self-heal on a later call. Signature unchanged (still awaitable Promise<void>).
+   */
+  initialize(args) {
+    if (this._initPromise) return this._initPromise;
+    this._initPromise = this._enqueue(() => this.runInitSequence(args)).then(
+      () => {
+        this._isInitialized = true;
+        this._initPromise = null;
+      },
+      (error) => {
+        this._initPromise = null;
+        throw error;
+      }
+    );
+    return this._initPromise;
+  }
+  /**
+   * Main initialization sequence (formerly the body of initialize()).
+   * 1. Load Defaults 2. Detect CLI -C 3. Process Hierarchy 4. Env 5. CLI overrides.
+   */
+  async runInitSequence(args) {
+    _ConfigManager._logger.trace("initialize: start");
+    const argv = args ?? (typeof process !== "undefined" && Array.isArray(process.argv) ? process.argv.slice(2) : []);
+    let configPath;
+    const overrides = {};
+    for (let i = 0; i < argv.length; i++) {
+      const tok = argv[i];
+      if (tok === "-C" || tok === "--config") {
+        if (i + 1 < argv.length && !argv[i + 1].startsWith("-"))
+          configPath = argv[++i];
+        continue;
+      }
+      if (tok.startsWith("--config=")) {
+        configPath = tok.slice("--config=".length);
+        continue;
+      }
+      if (!tok.startsWith("--")) continue;
+      let key = tok.slice(2);
+      if (key === "" || key.startsWith("=")) continue;
+      let value;
+      const eq = key.indexOf("=");
+      if (eq > -1) {
+        value = key.slice(eq + 1);
+        key = key.slice(0, eq);
+      } else if (i + 1 < argv.length && !argv[i + 1].startsWith("-")) {
+        value = argv[++i];
+      } else {
+        value = true;
+      }
+      overrides[key] = value;
+    }
+    _ConfigManager._logger.trace("initialize: resolved", {
+      hasConfigPath: configPath != null,
+      overrideCount: Object.keys(overrides).length
+    });
+    const tempConfig = {};
+    this._inFlightTempConfig = tempConfig;
+    try {
+      this.loadDefaults(tempConfig);
+      if (configPath) {
+        const externalData = await this.fetchExternalConfig(configPath);
+        this.processHierarchy(externalData, tempConfig);
+      }
+      this.applyEnvOverrides(tempConfig);
+      this.applyCliOverrides(overrides, tempConfig);
+      clearAndFill(this._config, tempConfig);
+      _ConfigManager._logger.trace("initialize: committed", {
+        keys: Object.keys(this._config ?? {}).length
+      });
+      this.emit("initialized", this._config);
+    } finally {
+      this._inFlightTempConfig = null;
+    }
+  }
+  /**
+   * Serializes an async mutator against all other mutators (initialize +
+   * loadExternalConfig) via _mutationChain. The work runs after the previous
+   * op settles (success OR failure — `.then(work, work)` so a prior rejection
+   * never wedges the chain). The chain itself swallows results/errors so it
+   * stays resolved; the caller still receives this op's real result/error.
+   *
+   * Note: the chain's swallow-handler means a `loadExternalConfig` rejection is
+   * absorbed if the caller discards the returned promise. `initialize()` is
+   * different — it wraps this result in `_initPromise`, which is NOT on the
+   * chain, so an un-awaited failed `initialize()` surfaces as an unhandled
+   * rejection in Node strict mode. Callers should await/catch both.
+   */
+  _enqueue(work) {
+    const run = this._mutationChain.then(work, work);
+    this._mutationChain = run.then(
+      () => void 0,
+      () => void 0
+    );
+    return run;
+  }
+  /**
+   * Retrieves the current active configuration object.
+   */
+  getConfig() {
+    return this._config;
+  }
+  /** True once a call to initialize() has settled successfully. */
+  get isInitialized() {
+    return this._isInitialized;
+  }
+  /**
+   * Resolves when the first initialize() settles successfully (rejects if that
+   * in-flight initialize fails). If initialize() was never started — OR a prior
+   * attempt failed and was evicted — this resolves immediately and does NOT
+   * imply the manager is initialized; callers needing guaranteed initialization
+   * must call initialize() first and catch its rejection.
+   */
+  whenReady() {
+    if (this._isInitialized) return Promise.resolve();
+    return this._initPromise ?? Promise.resolve();
+  }
+  /**
+   * Public method to load and merge a new configuration from a URL or file path on demand.
+   * Respects the established configuration hierarchy and maintains Env overrides.
+   * @param source - The URL or local file path to the configuration.
+   */
+  loadExternalConfig(source) {
+    return this._enqueue(() => this.loadExternalConfigInner(source));
+  }
+  async loadExternalConfigInner(source) {
+    try {
+      const externalData = await this.fetchExternalConfig(source);
+      const tempConfig = structuredClone(this._config);
+      this._inFlightTempConfig = tempConfig;
+      try {
+        this.processHierarchy(externalData, tempConfig);
+        this.applyEnvOverrides(tempConfig);
+        clearAndFill(this._config, tempConfig);
+        this.emit("configLoaded", this._config);
+      } finally {
+        this._inFlightTempConfig = null;
+      }
+    } catch (error) {
+      this.logError(
+        `Failed to load external config dynamically from ${source}`,
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Loads the base ConfigManager.json from the local directory.
+   * Always seeds from the bundled JSON (available in all runtimes, including edge).
+   * If the JSON file is also found on disk, it replaces the bundled defaults.
+   */
+  loadDefaults(target) {
+    let defaults = {
+      ...ConfigManager_default
+    };
+    if (existsSync(this._defaultsPath)) {
+      try {
+        defaults = JSON.parse(readTextFileSync(this._defaultsPath));
+      } catch (e) {
+        this.logError("Failed to load defaults", e);
+      }
+    }
+    clearAndFill(target, defaults);
+  }
+  /**
+   * Fetches and parses configuration from a URL or Local Path.
+   * Supports .enc decryption and dynamic confbox parsing by extension.
+   */
+  async fetchExternalConfig(source) {
+    _ConfigManager._logger.trace("external config", {
+      source: source.startsWith("http") ? "http" : "file"
+    });
+    let content;
+    if (source.startsWith("http")) {
+      const { endPoint: endPoint2 } = await import("./RequestUnlimited-CLB36IJX.js");
+      const result = await endPoint2(source);
+      if (result.status === "error") {
+        throw new Error("Failed to fetch external config");
+      }
+      content = result.value.body;
+    } else {
+      content = readTextFileSync(source);
+    }
+    const lowerSource = source.toLowerCase();
+    if (lowerSource.endsWith(".enc")) {
+      _ConfigManager._logger.trace("decrypting .enc config");
+      const decrypted = this.validateConfigObject(
+        await decryptConfig(content),
+        source
+      );
+      _ConfigManager._logger.trace("decryption ok");
+      return decrypted;
+    }
+    const confbox = await import("confbox");
+    if (lowerSource.endsWith(".yaml") || lowerSource.endsWith(".yml")) {
+      return this.validateConfigObject(confbox.parseYAML(content), source);
+    }
+    if (lowerSource.endsWith(".toml")) {
+      return this.validateConfigObject(confbox.parseTOML(content), source);
+    }
+    if (lowerSource.endsWith(".json5")) {
+      return this.validateConfigObject(confbox.parseJSON5(content), source);
+    }
+    if (lowerSource.endsWith(".jsonc")) {
+      return this.validateConfigObject(confbox.parseJSONC(content), source);
+    }
+    if (lowerSource.endsWith(".ini")) {
+      return this.validateConfigObject(confbox.parseINI(content), source);
+    }
+    return this.validateConfigObject(confbox.parseJSON(content), source);
+  }
+  validateConfigObject(parsed, source) {
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error(
+        `Config from "${source}" must be a JSON object, got ${Array.isArray(parsed) ? "array" : typeof parsed}`
+      );
+    }
+    return parsed;
+  }
+  /**
+   * Processes the specific hierarchy:
+   * commonAll -> [AppName].common -> [AppName].[platform] -> [AppName].[platform].[mode]
+   */
+  processHierarchy(data, target) {
+    if (!data) return;
+    const appName = this.getAppName();
+    const platform = getPlatform();
+    const mode = getMode();
+    let layeredConfig = data.commonAll || {};
+    const appKey = Object.keys(data).find(
+      (k) => k.toLowerCase() === appName.toLowerCase()
+    );
+    const appSection = appKey ? data[appKey] : null;
+    if (appSection) {
+      if (appSection.common) {
+        layeredConfig = leafMerger(
+          layeredConfig,
+          appSection.common
+        );
+      }
+      const platformSection = appSection[platform];
+      if (platformSection) {
+        const modeSection = platformSection[mode];
+        if (modeSection) {
+          layeredConfig = leafMerger(layeredConfig, modeSection);
+        }
+      }
+    }
+    const merged = leafMerger(target, layeredConfig);
+    clearAndFill(target, merged);
+  }
+  /**
+   * Maps CORELIB_ prefixed environment variables to config keys.
+   * Example: CORELIB_DB_PORT -> config.db.port
+   */
+  applyEnvOverrides(target) {
+    const prefix = "CORELIB_";
+    const env = getAllEnv();
+    Object.keys(env).forEach((envKey) => {
+      if (envKey.startsWith(prefix)) {
+        const configPath = envKey.slice(prefix.length).toLowerCase().replace(/_/g, ".");
+        _ConfigManager._logger.trace("env override", { key: configPath });
+        const value = this.parseValue(env[envKey]);
+        this.setPath(target, configPath, value);
+      }
+    });
+  }
+  /**
+   * Maps the parsed Kebab-case CLI overrides to the config structure.
+   * Unsafe keys (__proto__/constructor/prototype segments) are dropped.
+   */
+  applyCliOverrides(overrides, target) {
+    Object.keys(overrides).forEach((key) => {
+      if (key === "config") return;
+      if (!isSafeKey(key)) {
+        _ConfigManager._logger.warn(
+          `Dropped unsafe CLI override key "${key}" (prototype-pollution guard)`
+        );
+        return;
+      }
+      const configPath = key.replace(/-/g, ".");
+      _ConfigManager._logger.trace("cli override", { key: configPath });
+      const value = this.parseValue(overrides[key]);
+      this.setPath(target, configPath, value);
+    });
+  }
+  /**
+   * Core update method that updates both the local object
+   * and the active globalThis object, then emits events.
+   */
+  updateValue(path, value) {
+    this.setPath(this._config, path, value);
+    if (this._inFlightTempConfig !== null) {
+      this.setPath(this._inFlightTempConfig, path, value);
+    }
+    this.emit("change", { path, value });
+    this.emit(`change:${path}`, value);
+  }
+  /**
+   * Helper to set nested object values by string path (e.g., "db.mysql.port")
+   */
+  setPath(obj, path, value) {
+    const keys = path.split(".");
+    let current = obj;
+    while (keys.length > 1) {
+      const key = keys.shift();
+      if (!(key in current) || typeof current[key] !== "object" || current[key] === null) {
+        current[key] = {};
+      }
+      current = current[key];
+    }
+    current[keys[0]] = value;
+  }
+  /**
+   * Parses values from Env/CLI, automatically handling JSON strings for arrays/objects.
+   */
+  parseValue(val) {
+    if (typeof val !== "string") return val;
+    if (val.startsWith("[") && val.endsWith("]") || val.startsWith("{") && val.endsWith("}")) {
+      try {
+        return JSON.parse(val);
+      } catch (e) {
+        this.logError("Failed to parse complex JSON from CLI/Env flag", e);
+        return val;
+      }
+    }
+    if (val.toLowerCase() === "true") return true;
+    if (val.toLowerCase() === "false") return false;
+    if (!Number.isNaN(Number(val)) && val.trim() !== "") return Number(val);
+    return val;
+  }
+  getAppName() {
+    try {
+      const runtime = detectRuntime();
+      if (runtime === "node" || runtime === "bun" || typeof import.meta !== "undefined" && import.meta.url && import.meta.url.startsWith("file:")) {
+        const path = getRequire()("node:path");
+        return resolveAppName(
+          getCwd(),
+          path,
+          (p) => existsSync(p),
+          (p) => readTextFileSync(p)
+        );
+      }
+      return "edge-app";
+    } catch (e) {
+      this.logError(
+        "Failed to get app name from cwd. Falling back to default-app",
+        e
+      );
+      return "default-app";
+    }
+  }
+  /**
+   * Logs errors internally. If the global pino logger is available, it uses it
+   * along with `serialize-error` to structure the error object for Vector sidecars.
+   */
+  logError(msg, error) {
+    const serialized = error ? serializeError(error) : void 0;
+    _ConfigManager._logger.error(msg, { error: serialized });
+  }
+  // --- Rust Integration Helpers ---
+  toJsonString() {
+    return JSON.stringify(this._config);
+  }
+  toBuffer() {
+    return Buffer.from(this.toJsonString());
+  }
+  /**
+   * Test-only: reset init/concurrency state so single-flight and failed-init
+   * eviction can be exercised on the singleton. Does NOT clear _config.
+   */
+  __resetForTests() {
+    this._initPromise = null;
+    this._isInitialized = false;
+    this._inFlightTempConfig = null;
+    this._mutationChain = Promise.resolve();
+    _ConfigManager._prematureWarnEmitted = false;
+  }
+};
+
+// src/retrieve/RequestResponseSerialize.ts
+import { serializeError as serializeError2 } from "serialize-error";
+var requestResponseSerializeLogger = loggers_default.child({
+  section: "RequestResponseSerialize"
+});
+async function serializeResponse(response) {
+  if (!response) return null;
+  const headers = {};
+  response.headers.forEach((v, k) => {
+    headers[k.toLowerCase()] = v;
+  });
+  let body;
+  const contentType = response.headers.get("content-type") || "";
+  try {
+    if (response.bodyUsed) {
+      body = "[Body already consumed]";
+    } else {
+      const rawText = await response.clone().text();
+      if (contentType.includes("application/json")) {
+        try {
+          body = JSON.parse(rawText);
+        } catch {
+          body = rawText;
+        }
+      } else {
+        body = rawText;
+      }
+    }
+  } catch (error) {
+    requestResponseSerializeLogger.warn("Failed to read response body", {
+      status: response.status,
+      url: response.url,
+      bodyUsed: response.bodyUsed,
+      error: serializeError2(error)
+    });
+    body = "[Error reading body]";
+  }
+  return {
+    ok: response.ok,
+    status: response.status,
+    statusText: response.statusText,
+    headers,
+    url: response.url,
+    redirected: response.redirected,
+    type: response.type,
+    body
+  };
+}
+var RequestResponseSerialize = {
+  serialize: serializeResponse
+};
+
+// src/retrieve/RequestUnlimited.ts
+var requestUnlimitedLogger = loggers_default.child({ section: "RequestUnlimited" });
+var customDeepmerge = deepmergeCustom2({
+  mergeArrays: false
+});
+var MAX_RETRY_LIMIT = 10;
+var MIN_TIMEOUT_MS = 1e3;
+var MAX_TIMEOUT_MS = 12e4;
+var MAX_BACKOFF_LIMIT_MS = 6e4;
+function clampNumber(value, min, max, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+  return Math.min(max, Math.max(min, value));
+}
+function safeUrl(u) {
+  try {
+    const parsed = u instanceof URL ? u : new URL(u instanceof Request ? u.url : u);
+    return `${parsed.origin}${parsed.pathname}`;
+  } catch {
+    return "[unparseable url]";
+  }
+}
+function fullJitterDelay(attempt, backoffLimit) {
+  const base = Math.min(backoffLimit, 300 * 2 ** (attempt - 1));
+  const delayMs = Math.round(Math.random() * base);
+  requestUnlimitedLogger.trace("retry delay computed", {
+    attempt,
+    base,
+    cap: backoffLimit,
+    delayMs
+  });
+  return delayMs;
+}
+var DEFAULT_REQUEST_OPTIONS = {
+  timeout: 5e4,
+  throwHttpErrors: true,
+  retry: {
+    limit: 5,
+    methods: ["get", "post", "put", "delete", "patch"],
+    backoffLimit: 3e3,
+    shouldRetry: ({ error, retryCount }) => {
+      if (error instanceof HTTPError && error.response) {
+        const status = error.response.status;
+        if (status === 429 && retryCount <= 5) {
+          requestUnlimitedLogger.trace("retry decision", {
+            status,
+            willRetry: true
+          });
+          return true;
+        }
+        if (status >= 400 && status < 500) {
+          requestUnlimitedLogger.trace("retry decision: skip", {
+            status,
+            willRetry: false
+          });
+          return false;
+        }
+        const willRetry = status >= 500;
+        requestUnlimitedLogger.trace(
+          willRetry ? "retry decision" : "retry decision: skip",
+          { status, willRetry }
+        );
+        return willRetry;
+      }
+      requestUnlimitedLogger.trace("retry decision", { willRetry: true });
+      return true;
+    }
+  },
+  method: "get",
+  headers: {
+    "content-type": "application/json",
+    accept: "application/json"
+  },
+  hooks: {
+    // Retry logging is done per-call in endPoint() so it can carry the request's cid;
+    // a module-level default hook here has no access to that per-call correlation id.
+    beforeRetry: []
+  }
+};
+function toLowercaseKeys(obj) {
+  const newObj = {};
+  for (const key in obj) {
+    if (Object.hasOwn(obj, key) && obj[key] !== void 0) {
+      newObj[key.toLowerCase()] = obj[key];
+    }
+  }
+  return newObj;
+}
+async function endPoint(url, options = {}) {
+  const normalizedDefaultHeaders = toLowercaseKeys(
+    DEFAULT_REQUEST_OPTIONS.headers || {}
+  );
+  const normalizedInputHeaders = options.headers ? toLowercaseKeys(options.headers) : {};
+  const { headers, hooks, ...remainingOptions } = options;
+  const cfgTimeout = clampNumber(
+    ConfigManager.get("retrieve.timeout"),
+    MIN_TIMEOUT_MS,
+    MAX_TIMEOUT_MS,
+    5e4
+  );
+  const cfgRetryLimit = clampNumber(
+    ConfigManager.get("retrieve.retry.limit"),
+    0,
+    MAX_RETRY_LIMIT,
+    5
+  );
+  const cfgBackoffLimit = clampNumber(
+    ConfigManager.get("retrieve.retry.backoffLimit"),
+    0,
+    MAX_BACKOFF_LIMIT_MS,
+    3e3
+  );
+  const cid = nextCid();
+  const startedAt = performance.now();
+  requestUnlimitedLogger.trace("endPoint: request", {
+    cid,
+    url: safeUrl(url),
+    timeout: cfgTimeout,
+    retryLimit: cfgRetryLimit,
+    backoffLimit: cfgBackoffLimit
+  });
+  const defaultRetry = DEFAULT_REQUEST_OPTIONS.retry;
+  const kyOptions = customDeepmerge(
+    DEFAULT_REQUEST_OPTIONS,
+    {
+      timeout: cfgTimeout,
+      retry: {
+        ...defaultRetry,
+        limit: cfgRetryLimit,
+        backoffLimit: cfgBackoffLimit,
+        delay: (attempt) => fullJitterDelay(attempt, cfgBackoffLimit)
+      }
+    },
+    remainingOptions,
+    {
+      headers: { ...normalizedDefaultHeaders, ...normalizedInputHeaders },
+      hooks: {
+        beforeRetry: [
+          ...DEFAULT_REQUEST_OPTIONS.hooks?.beforeRetry || [],
+          // Per-call so the retry trace correlates to this request's cid.
+          async ({ retryCount }) => {
+            requestUnlimitedLogger.trace("endPoint: retry", {
+              cid,
+              retryCount,
+              durationMs: performance.now() - startedAt
+            });
+          },
+          ...hooks?.beforeRetry || []
+        ]
+      }
+    }
+  );
+  try {
+    const responseObject = await ky(url, kyOptions);
+    const response = await serializeResponse(responseObject);
+    requestUnlimitedLogger.trace("endPoint: ok", {
+      cid,
+      durationMs: performance.now() - startedAt,
+      url: safeUrl(url),
+      status: responseObject.status
+    });
+    return {
+      status: "success",
+      value: response
+    };
+  } catch (error) {
+    if (error instanceof HTTPError || error.response) {
+      const errorResponse = await serializeResponse(
+        // @ts-expect-error - ky error property
+        error.response
+      );
+      requestUnlimitedLogger.trace("endPoint: error", {
+        cid,
+        durationMs: performance.now() - startedAt,
+        status: errorResponse?.status,
+        errorMsg: "HTTP error"
+      });
+      requestUnlimitedLogger.warn("HTTP Error", {
+        cid,
+        status: errorResponse?.status,
+        url: url.toString()
+      });
+      return {
+        status: "error",
+        reason: errorResponse
+      };
+    }
+    const serializedError = serializeError3(error);
+    requestUnlimitedLogger.trace("endPoint: error", {
+      cid,
+      durationMs: performance.now() - startedAt,
+      errorMsg: serializedError?.message ?? "internal/network error"
+    });
+    requestUnlimitedLogger.error("Internal/Network Error", {
+      cid,
+      error: serializedError
+    });
+    return {
+      status: "error",
+      reason: serializedError
+    };
+  }
+}
+async function endPoints(urls, options = {}) {
+  const cid = nextCid();
+  const startedAt = performance.now();
+  requestUnlimitedLogger.trace("endPoints: batch", { cid, count: urls.length });
+  const promises = urls.map((url) => endPoint(url, options));
+  const results = await Promise.allSettled(promises);
+  const mapped = results.map((result) => {
+    if (result.status === "fulfilled") return result.value;
+    return {
+      status: "error",
+      reason: serializeError3(result.reason)
+    };
+  });
+  const ok = mapped.filter((r) => r.status === "success").length;
+  requestUnlimitedLogger.trace("endPoints: done", {
+    cid,
+    durationMs: performance.now() - startedAt,
+    ok,
+    failed: mapped.length - ok
+  });
+  return mapped;
+}
+var RequestUnlimited = {
+  defaults: DEFAULT_REQUEST_OPTIONS,
+  endPoint,
+  endPoints
+};
+
+export {
+  RequestResponseSerialize,
+  MAX_RETRY_LIMIT,
+  MIN_TIMEOUT_MS,
+  MAX_TIMEOUT_MS,
+  MAX_BACKOFF_LIMIT_MS,
+  clampNumber,
+  fullJitterDelay,
+  DEFAULT_REQUEST_OPTIONS,
+  endPoint,
+  endPoints,
+  RequestUnlimited,
+  ConfigManager
+};