@wrongstack/core 0.313.0 → 0.313.1

package/dist/chunk-4VWO3ZXL.js

@@ -0,0 +1,342 @@
+// src/utils/term.ts
+var hasStdout = () => typeof process !== "undefined" && !!process.stdout;
+var hasStdin = () => typeof process !== "undefined" && !!process.stdin;
+function isStdoutTTY() {
+  return hasStdout() && Boolean(process.stdout.isTTY);
+}
+function isStdinTTY() {
+  return hasStdin() && Boolean(process.stdin.isTTY);
+}
+function isInteractive() {
+  return isStdinTTY() && isStdoutTTY();
+}
+function getTermSize() {
+  if (!hasStdout()) return { rows: 24, cols: 80 };
+  return {
+    rows: process.stdout.rows ?? 24,
+    cols: process.stdout.columns ?? 80
+  };
+}
+function onResize(cb, stream = process.stdout) {
+  if (!stream || typeof stream.on !== "function") return () => {
+  };
+  const handler = () => {
+    cb({
+      rows: stream.rows ?? 24,
+      cols: stream.columns ?? 80
+    });
+  };
+  stream.on("resize", handler);
+  return () => {
+    stream.off("resize", handler);
+  };
+}
+function setRawMode(input, mode) {
+  if (input?.isTTY !== true) return false;
+  if (typeof input.setRawMode !== "function") return false;
+  input.setRawMode(mode);
+  return true;
+}
+var activeOutputGuard = null;
+function setOutputLineGuard(guard) {
+  activeOutputGuard = guard;
+}
+function writeTo(s, stream) {
+  if (!stream || typeof stream.write !== "function") return false;
+  const guard = activeOutputGuard;
+  if (!guard) {
+    stream.write(s);
+    return true;
+  }
+  guard.suspend();
+  stream.write(s);
+  guard.resume();
+  return true;
+}
+function writeOut(s, stream = process.stdout) {
+  return writeTo(s, stream);
+}
+function writeErr(s, stream = process.stderr) {
+  return writeTo(s, stream);
+}
+function parseColorDepth(env) {
+  if (env.FORCE_COLOR === "0") return 0;
+  if (env.FORCE_COLOR !== void 0) return 3;
+  if (typeof env.NO_COLOR === "string" && env.NO_COLOR !== "") return 0;
+  const colorterm = (env.COLORTERM ?? "").toLowerCase();
+  if (colorterm === "truecolor" || colorterm === "24bit") return 3;
+  const term = (env.TERM ?? "").toLowerCase();
+  if (term.includes("truecolor") || term.includes("24bit")) return 3;
+  if (term.includes("256color")) return 2;
+  if (term === "dumb") return 0;
+  return 1;
+}
+function parseMouseProtocol(term) {
+  const t = term.toLowerCase();
+  if (t.startsWith("xterm") || t.startsWith("tmux") || t.startsWith("screen") || t.includes("rxvt-unicode") || t.includes("urxvt") || t.includes("konsole") || t.includes("gnome") || t.includes("foot") || t.includes("alacritty") || t.includes("wezterm") || t.includes("kitty") || t.includes("vscode") || t.includes("Apple_Terminal")) {
+    return "sgr";
+  }
+  if (t.startsWith("rxvt") || t.startsWith("linux") || t.includes("Eterm")) {
+    return "urxvt";
+  }
+  if (t === "vt100" || t === "dumb") return "none";
+  return "sgr";
+}
+function detectTerminal(opts = {}) {
+  const stdin = opts.stdin ?? process.stdin;
+  const stdout = opts.stdout ?? process.stdout;
+  const env = opts.env ?? process.env;
+  const isRealTTY = (stdin?.isTTY ?? false) && (stdout?.isTTY ?? false);
+  const stdoutWritable = isRealTTY && typeof stdout?.write === "function";
+  const term = env.TERM ?? "";
+  const isTmux = term.toLowerCase().startsWith("tmux");
+  const isWindowsConhost = isRealTTY && process.platform === "win32" && typeof stdout.getColorDepth !== "function";
+  return {
+    isRealTTY,
+    colorDepth: isRealTTY ? parseColorDepth(env) : 0,
+    stdoutWritable,
+    mouseProtocol: parseMouseProtocol(term),
+    canSetTitle: isRealTTY && term !== "dumb",
+    isTmux,
+    isWindowsConhost
+  };
+}
+var TerminalLifecycle = class {
+  _active = false;
+  /**
+   * The stdin stream we took raw mode on. Set by `acquire()`; undefined before
+   * first call. Used by `release()` and by the ConPTY race-closer in
+   * `acquire()`.
+   */
+  _stdin;
+  /**
+   * The `isRaw` snapshot captured before the first `acquire()` call, so
+   * `release()` restores to the pre-TUI state rather than blindly disabling
+   * raw mode. Null when `acquire()` has never been called.
+   */
+  _wasRaw = null;
+  /**
+   * Whether stdin was paused before the TUI took ownership. Readline closes
+   * its interface by pausing the shared process stream, so raw mode alone is
+   * not enough to make Ink receive bytes during the boot-prompt -> TUI handoff.
+   */
+  _wasPaused = null;
+  /**
+   * Request the process to exit. Set the flag, trigger any registered
+   * `onRequestExit` callback (typically Ink's `unmount()`), and arm a
+   * deadline timer.  When the timer fires the process is hard-exited.
+   *
+   * Safe to call multiple times: subsequent calls no-op after the first.
+   */
+  requestExit;
+  /**
+   * Callback invoked when `requestExit` is called. Registered by the Ink
+   * mount point so unmount() runs before the deadline timer fires.
+   */
+  onRequestExit = null;
+  constructor() {
+    let exitCode = 0;
+    let requested = false;
+    this.requestExit = (code = 0) => {
+      exitCode = code;
+      if (requested) return;
+      requested = true;
+      try {
+        this.onRequestExit?.();
+      } catch {
+      }
+      setTimeout(() => process.exit(exitCode), 5e3).unref();
+    };
+  }
+  /** True while raw mode is held. */
+  get active() {
+    return this._active;
+  }
+  /**
+   * Acquire raw mode on `stdin`. Idempotent — calling twice is safe; only the
+   * first call has any effect.
+   *
+   * On Windows ConPTY, calls `setRawMode` twice: once immediately, then again
+   * after the next event-loop tick. This closes the ConPTY race where
+   * `readline`'s cleanup (registered before this class is constructed) can
+   * restore the original cooked mode after we set raw mode but before Ink's
+   * render loop takes over the stdin fd. The double-call ensures the last
+   * writer wins.
+   *
+   * @param stdin - The stdin stream (defaults to `process.stdin`).
+   * @returns `true` if raw mode was acquired; `false` if stdin is not a TTY
+   *          or already shut down.
+   */
+  acquire(stdin = process.stdin) {
+    if (this._active) return false;
+    if (stdin?.isTTY !== true) return false;
+    if (typeof stdin.setRawMode !== "function") return false;
+    this._wasRaw = stdin.isRaw ?? false;
+    this._wasPaused = stdin.isPaused();
+    this._stdin = stdin;
+    stdin.setRawMode(true);
+    stdin.resume();
+    this._active = true;
+    if (process.platform === "win32") {
+      setImmediate(() => {
+        if (this._active && this._stdin?.isTTY) {
+          this._stdin.setRawMode?.(true);
+        }
+      });
+    }
+    return true;
+  }
+  /**
+   * Release raw mode and restore the terminal to the state it was in before
+   * `acquire()` was called. Idempotent — subsequent calls are no-ops.
+   *
+   * Call this on: SIGINT, SIGTERM, SIGHUP, SIGBREAK, and `process.exit`.
+   *
+   * ⚠ **Windows caveat**: `setRawMode(false)` on ConPTY restores the original
+   * console mode captured when the process started — not the mode captured by
+   * `acquire()`. On ConPTY, the original mode was already raw (ConPTY starts
+   * raw), so this call is typically a no-op on Windows Terminal. On conhost.exe
+   * it may restore cooked mode, which is correct for that backend.
+   */
+  release() {
+    if (!this._active) return;
+    this._active = false;
+    const stdin = this._stdin;
+    if (stdin?.isTTY === true) {
+      stdin.setRawMode?.(this._wasRaw ?? false);
+      if (this._wasPaused) stdin.pause();
+    }
+    this._stdin = void 0;
+    this._wasRaw = null;
+    this._wasPaused = null;
+  }
+  /**
+   * Synchronously reset all terminal state written by the TUI layer:
+   * raw mode, SGR attributes, cursor visibility, and mouse tracking.
+   *
+   * Intended for the final `process.on('exit')` handler where async is
+   * impossible. Uses `\x1b[0m` (SGR reset), `\x1b[?25h` (cursor show),
+   * and `\x1b[?9l` (mouse off) — all safe to emit even if the terminal does
+   * not understand them (unknown CSI sequences are silently ignored).
+   *
+   * Safe to call multiple times from multiple exit paths because each write
+   * is a constant-time synchronous stream write.
+   *
+   * @param stdout - Stream to reset (defaults to `process.stdout`).
+   */
+  reset(stdout = process.stdout) {
+    if (typeof stdout?.write !== "function") return;
+    stdout.write("\x1B[0m");
+    stdout.write("\x1B[?25h");
+    stdout.write("\x1B[?1003l\x1B[?1002l\x1B[?1000l");
+  }
+};
+var ESCAPE_TERMINATOR = Object.freeze({
+  BEL: "\x07",
+  // OSC 0 / OSC 2 (title)
+  ST: "\x1B\\"
+  // DCS / strict OSC
+});
+function safeEmit(sequence, stdout = process.stdout) {
+  const raw = typeof sequence === "string" ? sequence : sequence.raw;
+  const term = typeof sequence === "string" ? void 0 : sequence.terminator;
+  if (!raw) {
+    return { ok: false, reason: "empty" };
+  }
+  if (stdout?.isTTY !== true) {
+    return { ok: false, reason: "not_a_tty" };
+  }
+  if (raw.startsWith("\x1B]") || raw.startsWith("\x1BP")) {
+    if (!term) {
+      void term;
+      const safe = `${raw}\x07`;
+      try {
+        stdout.write(safe);
+      } catch {
+        return { ok: false, reason: "unwritable" };
+      }
+      return { ok: true, reason: "empty" };
+    }
+    try {
+      stdout.write(`${raw}${term}`);
+    } catch {
+      return { ok: false, reason: "unwritable" };
+    }
+    return { ok: true, reason: "empty" };
+  }
+  try {
+    stdout.write(raw);
+  } catch {
+    return { ok: false, reason: "unwritable" };
+  }
+  return { ok: true, reason: "empty" };
+}
+function buildTitleSequence(title, terminator = ESCAPE_TERMINATOR.BEL) {
+  return {
+    raw: `\x1B]0;${title.replace(/\x07/g, "")}`,
+    terminator
+  };
+}
+function buildSgrSequence(...codes) {
+  return { raw: `\x1B[${codes.join(";")}m` };
+}
+function setTitle(title, stdout = process.stdout) {
+  return safeEmit(buildTitleSequence(title), stdout).ok;
+}
+
+// src/utils/color.ts
+var isColorTty = () => {
+  if (envFlag(process.env.NO_COLOR)) return false;
+  if (envFlag(process.env.FORCE_COLOR)) return true;
+  return isStdoutTTY();
+};
+function envFlag(value) {
+  if (value === void 0) return false;
+  if (value.trim() === "") return false;
+  return !/^(0|false|no|off)$/i.test(value.trim());
+}
+var COLOR = isColorTty();
+var wrap = (open, close) => (s) => COLOR ? `\x1B[${open}m${s}\x1B[${close}m` : s;
+var color = {
+  reset: wrap("0", "0"),
+  bold: wrap("1", "22"),
+  dim: wrap("2", "22"),
+  italic: wrap("3", "23"),
+  underline: wrap("4", "24"),
+  red: wrap("31", "39"),
+  green: wrap("32", "39"),
+  yellow: wrap("33", "39"),
+  blue: wrap("34", "39"),
+  magenta: wrap("35", "39"),
+  cyan: wrap("36", "39"),
+  gray: wrap("90", "39"),
+  amber: wrap("38;5;214", "39"),
+  pink: wrap("38;5;205", "39"),
+  bgRed: wrap("41", "49"),
+  bgGreen: wrap("42", "49")
+};
+function stripAnsi(s) {
+  return s.replace(/\x1b\[[0-9;]*[A-Za-z]/g, "");
+}
+
+export {
+  isStdoutTTY,
+  isStdinTTY,
+  isInteractive,
+  getTermSize,
+  onResize,
+  setRawMode,
+  setOutputLineGuard,
+  writeOut,
+  writeErr,
+  detectTerminal,
+  TerminalLifecycle,
+  ESCAPE_TERMINATOR,
+  safeEmit,
+  buildTitleSequence,
+  buildSgrSequence,
+  setTitle,
+  color,
+  stripAnsi
+};
+//# sourceMappingURL=chunk-4VWO3ZXL.js.map

package/dist/chunk-4XV6IR37.js

@@ -0,0 +1,187 @@
+import {
+  atomicWrite
+} from "./chunk-7ZHZE5EO.js";
+
+// src/utils/ulid.ts
+import { randomBytes } from "node:crypto";
+var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var ENCODING_LEN = ENCODING.length;
+var TIME_LEN = 10;
+var RANDOM_LEN = 16;
+function encodeTime(now, len) {
+  let mod;
+  let str = "";
+  for (let i = len - 1; i >= 0; i--) {
+    mod = now % ENCODING_LEN;
+    str = ENCODING[mod] + str;
+    now = (now - mod) / ENCODING_LEN;
+  }
+  return str;
+}
+function encodeRandom(len) {
+  const bytes = randomBytes(len);
+  let str = "";
+  for (let i = 0; i < len; i++) {
+    str += ENCODING[bytes[i] % ENCODING_LEN];
+  }
+  return str;
+}
+function ulid(seedTime = Date.now()) {
+  return encodeTime(seedTime, TIME_LEN) + encodeRandom(RANDOM_LEN);
+}
+function isUlid(value) {
+  if (value.length !== TIME_LEN + RANDOM_LEN) return false;
+  for (const ch of value) {
+    if (!ENCODING.includes(ch)) return false;
+  }
+  return true;
+}
+
+// src/utils/project-identity.ts
+import * as fs from "node:fs";
+import * as fsPromises from "node:fs/promises";
+import * as path from "node:path";
+var PROJECT_IDENTITY_VERSION = 1;
+var PROJECT_ID_PREFIX = "proj_";
+var PROJECT_IDENTITY_RELATIVE_PATH = path.join(".wrongstack", "project.json");
+var PROJECT_GITIGNORE_RULES = [
+  ".wrongstack/",
+  "!/.wrongstack/",
+  "/.wrongstack/*",
+  "!/.wrongstack/project.json"
+];
+function projectIdentityPath(projectRoot) {
+  return path.join(projectRoot, PROJECT_IDENTITY_RELATIVE_PATH);
+}
+function createProjectId(seedTime = Date.now()) {
+  return `${PROJECT_ID_PREFIX}${ulid(seedTime)}`;
+}
+function isProjectId(value) {
+  return value.startsWith(PROJECT_ID_PREFIX) && isUlid(value.slice(PROJECT_ID_PREFIX.length));
+}
+function readProjectIdentitySync(projectRoot) {
+  const filePath = projectIdentityPath(projectRoot);
+  try {
+    return parseProjectIdentity(fs.readFileSync(filePath, "utf8"), filePath);
+  } catch (error) {
+    if (isMissingFileError(error)) return void 0;
+    throw error;
+  }
+}
+async function readProjectIdentity(projectRoot) {
+  const filePath = projectIdentityPath(projectRoot);
+  try {
+    return parseProjectIdentity(await fsPromises.readFile(filePath, "utf8"), filePath);
+  } catch (error) {
+    if (isMissingFileError(error)) return void 0;
+    throw error;
+  }
+}
+async function ensureProjectIdentity(projectRoot, idFactory = createProjectId) {
+  const existing = await readProjectIdentity(projectRoot);
+  if (existing) return { identity: existing, created: false };
+  const filePath = projectIdentityPath(projectRoot);
+  const identity = makeIdentity(idFactory());
+  await fsPromises.mkdir(path.dirname(filePath), { recursive: true });
+  try {
+    await fsPromises.writeFile(filePath, serializeProjectIdentity(identity), {
+      encoding: "utf8",
+      flag: "wx"
+    });
+    return { identity, created: true };
+  } catch (error) {
+    if (!isAlreadyExistsError(error)) throw error;
+    const winner = await readProjectIdentity(projectRoot);
+    if (!winner) throw error;
+    return { identity: winner, created: false };
+  }
+}
+async function rekeyProjectIdentity(projectRoot, idFactory = createProjectId) {
+  const previous = await readProjectIdentity(projectRoot);
+  const identity = makeIdentity(idFactory());
+  const filePath = projectIdentityPath(projectRoot);
+  await fsPromises.mkdir(path.dirname(filePath), { recursive: true });
+  await atomicWrite(filePath, serializeProjectIdentity(identity));
+  return { previous, identity };
+}
+async function ensureProjectGitignore(projectRoot) {
+  const filePath = path.join(projectRoot, ".gitignore");
+  let content = "";
+  try {
+    content = await fsPromises.readFile(filePath, "utf8");
+  } catch (error) {
+    if (!isMissingFileError(error)) throw error;
+  }
+  const hadTrailingNewline = content.endsWith("\n");
+  const lines = content.length === 0 ? [] : content.split(/\r?\n/);
+  if (hadTrailingNewline) lines.pop();
+  let changed = false;
+  for (let index = 0; index < lines.length; index++) {
+    if (lines[index]?.trim() === ".wrongstack/*") {
+      lines[index] = ".wrongstack/";
+      changed = true;
+    }
+  }
+  for (const entry of PROJECT_GITIGNORE_RULES) {
+    if (!lines.some((line) => line.trim() === entry)) {
+      if (entry === ".wrongstack/" && lines.length > 0 && lines.at(-1) !== "") lines.push("");
+      lines.push(entry);
+      changed = true;
+    }
+  }
+  if (!changed) return;
+  await fsPromises.writeFile(filePath, `${lines.join("\n")}
+`, "utf8");
+}
+function makeIdentity(projectId) {
+  if (!isProjectId(projectId)) {
+    throw new Error(`Invalid WrongStack project id: ${projectId}`);
+  }
+  return { version: PROJECT_IDENTITY_VERSION, projectId };
+}
+function parseProjectIdentity(raw, filePath) {
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    throw new Error(`Invalid JSON in WrongStack project identity file: ${filePath}`);
+  }
+  if (typeof value !== "object" || value === null) {
+    throw new Error(`Invalid WrongStack project identity file: ${filePath}`);
+  }
+  const record = value;
+  if (record["version"] !== PROJECT_IDENTITY_VERSION) {
+    throw new Error(`Unsupported WrongStack project identity version in ${filePath}`);
+  }
+  if (typeof record["projectId"] !== "string" || !isProjectId(record["projectId"])) {
+    throw new Error(`Invalid projectId in WrongStack project identity file: ${filePath}`);
+  }
+  return { version: PROJECT_IDENTITY_VERSION, projectId: record["projectId"] };
+}
+function serializeProjectIdentity(identity) {
+  return `${JSON.stringify(identity, null, 2)}
+`;
+}
+function isMissingFileError(error) {
+  return error?.code === "ENOENT";
+}
+function isAlreadyExistsError(error) {
+  return error?.code === "EEXIST";
+}
+
+export {
+  ulid,
+  isUlid,
+  PROJECT_IDENTITY_VERSION,
+  PROJECT_ID_PREFIX,
+  PROJECT_IDENTITY_RELATIVE_PATH,
+  projectIdentityPath,
+  createProjectId,
+  isProjectId,
+  readProjectIdentitySync,
+  readProjectIdentity,
+  ensureProjectIdentity,
+  rekeyProjectIdentity,
+  ensureProjectGitignore
+};
+//# sourceMappingURL=chunk-4XV6IR37.js.map

