mixdog 0.7.18 → 0.8.1

package/src/channels/lib/config.mjs

@@ -1,292 +0,0 @@
-import { readFileSync, mkdirSync } from "fs";
-import { join } from "path";
-import { DiscordBackend } from "../backends/discord.mjs";
-import { readSection, updateSection, CONFIG_PATH as MIXDOG_CONFIG_PATH, getDiscordToken, diagnoseDiscordTokenValue } from "../../shared/config.mjs";
-import { listSchedules } from "../../shared/schedules-store.mjs";
-import { isHolidaySync } from "./holidays.mjs";
-if (!process.env.CLAUDE_PLUGIN_DATA) {
-  process.stderr.write(
-    "mixdog: CLAUDE_PLUGIN_DATA not set.\n  This plugin must be run through Claude Code.\n"
-  );
-  process.exit(1);
-}
-const DATA_DIR = process.env.CLAUDE_PLUGIN_DATA;
-const PLUGIN_ROOT = process.env.CLAUDE_PLUGIN_ROOT ?? new URL("..", import.meta.url).pathname;
-const CONFIG_FILE = MIXDOG_CONFIG_PATH;
-const DEFAULT_ACCESS = {
-  dmPolicy: "allowlist",
-  allowFrom: [],
-  channels: {}
-};
-const DEFAULT_CONFIG = {
-  backend: "discord",
-  discord: { token: "" },
-  access: DEFAULT_ACCESS,
-  mainChannel: "main",
-  channelsConfig: {
-    main: { channelId: "", mode: "interactive" }
-  }
-};
-// Shared defaults layer (DND / per-channel respectQuiet). Merge
-// semantics: user values win; defaults only fill missing fields.
-// Helper is exported so the setup UI and runtime both produce the same
-// shape when the file has missing sections.
-const CONFIG_DEFAULTS = {
-  quiet: { schedule: "23:00-09:00", holidays: false },
-  schedules: { respectQuiet: true },
-  webhook: { enabled: true, respectQuiet: false }
-};
-const DEFAULT_HOLIDAY_COUNTRY = "KR";
-function normalizeHolidaySetting(value) {
-  if (value === true) return DEFAULT_HOLIDAY_COUNTRY;
-  if (typeof value === "string") {
-    const code = value.trim().toUpperCase();
-    return /^[A-Z]{2}$/.test(code) ? code : false;
-  }
-  return false;
-}
-function applyDefaults(config) {
-  const out = { ...(config || {}) };
-  out.quiet = { ...CONFIG_DEFAULTS.quiet, ...(out.quiet || {}) };
-  out.quiet.holidays = normalizeHolidaySetting(out.quiet.holidays);
-  out.schedules = { ...CONFIG_DEFAULTS.schedules, ...(out.schedules || {}) };
-  out.webhook = { ...CONFIG_DEFAULTS.webhook, ...(out.webhook || {}) };
-  return out;
-}
-/**
- * Shared DND / quiet-window helper used by scheduler + webhook.
- *
- * Signature contract (as of 0.1.62):
- *   isInQuietWindow(cfg, now = new Date(), tz = null) -> boolean
- *
- * `cfg` accepts exactly two shapes (top-level config with `.quiet`
- * subtree, or a flat `{ schedule, holidays }` descriptor); anything
- * else returns `false`.
- *
- * `tz` is an optional IANA timezone. When set, both the schedule
- * window (HH:MM) and the holiday/weekend day are evaluated in that
- * zone; when absent, the host's local timezone is used (unchanged
- * behavior for callers that omit it, e.g. webhook.mjs).
- *
- * Behavior:
- *   - Schedule window uses "HH:MM-HH:MM". Midnight-crossing windows
- *     (start > end, e.g. "23:00-09:00") are honored. When start === end
- *     the window is treated as empty/never (preserved doc-ambiguous
- *     behavior — callers should avoid that shape).
- *   - `holidays` enabled AND today is a recognized holiday  => true,
- *     regardless of schedule window.
- *   - `holidays === false` or missing => holidays ignored.
- *
- * Holiday detection strategy (0.1.63):
- *   Sync, non-blocking lookup via holidays.mjs `isHolidaySync`, backed
- *   by a pre-warmed in-memory cache (Nager-sourced). The `holidays`
- *   value doubles as the ISO country code (`true` => default country).
- *   - cache WARM  => real public-holiday data (weekday holidays count).
- *   - cache COLD  => documented fallback: weekend-only (Sat/Sun), while
- *     an async warm is kicked off for the next evaluation. No blocking
- *     I/O and no heuristics beyond this weekend fallback.
- *
- * Exported so scheduler.mjs and webhook.mjs can share one implementation.
- */
-// Day-of-week and HH:MM for `now`, in `tz` when given, else host-local.
-// An invalid IANA `tz` makes `Intl.DateTimeFormat` throw a RangeError;
-// we catch it once and fall back to host-local rather than propagating.
-function quietDayTime(now, tz) {
-  if (tz) {
-    try {
-      const parts = new Intl.DateTimeFormat("en-US", {
-        hour12: false, timeZone: tz,
-        hour: "2-digit", minute: "2-digit", weekday: "short",
-      }).formatToParts(now).reduce((acc, p) => { acc[p.type] = p.value; return acc; }, {});
-      const hour = parts.hour === "24" ? "00" : parts.hour;
-      const dowMap = { Sun: 0, Mon: 1, Tue: 2, Wed: 3, Thu: 4, Fri: 5, Sat: 6 };
-      return {
-        dow: dowMap[parts.weekday] ?? now.getDay(),
-        hhmm: `${hour}:${parts.minute}`,
-      };
-    } catch {
-      // Invalid timezone — fall through to host-local.
-    }
-  }
-  return {
-    dow: now.getDay(),
-    hhmm: `${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}`,
-  };
-}
-// Return the target calendar day as a plain 'YYYY-MM-DD' string, in `tz`
-// when given (else host-local). A string (not a Date) keeps the holiday
-// contract symmetric: isHolidaySync compares the same string, so there
-// is no UTC<->local round-trip to shift the day on UTC+12..+14 hosts.
-// An invalid IANA `tz` throws a RangeError; catch once, fall to local.
-function quietHolidayDateStr(now, tz) {
-  if (tz) {
-    try {
-      const parts = new Intl.DateTimeFormat("en-CA", {
-        timeZone: tz, year: "numeric", month: "2-digit", day: "2-digit",
-      }).formatToParts(now).reduce((acc, p) => { acc[p.type] = p.value; return acc; }, {});
-      return `${parts.year}-${parts.month}-${parts.day}`;
-    } catch {
-      // Invalid timezone — fall through to host-local.
-    }
-  }
-  return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}`;
-}
-function isInQuietWindow(cfg, now = new Date(), tz = null) {
-  if (!cfg || typeof cfg !== "object") return false;
-  // Auto-detect shape: prefer cfg.quiet when present, else treat cfg as
-  // the flat { schedule, holidays } descriptor.
-  const quiet = cfg.quiet && typeof cfg.quiet === "object" ? cfg.quiet : cfg;
-  const schedule = quiet.schedule;
-  const holidaysOn = quiet.holidays === true || (typeof quiet.holidays === "string" && !!quiet.holidays.trim());
-  const country = quiet.holidays === true
-    ? DEFAULT_HOLIDAY_COUNTRY
-    : (typeof quiet.holidays === "string" ? quiet.holidays.trim().toUpperCase() : null);
-
-  // Holiday branch: toggle on AND today qualifies => quiet regardless of window.
-  // Sync, pre-warmed cache lookup; cold cache falls back to weekend-only.
-  if (holidaysOn) {
-    const holiday = isHolidaySync(quietHolidayDateStr(now, tz), country);
-    if (holiday === true) return true;
-    if (holiday === null) {
-      // Cold cache: documented Sat/Sun fallback until the async warm lands.
-      const { dow } = quietDayTime(now, tz);
-      if (dow === 0 || dow === 6) return true;
-    }
-    // Warm cache + not a holiday: fall through to the schedule window.
-  }
-
-  // Schedule window check (TZ-aware when tz is set; host-local otherwise).
-  if (!schedule || typeof schedule !== "string") return false;
-  const parts = schedule.split("-");
-  if (parts.length !== 2) return false;
-  const [start, end] = parts;
-  // start === end => empty window (never matches); documented caveat.
-  const { hhmm } = quietDayTime(now, tz);
-  if (start > end) return hhmm >= start || hhmm < end; // midnight-crossing
-  return hhmm >= start && hhmm < end;
-}
-function loadConfig() {
-  try {
-    let raw = readSection("channels");
-    raw = raw && typeof raw === "object" ? raw : {};
-    // Schedules live in `${CLAUDE_PLUGIN_DATA}/schedules/<name>/` (single
-    // source of truth). The legacy `raw.schedules.items` / `raw.nonInteractive`
-    // / `raw.interactive` arrays in mixdog-config.json are no longer read.
-    const scheduleEntries = listSchedules().filter((s) => s.enabled !== false);
-    // Channel-presence routing (no `type` field): an entry WITH a channel is
-    // dispatched directly to that channel; an entry WITHOUT a channel is
-    // injected into the current (Lead) session. Mirrors the webhook model.
-    raw.nonInteractive = scheduleEntries.filter((i) => !!i.channel);
-    raw.interactive = scheduleEntries.filter((i) => !i.channel);
-    const accessChannels = { ...raw.access?.channels ?? {} };
-    // voice config lives at the top level of mixdog-config.json (peer of
-    // channels), so readSection("channels") never sees it. Pull it explicitly.
-    let voice = {};
-    try {
-      const v = readSection("voice");
-      if (v && typeof v === "object") voice = v;
-    } catch { /* missing section is fine */ }
-    const discordToken = getDiscordToken();
-    const discordTokenProblem = diagnoseDiscordTokenValue(discordToken, raw);
-    if (discordTokenProblem) {
-      process.stderr.write(`mixdog: discord token ignored: ${discordTokenProblem}\n`);
-    }
-    return applyDefaults({
-      ...DEFAULT_CONFIG,
-      ...raw,
-      backend: "discord",
-      discord: { ...DEFAULT_CONFIG.discord, ...(({ token: _, ...rest }) => rest)(raw.discord || {}), ...(discordToken && !discordTokenProblem ? { token: discordToken } : {}) },
-      access: {
-        ...DEFAULT_ACCESS,
-        // Drop the retired pairing-era keys at the config layer too (the
-        // Discord backend's normalizeAccess() is the runtime belt): legacy
-        // dmPolicy "pairing" → "allowlist", and the `pending` code store is
-        // gone entirely.
-        ...(({ pending: _pending, ...rest }) => rest)(raw.access || {}),
-        ...(raw.access?.dmPolicy === "pairing" ? { dmPolicy: "allowlist" } : {}),
-        channels: accessChannels,
-      },
-      voice: { ...(raw.voice || {}), ...voice }
-    });
-  } catch (err) {
-    if (err.code === "ENOENT") {
-      mkdirSync(DATA_DIR, { recursive: true });
-      updateSection("channels", () => DEFAULT_CONFIG);
-      process.stderr.write(
-        `mixdog: default channels config created in ${MIXDOG_CONFIG_PATH}
-  edit discord.token and channelsConfig.main.channelId to connect.
-`
-      );
-      return applyDefaults(DEFAULT_CONFIG);
-    }
-    throw err;
-  }
-}
-const HEADLESS_BACKEND = {
-  name: "headless",
-  async connect() {
-  },
-  async disconnect() {
-  },
-  async sendMessage() {
-    return { sentIds: [] };
-  },
-  async fetchMessages() {
-    return [];
-  },
-  async react() {
-  },
-  async removeReaction() {
-  },
-  async editMessage() {
-    return "";
-  },
-  async deleteMessage() {
-  },
-  async downloadAttachment() {
-    return Buffer.alloc(0);
-  },
-  on() {
-  }
-};
-function createBackend(config) {
-  const discordToken = getDiscordToken();
-  const discordTokenProblem = diagnoseDiscordTokenValue(discordToken, config);
-  if (discordTokenProblem) {
-    process.stderr.write(`mixdog: discord token ignored: ${discordTokenProblem}\n`);
-  }
-  if (config.backend !== "discord" || !discordToken || discordTokenProblem) {
-    process.stderr.write("mixdog: discord bot not configured; channel worker running in headless mode\n");
-    return HEADLESS_BACKEND;
-  }
-  const stateDir = config.discord.stateDir ?? join(DATA_DIR, "discord");
-  mkdirSync(stateDir, { recursive: true });
-  return new DiscordBackend({
-    ...config.discord,
-    configPath: CONFIG_FILE,
-    access: config.access,
-    // Single-source channel setup: the main channel is auto-allowed inside
-    // DiscordBackend.loadAccess() so a configured channelsConfig.main.channelId
-    // is enough for both inbound and outbound — no separate access.channels entry.
-    mainChannelId: config.channelsConfig?.main?.channelId
-  }, stateDir);
-}
-const PROFILE_FILE = join(DATA_DIR, "profile.json");
-function loadProfileConfig() {
-  try {
-    return JSON.parse(readFileSync(PROFILE_FILE, "utf8"));
-  } catch {
-    return {};
-  }
-}
-export {
-  DATA_DIR,
-  DEFAULT_HOLIDAY_COUNTRY,
-  PLUGIN_ROOT,
-  applyDefaults,
-  createBackend,
-  getDiscordToken,
-  isInQuietWindow,
-  loadConfig,
-  loadProfileConfig
-};

package/src/channels/lib/drop-trace.mjs

@@ -1,71 +0,0 @@
-import { statSync, renameSync, createWriteStream } from "fs";
-import { join } from "path";
-import { homedir } from "os";
-// ── drop-trace (output-forwarder) ───────────────────────────────────────────
-const _dtDataDir = process.env.CLAUDE_PLUGIN_DATA || join(homedir(), ".mixdog-data");
-const _dtLog = join(_dtDataDir, "drop-trace.log");
-const DROP_TRACE_ENABLED =
-  process.env.MIXDOG_DROP_TRACE === "1" ||
-  process.env.MIXDOG_DROP_TRACE === "true" ||
-  process.env.MIXDOG_DEBUG_CHANNELS === "1" ||
-  process.env.MIXDOG_DEBUG_CHANNELS === "true";
-// One-shot rotation at module init (10 MB threshold, .1 suffix overwrite).
-if (DROP_TRACE_ENABLED) {
-  try { if (statSync(_dtLog).size > 10 * 1024 * 1024) renameSync(_dtLog, _dtLog + '.1') } catch {}
-}
-
-// ── Buffered drop-trace writer ───────────────────────────────────────────────
-// Flushes every 1 s OR when the buffer reaches 64 KB — whichever fires first.
-// Drains synchronously on process exit so no log lines are lost.
-let _dtBuf = "";
-let _dtBufBytes = 0;
-let _dtFlushTimer = null;
-let _dtStream = null;
-function _dtGetStream() {
-  if (!_dtStream) _dtStream = createWriteStream(_dtLog, { flags: "a" });
-  return _dtStream;
-}
-function _dtFlush() {
-  if (_dtFlushTimer) { clearTimeout(_dtFlushTimer); _dtFlushTimer = null; }
-  if (!_dtBuf) return;
-  try { _dtGetStream().write(_dtBuf); } catch {}
-  _dtBuf = "";
-  _dtBufBytes = 0;
-}
-function _dtScheduleFlush() {
-  if (_dtFlushTimer) return;
-  _dtFlushTimer = setTimeout(_dtFlush, 1000);
-  if (_dtFlushTimer.unref) _dtFlushTimer.unref();
-}
-function _dtAppend(line) {
-  _dtBuf += line;
-  _dtBufBytes += Buffer.byteLength(line);
-  if (_dtBufBytes >= 65536) { _dtFlush(); return; }
-  _dtScheduleFlush();
-}
-process.on("exit", _dtFlush);
-// Note: do not install a module-level SIGTERM handler that calls
-// process.exit() here. The channels worker owns shutdown sequencing
-// (forwarder drain, queue persist, etc.) and a library-level exit(0)
-// preempts that drain. The `exit` listener above still synchronously
-// flushes buffered trace bytes when the worker exits on its own terms.
-
-function _dtPreview(text) {
-  if (!text) return "";
-  const s = String(text).slice(0, 121).replace(/\n/g, "\\n");
-  return s.length > 120 ? s.slice(0, 120) + "…" : s;
-}
-function dropTrace(event, fields) {
-  if (!DROP_TRACE_ENABLED) return;
-  try {
-    const ts = new Date().toISOString();
-    if (!fields) {
-      _dtAppend(`[${ts}][pid=${process.pid}] ${event}\n`);
-      return;
-    }
-    const kv = " " + Object.entries(fields).map(([k, v]) => `${k}=${v}`).join(" ");
-    _dtAppend(`[${ts}][pid=${process.pid}] ${event}${kv}\n`);
-  } catch {}
-}
-
-export { dropTrace, _dtPreview, DROP_TRACE_ENABLED };

package/src/channels/lib/event-pipeline.mjs

@@ -1,81 +0,0 @@
-import { EventQueue } from "./event-queue.mjs";
-import { applyParser, evaluateFilter, applyTemplate, logEvent } from "./executor.mjs";
-class EventPipeline {
-  rules;
-  queue;
-  constructor(config, channelsConfig) {
-    const rawRules = config?.rules;
-    this.rules = (Array.isArray(rawRules) ? rawRules : [])
-      .filter((r) => r && typeof r === "object" && r.enabled !== false);
-    this.queue = new EventQueue(config?.queue, channelsConfig);
-  }
-  getQueue() {
-    return this.queue;
-  }
-  start() {
-    this.queue.start();
-  }
-  stop() {
-    this.queue.stop();
-  }
-  reloadConfig(config, channelsConfig) {
-    const rawRules = config?.rules;
-    this.rules = (Array.isArray(rawRules) ? rawRules : [])
-      .filter((r) => r && typeof r === "object" && r.enabled !== false);
-    this.queue.reloadConfig(config?.queue, channelsConfig);
-  }
-  // ── Source: webhook ───────────────────────────────────────────────
-  /** Handle an incoming webhook event */
-  handleWebhook(endpointName, body, headers) {
-    const rule = this.rules.find((r) => r.source === "webhook" && r.name === endpointName);
-    if (!rule) return false;
-    const data = applyParser(rule.parser, body, headers);
-    if (rule.filter && !evaluateFilter(rule.filter, data)) {
-      return true;
-    }
-    const prompt = applyTemplate(rule.execute, data);
-    this.enqueue(rule, prompt);
-    return true;
-  }
-  // ── Direct enqueue (folder-based webhooks) ─────────────────────────
-  enqueueDirect(name, prompt, channel, exec = "interactive", instruction) {
-    const item = {
-      name,
-      source: "webhook",
-      priority: "normal",
-      prompt,
-      instruction,
-      exec,
-      channel,
-      timestamp: Date.now()
-    };
-    this.queue.enqueue(item);
-  }
-  // ── Common enqueue ────────────────────────────────────────────────
-  enqueue(rule, prompt) {
-    const item = {
-      name: rule.name,
-      source: rule.source,
-      priority: rule.priority,
-      prompt,
-      exec: rule.exec,
-      channel: rule.channel,
-      script: rule.script,
-      timestamp: Date.now()
-    };
-    this.queue.enqueue(item);
-  }
-  // ── Status ────────────────────────────────────────────────────────
-  getRules() {
-    return this.rules;
-  }
-  getStatus() {
-    return {
-      rules: this.rules.length,
-      queue: this.queue.getStatus()
-    };
-  }
-}
-export {
-  EventPipeline
-};

package/src/channels/lib/holidays.mjs

@@ -1,138 +0,0 @@
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
-import { join, dirname } from "path";
-import { homedir } from "os";
-import { DATA_DIR } from "./config.mjs";
-// Computed lazily (not at module top) so this module can be imported in a
-// cycle with config.mjs without touching DATA_DIR before config.mjs has
-// finished evaluating it (ESM temporal-dead-zone safety).
-function cacheFile() {
-  return join(DATA_DIR, "holidays-cache.json");
-}
-const FALLBACK_FILE = join(homedir(), ".claude", "schedules", "holidays.json");
-const CACHE_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
-// In-memory, pre-warmed holiday cache for SYNC reads (isHolidaySync).
-// Keyed by `${year}:${countryCode}` -> Set<dateStr>. Absent key == cold
-// (not yet warmed); callers fall back to their documented cold-cache
-// behavior until a warm completes.
-const memCache = /* @__PURE__ */ new Map();
-const warming = /* @__PURE__ */ new Set();
-function cacheKey(year, countryCode) {
-  return `${year}:${countryCode}`;
-}
-function holidaySet(holidays) {
-  return new Set((holidays || []).map((h) => h.date));
-}
-async function fetchHolidays(year, countryCode) {
-  const url = `https://date.nager.at/api/v3/publicholidays/${year}/${countryCode}`;
-  const res = await fetch(url, { signal: AbortSignal.timeout(10_000) });
-  if (!res.ok) throw new Error(`Nager API ${res.status}: ${res.statusText}`);
-  return res.json();
-}
-function loadCache(year, countryCode) {
-  try {
-    const file = cacheFile();
-    if (!existsSync(file)) return null;
-    const cache = JSON.parse(readFileSync(file, "utf8"));
-    if (cache.year !== year || cache.countryCode !== countryCode) return null;
-    if (Date.now() - cache.fetchedAt > CACHE_MAX_AGE_MS) return null;
-    return cache.holidays;
-  } catch {
-    return null;
-  }
-}
-function saveCache(year, countryCode, holidays) {
-  const cache = { year, countryCode, fetchedAt: Date.now(), holidays };
-  try {
-    const file = cacheFile();
-    mkdirSync(dirname(file), { recursive: true });
-    writeFileSync(file, JSON.stringify(cache, null, 2));
-  } catch {
-  }
-}
-function loadFallback() {
-  try {
-    if (!existsSync(FALLBACK_FILE)) return /* @__PURE__ */ new Set();
-    const data = JSON.parse(readFileSync(FALLBACK_FILE, "utf8"));
-    const dates = data.holidays ?? [];
-    return new Set(dates);
-  } catch {
-    return /* @__PURE__ */ new Set();
-  }
-}
-async function isHoliday(date, countryCode) {
-  const year = date.getFullYear();
-  const dateStr = `${year}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}`;
-  let holidays = loadCache(year, countryCode);
-  if (!holidays) {
-    try {
-      holidays = await fetchHolidays(year, countryCode);
-      saveCache(year, countryCode, holidays);
-    } catch (err) {
-      process.stderr.write(`mixdog holidays: API fetch failed: ${err}
-`);
-      holidays = null;
-    }
-  }
-  if (holidays) {
-    return holidays.some((h) => h.date === dateStr);
-  }
-  const fallback = loadFallback();
-  return fallback.has(dateStr);
-}
-// Synchronous, non-blocking holiday lookup backed by the pre-warmed
-// in-memory cache. `dateStr` is a plain 'YYYY-MM-DD' string (the same
-// representation warmHolidays stores), so there is no Date round-trip to
-// shift the day across host offsets. Returns:
-//   true  — date is a recognized public holiday (cache warm),
-//   false — date is NOT a holiday (cache warm),
-//   null  — cache is cold (not warmed yet); the async warm is kicked off
-//           and the caller should apply its documented cold-cache
-//           fallback. Never performs network OR blocking disk I/O — the
-//           cold path consults the in-memory cache only.
-function isHolidaySync(dateStr, countryCode) {
-  if (!countryCode) return false;
-  const year = Number(dateStr.slice(0, 4));
-  const key = cacheKey(year, countryCode);
-  const set = memCache.get(key);
-  if (set === void 0) {
-    // Cold: no synchronous disk probe here. Kick off the async warm
-    // (which does any on-disk/network lookup off the sync path) and
-    // report cold so the caller applies its documented fallback.
-    warmHolidays(dateStr, countryCode);
-    return null;
-  }
-  return set.has(dateStr);
-}
-// Asynchronously populate the in-memory sync cache for the given
-// dateStr's year/country (from the on-disk cache when fresh, else Nager).
-// `dateStr` is a plain 'YYYY-MM-DD' string. Idempotent and
-// self-deduplicating; failures leave the entry cold so the next sync
-// read retries.
-async function warmHolidays(dateStr, countryCode) {
-  if (!countryCode) return;
-  const year = Number(dateStr.slice(0, 4));
-  const key = cacheKey(year, countryCode);
-  if (memCache.has(key) || warming.has(key)) return;
-  warming.add(key);
-  try {
-    // Yield once before touching disk so the cold sync caller that
-    // triggered this warm is never blocked by the loadCache file read.
-    await Promise.resolve();
-    let holidays = loadCache(year, countryCode);
-    if (!holidays) {
-      holidays = await fetchHolidays(year, countryCode);
-      saveCache(year, countryCode, holidays);
-    }
-    memCache.set(key, holidaySet(holidays));
-  } catch (err) {
-    process.stderr.write(`mixdog holidays: warm failed: ${err}
-`);
-  } finally {
-    warming.delete(key);
-  }
-}
-export {
-  isHoliday,
-  isHolidaySync,
-  warmHolidays
-};