tokmon 0.28.2 → 0.28.3

package/dist/chunk-HNWEJ6MS.js

@@ -0,0 +1,1094 @@
+#!/usr/bin/env node
+
+// src/config.ts
+import { chmod, readFile, writeFile, mkdir, rename, unlink } from "fs/promises";
+import { chmodSync, mkdirSync, renameSync, unlinkSync, writeFileSync } from "fs";
+import { join, isAbsolute } from "path";
+import { homedir } from "os";
+
+// src/providers/types.ts
+var PROVIDER_IDS = ["claude", "codex", "cursor", "copilot", "pi", "opencode", "antigravity", "gemini", "grok"];
+
+// src/theme/catalog.ts
+var IMPORTED_THEME_IDS = [
+  "vscode",
+  "monokai",
+  "dracula",
+  "github",
+  "nord",
+  "one-dark-pro",
+  "solarized",
+  "tokyo-night",
+  "catppuccin",
+  "midnight",
+  "forest",
+  "sunset",
+  "cyberpunk",
+  "synthwave",
+  "luxury",
+  "minimal"
+];
+var IMPORTED_THEME_CATALOG = {
+  vscode: {
+    name: "VS Code",
+    light: { name: "Light+", primary: "#007ACC", background: "#FFFFFF", foreground: "#333333", card: "#F3F3F3", cardForeground: "#1E1E1E", border: "#E5E5E5", accent: "#0066BF", accentForeground: "#FFFFFF", muted: "#F6F6F6", mutedForeground: "#6E6E6E" },
+    dark: { name: "Dark+", primary: "#007ACC", background: "#1E1E1E", foreground: "#CCCCCC", card: "#252526", cardForeground: "#CCCCCC", border: "#3E3E42", accent: "#0E639C", accentForeground: "#FFFFFF", muted: "#2D2D30", mutedForeground: "#858585" }
+  },
+  monokai: {
+    name: "Monokai",
+    light: { name: "Monokai Light", primary: "#A6E22E", background: "#F8F8F2", foreground: "#272822", card: "#E6E6E0", cardForeground: "#272822", border: "#C4C4B8", accent: "#66D9EF", accentForeground: "#272822", muted: "#E6E6E0", mutedForeground: "#75715E" },
+    dark: { name: "Monokai", primary: "#A6E22E", background: "#272822", foreground: "#F8F8F2", card: "#3E3D32", cardForeground: "#F8F8F2", border: "#75715E", accent: "#66D9EF", accentForeground: "#272822", muted: "#49483E", mutedForeground: "#75715E" }
+  },
+  dracula: {
+    name: "Dracula",
+    light: { name: "Dracula Light", primary: "#BD93F9", background: "#F8F8F2", foreground: "#282A36", card: "#E6E6E0", cardForeground: "#282A36", border: "#C4C4B8", accent: "#FF79C6", accentForeground: "#282A36", muted: "#E6E6E0", mutedForeground: "#6272A4" },
+    dark: { name: "Dracula", primary: "#BD93F9", background: "#282A36", foreground: "#F8F8F2", card: "#343746", cardForeground: "#F8F8F2", border: "#44475A", accent: "#FF79C6", accentForeground: "#282A36", muted: "#44475A", mutedForeground: "#6272A4" }
+  },
+  github: {
+    name: "GitHub",
+    light: { name: "GitHub Light", primary: "#0969DA", background: "#FFFFFF", foreground: "#24292F", card: "#F6F8FA", cardForeground: "#24292F", border: "#D0D7DE", accent: "#0969DA", accentForeground: "#FFFFFF", muted: "#F6F8FA", mutedForeground: "#57606A" },
+    dark: { name: "GitHub Dark", primary: "#58A6FF", background: "#0D1117", foreground: "#C9D1D9", card: "#161B22", cardForeground: "#C9D1D9", border: "#30363D", accent: "#1F6FEB", accentForeground: "#FFFFFF", muted: "#161B22", mutedForeground: "#8B949E" }
+  },
+  nord: {
+    name: "Nord",
+    light: { name: "Nord Light", primary: "#5E81AC", background: "#ECEFF4", foreground: "#2E3440", card: "#E5E9F0", cardForeground: "#2E3440", border: "#D8DEE9", accent: "#88C0D0", accentForeground: "#2E3440", muted: "#E5E9F0", mutedForeground: "#4C566A" },
+    dark: { name: "Nord", primary: "#88C0D0", background: "#2E3440", foreground: "#D8DEE9", card: "#3B4252", cardForeground: "#E5E9F0", border: "#434C5E", accent: "#5E81AC", accentForeground: "#ECEFF4", muted: "#434C5E", mutedForeground: "#88C0D0" }
+  },
+  "one-dark-pro": {
+    name: "One Dark Pro",
+    light: { name: "One Light Pro", primary: "#528BFF", background: "#FAFAFA", foreground: "#383A42", card: "#F0F0F0", cardForeground: "#383A42", border: "#E0E0E0", accent: "#61AFEF", accentForeground: "#FAFAFA", muted: "#F0F0F0", mutedForeground: "#5C6370" },
+    dark: { name: "One Dark Pro", primary: "#61AFEF", background: "#282C34", foreground: "#ABB2BF", card: "#2C313C", cardForeground: "#ABB2BF", border: "#3E4451", accent: "#528BFF", accentForeground: "#FFFFFF", muted: "#3E4451", mutedForeground: "#5C6370" }
+  },
+  solarized: {
+    name: "Solarized",
+    light: { name: "Solarized Light", primary: "#268BD2", background: "#FDF6E3", foreground: "#657B83", card: "#EEE8D5", cardForeground: "#586E75", border: "#93A1A1", accent: "#2AA198", accentForeground: "#FDF6E3", muted: "#FDF6E3", mutedForeground: "#839496" },
+    dark: { name: "Solarized Dark", primary: "#268BD2", background: "#002B36", foreground: "#839496", card: "#073642", cardForeground: "#93A1A1", border: "#586E75", accent: "#2AA198", accentForeground: "#FDF6E3", muted: "#073642", mutedForeground: "#657B83" }
+  },
+  "tokyo-night": {
+    name: "Tokyo Night",
+    light: { name: "Tokyo Night Day", primary: "#2E7DE9", background: "#E1E2E7", foreground: "#343B58", card: "#D5D6DB", cardForeground: "#343B58", border: "#9699A3", accent: "#7AA2F7", accentForeground: "#343B58", muted: "#D5D6DB", mutedForeground: "#565F89" },
+    dark: { name: "Tokyo Night", primary: "#7AA2F7", background: "#1A1B26", foreground: "#C0CAF5", card: "#24283B", cardForeground: "#C0CAF5", border: "#414868", accent: "#BB9AF7", accentForeground: "#1A1B26", muted: "#2F3549", mutedForeground: "#565F89" }
+  },
+  catppuccin: {
+    name: "Catppuccin",
+    light: { name: "Catppuccin Latte", primary: "#1E66F5", background: "#EFF1F5", foreground: "#4C4F69", card: "#E6E9EF", cardForeground: "#4C4F69", border: "#BCC0CC", accent: "#EA76CB", accentForeground: "#EFF1F5", muted: "#E6E9EF", mutedForeground: "#6C6F85" },
+    dark: { name: "Catppuccin Mocha", primary: "#89B4FA", background: "#1E1E2E", foreground: "#CDD6F4", card: "#313244", cardForeground: "#CDD6F4", border: "#45475A", accent: "#F38BA8", accentForeground: "#1E1E2E", muted: "#313244", mutedForeground: "#6C7086" }
+  },
+  midnight: {
+    name: "Midnight",
+    light: { name: "Midnight Light", primary: "#3B82F6", background: "#F8FAFC", foreground: "#0F172A", card: "#E2E8F0", cardForeground: "#0F172A", border: "#CBD5E1", accent: "#1D4ED8", accentForeground: "#F8FAFC", muted: "#E2E8F0", mutedForeground: "#64748B" },
+    dark: { name: "Midnight", primary: "#3B82F6", background: "#0F172A", foreground: "#F8FAFC", card: "#1E293B", cardForeground: "#F8FAFC", border: "#334155", accent: "#1D4ED8", accentForeground: "#FFFFFF", muted: "#1E293B", mutedForeground: "#94A3B8" }
+  },
+  forest: {
+    name: "Forest",
+    light: { name: "Forest Light", primary: "#22C55E", background: "#F0FDF4", foreground: "#052E16", card: "#DCFCE7", cardForeground: "#052E16", border: "#BBF7D0", accent: "#15803D", accentForeground: "#F0FDF4", muted: "#DCFCE7", mutedForeground: "#166534" },
+    dark: { name: "Forest", primary: "#22C55E", background: "#052E16", foreground: "#DCFCE7", card: "#14532D", cardForeground: "#DCFCE7", border: "#166534", accent: "#15803D", accentForeground: "#FFFFFF", muted: "#14532D", mutedForeground: "#86EFAC" }
+  },
+  sunset: {
+    name: "Sunset",
+    light: { name: "Sunset Light", primary: "#F97316", background: "#FFF7ED", foreground: "#431407", card: "#FFEDD5", cardForeground: "#431407", border: "#FED7AA", accent: "#EA580C", accentForeground: "#FFF7ED", muted: "#FFEDD5", mutedForeground: "#9A3412" },
+    dark: { name: "Sunset", primary: "#F97316", background: "#431407", foreground: "#FFEDD5", card: "#7C2D12", cardForeground: "#FFEDD5", border: "#9A3412", accent: "#EA580C", accentForeground: "#FFFFFF", muted: "#7C2D12", mutedForeground: "#FDBA74" }
+  },
+  cyberpunk: {
+    name: "Cyberpunk",
+    light: { name: "Cyberpunk Light", primary: "#F472B6", background: "#FFFFFF", foreground: "#000000", card: "#F3F4F6", cardForeground: "#000000", border: "#E5E7EB", accent: "#E879F9", accentForeground: "#000000", muted: "#F3F4F6", mutedForeground: "#22D3EE" },
+    dark: { name: "Cyberpunk", primary: "#F472B6", background: "#000000", foreground: "#22D3EE", card: "#111111", cardForeground: "#E879F9", border: "#F472B6", accent: "#FFFF00", accentForeground: "#000000", muted: "#111111", mutedForeground: "#22D3EE" }
+  },
+  synthwave: {
+    name: "Synthwave",
+    light: { name: "Synthwave Light", primary: "#D946EF", background: "#FAF5FF", foreground: "#2A0A3B", card: "#F3E8FF", cardForeground: "#2A0A3B", border: "#E9D5FF", accent: "#06B6D4", accentForeground: "#FAF5FF", muted: "#F3E8FF", mutedForeground: "#C026D3" },
+    dark: { name: "Synthwave", primary: "#D946EF", background: "#2A0A3B", foreground: "#F5D0FE", card: "#4A1D66", cardForeground: "#F5D0FE", border: "#C026D3", accent: "#06B6D4", accentForeground: "#FFFFFF", muted: "#4A1D66", mutedForeground: "#E879F9" }
+  },
+  luxury: {
+    name: "Luxury",
+    light: { name: "Luxury Light", primary: "#D4AF37", background: "#FAFAF9", foreground: "#1C1917", card: "#F5F5F4", cardForeground: "#1C1917", border: "#E7E5E4", accent: "#B45309", accentForeground: "#FAFAF9", muted: "#F5F5F4", mutedForeground: "#78716C" },
+    dark: { name: "Luxury", primary: "#D4AF37", background: "#1C1917", foreground: "#E7E5E4", card: "#292524", cardForeground: "#D4AF37", border: "#78716C", accent: "#B45309", accentForeground: "#FFFFFF", muted: "#292524", mutedForeground: "#A8A29E" }
+  },
+  minimal: {
+    name: "Minimal",
+    light: { name: "Minimal", primary: "#18181B", background: "#FFFFFF", foreground: "#18181B", card: "#FFFFFF", cardForeground: "#18181B", border: "#E4E4E7", accent: "#F4F4F5", accentForeground: "#18181B", muted: "#FAFAFA", mutedForeground: "#71717A" },
+    dark: { name: "Minimal Dark", primary: "#FAFAFA", background: "#18181B", foreground: "#FAFAFA", card: "#27272A", cardForeground: "#FAFAFA", border: "#3F3F46", accent: "#27272A", accentForeground: "#FAFAFA", muted: "#27272A", mutedForeground: "#A1A1AA" }
+  }
+};
+
+// src/theme/index.ts
+var BUILT_IN_THEME_PRESET_IDS = ["tokmon", "phosphor", ...IMPORTED_THEME_IDS];
+var THEME_PRESET_IDS = [...BUILT_IN_THEME_PRESET_IDS, "custom"];
+var IMPORTED_THEME_HINTS = {
+  vscode: "VS Code Light+ and Dark+",
+  monokai: "Classic editor green and cyan",
+  dracula: "Purple and pink on deep slate",
+  github: "GitHub light and dark",
+  nord: "Arctic blue-gray palette",
+  "one-dark-pro": "Atom-inspired editor palette",
+  solarized: "Precision blue and teal",
+  "tokyo-night": "Cool blue and violet",
+  catppuccin: "Latte and Mocha palettes",
+  midnight: "Deep navy and bright blue",
+  forest: "Natural green surfaces",
+  sunset: "Warm orange and earth tones",
+  cyberpunk: "Neon cyan, pink, and yellow",
+  synthwave: "Purple and electric cyan",
+  luxury: "Gold on warm neutrals",
+  minimal: "High-contrast monochrome"
+};
+var THEME_PRESET_OPTIONS = [
+  { id: "tokmon", name: "Tokmon", hint: "Calm system utility", darkOnly: false, custom: false },
+  { id: "phosphor", name: "Phosphor", hint: "Black terminal green", darkOnly: true, custom: false },
+  ...IMPORTED_THEME_IDS.map((id) => ({
+    id,
+    name: IMPORTED_THEME_CATALOG[id].name,
+    hint: IMPORTED_THEME_HINTS[id],
+    darkOnly: false,
+    custom: false
+  })),
+  { id: "custom", name: "Custom", hint: "Your shared palette", darkOnly: false, custom: true }
+];
+function isThemePreset(value) {
+  return typeof value === "string" && THEME_PRESET_IDS.includes(value);
+}
+function isBuiltInThemePreset(value) {
+  return typeof value === "string" && BUILT_IN_THEME_PRESET_IDS.includes(value);
+}
+function themePresetOption(preset) {
+  return THEME_PRESET_OPTIONS.find((option) => option.id === preset) ?? THEME_PRESET_OPTIONS[0];
+}
+function isDarkOnlyThemePreset(preset) {
+  return themePresetOption(preset).darkOnly;
+}
+var EDITABLE_THEME_TOKEN_KEYS = [
+  "canvas",
+  "panel",
+  "inset",
+  "insetStrong",
+  "chrome",
+  "line",
+  "lineStrong",
+  "lineFaint",
+  "text",
+  "textDim",
+  "textFaint",
+  "textStrong",
+  "accent",
+  "cost",
+  "positive"
+];
+var DEFAULT_APPEARANCE = Object.freeze({
+  version: 1,
+  mode: "auto",
+  preset: "tokmon",
+  terminal: "ansi"
+});
+var TOKMON_DARK = {
+  canvas: "#0a0a0a",
+  panel: "#101011",
+  inset: "#161617",
+  insetStrong: "#1d1d1e",
+  chrome: "#1e1f22",
+  line: "#262627",
+  lineStrong: "#343435",
+  lineFaint: "#1a1a1b",
+  text: "#d4d6d6",
+  textDim: "#8d9090",
+  textFaint: "#585b5b",
+  textStrong: "#f3f5f5",
+  accent: "#79be7e",
+  cost: "#d9c074",
+  positive: "#6caa71",
+  ok: "#79be7e",
+  warn: "#e0b84c",
+  crit: "#e5584b",
+  unknown: "#8d9090"
+};
+var TOKMON_LIGHT = {
+  canvas: "#f4f5f5",
+  panel: "#ffffff",
+  inset: "#eceeee",
+  insetStrong: "#e1e4e4",
+  chrome: "#f4f5f5",
+  line: "#d4d9d9",
+  lineStrong: "#bcc2c2",
+  lineFaint: "#e7eaea",
+  text: "#2b2e2e",
+  textDim: "#5a6060",
+  textFaint: "#979d9d",
+  textStrong: "#0d1010",
+  accent: "#2f8f57",
+  cost: "#9a7b1c",
+  positive: "#2f8f57",
+  ok: "#2f8f57",
+  warn: "#9a7b1c",
+  crit: "#b0403a",
+  unknown: "#5a6060"
+};
+var PHOSPHOR_DARK = {
+  canvas: "#000000",
+  panel: "#050705",
+  inset: "#0a0f0b",
+  insetStrong: "#101710",
+  chrome: "#070b08",
+  line: "#1a2a1e",
+  lineStrong: "#2c4634",
+  lineFaint: "#101812",
+  text: "#c6f7d3",
+  textDim: "#7fc98d",
+  textFaint: "#4c7d57",
+  textStrong: "#eafff0",
+  accent: "#35f38a",
+  cost: "#ffd24a",
+  positive: "#35f38a",
+  ok: "#35f38a",
+  warn: "#ffc44d",
+  crit: "#ff6b5b",
+  unknown: "#7fc98d"
+};
+var PHOSPHOR_LIGHT = {
+  canvas: "#f3f5f0",
+  panel: "#ffffff",
+  inset: "#e8ede7",
+  insetStrong: "#dce5dc",
+  chrome: "#f3f5f0",
+  line: "#cad7ca",
+  lineStrong: "#a9bca9",
+  lineFaint: "#e4ebe4",
+  text: "#0b2610",
+  textDim: "#426b49",
+  textFaint: "#748c78",
+  textStrong: "#031507",
+  accent: "#128a2e",
+  cost: "#826500",
+  positive: "#128a2e",
+  ok: "#128a2e",
+  warn: "#826500",
+  crit: "#b23a32",
+  unknown: "#5c705f"
+};
+var HEX_COLOR = /^#[0-9a-f]{6}$/i;
+function normalizeHexColor(value) {
+  return typeof value === "string" && HEX_COLOR.test(value) ? value.toLowerCase() : null;
+}
+function channels(hex) {
+  return [Number.parseInt(hex.slice(1, 3), 16), Number.parseInt(hex.slice(3, 5), 16), Number.parseInt(hex.slice(5, 7), 16)];
+}
+function hexChannel(value) {
+  return Math.round(Math.max(0, Math.min(255, value))).toString(16).padStart(2, "0");
+}
+function mixColors(from, to, amount) {
+  const [fr, fg, fb] = channels(from);
+  const [tr, tg, tb] = channels(to);
+  const ratio = Math.max(0, Math.min(1, amount));
+  return `#${hexChannel(fr + (tr - fr) * ratio)}${hexChannel(fg + (tg - fg) * ratio)}${hexChannel(fb + (tb - fb) * ratio)}`;
+}
+function relativeLuminance(hex) {
+  const normalized = normalizeHexColor(hex);
+  if (!normalized) throw new TypeError("expected a #RRGGBB color");
+  const linear = channels(normalized).map((channel) => {
+    const value = channel / 255;
+    return value <= 0.04045 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4;
+  });
+  return 0.2126 * linear[0] + 0.7152 * linear[1] + 0.0722 * linear[2];
+}
+function contrastRatio(first, second) {
+  const a = relativeLuminance(first);
+  const b = relativeLuminance(second);
+  return (Math.max(a, b) + 0.05) / (Math.min(a, b) + 0.05);
+}
+function accessibleColor(color, backgrounds, minimum, toward) {
+  const intended = normalizeHexColor(color);
+  if (backgrounds.every((background) => contrastRatio(intended, background) >= minimum)) return intended;
+  const target = [toward, "#000000", "#ffffff"].reduce((best, candidate) => Math.min(...backgrounds.map((background) => contrastRatio(candidate, background))) > Math.min(...backgrounds.map((background) => contrastRatio(best, background))) ? candidate : best);
+  let low = 0;
+  let high = 1;
+  for (let i = 0; i < 16; i++) {
+    const mid = (low + high) / 2;
+    const candidate = mixColors(intended, target, mid);
+    if (backgrounds.every((background) => contrastRatio(candidate, background) >= minimum)) high = mid;
+    else low = mid;
+  }
+  return mixColors(intended, target, high);
+}
+function importedTokens(colors, mode) {
+  const canvas = normalizeHexColor(colors.background);
+  const panel = normalizeHexColor(colors.card);
+  const rawText = normalizeHexColor(colors.foreground);
+  const contrastTarget = mode === "dark" ? "#ffffff" : "#000000";
+  const text = accessibleColor(rawText, [canvas, panel], 4.5, contrastTarget);
+  const textStrong = accessibleColor(colors.cardForeground, [canvas, panel], 4.5, contrastTarget);
+  const textDim = accessibleColor(colors.mutedForeground, [canvas], 3, text);
+  const accent = accessibleColor(colors.primary, [canvas, panel], 3, text);
+  const cost = accessibleColor(colors.accent, [panel], 3, text);
+  const positive = accessibleColor(colors.primary, [panel], 3, text);
+  const truth = mode === "dark" ? TOKMON_DARK : TOKMON_LIGHT;
+  return {
+    canvas,
+    panel,
+    inset: normalizeHexColor(colors.muted),
+    insetStrong: mixColors(colors.muted, colors.foreground, 0.08),
+    chrome: canvas,
+    line: normalizeHexColor(colors.border),
+    lineStrong: mixColors(colors.border, colors.foreground, 0.18),
+    lineFaint: mixColors(colors.background, colors.border, 0.5),
+    text,
+    textDim,
+    textFaint: normalizeHexColor(colors.mutedForeground),
+    textStrong,
+    accent,
+    cost,
+    positive,
+    ok: accessibleColor(truth.ok, [panel], 3, text),
+    warn: accessibleColor(truth.warn, [panel], 3, text),
+    crit: accessibleColor(truth.crit, [panel], 3, text),
+    unknown: textDim
+  };
+}
+var IMPORTED_PRESETS = Object.fromEntries(IMPORTED_THEME_IDS.map((id) => [
+  id,
+  {
+    light: importedTokens(IMPORTED_THEME_CATALOG[id].light, "light"),
+    dark: importedTokens(IMPORTED_THEME_CATALOG[id].dark, "dark")
+  }
+]));
+var PRESETS = {
+  tokmon: { light: TOKMON_LIGHT, dark: TOKMON_DARK },
+  phosphor: { light: PHOSPHOR_LIGHT, dark: PHOSPHOR_DARK },
+  ...IMPORTED_PRESETS
+};
+var CONTRAST_RULES = [
+  ["text", "canvas", 4.5],
+  ["text", "panel", 4.5],
+  ["textStrong", "canvas", 4.5],
+  ["textStrong", "panel", 4.5],
+  ["textDim", "canvas", 3],
+  ["accent", "canvas", 3],
+  ["accent", "panel", 3],
+  ["cost", "panel", 3],
+  ["positive", "panel", 3],
+  ["ok", "panel", 3],
+  ["warn", "panel", 3],
+  ["crit", "panel", 3]
+];
+function validateThemeContrast(tokens) {
+  return CONTRAST_RULES.flatMap(([foreground, background, minimum]) => {
+    const actual = contrastRatio(tokens[foreground], tokens[background]);
+    return actual + Number.EPSILON < minimum ? [{ foreground, background, minimum, actual }] : [];
+  });
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function cleanOverrides(value, mode, base, reasons) {
+  if (!isRecord(value)) {
+    if (value !== void 0) reasons.push(`custom.${mode} was not an object`);
+    return {};
+  }
+  const overrides = {};
+  for (const key of EDITABLE_THEME_TOKEN_KEYS) {
+    if (!(key in value)) continue;
+    const color = normalizeHexColor(value[key]);
+    if (color) overrides[key] = color;
+    else reasons.push(`custom.${mode}.${key} was not a #RRGGBB color`);
+  }
+  for (; ; ) {
+    const candidate = { ...base, ...overrides };
+    const failure = validateThemeContrast(candidate)[0];
+    if (!failure) break;
+    const foreground = failure.foreground;
+    const background = failure.background;
+    if (foreground in overrides) {
+      delete overrides[foreground];
+      reasons.push(`custom.${mode}.${foreground} did not meet WCAG contrast`);
+    } else if (background in overrides) {
+      delete overrides[background];
+      reasons.push(`custom.${mode}.${background} did not meet WCAG contrast`);
+    } else {
+      break;
+    }
+  }
+  return overrides;
+}
+function repairAppearance(input) {
+  const reasons = [];
+  const raw = isRecord(input) ? input : {};
+  if (raw !== input && input !== void 0) reasons.push("appearance was not an object");
+  const mode = raw.mode === "light" || raw.mode === "dark" || raw.mode === "auto" ? raw.mode : DEFAULT_APPEARANCE.mode;
+  if (raw.mode !== void 0 && raw.mode !== mode) reasons.push("appearance.mode was invalid");
+  const preset = isThemePreset(raw.preset) ? raw.preset : DEFAULT_APPEARANCE.preset;
+  if (raw.preset !== void 0 && raw.preset !== preset) reasons.push("appearance.preset was invalid");
+  const terminal = raw.terminal === "dark" || raw.terminal === "light" || raw.terminal === "off" || raw.terminal === "ansi" ? raw.terminal : DEFAULT_APPEARANCE.terminal;
+  if (raw.terminal !== void 0 && raw.terminal !== terminal) reasons.push("appearance.terminal was invalid");
+  if (raw.version !== void 0 && raw.version !== 1) reasons.push("appearance.version was invalid");
+  let custom;
+  if (preset === "custom" || raw.custom !== void 0) {
+    const rawCustom = isRecord(raw.custom) ? raw.custom : {};
+    if (raw.custom !== void 0 && rawCustom !== raw.custom) reasons.push("appearance.custom was not an object");
+    const base = isBuiltInThemePreset(rawCustom.base) ? rawCustom.base : "tokmon";
+    if (rawCustom.base !== void 0 && rawCustom.base !== base) reasons.push("custom.base was invalid");
+    custom = {
+      base,
+      light: cleanOverrides(rawCustom.light, "light", PRESETS[base].light, reasons),
+      dark: cleanOverrides(rawCustom.dark, "dark", PRESETS[base].dark, reasons)
+    };
+  }
+  const appearance = { version: 1, mode, preset, terminal, ...custom ? { custom } : {} };
+  return { appearance, repaired: reasons.length > 0 || JSON.stringify(raw) !== JSON.stringify(appearance), reasons };
+}
+function normalizeAppearance(input) {
+  return repairAppearance(input).appearance;
+}
+function addDerived(tokens) {
+  return {
+    ...tokens,
+    card: mixColors(tokens.panel, tokens.text, 0.06),
+    cardHover: mixColors(tokens.panel, tokens.text, 0.1),
+    divider: tokens.line,
+    track: mixColors(tokens.panel, tokens.text, 0.1),
+    accentTint: mixColors(tokens.panel, tokens.accent, 0.14),
+    accentOn: contrastRatio(tokens.accent, "#000000") >= contrastRatio(tokens.accent, "#ffffff") ? "#000000" : "#ffffff",
+    focusRing: tokens.accent
+  };
+}
+function resolveTheme(input, systemMode = "dark") {
+  const appearance = normalizeAppearance(input);
+  const requestedMode = appearance.mode === "auto" ? systemMode : appearance.mode;
+  const mode = isDarkOnlyThemePreset(appearance.preset) ? "dark" : requestedMode;
+  const preset = appearance.preset === "custom" ? appearance.custom?.base ?? "tokmon" : appearance.preset;
+  const base = PRESETS[preset][mode];
+  const overrides = appearance.preset === "custom" ? appearance.custom?.[mode] ?? {} : {};
+  return { mode, tokens: addDerived({ ...base, ...overrides }) };
+}
+function resolveTerminalTheme(input, terminalIsDark = true) {
+  const appearance = normalizeAppearance(input);
+  if (appearance.terminal === "off" || appearance.terminal === "ansi") return null;
+  return resolveTheme(appearance, appearance.terminal === "dark" ? "dark" : appearance.terminal === "light" ? "light" : terminalIsDark ? "dark" : "light");
+}
+
+// src/config-schema.ts
+var DESKTOP_GRAPH_RANGES = [7, 14, 30];
+function normalizePins(raw, legacy) {
+  const source = Array.isArray(raw) ? raw : legacy && typeof legacy === "string" && legacy.trim() ? [legacy] : [];
+  return normalizeStringIdList(source, 2);
+}
+function normalizeStringIdList(raw, max) {
+  if (!Array.isArray(raw)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const value of raw) {
+    if (typeof value !== "string") continue;
+    const id = value.trim();
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+    out.push(id);
+    if (out.length >= max) break;
+  }
+  return out;
+}
+var MAX_PINNED_PROVIDERS = 2;
+function cleanProviderSelection(values, knownProviderIds, max = Number.POSITIVE_INFINITY) {
+  return normalizeStringIdList(values.filter((value) => knownProviderIds.has(value)), max);
+}
+function toggleProviderSelection(values, providerId, knownProviderIds, max = Number.POSITIVE_INFINITY) {
+  const current = cleanProviderSelection(values, knownProviderIds, max);
+  if (current.includes(providerId)) return current.filter((id) => id !== providerId);
+  if (!knownProviderIds.has(providerId) || current.length >= max) return current;
+  return [...current, providerId];
+}
+function moveProviderSelection(values, providerId, direction) {
+  const next = [...values];
+  const index = next.indexOf(providerId);
+  const target = index + direction;
+  if (index < 0 || target < 0 || target >= next.length) return next;
+  [next[index], next[target]] = [next[target], next[index]];
+  return next;
+}
+var DEFAULT_TRAY_CONFIG = {
+  enabled: true,
+  showMenuBarText: true,
+  displayMetric: "smartHeadroom",
+  pollIntervalSec: 30,
+  activeTimeoutMin: 10,
+  graceMin: 30,
+  promotionHoldMin: 5,
+  lowWatermarkPct: 20,
+  criticalWatermarkPct: 5,
+  pinnedAccount: null,
+  pins: [],
+  pinnedProviders: [],
+  launchAtLogin: false,
+  theme: "dark"
+};
+var MAX_EXPANDED_PROVIDERS = 32;
+var DEFAULT_DESKTOP_CONFIG = {
+  expandedProviders: [],
+  graphRangeDays: 14
+};
+var DEFAULT_ACCOUNT_DETECTION_CONFIG = {
+  enabled: true,
+  disabledProviders: [],
+  excludedAccounts: []
+};
+var DEFAULTS = {
+  revision: 0,
+  interval: 2,
+  billingInterval: 5,
+  clearScreen: true,
+  privacyMode: true,
+  privacyToggleKey: "p",
+  timezone: null,
+  accounts: [],
+  activeAccountId: null,
+  disabledProviders: [],
+  onboarded: false,
+  dashboardLayout: "grid",
+  defaultFocus: "all",
+  ascii: "auto",
+  allowNetworkAccess: false,
+  allowedHosts: [],
+  resetDisplay: "relative",
+  knownProviders: [],
+  appearance: { ...DEFAULT_APPEARANCE },
+  accountDetection: { ...DEFAULT_ACCOUNT_DETECTION_CONFIG },
+  tray: { ...DEFAULT_TRAY_CONFIG },
+  desktop: { ...DEFAULT_DESKTOP_CONFIG }
+};
+var LEGACY_KNOWN = ["claude", "codex", "cursor"];
+var ACCENT_COLORS = ["cyan", "magenta", "green", "yellow", "blue", "red"];
+var PROVIDER_ORDER = [...PROVIDER_IDS];
+var COLOR_PALETTE = [
+  "cyan",
+  "magenta",
+  "green",
+  "yellow",
+  "blue",
+  "red",
+  "cyanBright",
+  "magentaBright",
+  "greenBright"
+];
+var PROVIDER_META = {
+  claude: { name: "Claude", color: "green" },
+  codex: { name: "Codex", color: "cyan" },
+  cursor: { name: "Cursor", color: "magenta" },
+  copilot: { name: "Copilot", color: "white" },
+  pi: { name: "Pi", color: "blue" },
+  opencode: { name: "opencode", color: "yellow" },
+  antigravity: { name: "Antigravity", color: "red" },
+  gemini: { name: "Gemini", color: "greenBright" },
+  grok: { name: "Grok", color: "yellowBright" }
+};
+var EMAIL_RE = /[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/i;
+var EMAIL_RE_GLOBAL = /[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/gi;
+function containsEmail(value) {
+  return typeof value === "string" && EMAIL_RE.test(value);
+}
+function redactEmail(value) {
+  return value.replace(EMAIL_RE_GLOBAL, "[redacted]");
+}
+function getTrackedAccountRows(config, trackedProviders = PROVIDER_ORDER.filter((pid) => !config.disabledProviders.includes(pid)), autoAccounts) {
+  const tracked = new Set(trackedProviders);
+  const configuredIds = /* @__PURE__ */ new Set();
+  const configuredKeys = /* @__PURE__ */ new Set();
+  const rowIds = /* @__PURE__ */ new Set();
+  const rowKeys = /* @__PURE__ */ new Set();
+  const rows = [];
+  const detectionEnabled = config.accountDetection.enabled;
+  const detectorDisabled = new Set(config.accountDetection.disabledProviders);
+  const keyFor = (providerId, homeDir) => `${providerId}:${homeDir && homeDir !== "~" ? homeDir : "~"}`;
+  const excludedKeys = new Set(
+    config.accountDetection.excludedAccounts.map((ref) => keyFor(ref.providerId, ref.homeDir))
+  );
+  const rememberRow = (row) => {
+    rowIds.add(row.id);
+    rowKeys.add(keyFor(row.providerId, row.homeDir));
+    rows.push(row);
+  };
+  config.accounts.forEach((account, explicitIndex) => {
+    const meta = PROVIDER_META[account.providerId];
+    configuredIds.add(account.id);
+    configuredKeys.add(keyFor(account.providerId, account.homeDir));
+    rememberRow({
+      id: account.id,
+      providerId: account.providerId,
+      name: account.name,
+      homeDir: account.homeDir || "~",
+      color: account.color || meta.color,
+      source: "configured",
+      explicitId: account.id,
+      explicitIndex
+    });
+  });
+  if (autoAccounts) {
+    for (const account of autoAccounts) {
+      if (!detectionEnabled || detectorDisabled.has(account.providerId)) continue;
+      if (config.disabledProviders.includes(account.providerId)) continue;
+      const key = keyFor(account.providerId, account.homeDir);
+      if (excludedKeys.has(key)) continue;
+      if (configuredIds.has(account.id) || configuredKeys.has(key) || rowIds.has(account.id) || rowKeys.has(key)) continue;
+      const meta = PROVIDER_META[account.providerId];
+      rememberRow({
+        id: account.id,
+        providerId: account.providerId,
+        name: account.name,
+        homeDir: account.homeDir || "~",
+        color: account.color || meta.color,
+        source: "auto"
+      });
+    }
+  }
+  for (const providerId of PROVIDER_ORDER) {
+    if (!detectionEnabled || detectorDisabled.has(providerId)) continue;
+    if (config.disabledProviders.includes(providerId)) continue;
+    if (!tracked.has(providerId)) continue;
+    const key = keyFor(providerId, "~");
+    if (excludedKeys.has(key)) continue;
+    if (configuredIds.has(providerId) || configuredKeys.has(key) || rowIds.has(providerId) || rowKeys.has(key)) continue;
+    const meta = PROVIDER_META[providerId];
+    rememberRow({
+      id: providerId,
+      providerId,
+      name: meta.name,
+      homeDir: "~",
+      color: meta.color,
+      source: "auto"
+    });
+  }
+  for (const ref of config.accountDetection.excludedAccounts) {
+    if (configuredKeys.has(keyFor(ref.providerId, ref.homeDir))) continue;
+    const meta = PROVIDER_META[ref.providerId];
+    rememberRow({
+      id: `ignored:${ref.providerId}:${ref.homeDir}`,
+      providerId: ref.providerId,
+      name: `${meta.name} account`,
+      homeDir: ref.homeDir,
+      color: meta.color,
+      source: "ignored",
+      excludedRef: ref
+    });
+  }
+  return rows;
+}
+function providerDetectionEnabled(config, providerId) {
+  return config.enabled && !config.disabledProviders.includes(providerId);
+}
+function setProviderDetectionEnabled(config, providerId, enabled) {
+  const without = config.disabledProviders.filter((id) => id !== providerId);
+  return {
+    ...config,
+    disabledProviders: enabled ? without : [...without, providerId]
+  };
+}
+function setDetectedAccountExcluded(config, ref, excluded) {
+  const homeDir = ref.homeDir.trim() || "~";
+  const matches = (candidate) => candidate.providerId === ref.providerId && candidate.homeDir === homeDir;
+  const without = config.excludedAccounts.filter((candidate) => !matches(candidate));
+  return {
+    ...config,
+    excludedAccounts: excluded ? [...without, { providerId: ref.providerId, homeDir }] : without
+  };
+}
+function clampNum(v, fallback, min) {
+  return typeof v === "number" && Number.isFinite(v) && v >= min ? v : fallback;
+}
+function finiteInRange(v, fallback, min, max) {
+  return typeof v === "number" && Number.isFinite(v) && v >= min && v <= max ? v : fallback;
+}
+function isValidTimezone(tz) {
+  try {
+    new Intl.DateTimeFormat("en-CA", { timeZone: tz });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isRecord2(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function validProvider(value) {
+  return PROVIDER_IDS.includes(value);
+}
+function sameJson(a, b) {
+  try {
+    return JSON.stringify(a) === JSON.stringify(b);
+  } catch {
+    return false;
+  }
+}
+function normalizeAllowedHost(value) {
+  if (typeof value !== "string") return null;
+  const candidate = value.trim();
+  if (!candidate) return null;
+  try {
+    const url = new URL(`http://${candidate}`);
+    if (url.username || url.password || url.port || url.pathname !== "/" || url.search || url.hash) return null;
+    const hostname = url.hostname.toLowerCase().replace(/\.$/, "");
+    if (!hostname || hostname.length > 253 || hostname.includes("*")) return null;
+    const labels = hostname.split(".");
+    if (labels.some((label) => !label || label.length > 63 || !/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/.test(label))) return null;
+    return hostname;
+  } catch {
+    return null;
+  }
+}
+function normalizeAllowedHosts(value) {
+  if (!Array.isArray(value)) return [];
+  const hosts = value.map(normalizeAllowedHost).filter((host) => host !== null);
+  return [...new Set(hosts)];
+}
+function repairConfig(input) {
+  const reasons = [];
+  const parsed = isRecord2(input) ? input : {};
+  if (parsed !== input) reasons.push("config root was not an object");
+  const rawAccounts = Array.isArray(parsed.accounts) ? parsed.accounts : [];
+  if (!Array.isArray(parsed.accounts) && parsed.accounts !== void 0) reasons.push("accounts was not an array");
+  const accounts = [];
+  const accountIds = /* @__PURE__ */ new Set();
+  rawAccounts.forEach((raw, index) => {
+    if (!isRecord2(raw)) {
+      reasons.push(`accounts[${index}] was not an object`);
+      return;
+    }
+    const providerId = raw.providerId ?? "claude";
+    if (!validProvider(providerId)) {
+      reasons.push(`accounts[${index}].providerId was invalid`);
+      return;
+    }
+    const id = typeof raw.id === "string" && raw.id.trim() ? raw.id.trim() : "";
+    const name = typeof raw.name === "string" && raw.name.trim() ? raw.name.trim() : "";
+    if (!id || !name) {
+      reasons.push(`accounts[${index}] was missing id or name`);
+      return;
+    }
+    if (accountIds.has(id)) {
+      reasons.push(`accounts[${index}].id was duplicated`);
+      return;
+    }
+    accountIds.add(id);
+    accounts.push({
+      id,
+      providerId,
+      name,
+      homeDir: typeof raw.homeDir === "string" && raw.homeDir.trim() ? raw.homeDir : "~",
+      ...typeof raw.color === "string" && raw.color.trim() ? { color: raw.color } : {}
+    });
+  });
+  const disabledProviders = (Array.isArray(parsed.disabledProviders) ? parsed.disabledProviders : []).filter(validProvider);
+  if (parsed.disabledProviders !== void 0 && !Array.isArray(parsed.disabledProviders)) {
+    reasons.push("disabledProviders was not an array");
+  }
+  const knownProviders = Array.isArray(parsed.knownProviders) ? parsed.knownProviders.filter(validProvider) : parsed.onboarded === true ? [...LEGACY_KNOWN] : [];
+  if (parsed.knownProviders !== void 0 && !Array.isArray(parsed.knownProviders)) {
+    reasons.push("knownProviders was not an array");
+  }
+  const allowedHosts = normalizeAllowedHosts(parsed.allowedHosts);
+  if (parsed.allowedHosts !== void 0 && !sameJson(parsed.allowedHosts, allowedHosts)) {
+    reasons.push("allowedHosts contained invalid or duplicate hostnames");
+  }
+  const appearanceRepair = repairAppearance(parsed.appearance);
+  if (parsed.appearance !== void 0 && appearanceRepair.repaired) {
+    reasons.push(...appearanceRepair.reasons);
+  }
+  const rawAccountDetection = isRecord2(parsed.accountDetection) ? parsed.accountDetection : {};
+  if (parsed.accountDetection !== void 0 && !isRecord2(parsed.accountDetection)) {
+    reasons.push("accountDetection was not an object");
+  }
+  const detectionDisabledProviders = Array.isArray(rawAccountDetection.disabledProviders) ? [...new Set(rawAccountDetection.disabledProviders.filter(validProvider))] : [];
+  const excludedAccounts = [];
+  const excludedKeys = /* @__PURE__ */ new Set();
+  if (Array.isArray(rawAccountDetection.excludedAccounts)) {
+    rawAccountDetection.excludedAccounts.forEach((raw, index) => {
+      if (!isRecord2(raw) || !validProvider(raw.providerId) || typeof raw.homeDir !== "string" || !raw.homeDir.trim()) {
+        reasons.push(`accountDetection.excludedAccounts[${index}] was invalid`);
+        return;
+      }
+      const homeDir = raw.homeDir.trim();
+      const key = `${raw.providerId}:${homeDir}`;
+      if (excludedKeys.has(key)) return;
+      excludedKeys.add(key);
+      excludedAccounts.push({ providerId: raw.providerId, homeDir });
+    });
+  } else if (rawAccountDetection.excludedAccounts !== void 0) {
+    reasons.push("accountDetection.excludedAccounts was not an array");
+  }
+  const accountDetection = {
+    enabled: typeof rawAccountDetection.enabled === "boolean" ? rawAccountDetection.enabled : DEFAULT_ACCOUNT_DETECTION_CONFIG.enabled,
+    disabledProviders: detectionDisabledProviders,
+    excludedAccounts
+  };
+  if (parsed.accountDetection !== void 0 && !sameJson(parsed.accountDetection, accountDetection)) {
+    reasons.push("accountDetection contained invalid settings");
+  }
+  const rawTray = isRecord2(parsed.tray) ? parsed.tray : {};
+  if (parsed.tray !== void 0 && !isRecord2(parsed.tray)) reasons.push("tray was not an object");
+  const tray = {
+    enabled: typeof rawTray.enabled === "boolean" ? rawTray.enabled : DEFAULT_TRAY_CONFIG.enabled,
+    showMenuBarText: typeof rawTray.showMenuBarText === "boolean" ? rawTray.showMenuBarText : DEFAULT_TRAY_CONFIG.showMenuBarText,
+    displayMetric: rawTray.displayMetric === "tightestRemaining" || rawTray.displayMetric === "smartHeadroom" ? rawTray.displayMetric : DEFAULT_TRAY_CONFIG.displayMetric,
+    pollIntervalSec: finiteInRange(rawTray.pollIntervalSec, DEFAULT_TRAY_CONFIG.pollIntervalSec, 1, 86400),
+    activeTimeoutMin: finiteInRange(rawTray.activeTimeoutMin, DEFAULT_TRAY_CONFIG.activeTimeoutMin, 1, 1440),
+    graceMin: finiteInRange(rawTray.graceMin, DEFAULT_TRAY_CONFIG.graceMin, 1, 10080),
+    promotionHoldMin: finiteInRange(rawTray.promotionHoldMin, DEFAULT_TRAY_CONFIG.promotionHoldMin, 0, 1440),
+    lowWatermarkPct: finiteInRange(rawTray.lowWatermarkPct, DEFAULT_TRAY_CONFIG.lowWatermarkPct, 0, 100),
+    criticalWatermarkPct: finiteInRange(rawTray.criticalWatermarkPct, DEFAULT_TRAY_CONFIG.criticalWatermarkPct, 0, 100),
+    pinnedAccount: typeof rawTray.pinnedAccount === "string" && rawTray.pinnedAccount.trim() ? rawTray.pinnedAccount.trim() : null,
+    pins: normalizePins(rawTray.pins, typeof rawTray.pinnedAccount === "string" ? rawTray.pinnedAccount : null),
+    // Provider-scoped pins are the source of truth. The account→provider migration
+    // needs the live snapshot, so it happens in the renderer; here we only enforce
+    // the persisted invariant (unique non-empty strings, ≤2, order preserved).
+    pinnedProviders: normalizeStringIdList(rawTray.pinnedProviders, MAX_PINNED_PROVIDERS),
+    launchAtLogin: typeof rawTray.launchAtLogin === "boolean" ? rawTray.launchAtLogin : DEFAULT_TRAY_CONFIG.launchAtLogin,
+    theme: rawTray.theme === "dark" ? rawTray.theme : DEFAULT_TRAY_CONFIG.theme
+  };
+  if (tray.graceMin < tray.activeTimeoutMin) {
+    tray.graceMin = Math.max(DEFAULT_TRAY_CONFIG.graceMin, tray.activeTimeoutMin);
+  }
+  if (tray.criticalWatermarkPct > tray.lowWatermarkPct) {
+    tray.criticalWatermarkPct = Math.min(DEFAULT_TRAY_CONFIG.criticalWatermarkPct, tray.lowWatermarkPct);
+  }
+  if (parsed.tray !== void 0 && !sameJson(parsed.tray, tray)) reasons.push("tray contained invalid settings");
+  const rawDesktop = isRecord2(parsed.desktop) ? parsed.desktop : {};
+  if (parsed.desktop !== void 0 && !isRecord2(parsed.desktop)) reasons.push("desktop was not an object");
+  const desktop = {
+    expandedProviders: normalizeStringIdList(rawDesktop.expandedProviders, MAX_EXPANDED_PROVIDERS),
+    graphRangeDays: DESKTOP_GRAPH_RANGES.includes(rawDesktop.graphRangeDays) ? rawDesktop.graphRangeDays : DEFAULT_DESKTOP_CONFIG.graphRangeDays
+  };
+  if (parsed.desktop !== void 0 && !sameJson(parsed.desktop, desktop)) reasons.push("desktop contained invalid settings");
+  const activeAccountId = typeof parsed.activeAccountId === "string" && (accountIds.has(parsed.activeAccountId) || PROVIDER_IDS.includes(parsed.activeAccountId)) ? parsed.activeAccountId : null;
+  if (parsed.activeAccountId !== void 0 && parsed.activeAccountId !== null && activeAccountId === null) {
+    reasons.push("activeAccountId did not match a known account/provider");
+  }
+  const timezone = typeof parsed.timezone === "string" && parsed.timezone.trim() && isValidTimezone(parsed.timezone.trim()) ? parsed.timezone.trim() : null;
+  if (parsed.timezone !== void 0 && parsed.timezone !== null && timezone === null) {
+    reasons.push("timezone was invalid");
+  }
+  const config = {
+    ...DEFAULTS,
+    revision: typeof parsed.revision === "number" && Number.isSafeInteger(parsed.revision) && parsed.revision >= 0 ? parsed.revision : DEFAULTS.revision,
+    interval: clampNum(parsed.interval, DEFAULTS.interval, 1),
+    billingInterval: clampNum(parsed.billingInterval, DEFAULTS.billingInterval, 1),
+    clearScreen: typeof parsed.clearScreen === "boolean" ? parsed.clearScreen : DEFAULTS.clearScreen,
+    privacyMode: typeof parsed.privacyMode === "boolean" ? parsed.privacyMode : DEFAULTS.privacyMode,
+    privacyToggleKey: typeof parsed.privacyToggleKey === "string" && parsed.privacyToggleKey.length === 1 ? parsed.privacyToggleKey : DEFAULTS.privacyToggleKey,
+    timezone,
+    accounts,
+    activeAccountId,
+    disabledProviders,
+    onboarded: parsed.onboarded === true,
+    dashboardLayout: parsed.dashboardLayout === "single" ? "single" : "grid",
+    defaultFocus: parsed.defaultFocus === "last" ? "last" : "all",
+    ascii: parsed.ascii === "on" ? "on" : parsed.ascii === "off" ? "off" : "auto",
+    allowNetworkAccess: parsed.allowNetworkAccess === true,
+    allowedHosts,
+    resetDisplay: parsed.resetDisplay === "absolute" ? "absolute" : "relative",
+    knownProviders,
+    appearance: appearanceRepair.appearance,
+    accountDetection,
+    tray,
+    desktop
+  };
+  for (const key of Object.keys(DEFAULTS)) {
+    if (!(key in parsed)) reasons.push(`missing ${key}`);
+  }
+  return { config, repaired: reasons.length > 0 || !sameJson(parsed, config), reasons };
+}
+function normalizeConfig(parsed) {
+  try {
+    return repairConfig(parsed).config;
+  } catch {
+    return {
+      ...DEFAULTS,
+      appearance: { ...DEFAULT_APPEARANCE },
+      accountDetection: { ...DEFAULT_ACCOUNT_DETECTION_CONFIG },
+      tray: { ...DEFAULT_TRAY_CONFIG },
+      desktop: { ...DEFAULT_DESKTOP_CONFIG }
+    };
+  }
+}
+function slugify(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 48);
+}
+function generateAccountId(name, existing) {
+  const base = slugify(name) || "account";
+  const taken = new Set(existing.map((a) => a.id));
+  if (!taken.has(base)) return base;
+  for (let i = 2; i < 1e3; i++) {
+    const candidate = `${base}_${i}`;
+    if (!taken.has(candidate)) return candidate;
+  }
+  return `${base}_${Date.now()}`;
+}
+function pickAccentColor(existing) {
+  const used = new Set(existing.map((a) => a.color).filter(Boolean));
+  for (const c of ACCENT_COLORS) {
+    if (!used.has(c)) return c;
+  }
+  return ACCENT_COLORS[existing.length % ACCENT_COLORS.length];
+}
+function sanitizeTyped(input) {
+  if (!input) return "";
+  return input.replace(/\x1b\][\s\S]*?(?:\x07|\x1b\\)/g, "").replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "").replace(/\x1bO./g, "").replace(/\x1b/g, "").replace(/[\x00-\x1f\x7f-\x9f]/g, "").replace(/\[20[01]~/g, "");
+}
+
+// src/config.ts
+function envDir(name) {
+  const v = process.env[name];
+  return v && v.trim() && isAbsolute(v.trim()) ? v.trim() : void 0;
+}
+function configDir() {
+  if (process.platform === "win32") {
+    return join(envDir("APPDATA") ?? join(homedir(), "AppData", "Roaming"), "tokmon");
+  }
+  return join(envDir("XDG_CONFIG_HOME") ?? join(homedir(), ".config"), "tokmon");
+}
+function configLocation() {
+  return join(configDir(), "config.json");
+}
+function cacheDir() {
+  if (process.platform === "win32") {
+    return join(envDir("LOCALAPPDATA") ?? envDir("APPDATA") ?? join(homedir(), "AppData", "Local"), "tokmon", "cache");
+  }
+  if (process.platform === "darwin") {
+    return join(homedir(), "Library", "Caches", "tokmon");
+  }
+  return join(envDir("XDG_CACHE_HOME") ?? join(homedir(), ".cache"), "tokmon");
+}
+function snapshotCacheFile() {
+  return join(cacheDir(), "web-snapshot.json");
+}
+async function loadConfig() {
+  let raw;
+  try {
+    raw = await readFile(configLocation(), "utf-8");
+  } catch {
+    return { ...DEFAULTS };
+  }
+  try {
+    await chmod(configDir(), 448);
+    await chmod(configLocation(), 384);
+  } catch {
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    try {
+      const dir = configDir();
+      await mkdir(dir, { recursive: true, mode: 448 });
+      await chmod(dir, 448);
+      const backup = configLocation() + ".bak";
+      await writeFile(backup, raw, { mode: 384 });
+      await chmod(backup, 384);
+    } catch {
+    }
+    return { ...DEFAULTS };
+  }
+  const repaired = repairConfig(parsed);
+  if (repaired.repaired) {
+    try {
+      await saveConfig(repaired.config);
+    } catch {
+    }
+  }
+  return repaired.config;
+}
+var saveQueue = Promise.resolve();
+var tempSequence = 0;
+function configTempFile(dir) {
+  tempSequence = (tempSequence + 1) % Number.MAX_SAFE_INTEGER;
+  return join(dir, `config.json.${process.pid}.${Date.now()}.${tempSequence}.tmp`);
+}
+function configJson(config) {
+  return JSON.stringify(normalizeConfig(config), null, 2) + "\n";
+}
+function saveConfig(config) {
+  const write = async () => {
+    const dir = configDir();
+    await mkdir(dir, { recursive: true, mode: 448 });
+    await chmod(dir, 448);
+    const tmp = configTempFile(dir);
+    try {
+      await writeFile(tmp, configJson(config), { mode: 384 });
+      await chmod(tmp, 384);
+      await rename(tmp, configLocation());
+    } catch (error) {
+      try {
+        await unlink(tmp);
+      } catch {
+      }
+      throw error;
+    }
+  };
+  const operation = saveQueue.catch(() => void 0).then(write);
+  saveQueue = operation;
+  return operation;
+}
+function saveConfigSync(config) {
+  const dir = configDir();
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  chmodSync(dir, 448);
+  const tmp = configTempFile(dir);
+  try {
+    writeFileSync(tmp, configJson(config), { mode: 384 });
+    chmodSync(tmp, 384);
+    renameSync(tmp, configLocation());
+  } catch (error) {
+    try {
+      unlinkSync(tmp);
+    } catch {
+    }
+    throw error;
+  }
+}
+function expandHome(p) {
+  if (!p) return homedir();
+  if (p === "~" || p === "~/" || p === "~\\") return homedir();
+  if (p.startsWith("~/") || p.startsWith("~\\")) return join(homedir(), p.slice(2));
+  return p;
+}
+function findAccount(config, id) {
+  if (!id) return null;
+  return config.accounts.find((a) => a.id === id) ?? null;
+}
+
+export {
+  PROVIDER_IDS,
+  BUILT_IN_THEME_PRESET_IDS,
+  THEME_PRESET_IDS,
+  themePresetOption,
+  isDarkOnlyThemePreset,
+  resolveTerminalTheme,
+  DESKTOP_GRAPH_RANGES,
+  MAX_PINNED_PROVIDERS,
+  cleanProviderSelection,
+  toggleProviderSelection,
+  moveProviderSelection,
+  DEFAULT_TRAY_CONFIG,
+  DEFAULT_ACCOUNT_DETECTION_CONFIG,
+  DEFAULTS,
+  ACCENT_COLORS,
+  COLOR_PALETTE,
+  PROVIDER_META,
+  containsEmail,
+  redactEmail,
+  getTrackedAccountRows,
+  providerDetectionEnabled,
+  setProviderDetectionEnabled,
+  setDetectedAccountExcluded,
+  clampNum,
+  isValidTimezone,
+  normalizeAllowedHost,
+  normalizeAllowedHosts,
+  repairConfig,
+  normalizeConfig,
+  slugify,
+  generateAccountId,
+  pickAccentColor,
+  sanitizeTyped,
+  envDir,
+  configLocation,
+  cacheDir,
+  snapshotCacheFile,
+  loadConfig,
+  saveConfig,
+  saveConfigSync,
+  expandHome,
+  findAccount
+};