package/dist/chunk-4ZHTKJHM.js

@@ -0,0 +1,183 @@
+// src/wiring/proxy-rewrite.ts
+var PROXY_PATH_PREFIX = "/proxy/";
+var PROXY_EXCLUDED_PROVIDERS = /* @__PURE__ */ new Set(["openai-codex"]);
+function isProxyEligible(providerId) {
+  if (!providerId) return false;
+  if (PROXY_EXCLUDED_PROVIDERS.has(providerId)) return false;
+  return true;
+}
+function rewriteBaseUrl(originalBaseUrl, proxyUrl) {
+  if (!originalBaseUrl) return void 0;
+  if (!proxyUrl) return originalBaseUrl;
+  if (!isProxyEligibleForRewrite(originalBaseUrl, proxyUrl)) return originalBaseUrl;
+  return composeRewrittenUrl(originalBaseUrl, proxyUrl);
+}
+function isProxyEligibleForRewrite(originalBaseUrl, proxyUrl) {
+  if (!originalBaseUrl.includes("://")) return false;
+  if (!proxyUrl.includes("://")) return false;
+  const normalizedProxy = proxyUrl.replace(/\/+$/, "");
+  if (originalBaseUrl.startsWith(`${normalizedProxy}${PROXY_PATH_PREFIX}`)) {
+    return false;
+  }
+  try {
+    const parsed = new URL(originalBaseUrl);
+    const isLoopback = parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1" || // WHATWG URL serializes IPv6 hosts with brackets — `[::1]`, not `::1`.
+    parsed.hostname === "[::1]";
+    if (isLoopback && parsed.port !== "") return false;
+  } catch {
+  }
+  return true;
+}
+function composeRewrittenUrl(originalBaseUrl, proxyUrl) {
+  const parsedOriginal = new URL(originalBaseUrl);
+  const hostAndPath = `${parsedOriginal.host}${parsedOriginal.pathname}`;
+  const trailingQuery = parsedOriginal.search || "";
+  const trailingHash = parsedOriginal.hash || "";
+  const proxyRoot = proxyUrl.replace(/\/+$/, "");
+  return `${proxyRoot}${PROXY_PATH_PREFIX}${hostAndPath}${trailingQuery}${trailingHash}`;
+}
+var DEFAULT_PROXY_CONFIG = { enabled: false, url: "", active: false };
+var currentConfig = { ...DEFAULT_PROXY_CONFIG };
+function getProxyConfig() {
+  return currentConfig;
+}
+var listeners = /* @__PURE__ */ new Set();
+function subscribeToProxyConfig(listener) {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+function applyProxyConfig(next) {
+  const previous = currentConfig;
+  currentConfig = {
+    enabled: next.enabled ?? previous.enabled,
+    url: next.url ?? previous.url,
+    active: next.active ?? previous.active
+  };
+  const materialChange = currentConfig.enabled !== previous.enabled || currentConfig.url !== previous.url || currentConfig.active !== previous.active;
+  if (materialChange) {
+    for (const listener of listeners) {
+      try {
+        listener(currentConfig, previous);
+      } catch {
+      }
+    }
+  }
+  return previous;
+}
+function shouldRewriteFor(providerId) {
+  const cfg = currentConfig;
+  if (!cfg.enabled || !cfg.active || !cfg.url) return false;
+  return isProxyEligible(providerId);
+}
+function deactivateProxyOnConnectionFailure(err) {
+  const cfg = currentConfig;
+  if (!cfg.enabled || !cfg.active) return false;
+  const msg = (err instanceof Error ? `${err.name} ${err.message} ${err.code ?? ""}` : String(err)).toLowerCase();
+  let isProxyFail = false;
+  if (cfg.url) {
+    try {
+      const parsed = new URL(cfg.url);
+      if (msg.includes(parsed.host.toLowerCase())) isProxyFail = true;
+    } catch {
+    }
+  }
+  if (!isProxyFail && (msg.includes("econnrefused") || msg.includes("ehostunreach") || msg.includes("enetunreach") || msg.includes("fetch failed") || msg.includes("failed to fetch") || msg.includes("connect error") || msg.includes("proxy error") || msg.includes("502") || msg.includes("503") || msg.includes("504"))) {
+    isProxyFail = true;
+  }
+  if (isProxyFail) {
+    applyProxyConfig({ active: false });
+    return true;
+  }
+  return false;
+}
+function __resetProxyConfigForTests() {
+  currentConfig = { ...DEFAULT_PROXY_CONFIG };
+  listeners.clear();
+  instantApplyChains.clear();
+}
+var PROXY_ROUTING_SETTLE_CAP_MS = 2e3;
+var instantApplyChains = /* @__PURE__ */ new Set();
+async function waitForProxyRoutingSettle(timeoutMs = PROXY_ROUTING_SETTLE_CAP_MS, signal) {
+  if (signal?.aborted) return;
+  const chains = [...instantApplyChains].map((get) => get());
+  if (chains.length === 0) return;
+  let timer;
+  let onAbort;
+  try {
+    await Promise.race([
+      Promise.allSettled(chains),
+      new Promise((resolve) => {
+        onAbort = () => resolve();
+        timer = setTimeout(resolve, Math.max(0, timeoutMs));
+        signal?.addEventListener("abort", onAbort, { once: true });
+      })
+    ]);
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+    if (onAbort !== void 0) signal?.removeEventListener("abort", onAbort);
+  }
+}
+function effectiveBaseUrlFor(cfg, providerId, rawBaseUrl) {
+  if (!rawBaseUrl) return void 0;
+  const active = cfg.enabled && cfg.active && !!cfg.url && isProxyEligible(providerId);
+  return active ? rewriteBaseUrl(rawBaseUrl, cfg.url) : rawBaseUrl;
+}
+function effectiveBaseUrl(providerId, rawBaseUrl) {
+  return effectiveBaseUrlFor(currentConfig, providerId, rawBaseUrl);
+}
+function createProxyInstantApply(deps) {
+  const { getActiveProviderId, getRawBaseUrl, rebuildProvider, logger } = deps;
+  let lastProviderId = getActiveProviderId();
+  let lastEffectiveUrl = effectiveBaseUrl(lastProviderId, getRawBaseUrl(lastProviderId));
+  let disposed = false;
+  let rebuildChain = Promise.resolve();
+  const chainGetter = () => rebuildChain;
+  instantApplyChains.add(chainGetter);
+  const unsubscribe = subscribeToProxyConfig((next, previous) => {
+    if (disposed) return;
+    const providerId = getActiveProviderId();
+    const raw = getRawBaseUrl(providerId);
+    const nextUrl = effectiveBaseUrlFor(next, providerId, raw);
+    const baselineUrl = providerId === lastProviderId ? lastEffectiveUrl : effectiveBaseUrlFor(previous, providerId, raw);
+    lastProviderId = providerId;
+    lastEffectiveUrl = nextUrl;
+    if (nextUrl === baselineUrl) return;
+    rebuildChain = rebuildChain.then(() => rebuildProvider(providerId)).then(() => {
+      if (!disposed) {
+        logger.info(`WrongProxy routing changed \u2014 live provider rebuilt (${providerId})`);
+      }
+    }).catch((err) => {
+      if (!disposed) {
+        logger.warn(
+          `WrongProxy instant-apply: provider rebuild failed for ${providerId}: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    });
+  });
+  return {
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      instantApplyChains.delete(chainGetter);
+      unsubscribe();
+    }
+  };
+}
+
+export {
+  PROXY_EXCLUDED_PROVIDERS,
+  isProxyEligible,
+  rewriteBaseUrl,
+  getProxyConfig,
+  subscribeToProxyConfig,
+  applyProxyConfig,
+  shouldRewriteFor,
+  deactivateProxyOnConnectionFailure,
+  __resetProxyConfigForTests,
+  PROXY_ROUTING_SETTLE_CAP_MS,
+  waitForProxyRoutingSettle,
+  createProxyInstantApply
+};
+//# sourceMappingURL=chunk-4ZHTKJHM.js.map