mixdog 0.7.18 → 0.8.0

package/src/runtime/channels/lib/config.mjs

@@ -0,0 +1,285 @@
+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 { resolvePluginData } from "../../shared/plugin-paths.mjs";
+import { isHolidaySync } from "./holidays.mjs";
+const DATA_DIR = resolvePluginData();
+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 the Mixdog data dir under `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 runtime 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,
+  applyDefaults,
+  createBackend,
+  getDiscordToken,
+  isInQuietWindow,
+  loadConfig,
+  loadProfileConfig
+};

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

@@ -0,0 +1,71 @@
+import { statSync, renameSync, createWriteStream } from "fs";
+import { join } from "path";
+import { resolvePluginData } from "../../shared/plugin-paths.mjs";
+// ── drop-trace (output-forwarder) ───────────────────────────────────────────
+const _dtDataDir = resolvePluginData();
+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/runtime/channels/lib/event-pipeline.mjs

@@ -0,0 +1,81 @@
+import { EventQueue } from "./event-queue.mjs";
+import { applyParser, evaluateFilter, applyTemplate } 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/runtime/channels/lib/holidays.mjs

@@ -0,0 +1,138 @@
+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(), ".mixdog", "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
+};