mysticals 0.1.0

package/dist/cli.js

@@ -0,0 +1,4219 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { createElement } from "react";
+import { render } from "ink";
+
+// package.json
+var version = "0.1.0";
+
+// src/client.ts
+import { spawn } from "child_process";
+import { mkdirSync, openSync } from "fs";
+import { createConnection } from "net";
+import { join as join2 } from "path";
+import { fileURLToPath } from "url";
+
+// src/paths.ts
+import { createHash } from "crypto";
+import { homedir, tmpdir, userInfo } from "os";
+import { join } from "path";
+var isMock = () => process.env.MYSTICALS_MOCK === "1";
+function homeDir() {
+  if (process.env.MYSTICALS_HOME) return process.env.MYSTICALS_HOME;
+  if (isMock()) return join(tmpdir(), `mysticals-mock-${userInfo().uid}`);
+  return join(dataRoot(), "mysticals-terminal");
+}
+function dataRoot(platform = process.platform, env = process.env) {
+  if (platform === "darwin") return join(homedir(), "Library", "Application Support");
+  if (platform === "win32") return env.APPDATA || join(homedir(), "AppData", "Roaming");
+  return env.XDG_DATA_HOME || join(homedir(), ".local", "share");
+}
+var MAX_SOCKET_PATH = 100;
+var hash = (home) => createHash("sha256").update(home).digest("hex").slice(0, 16);
+function socketPath(home = homeDir(), platform = process.platform) {
+  if (platform === "win32") return `\\\\.\\pipe\\mysticals-${hash(home)}`;
+  const p = join(home, "daemon.sock");
+  if (Buffer.byteLength(p) <= MAX_SOCKET_PATH) return p;
+  return join(tmpdir(), `mysticals-${hash(home)}.sock`);
+}
+
+// src/protocol.ts
+import { StringDecoder } from "string_decoder";
+var methodSet = {
+  "accounts.list": true,
+  "accounts.addGoogle": true,
+  "accounts.addCaldav": true,
+  "accounts.update": true,
+  "accounts.remove": true,
+  "calendars.list": true,
+  "calendars.setVisible": true,
+  "events.list": true,
+  "events.create": true,
+  "events.update": true,
+  "events.delete": true,
+  "events.respond": true,
+  "sync.now": true
+};
+var METHODS = Object.keys(methodSet);
+var isMethod = (m) => typeof m === "string" && Object.hasOwn(methodSet, m);
+var encode = (msg) => JSON.stringify(msg) + "\n";
+function lineReader(onMessage, onBad = () => {
+}) {
+  let buf = "";
+  let scanned = 0;
+  const utf8 = new StringDecoder("utf8");
+  return (chunk) => {
+    buf += typeof chunk === "string" ? chunk : utf8.write(chunk);
+    let nl;
+    while ((nl = buf.indexOf("\n", scanned)) >= 0) {
+      scanned = 0;
+      const line = buf.slice(0, nl);
+      buf = buf.slice(nl + 1);
+      if (!line.trim()) continue;
+      let msg;
+      try {
+        msg = JSON.parse(line);
+      } catch {
+        onBad(line);
+        continue;
+      }
+      onMessage(msg);
+    }
+    scanned = buf.length;
+  };
+}
+function dispatch(api, method, params) {
+  const [group, fn] = method.split(".");
+  const target = api[group];
+  return target[fn](...params);
+}
+
+// src/client.ts
+var connectOnce = (path) => new Promise((resolve, reject) => {
+  const s = createConnection(path);
+  s.once("connect", () => {
+    s.off("error", reject);
+    resolve(s);
+  });
+  s.once("error", reject);
+});
+function spawnDaemon() {
+  const home = homeDir();
+  mkdirSync(home, { recursive: true, mode: 448 });
+  const log = openSync(join2(home, "daemon.log"), "a", 384);
+  const cli = fileURLToPath(import.meta.url);
+  spawn(process.execPath, [cli, "--daemon"], { detached: true, windowsHide: true, stdio: ["ignore", log, log], env: process.env }).unref();
+}
+async function dial(path = socketPath(), start = spawnDaemon) {
+  try {
+    return await connectOnce(path);
+  } catch {
+    start();
+  }
+  const deadline = Date.now() + 1e4;
+  for (; ; ) {
+    try {
+      return await connectOnce(path);
+    } catch (e) {
+      if (Date.now() > deadline) throw new Error(`Could not start the mysticals daemon (see ${join2(homeDir(), "daemon.log")})`, { cause: e });
+      await new Promise((r) => setTimeout(r, 100));
+    }
+  }
+}
+function clientFor(open) {
+  let seq = 0;
+  let current;
+  let closed = false;
+  const pending = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  const emit = (accountId) => listeners.forEach((l) => l(accountId));
+  const authListeners = /* @__PURE__ */ new Set();
+  const attach = (sock) => {
+    sock.on(
+      "data",
+      lineReader((msg) => {
+        const m = msg;
+        if (m.event === "changed" && typeof m.accountId === "string") return emit(m.accountId);
+        if (m.event === "authUrl" && typeof m.url === "string") return authListeners.forEach((l) => l(m.url));
+        const p = pending.get(m.id);
+        if (!p) return;
+        pending.delete(m.id);
+        if (m.error !== void 0) p.reject(new Error(m.error));
+        else p.resolve(m.result);
+      })
+    );
+    sock.on("error", () => {
+    });
+    sock.on("close", () => {
+      current = void 0;
+      for (const p of pending.values()) p.reject(new Error("Lost connection to the mysticals daemon"));
+      pending.clear();
+      if (!closed) emit("");
+    });
+    return sock;
+  };
+  const socket = () => {
+    if (closed) return Promise.reject(new Error("Client closed"));
+    current ??= open().then(attach, (e) => {
+      current = void 0;
+      throw e;
+    });
+    return current;
+  };
+  const call = async (method, params) => {
+    const sock = await socket();
+    return new Promise((resolve, reject) => {
+      if (sock.destroyed) return reject(new Error("Lost connection to the mysticals daemon"));
+      const id2 = ++seq;
+      pending.set(id2, { resolve, reject });
+      sock.write(encode({ id: id2, method, params }));
+    });
+  };
+  const api = {};
+  for (const m of METHODS) {
+    const [group, fn] = m.split(".");
+    api[group] ??= {};
+    api[group][fn] = (...params) => call(m, params);
+  }
+  return Object.assign(api, {
+    onChanged(cb) {
+      listeners.add(cb);
+      return () => void listeners.delete(cb);
+    },
+    onAuthUrl(cb) {
+      authListeners.add(cb);
+      return () => void authListeners.delete(cb);
+    },
+    close() {
+      closed = true;
+      void current?.then((s) => s.end());
+    }
+  });
+}
+async function connect(path = socketPath(), start = spawnDaemon) {
+  const client = clientFor(() => dial(path, start));
+  await client.accounts.list();
+  return client;
+}
+
+// src/daemon/server.ts
+import { chmodSync, mkdirSync as mkdirSync4, rmSync } from "fs";
+import { createConnection as createConnection2, createServer as createServer2 } from "net";
+
+// ../../packages/core/src/api.ts
+import { z } from "zod";
+
+// ../../packages/core/src/sync/engine.ts
+import { addMonths, parseISO as parseISO2, subMonths } from "date-fns";
+
+// ../../packages/core/src/sync/notify.ts
+import { format, isSameDay, parseISO } from "date-fns";
+var at = (iso2, allDay) => (allDay ? parseISO(iso2) : new Date(iso2)).getTime();
+var key = (e) => `${e.calendarId}/${e.id}`;
+var WATCHED = ["title", "start", "end", "location"];
+function diffEvents(prev, next, now = /* @__PURE__ */ new Date()) {
+  const live = (e) => at(e.end, e.allDay) > now.getTime() && e.myStatus !== "declined";
+  const before = new Map(prev.map((e) => [key(e), e]));
+  const after = new Set(next.map(key));
+  const notes = [];
+  for (const e of next) {
+    if (!live(e)) continue;
+    const old = before.get(key(e));
+    if (!old) {
+      if (e.myStatus === "needsAction") notes.push({ kind: "invite", event: e });
+    } else if (WATCHED.some((f) => (old[f] ?? "") !== (e[f] ?? ""))) notes.push({ kind: "changed", event: e });
+  }
+  for (const e of prev) if (live(e) && !after.has(key(e))) notes.push({ kind: "cancelled", event: e });
+  return notes;
+}
+var TITLE = { invite: "New invite", changed: "Event changed", cancelled: "Event cancelled" };
+function noteText(notes, account, now = /* @__PURE__ */ new Date()) {
+  if (notes.length > 3) return [{ title: `${notes.length} calendar updates`, body: account }];
+  return notes.map(({ kind, event: e }) => ({ title: `${TITLE[kind]}: ${e.title || "Untitled"}`, body: `${when(e, now)} \xB7 ${account}` }));
+}
+function when(e, now) {
+  const s = e.allDay ? parseISO(e.start) : new Date(e.start);
+  if (e.allDay) return `${format(s, "EEE, d MMM")} \xB7 all day`;
+  return `${isSameDay(s, now) ? "Today" : format(s, "EEE, d MMM")} \xB7 ${format(s, "HH:mm")}`;
+}
+
+// ../../packages/core/src/sync/engine.ts
+var MIN = 6e4;
+var SyncEngine = class {
+  constructor(store, onChanged, opts = {}) {
+    this.store = store;
+    this.onChanged = onChanged;
+    this.opts = opts;
+    this.intervalMs = opts.intervalMs ?? 2 * MIN;
+    this.maxBackoffMs = opts.maxBackoffMs ?? 30 * MIN;
+  }
+  store;
+  onChanged;
+  opts;
+  intervalMs;
+  maxBackoffMs;
+  timers = /* @__PURE__ */ new Map();
+  inflight = /* @__PURE__ */ new Map();
+  failures = /* @__PURE__ */ new Map();
+  running = false;
+  unsubscribe;
+  start() {
+    if (this.running) return;
+    this.running = true;
+    const fire = () => void this.syncNow();
+    this.unsubscribe = this.opts.triggers?.(fire);
+    void this.syncNow();
+  }
+  stop() {
+    this.running = false;
+    this.unsubscribe?.();
+    this.unsubscribe = void 0;
+    for (const t of this.timers.values()) clearTimeout(t);
+    this.timers.clear();
+  }
+  /**
+   * Sync one account, or all accounts independently when id omitted.
+   * A single-account call rejects with that account's error; the all-accounts call never rejects.
+   */
+  /** `quiet`: the change came from this app (own edit/RSVP), so don't notify about it. */
+  async syncNow(accountId, opts = {}) {
+    if (accountId === void 0) {
+      await Promise.allSettled(this.store.list().map((a) => this.syncNow(a.id)));
+      return;
+    }
+    const existing = this.inflight.get(accountId);
+    if (existing) return existing;
+    const p = this.syncAccount(accountId, !!opts.quiet).finally(() => {
+      this.inflight.delete(accountId);
+      this.schedule(accountId);
+      this.opts.onSyncing?.(accountId);
+    });
+    this.inflight.set(accountId, p);
+    this.opts.onSyncing?.(accountId);
+    return p;
+  }
+  /** True while a sync of this account is running. */
+  isSyncing(accountId) {
+    return this.inflight.has(accountId);
+  }
+  /** (Re)arms this account's own timer: normal interval, or backoff after failures. */
+  schedule(id2) {
+    clearTimeout(this.timers.get(id2));
+    this.timers.delete(id2);
+    if (!this.running || !this.store.list().some((a) => a.id === id2)) {
+      this.failures.delete(id2);
+      return;
+    }
+    const n = this.failures.get(id2) ?? 0;
+    const delay = n === 0 ? this.intervalMs : Math.min(this.intervalMs * 2 ** n, this.maxBackoffMs);
+    this.timers.set(
+      id2,
+      setTimeout(() => void this.syncNow(id2).catch(() => {
+      }), delay)
+    );
+  }
+  // ponytail: quiet silences the whole sync, so an external change landing in the same pass is not announced.
+  async syncAccount(id2, quiet) {
+    const hadError = !!this.store.list().find((a) => a.id === id2)?.error;
+    try {
+      const provider = this.store.getProvider(id2);
+      const now = /* @__PURE__ */ new Date();
+      const range = { start: subMonths(now, 3).toISOString(), end: addMonths(now, 3).toISOString() };
+      const calendars = (await provider.listCalendars()).map((c) => ({ ...c, accountId: id2 }));
+      const lists = await Promise.all(
+        calendars.map(
+          async (cal) => (await provider.listEvents(cal.id, range)).map((e) => ({ ...e, accountId: id2, calendarId: cal.id }))
+        )
+      );
+      const next = { calendars, events: lists.flat(), syncedAt: now.toISOString() };
+      let prev;
+      try {
+        prev = this.store.readCache(id2);
+      } catch {
+        prev = void 0;
+      }
+      const changed = !prev || JSON.stringify([prev.calendars, prev.events]) !== JSON.stringify([next.calendars, next.events]);
+      await this.store.writeCache(id2, next);
+      this.failures.delete(id2);
+      if (hadError) await this.store.update(id2, { error: void 0 });
+      if (changed || hadError) this.onChanged(id2);
+      if (changed && !quiet && prev?.syncedAt && this.opts.onEvents) {
+        const notes = diffEvents(prev.events, next.events, now);
+        if (notes.length) this.opts.onEvents(id2, notes);
+      }
+    } catch (e) {
+      this.failures.set(id2, (this.failures.get(id2) ?? 0) + 1);
+      const message = e instanceof Error ? e.message : String(e);
+      await this.store.update(id2, { error: message }).catch(() => {
+      });
+      if (!hadError) this.onChanged(id2);
+      throw e;
+    }
+  }
+};
+function queryEvents(store, range, visibleOnly = true) {
+  const from = parseISO2(range.start).getTime();
+  const to = parseISO2(range.end).getTime();
+  const out = [];
+  for (const acc of store.list()) {
+    let cache;
+    try {
+      cache = store.readCache(acc.id);
+    } catch {
+      continue;
+    }
+    const hidden = new Set(visibleOnly ? store.hiddenCalendars(acc.id) : []);
+    for (const e of cache.events) {
+      if (e.accountId !== acc.id || hidden.has(e.calendarId)) continue;
+      if (parseISO2(e.end).getTime() > from && parseISO2(e.start).getTime() < to) out.push(e);
+    }
+  }
+  return out;
+}
+
+// ../../packages/core/src/telemetry.ts
+import { randomUUID } from "crypto";
+import { mkdirSync as mkdirSync2, readFileSync, writeFileSync } from "fs";
+import { join as join3 } from "path";
+var HOST = "https://eu.i.posthog.com";
+function telemetryOff(env = process.env) {
+  const no = (v) => v === "0" || v?.toLowerCase() === "false";
+  return !!env.DO_NOT_TRACK && !no(env.DO_NOT_TRACK) || no(env.MYSTICALS_TELEMETRY) || env.MYSTICALS_MOCK === "1";
+}
+var PRESETS = {
+  "dav.privateemail.com": "privateemail",
+  "caldav.icloud.com": "icloud",
+  "caldav.fastmail.com": "fastmail"
+};
+var caldavPreset = (serverUrl) => PRESETS[new URL(serverUrl).hostname] ?? "custom";
+function installId(dir) {
+  const file = join3(dir, "telemetry-id");
+  try {
+    const id3 = readFileSync(file, "utf8").trim();
+    if (id3) return { id: id3, fresh: false };
+  } catch {
+  }
+  const id2 = randomUUID();
+  mkdirSync2(dir, { recursive: true, mode: 448 });
+  writeFileSync(file, id2);
+  return { id: id2, fresh: true };
+}
+function startTelemetry(o) {
+  const env = o.env ?? process.env;
+  if (!o.key || telemetryOff(env)) return void 0;
+  let install;
+  try {
+    install = installId(o.dir);
+  } catch {
+    return void 0;
+  }
+  const host = env.MYSTICALS_TELEMETRY_HOST || HOST;
+  const doFetch = o.fetch ?? fetch;
+  const track = (event, props) => {
+    if (o.allowed && !o.allowed()) return;
+    const properties = {
+      app: o.app,
+      version: o.version,
+      os: process.platform,
+      arch: process.arch,
+      ...props && { provider: props.provider, ...props.preset && { preset: props.preset } },
+      $process_person_profiles: false,
+      $geoip_disable: true
+    };
+    try {
+      doFetch(`${host}/i/v0/e/`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ api_key: o.key, event, distinct_id: install.id, properties }),
+        // Never aborted early: the install id already exists, so a cancelled app_installed would never be resent.
+        signal: AbortSignal.timeout(5e3)
+      }).catch(() => {
+      });
+    } catch {
+    }
+  };
+  if (install.fresh) track("app_installed");
+  return { track, installed: install.fresh };
+}
+
+// ../../packages/core/src/api.ts
+var PALETTE = ["#bd93f9", "#50fa7b", "#8be9fd", "#ff79c6", "#ffb86c", "#f1fa8c"];
+var id = z.string().min(1).max(1024);
+var isoDateOrTime = z.union([z.iso.datetime({ offset: true }), z.iso.date()]);
+var color = z.string().regex(/^#[0-9a-fA-F]{6}$/);
+var text = (max2) => z.string().max(max2);
+var ordered = (v) => Date.parse(v.end) >= Date.parse(v.start);
+var Range = z.object({ start: isoDateOrTime, end: isoDateOrTime }).refine(ordered, "end before start");
+var NewEvent = z.object({
+  accountId: id,
+  calendarId: id,
+  title: text(1e3),
+  start: isoDateOrTime,
+  end: isoDateOrTime,
+  allDay: z.boolean(),
+  location: text(1e3).optional(),
+  description: text(2e4).optional(),
+  attendees: z.array(z.email()).max(500).optional()
+}).refine(ordered, "end before start");
+var Attendee = z.object({
+  email: text(320).min(1),
+  name: text(500).optional(),
+  status: z.enum(["accepted", "declined", "tentative", "needsAction"]),
+  self: z.boolean().optional(),
+  organizer: z.boolean().optional()
+});
+var EventRef = z.object({ id, accountId: id, calendarId: id });
+var EventEdit = EventRef.extend({
+  title: text(1e3),
+  start: isoDateOrTime,
+  end: isoDateOrTime,
+  allDay: z.boolean(),
+  location: text(1e3).optional(),
+  description: text(2e4).optional(),
+  attendees: z.array(Attendee).max(500)
+}).refine(ordered, "end before start");
+var LOOPBACK = /* @__PURE__ */ new Set(["127.0.0.1", "localhost"]);
+var CaldavInput = z.object({
+  label: text(200).min(1),
+  serverUrl: z.string().refine((u) => {
+    if (!URL.canParse(u)) return false;
+    const { protocol, hostname } = new URL(u);
+    return protocol === "https:" || protocol === "http:" && LOOPBACK.has(hostname);
+  }, "server URL must be https"),
+  username: text(500).min(1),
+  password: text(2e3).min(1),
+  color: color.optional()
+});
+var AccountPatch = z.object({ label: text(200).min(1).optional(), color: color.optional() }).strict();
+var RsvpStatus = z.enum(["accepted", "declined", "tentative"]);
+var Scope = z.enum(["one", "following", "all"]).default("one");
+function createApi(store, sync, deps) {
+  const account = (accountId) => {
+    const a = store.get(id.parse(accountId));
+    if (!a) throw new Error("unknown account");
+    return a;
+  };
+  const syncOne = (accountId) => {
+    sync.syncNow(accountId, { quiet: true }).catch((e) => console.error(`sync ${accountId} failed`, e));
+  };
+  const nextColor = () => PALETTE[store.list().length % PALETTE.length];
+  const cachedEvent = (ref) => {
+    account(ref.accountId);
+    const ev = store.readCache(ref.accountId).events.find((e) => e.id === ref.id);
+    if (!ev || ev.accountId !== ref.accountId || ev.calendarId !== ref.calendarId)
+      throw new Error("event does not belong to this account/calendar");
+    return ev;
+  };
+  const writable = (ev) => {
+    const cal = store.readCache(ev.accountId).calendars.find((c) => c.id === ev.calendarId);
+    if (!cal || cal.readOnly) throw new Error("calendar is read-only");
+    return ev;
+  };
+  return {
+    accounts: {
+      list: async () => store.list().map((a) => ({ ...a, syncing: sync.isSyncing(a.id), synced: !!store.readCache(a.id).syncedAt })),
+      addGoogle: async () => {
+        const { email, credentials } = await deps.googleSignIn();
+        const a = await store.add({ kind: "google", label: email, email, color: nextColor() }, credentials);
+        syncOne(a.id);
+        deps.onAccountAdded?.({ provider: "google" });
+        return a;
+      },
+      addCaldav: async (raw) => {
+        const input = CaldavInput.parse(raw);
+        const { email } = await deps.verifyCaldav(input);
+        const { label, serverUrl, username, password } = input;
+        const a = await store.add(
+          { kind: "caldav", label, email, color: input.color ?? nextColor() },
+          { kind: "caldav", serverUrl, username, password }
+        );
+        syncOne(a.id);
+        deps.onAccountAdded?.({ provider: "caldav", preset: caldavPreset(serverUrl) });
+        return a;
+      },
+      update: async (accountId, patch) => {
+        const a = await store.update(account(accountId).id, AccountPatch.parse(patch));
+        deps.onChanged?.(a.id);
+        return a;
+      },
+      remove: async (accountId) => {
+        const a = account(accountId);
+        await store.remove(a.id);
+        deps.onChanged?.(a.id);
+      }
+    },
+    calendars: {
+      list: async () => store.list().flatMap((a) => {
+        const hidden = new Set(store.hiddenCalendars(a.id));
+        return store.readCache(a.id).calendars.map((c) => ({ ...c, accountId: a.id, visible: !hidden.has(c.id) }));
+      }),
+      setVisible: async (accountId, calendarId, visible) => {
+        const a = account(accountId);
+        const cal = id.parse(calendarId);
+        if (!store.readCache(a.id).calendars.some((c) => c.id === cal)) throw new Error("calendar does not belong to account");
+        await store.setCalendarVisible(a.id, cal, z.boolean().parse(visible));
+        deps.onChanged?.(a.id);
+      }
+    },
+    events: {
+      // `raw` stays in the daemon/main process: it can be huge (CalDAV series ICS) and writes re-read it from the cache.
+      list: async (raw) => queryEvents(store, Range.parse(raw), false).map(({ raw: _raw, ...e }) => e),
+      create: async (raw) => {
+        const input = NewEvent.parse(raw);
+        const a = account(input.accountId);
+        const cal = store.readCache(a.id).calendars.find((c) => c.id === input.calendarId);
+        if (!cal) throw new Error("calendar does not belong to account");
+        if (cal.readOnly) throw new Error("calendar is read-only");
+        const ev = await store.getProvider(a.id).createEvent(cal.id, { ...input, accountId: a.id });
+        syncOne(a.id);
+        return ev;
+      },
+      update: async (raw) => {
+        const edit = EventEdit.parse(raw);
+        const cached2 = writable(cachedEvent(edit));
+        const { title: title2, start, end, allDay, location, description, attendees } = edit;
+        const ev = await store.getProvider(cached2.accountId).updateEvent({ ...cached2, title: title2, start, end, allDay, location, description, attendees });
+        syncOne(cached2.accountId);
+        return ev;
+      },
+      delete: async (raw, scope) => {
+        const cached2 = writable(cachedEvent(EventRef.parse(raw)));
+        await store.getProvider(cached2.accountId).deleteEvent(cached2, Scope.parse(scope));
+        syncOne(cached2.accountId);
+      },
+      respond: async (raw, status) => {
+        const cached2 = cachedEvent(EventRef.parse(raw));
+        const ev = await store.getProvider(cached2.accountId).respond(cached2, RsvpStatus.parse(status));
+        syncOne(cached2.accountId);
+        return ev;
+      }
+    },
+    sync: {
+      now: async (accountId) => {
+        if (accountId === void 0 || accountId === null) return sync.syncNow();
+        return sync.syncNow(account(accountId).id);
+      }
+    }
+  };
+}
+
+// ../../packages/core/src/accounts/store.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { existsSync, readFileSync as readFileSync2 } from "fs";
+import { mkdir, rename, rm, writeFile } from "fs/promises";
+import { join as join4 } from "path";
+var ID_RE = /^[a-zA-Z0-9-]{1,64}$/;
+function readJson(file, fallback) {
+  if (!existsSync(file)) return fallback;
+  try {
+    return JSON.parse(readFileSync2(file, "utf8"));
+  } catch (e) {
+    throw new Error(`Could not read ${file}: ${e.message}`);
+  }
+}
+async function writeAtomic(file, data) {
+  const tmp = `${file}.${randomUUID2()}.tmp`;
+  await writeFile(tmp, data, { mode: 384 });
+  await rename(tmp, file);
+}
+var AccountStore = class {
+  constructor(dir, factories, crypto) {
+    this.dir = dir;
+    this.factories = factories;
+    this.crypto = crypto;
+    this.accounts = readJson(this.registryFile, []);
+    if (!Array.isArray(this.accounts)) throw new Error(`Could not read ${this.registryFile}: not a list of accounts`);
+  }
+  dir;
+  factories;
+  crypto;
+  accounts;
+  providers = /* @__PURE__ */ new Map();
+  /** Parsed cache.json per account; caches can be tens of MB, so they are read from disk once. */
+  caches = /* @__PURE__ */ new Map();
+  queue = Promise.resolve();
+  get registryFile() {
+    return join4(this.dir, "accounts.json");
+  }
+  /** Validates the id before it ever becomes part of a path (no traversal). */
+  accountDir(id2) {
+    if (!ID_RE.test(id2)) throw new Error(`Invalid account id: ${JSON.stringify(id2)}`);
+    return join4(this.dir, "accounts", id2);
+  }
+  require(id2) {
+    const acc = this.get(id2);
+    if (!acc) throw new Error(`Unknown account: ${id2}`);
+    return acc;
+  }
+  /** All writes run one at a time, so checks and file snapshots never race (e.g. a refresh vs. remove). */
+  // ponytail: one queue for all accounts; per-account queues if write throughput ever matters.
+  serial(fn) {
+    const run = this.queue.then(fn);
+    this.queue = run.catch(() => {
+    });
+    return run;
+  }
+  saveRegistry() {
+    return writeAtomic(this.registryFile, JSON.stringify(this.accounts, null, 2));
+  }
+  async writeCreds(id2, creds) {
+    const dir = this.accountDir(id2);
+    const data = this.crypto.encrypt(JSON.stringify(creds));
+    await mkdir(dir, { recursive: true });
+    await writeAtomic(join4(dir, "creds.bin"), data);
+  }
+  readCreds(id2) {
+    return JSON.parse(this.crypto.decrypt(readFileSync2(join4(this.accountDir(id2), "creds.bin"))));
+  }
+  list() {
+    return this.accounts.map((a) => ({ ...a }));
+  }
+  get(id2) {
+    const acc = this.accounts.find((a) => a.id === id2);
+    return acc && { ...acc };
+  }
+  async add(meta, creds) {
+    if (creds.kind !== meta.kind) throw new Error("Credentials kind does not match account kind");
+    const account = { id: randomUUID2(), kind: meta.kind, label: meta.label, email: meta.email, color: meta.color };
+    return this.serial(async () => {
+      await this.writeCreds(account.id, creds);
+      this.accounts.push(account);
+      await this.saveRegistry();
+      return { ...account };
+    });
+  }
+  async update(id2, patch) {
+    return this.serial(async () => {
+      const acc = this.accounts.find((a) => a.id === id2);
+      if (!acc) throw new Error(`Unknown account: ${id2}`);
+      if (patch.credentials) {
+        if (patch.credentials.kind !== acc.kind) throw new Error("Credentials kind does not match account kind");
+        await this.writeCreds(id2, patch.credentials);
+        this.providers.delete(id2);
+      }
+      if (patch.label !== void 0) acc.label = patch.label;
+      if (patch.color !== void 0) acc.color = patch.color;
+      if ("error" in patch) {
+        if (patch.error) acc.error = patch.error;
+        else delete acc.error;
+      }
+      await this.saveRegistry();
+      return { ...acc };
+    });
+  }
+  /** Removes account and wipes its directory (creds + cache). */
+  async remove(id2) {
+    const dir = this.accountDir(id2);
+    return this.serial(async () => {
+      this.providers.delete(id2);
+      this.caches.delete(id2);
+      this.accounts = this.accounts.filter((a) => a.id !== id2);
+      await this.saveRegistry();
+      await rm(dir, { recursive: true, force: true });
+    });
+  }
+  /** Isolated provider instance for this account only (memoized per account). */
+  getProvider(id2) {
+    const cached2 = this.providers.get(id2);
+    if (cached2) return cached2;
+    const acc = this.require(id2);
+    const provider = this.factories[acc.kind]({
+      accountId: acc.id,
+      email: acc.email,
+      credentials: this.readCreds(acc.id),
+      // Bound to this account only; a no-op once the account is removed (never resurrects its dir).
+      saveCredentials: (creds) => this.serial(async () => {
+        if (this.providers.get(acc.id) !== provider) return;
+        if (creds.kind !== acc.kind) throw new Error("Credentials kind does not match account kind");
+        await this.writeCreds(acc.id, creds);
+      })
+    });
+    this.providers.set(id2, provider);
+    return provider;
+  }
+  readCache(id2) {
+    const hit = this.caches.get(id2);
+    if (hit) return hit;
+    const cache = readJson(join4(this.accountDir(id2), "cache.json"), { calendars: [], events: [] });
+    if (this.get(id2)) this.caches.set(id2, cache);
+    return cache;
+  }
+  writeCache(id2, cache) {
+    return this.serial(async () => {
+      const dir = this.accountDir(id2);
+      this.require(id2);
+      await mkdir(dir, { recursive: true });
+      await writeAtomic(join4(dir, "cache.json"), JSON.stringify(cache));
+      this.caches.set(id2, cache);
+    });
+  }
+  hiddenCalendars(id2) {
+    const file = join4(this.accountDir(id2), "prefs.json");
+    try {
+      const hidden = readJson(file, {}).hidden;
+      return Array.isArray(hidden) ? hidden.filter((h) => typeof h === "string") : [];
+    } catch {
+      return [];
+    }
+  }
+  setCalendarVisible(id2, calendarId, visible) {
+    return this.serial(async () => {
+      this.require(id2);
+      const hidden = new Set(this.hiddenCalendars(id2));
+      if (visible) hidden.delete(calendarId);
+      else hidden.add(calendarId);
+      const dir = this.accountDir(id2);
+      await mkdir(dir, { recursive: true });
+      await writeAtomic(join4(dir, "prefs.json"), JSON.stringify({ hidden: [...hidden] }));
+    });
+  }
+};
+
+// ../../packages/core/src/mock/mockApi.ts
+import { addDays, format as format2 } from "date-fns";
+
+// ../../packages/core/src/mock/MockProvider.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import { parseISO as parseISO3 } from "date-fns";
+var MockProvider = class {
+  constructor(accountId, email, calendars) {
+    this.accountId = accountId;
+    this.email = email;
+    this.calendars = calendars.map((c) => ({ ...c, accountId }));
+  }
+  accountId;
+  email;
+  calendars;
+  events = [];
+  async listCalendars() {
+    return structuredClone(this.calendars);
+  }
+  async listEvents(calendarId, range) {
+    const t = (iso2) => parseISO3(iso2).getTime();
+    return structuredClone(
+      this.events.filter((e) => e.calendarId === calendarId && t(e.end) > t(range.start) && t(e.start) < t(range.end))
+    );
+  }
+  async createEvent(calendarId, input) {
+    const ev = {
+      id: randomUUID3(),
+      accountId: this.accountId,
+      calendarId,
+      title: input.title,
+      start: input.start,
+      end: input.end,
+      allDay: input.allDay,
+      location: input.location,
+      description: input.description,
+      organizer: { email: this.email },
+      attendees: (input.attendees ?? []).map((email) => ({ email, status: "needsAction" }))
+    };
+    this.events.push(ev);
+    return structuredClone(ev);
+  }
+  async updateEvent(event) {
+    const i = this.events.findIndex((e) => e.id === event.id);
+    if (i < 0) throw new Error("not found");
+    this.events[i] = { ...event, accountId: this.accountId };
+    return structuredClone(this.events[i]);
+  }
+  async deleteEvent(event, scope = "one") {
+    const series = event.recurringEventId;
+    const hit = (e) => !series || scope === "one" ? e.id === event.id : e.recurringEventId === series && (scope === "all" || e.start >= event.start);
+    this.events = this.events.filter((e) => !hit(e));
+  }
+  async respond(event, status) {
+    const ev = this.events.find((e) => e.id === event.id);
+    if (!ev) throw new Error("not found");
+    ev.myStatus = status;
+    ev.attendees = ev.attendees.map((a) => a.self ? { ...a, status } : a);
+    return structuredClone(ev);
+  }
+};
+
+// ../../packages/core/src/mock/mockApi.ts
+var iso = (dayOffset, h, m = 0) => {
+  const d = /* @__PURE__ */ new Date();
+  d.setHours(h, m, 0, 0);
+  d.setDate(d.getDate() + dayOffset);
+  return d.toISOString();
+};
+function createMockApi(onChanged) {
+  const accounts = [
+    { id: "work", kind: "caldav", label: "Work", email: "me@work.example", color: "#8be9fd" },
+    { id: "personal", kind: "google", label: "Personal", email: "me@gmail.example", color: "#50fa7b" }
+  ];
+  const providers = /* @__PURE__ */ new Map([
+    ["work", new MockProvider("work", "me@work.example", [{ id: "work-main", name: "Work", color: "#8be9fd", readOnly: false }])],
+    [
+      "personal",
+      new MockProvider("personal", "me@gmail.example", [
+        { id: "p-main", name: "Personal", color: "#50fa7b", readOnly: false },
+        { id: "p-holidays", name: "Holidays", color: "#f1fa8c", readOnly: true }
+      ])
+    ]
+  ]);
+  const hidden = /* @__PURE__ */ new Set();
+  const work = providers.get("work");
+  const personal = providers.get("personal");
+  const seed = (p, calendarId, e) => {
+    p.events.push({ id: `${p.accountId}-${p.events.length}`, accountId: p.accountId, calendarId, allDay: false, attendees: [], ...e });
+  };
+  for (let d = -3; d <= 7; d++) {
+    seed(work, "work-main", {
+      title: "Daily standup",
+      start: iso(d, 10),
+      end: iso(d, 10, 15),
+      location: "https://meet.google.com/abc-defg-hij",
+      organizer: { email: "lead@work.example" },
+      myStatus: "accepted",
+      attendees: [{ email: "lead@work.example", status: "accepted", organizer: true }, { email: "me@work.example", status: "accepted", self: true }]
+    });
+  }
+  seed(work, "work-main", {
+    title: "Sprint planning",
+    start: iso(1, 14),
+    end: iso(1, 15, 30),
+    location: "Room 3 / https://meet.example.com/sprint-planning",
+    organizer: { email: "pm@work.example" },
+    myStatus: "needsAction",
+    attendees: [{ email: "pm@work.example", status: "accepted", organizer: true }, { email: "me@work.example", status: "needsAction", self: true }]
+  });
+  seed(personal, "p-main", { title: "Gym", start: iso(0, 19), end: iso(0, 20) });
+  for (let d = -2; d <= 4; d++) {
+    seed(personal, "p-main", { title: "Morning run", start: iso(d, 7), end: iso(d, 7, 45), recurringEventId: "run-series" });
+  }
+  seed(personal, "p-main", { title: "Dinner with friends", start: iso(2, 20), end: iso(2, 22), location: "Kyiv" });
+  const day = (offset) => format2(addDays(/* @__PURE__ */ new Date(), offset), "yyyy-MM-dd");
+  seed(personal, "p-holidays", { title: "Holiday", start: day(0), end: day(1), allDay: true });
+  const prov = (id2) => {
+    const p = providers.get(id2);
+    if (!p) throw new Error(`unknown account ${id2}`);
+    return p;
+  };
+  const own = (accountId, calendarId) => {
+    const p = prov(accountId);
+    if (!p.calendars.some((c) => c.id === calendarId)) throw new Error("calendar does not belong to account");
+    return p;
+  };
+  return {
+    accounts: {
+      list: async () => structuredClone(accounts),
+      addGoogle: async () => {
+        throw new Error("Not available in mock mode");
+      },
+      addCaldav: async () => {
+        throw new Error("Not available in mock mode");
+      },
+      update: async (id2, patch) => {
+        const a = accounts.find((x) => x.id === id2);
+        if (!a) throw new Error("unknown account");
+        Object.assign(a, patch);
+        onChanged(id2);
+        return structuredClone(a);
+      },
+      remove: async (id2) => {
+        const i = accounts.findIndex((a) => a.id === id2);
+        if (i >= 0) accounts.splice(i, 1);
+        providers.delete(id2);
+        onChanged(id2);
+      }
+    },
+    calendars: {
+      list: async () => (await Promise.all([...providers.values()].map((p) => p.listCalendars()))).flat().map((c) => ({ ...c, visible: !hidden.has(`${c.accountId}/${c.id}`) })),
+      setVisible: async (accountId, calendarId, visible) => {
+        const k = `${accountId}/${calendarId}`;
+        if (visible) hidden.delete(k);
+        else hidden.add(k);
+        onChanged(accountId);
+      }
+    },
+    events: {
+      list: async (range) => {
+        const out = [];
+        for (const p of providers.values())
+          for (const c of p.calendars) out.push(...await p.listEvents(c.id, range));
+        return out;
+      },
+      create: async (input) => {
+        const ev = await own(input.accountId, input.calendarId).createEvent(input.calendarId, input);
+        onChanged(input.accountId);
+        return ev;
+      },
+      update: async (ev) => {
+        const r = await own(ev.accountId, ev.calendarId).updateEvent(ev);
+        onChanged(ev.accountId);
+        return r;
+      },
+      delete: async (ev, scope) => {
+        await own(ev.accountId, ev.calendarId).deleteEvent(ev, scope);
+        onChanged(ev.accountId);
+      },
+      respond: async (ev, status) => {
+        const r = await own(ev.accountId, ev.calendarId).respond(ev, status);
+        onChanged(ev.accountId);
+        return r;
+      }
+    },
+    sync: { now: async () => {
+    } }
+  };
+}
+
+// ../../packages/core/src/providers/caldav/index.ts
+import { randomUUID as randomUUID4 } from "crypto";
+import {
+  createAccount,
+  createCalendarObject,
+  deleteCalendarObject,
+  fetchCalendarObjects,
+  fetchCalendars,
+  fetchCalendarUserAddresses,
+  getBasicAuthHeaders,
+  updateCalendarObject
+} from "tsdav";
+
+// ../../packages/core/src/providers/caldav/ics.ts
+import ICAL from "ical.js";
+var MAX_INSTANCES = 1e5;
+var PARTSTAT_IN = {
+  ACCEPTED: "accepted",
+  DECLINED: "declined",
+  TENTATIVE: "tentative",
+  "NEEDS-ACTION": "needsAction"
+};
+var PARTSTAT_OUT = {
+  accepted: "ACCEPTED",
+  declined: "DECLINED",
+  tentative: "TENTATIVE",
+  needsAction: "NEEDS-ACTION"
+};
+var mapPartStat = (v) => PARTSTAT_IN[String(v ?? "").toUpperCase()] ?? "needsAction";
+var cleanEmail = (v) => String(v ?? "").replace(/^mailto:/i, "").trim().toLowerCase();
+var sameEmail = (a, b) => cleanEmail(a) !== "" && cleanEmail(a) === cleanEmail(b);
+function parse(ics) {
+  const root = new ICAL.Component(ICAL.parse(ics));
+  for (const vtz of root.getAllSubcomponents("vtimezone")) {
+    const tz = new ICAL.Timezone(vtz);
+    if (!ICAL.TimezoneService.has(tz.tzid)) ICAL.TimezoneService.register(tz);
+  }
+  return root;
+}
+var toIso = (t) => t.isDate ? t.toString() : t.toJSDate().toISOString();
+function fromIso(iso2, allDay) {
+  if (allDay) return ICAL.Time.fromDateString(iso2.slice(0, 10));
+  const d = new Date(iso2);
+  if (Number.isNaN(d.getTime())) throw new Error(`Invalid date: ${iso2}`);
+  return ICAL.Time.fromJSDate(d, true);
+}
+function setTime(vevent, name, t) {
+  vevent.removeAllProperties(name);
+  vevent.addPropertyWithValue(name, t);
+}
+function setText(vevent, name, value) {
+  vevent.removeAllProperties(name);
+  if (value) vevent.addPropertyWithValue(name, value);
+}
+function touch(vevent) {
+  vevent.updatePropertyWithValue("dtstamp", ICAL.Time.now());
+  vevent.updatePropertyWithValue("last-modified", ICAL.Time.now());
+}
+function mapPeople(vevent, email) {
+  const orgProp = vevent.getFirstProperty("organizer");
+  const organizer = orgProp ? { email: cleanEmail(orgProp.getFirstValue()), name: orgProp.getParameter("cn") || void 0 } : void 0;
+  const attendees = vevent.getAllProperties("attendee").map((p) => {
+    const a = { email: cleanEmail(p.getFirstValue()), status: mapPartStat(p.getParameter("partstat")) };
+    const cn = p.getParameter("cn");
+    if (cn) a.name = String(cn);
+    if (sameEmail(a.email, email)) a.self = true;
+    if (organizer && sameEmail(a.email, organizer.email)) a.organizer = true;
+    return a;
+  });
+  return { organizer, attendees, myStatus: attendees.find((a) => a.self)?.status };
+}
+function parseEvents(ics, href, etag, ctx, range) {
+  const root = parse(ics);
+  const vevents = root.getAllSubcomponents("vevent");
+  const rangeStart = new Date(range.start).getTime();
+  const rangeEnd = new Date(range.end).getTime();
+  const inRange = (s, e) => {
+    const sm = s.toJSDate().getTime();
+    const em = e.toJSDate().getTime();
+    return sm < rangeEnd && (em > rangeStart || em === sm && sm >= rangeStart);
+  };
+  const build = (item, start, end, recurrenceId) => {
+    const rid = recurrenceId?.toString();
+    const raw = { href, ics, ...rid ? { recurrenceId: rid } : {} };
+    return {
+      id: rid ? `${href}#${rid}` : href,
+      accountId: ctx.accountId,
+      calendarId: ctx.calendarId,
+      title: item.summary ?? "",
+      start: toIso(start),
+      end: toIso(end),
+      allDay: start.isDate,
+      location: item.location || void 0,
+      description: item.description || void 0,
+      ...mapPeople(item.component, ctx.email),
+      etag,
+      raw,
+      ...rid ? { recurringEventId: href } : {}
+    };
+  };
+  const master = vevents.find((v) => !v.hasProperty("recurrence-id"));
+  if (!master) {
+    return vevents.map((v) => new ICAL.Event(v)).filter((e) => inRange(e.startDate, e.endDate)).map((e) => build(e, e.startDate, e.endDate, e.recurrenceId));
+  }
+  const event = new ICAL.Event(master);
+  for (const v of vevents) if (v !== master) event.relateException(v);
+  if (!event.isRecurring()) return inRange(event.startDate, event.endDate) ? [build(event, event.startDate, event.endDate)] : [];
+  const out = [];
+  const it = event.iterator();
+  const lastOverride = Math.max(
+    -Infinity,
+    ...vevents.filter((v) => v !== master).map((v) => v.getFirstPropertyValue("recurrence-id").toJSDate().getTime())
+  );
+  for (let i = 0, next = it.next(); next && i < MAX_INSTANCES; i++, next = it.next()) {
+    const ms = next.toJSDate().getTime();
+    if (ms >= rangeEnd && ms > lastOverride) break;
+    const d = event.getOccurrenceDetails(next);
+    if (inRange(d.startDate, d.endDate)) out.push(build(d.item, d.startDate, d.endDate, d.recurrenceId));
+  }
+  return out;
+}
+function buildIcs(uid, input, email) {
+  const root = new ICAL.Component(["vcalendar", [], []]);
+  root.addPropertyWithValue("prodid", "-//Mysticals//EN");
+  root.addPropertyWithValue("version", "2.0");
+  const v = new ICAL.Component("vevent");
+  v.addPropertyWithValue("uid", uid);
+  v.addPropertyWithValue("dtstamp", ICAL.Time.now());
+  v.addPropertyWithValue("created", ICAL.Time.now());
+  v.addPropertyWithValue("sequence", 0);
+  setTime(v, "dtstart", fromIso(input.start, input.allDay));
+  setTime(v, "dtend", fromIso(input.end, input.allDay));
+  setText(v, "summary", input.title);
+  setText(v, "location", input.location);
+  setText(v, "description", input.description);
+  setAttendees(v, input.attendees ?? [], email);
+  root.addSubcomponent(v);
+  return root.toString();
+}
+function setAttendees(v, emails, email) {
+  const wanted = [...new Set(emails.map(cleanEmail).filter(Boolean))];
+  const existing = new Map(v.getAllProperties("attendee").map((p) => [cleanEmail(p.getFirstValue()), p]));
+  v.removeAllProperties("attendee");
+  for (const e of wanted) {
+    let p = existing.get(e);
+    if (!p) {
+      p = new ICAL.Property("attendee");
+      p.setValue(`mailto:${e}`);
+      p.setParameter("partstat", "NEEDS-ACTION");
+      p.setParameter("rsvp", "TRUE");
+    }
+    v.addProperty(p);
+  }
+  if (wanted.length && !v.hasProperty("organizer")) v.addPropertyWithValue("organizer", `mailto:${cleanEmail(email)}`);
+}
+var findMaster = (root) => root.getAllSubcomponents("vevent").find((v) => !v.hasProperty("recurrence-id"));
+function masterOf(root) {
+  const m = findMaster(root);
+  if (!m) throw new Error("Calendar object has no master VEVENT");
+  return m;
+}
+function ridTime(master, rid) {
+  const time = rid.length === 10 ? ICAL.Time.fromDateString(rid) : ICAL.Time.fromDateTimeString(rid);
+  const tzid = rid.endsWith("Z") ? void 0 : master.getFirstProperty("dtstart")?.getParameter("tzid");
+  const zone = tzid ? ICAL.TimezoneService.get(tzid) : void 0;
+  if (zone) time.zone = zone;
+  return { time, tzid };
+}
+function findOverride(root, rid) {
+  const master = findMaster(root);
+  const want = master ? ridTime(master, rid).time.toJSDate().getTime() : NaN;
+  return root.getAllSubcomponents("vevent").find((v) => {
+    const t = v.getFirstPropertyValue("recurrence-id");
+    return !!t && (String(t) === rid || t.toJSDate().getTime() === want);
+  });
+}
+function ridProp(master, name, rid) {
+  const { time, tzid } = ridTime(master, rid);
+  const p = new ICAL.Property(name);
+  p.setValue(time);
+  if (tzid) p.setParameter("tzid", tzid);
+  return p;
+}
+function targetVevent(root, raw) {
+  if (!raw.recurrenceId) return masterOf(root);
+  const existing = findOverride(root, raw.recurrenceId);
+  if (existing) return existing;
+  const master = masterOf(root);
+  const o = new ICAL.Component(structuredClone(master.toJSON()));
+  for (const n of ["rrule", "rdate", "exdate", "exrule"]) o.removeAllProperties(n);
+  o.addProperty(ridProp(master, "recurrence-id", raw.recurrenceId));
+  root.addSubcomponent(o);
+  return o;
+}
+function applyUpdate(event, email) {
+  const raw = event.raw;
+  const root = parse(raw.ics);
+  const v = targetVevent(root, raw);
+  setTime(v, "dtstart", fromIso(event.start, event.allDay));
+  v.removeAllProperties("duration");
+  setTime(v, "dtend", fromIso(event.end, event.allDay));
+  setText(v, "summary", event.title);
+  setText(v, "location", event.location);
+  setText(v, "description", event.description);
+  setAttendees(
+    v,
+    event.attendees.map((a) => a.email),
+    email
+  );
+  v.updatePropertyWithValue("sequence", Number(v.getFirstPropertyValue("sequence") ?? 0) + 1);
+  touch(v);
+  return root.toString();
+}
+function applyDeleteInstance(raw) {
+  if (!raw.recurrenceId) throw new Error("Not a recurring instance");
+  const root = parse(raw.ics);
+  const override = findOverride(root, raw.recurrenceId);
+  if (override) root.removeSubcomponent(override);
+  const master = findMaster(root);
+  if (!master) return root.getAllSubcomponents("vevent").length ? root.toString() : null;
+  master.addProperty(ridProp(master, "exdate", raw.recurrenceId));
+  master.updatePropertyWithValue("sequence", Number(master.getFirstPropertyValue("sequence") ?? 0) + 1);
+  touch(master);
+  return root.toString();
+}
+function applyDeleteFollowing(raw) {
+  if (!raw.recurrenceId) throw new Error("Not a recurring instance");
+  const root = parse(raw.ics);
+  const master = findMaster(root);
+  if (!master) return null;
+  const { time } = ridTime(master, raw.recurrenceId);
+  const cut = time.toJSDate().getTime();
+  if (cut <= master.getFirstPropertyValue("dtstart").toJSDate().getTime()) return null;
+  for (const v of root.getAllSubcomponents("vevent")) {
+    const t = v.getFirstPropertyValue("recurrence-id");
+    if (t && t.toJSDate().getTime() >= cut) root.removeSubcomponent(v);
+  }
+  let until = time.clone();
+  if (until.isDate) until.adjust(-1, 0, 0, 0);
+  else {
+    until.adjust(0, 0, 0, -1);
+    if (until.zone !== ICAL.Timezone.localTimezone) until = until.convertToZone(ICAL.Timezone.utcTimezone);
+  }
+  for (const p of master.getAllProperties("rrule")) {
+    const r = p.getFirstValue().clone();
+    r.count = null;
+    r.until = until;
+    p.setValue(r);
+  }
+  master.updatePropertyWithValue("sequence", Number(master.getFirstPropertyValue("sequence") ?? 0) + 1);
+  touch(master);
+  return root.toString();
+}
+function applyRespond(raw, email, status) {
+  const root = parse(raw.ics);
+  let found = false;
+  for (const v of root.getAllSubcomponents("vevent")) {
+    for (const p of v.getAllProperties("attendee")) {
+      if (!sameEmail(p.getFirstValue(), email)) continue;
+      p.setParameter("partstat", PARTSTAT_OUT[status]);
+      p.removeParameter("rsvp");
+      p.removeParameter("schedule-status");
+      found = true;
+    }
+    if (found) v.updatePropertyWithValue("dtstamp", ICAL.Time.now());
+  }
+  if (!found) throw new Error("This account is not an attendee of the event");
+  return root.toString();
+}
+
+// ../../packages/core/src/providers/http.ts
+var http = { timeoutMs: 3e4 };
+var timedFetch = async (input, init) => {
+  const timeout = AbortSignal.timeout(http.timeoutMs);
+  try {
+    return await fetch(input, { ...init, signal: init?.signal ? AbortSignal.any([init.signal, timeout]) : timeout });
+  } catch (e) {
+    if (timeout.aborted) throw new Error(`Request to ${new URL(String(input instanceof Request ? input.url : input)).host} timed out`);
+    throw e;
+  }
+};
+
+// ../../packages/core/src/providers/caldav/index.ts
+var FALLBACK_COLOR = "#8e8e93";
+var DAY = 864e5;
+async function connect2(serverUrl, username, password) {
+  try {
+    new URL(serverUrl);
+  } catch {
+    throw new Error(`Invalid server URL: ${serverUrl}`);
+  }
+  const headers = getBasicAuthHeaders({ username, password });
+  let unauthorized = false;
+  const trackingFetch = async (input, init) => {
+    const res = await timedFetch(input, init);
+    if (res.status === 401) unauthorized = true;
+    return res;
+  };
+  try {
+    const account = await createAccount({
+      account: { serverUrl, accountType: "caldav", credentials: { username, password } },
+      headers,
+      fetch: trackingFetch
+    });
+    return { account, headers };
+  } catch (e) {
+    if (unauthorized) throw new Error("CalDAV login failed: wrong username or password");
+    throw new Error(`Could not find a CalDAV service at ${serverUrl}: ${e.message}`);
+  }
+}
+function toCalendar(c, accountId) {
+  const name = typeof c.displayName === "string" && c.displayName ? c.displayName : decodeURIComponent(c.url.split("/").filter(Boolean).pop() ?? c.url);
+  const color2 = typeof c.calendarColor === "string" && /^#[0-9a-f]{6}/i.test(c.calendarColor) ? c.calendarColor.slice(0, 7) : FALLBACK_COLOR;
+  const privileges = JSON.stringify(c.projectedProps?.currentUserPrivilegeSet ?? "");
+  const readOnly = privileges.includes("privilege") && !/"(write|writeContent|all)"/.test(privileges);
+  return { id: c.url, accountId, name, color: color2, readOnly };
+}
+var CALENDAR_PROPS = {
+  "d:displayname": {},
+  "ca:calendar-color": {},
+  "cs:getctag": {},
+  "d:resourcetype": {},
+  "c:supported-calendar-component-set": {},
+  "d:sync-token": {},
+  "d:current-user-privilege-set": {}
+};
+async function listVeventCalendars(conn) {
+  const cals = await fetchCalendars({
+    account: conn.account,
+    headers: conn.headers,
+    props: CALENDAR_PROPS,
+    projectedProps: { currentUserPrivilegeSet: true },
+    fetch: timedFetch
+  });
+  return cals.filter((c) => !c.components?.length || c.components.includes("VEVENT"));
+}
+function check(res, what) {
+  if (res.ok) return;
+  if (res.status === 412) throw new Error(`${what} failed: the event was changed on the server, refresh and try again`);
+  throw new Error(`${what} failed: ${res.status} ${res.statusText}`);
+}
+var createCaldavProvider = (ctx) => {
+  if (ctx.credentials.kind !== "caldav") throw new Error("CalDAV provider needs caldav credentials");
+  const { serverUrl, username, password } = ctx.credentials;
+  let conn;
+  const getConn = () => {
+    conn ??= connect2(serverUrl, username, password).catch((e) => {
+      conn = void 0;
+      throw e;
+    });
+    return conn;
+  };
+  const mapCtx = (calendarId) => ({ accountId: ctx.accountId, calendarId, email: ctx.email });
+  async function reload(calendarId, href, id2, around) {
+    const { headers } = await getConn();
+    const [obj] = await fetchCalendarObjects({ calendar: { url: calendarId }, objectUrls: [href], headers, urlFilter: () => true, fetch: timedFetch });
+    if (!obj?.data) throw new Error("Saved event could not be read back from the server");
+    const range = { start: new Date(new Date(around.start).getTime() - DAY).toISOString(), end: new Date(new Date(around.end).getTime() + DAY).toISOString() };
+    const events = parseEvents(obj.data, id2 === void 0 ? obj.url : href, obj.etag, mapCtx(calendarId), range);
+    const ev = id2 === void 0 ? events[0] : events.find((e) => e.id === id2);
+    if (!ev) throw new Error("Saved event not found on the server");
+    return ev;
+  }
+  const put = async (event, ics, what) => {
+    const { headers } = await getConn();
+    const raw = event.raw;
+    check(await updateCalendarObject({ calendarObject: { url: raw.href, data: ics, etag: event.etag }, headers, fetch: timedFetch }), what);
+  };
+  const provider = {
+    async listCalendars() {
+      const c = await getConn();
+      return (await listVeventCalendars(c)).map((cal) => toCalendar(cal, ctx.accountId));
+    },
+    async listEvents(calendarId, range) {
+      const { headers } = await getConn();
+      const objs = await fetchCalendarObjects({ calendar: { url: calendarId }, timeRange: range, headers, urlFilter: () => true, fetch: timedFetch });
+      return objs.flatMap((o) => o.data ? parseEvents(o.data, o.url, o.etag, mapCtx(calendarId), range) : []);
+    },
+    async createEvent(calendarId, input) {
+      const { headers } = await getConn();
+      const uid = randomUUID4();
+      const filename = `${uid}.ics`;
+      const ics = buildIcs(uid, input, ctx.email);
+      check(await createCalendarObject({ calendar: { url: calendarId }, filename, iCalString: ics, headers, fetch: timedFetch }), "Create event");
+      const href = new URL(filename, calendarId.endsWith("/") ? calendarId : `${calendarId}/`).href;
+      return reload(calendarId, href, void 0, input);
+    },
+    async updateEvent(event) {
+      await put(event, applyUpdate(event, ctx.email), "Update event");
+      return reload(event.calendarId, event.raw.href, event.id, event);
+    },
+    async deleteEvent(event, scope = "one") {
+      const raw = event.raw;
+      const rest = !raw.recurrenceId || scope === "all" ? null : scope === "following" ? applyDeleteFollowing(raw) : applyDeleteInstance(raw);
+      if (rest) return put(event, rest, "Delete event");
+      const { headers } = await getConn();
+      check(await deleteCalendarObject({ calendarObject: { url: raw.href, etag: event.etag }, headers, fetch: timedFetch }), "Delete event");
+    },
+    async respond(event, status) {
+      await put(event, applyRespond(event.raw, ctx.email, status), "Respond");
+      return reload(event.calendarId, event.raw.href, event.id, event);
+    }
+  };
+  return provider;
+};
+async function verifyCaldav(input) {
+  const c = await connect2(input.serverUrl.trim(), input.username, input.password);
+  await listVeventCalendars(c);
+  const addresses = await fetchCalendarUserAddresses({ account: c.account, headers: c.headers, fetch: timedFetch }).catch(() => []);
+  const mails = addresses.filter((a) => /^mailto:/i.test(a)).map(cleanEmail);
+  const login = cleanEmail(input.username);
+  const email = mails.find((m) => m === login) ?? mails[0] ?? (login.includes("@") ? login : void 0);
+  if (!email) throw new Error("Could not determine the account email; use your full email address as the username");
+  return { email };
+}
+
+// ../../packages/core/src/providers/google/oauth.ts
+import { createHash as createHash2, randomBytes } from "crypto";
+import { createServer } from "http";
+var AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth";
+var TOKEN_URL = "https://oauth2.googleapis.com/token";
+var SCOPES = "openid email https://www.googleapis.com/auth/calendar";
+var TIMEOUT_MS = 5 * 60 * 1e3;
+var clientConfig = {};
+function setClientConfig(cfg) {
+  clientConfig = cfg;
+}
+function getClientConfig() {
+  const { clientId, clientSecret } = clientConfig;
+  if (!clientId || !clientSecret) throw new Error("Google sign-in is not configured in this build: add a CalDAV account, or build from source with MYSTICALS_GOOGLE_CLIENT_ID/SECRET set");
+  return { clientId, clientSecret };
+}
+function createPkce() {
+  const verifier = randomBytes(32).toString("base64url");
+  return { verifier, challenge: createHash2("sha256").update(verifier).digest("base64url") };
+}
+function buildAuthUrl(p) {
+  const url = new URL(AUTH_URL);
+  url.search = new URLSearchParams({
+    client_id: p.clientId,
+    redirect_uri: p.redirectUri,
+    response_type: "code",
+    scope: SCOPES,
+    state: p.state,
+    code_challenge: p.codeChallenge,
+    code_challenge_method: "S256",
+    access_type: "offline",
+    prompt: "consent"
+  }).toString();
+  return url.toString();
+}
+function emailFromIdToken(idToken) {
+  try {
+    const payload = JSON.parse(Buffer.from(idToken.split(".")[1], "base64url").toString("utf8"));
+    return typeof payload.email === "string" ? payload.email : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function parseTokenResponse(json, now = Date.now()) {
+  const j = json ?? {};
+  if (typeof j.error === "string") throw new Error(`Google token error: ${j.error}${j.error_description ? ` (${j.error_description})` : ""}`);
+  if (typeof j.access_token !== "string") throw new Error("Google token response has no access_token");
+  const expiresIn = typeof j.expires_in === "number" ? j.expires_in : 3600;
+  return {
+    accessToken: j.access_token,
+    expiresAt: now + expiresIn * 1e3,
+    refreshToken: typeof j.refresh_token === "string" ? j.refresh_token : void 0,
+    email: typeof j.id_token === "string" ? emailFromIdToken(j.id_token) : void 0
+  };
+}
+async function postToken(params) {
+  const res = await timedFetch(TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams(params).toString()
+  });
+  const json = await res.json().catch(() => ({ error: `http_${res.status}` }));
+  if (!res.ok && !json.error) json.error = `http_${res.status}`;
+  return parseTokenResponse(json);
+}
+var DONE_HTML = (msg) => `<!doctype html><meta charset="utf-8"><title>Mysticals</title><body style="font:15px -apple-system,sans-serif;text-align:center;padding-top:80px"><h2>${msg}</h2><p>You can close this tab and return to Mysticals.</p></body>`;
+async function runOAuthFlow(openUrl3) {
+  const cfg = getClientConfig();
+  const { verifier, challenge } = createPkce();
+  const state = randomBytes(16).toString("base64url");
+  const server = createServer();
+  try {
+    await new Promise((resolve, reject) => {
+      server.once("error", reject);
+      server.listen(0, "127.0.0.1", resolve);
+    });
+    const redirectUri = `http://127.0.0.1:${server.address().port}`;
+    const code = await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error("Google sign-in timed out")), TIMEOUT_MS);
+      const finish = (err, value) => {
+        clearTimeout(timer);
+        if (err) reject(err);
+        else resolve(value);
+      };
+      server.on("request", (req, res) => {
+        const params = new URL(req.url ?? "/", redirectUri).searchParams;
+        const reply = (status, msg, then) => {
+          res.writeHead(status, { "Content-Type": "text/html; charset=utf-8", Connection: "close" });
+          res.end(DONE_HTML(msg), then);
+        };
+        if (!params.has("code") && !params.has("error")) {
+          res.writeHead(404, { Connection: "close" }).end();
+          return;
+        }
+        if (params.get("state") !== state) {
+          reply(400, "Sign-in failed", () => finish(new Error("Google sign-in failed: state mismatch")));
+        } else if (params.has("error")) {
+          reply(400, "Sign-in cancelled", () => finish(new Error(`Google sign-in failed: ${params.get("error")}`)));
+        } else {
+          const code2 = params.get("code");
+          reply(200, "Signed in", () => finish(null, code2));
+        }
+      });
+      openUrl3(buildAuthUrl({ clientId: cfg.clientId, redirectUri, state, codeChallenge: challenge })).catch(
+        (e) => finish(e instanceof Error ? e : new Error(String(e)))
+      );
+    });
+    const tok = await postToken({
+      grant_type: "authorization_code",
+      code,
+      code_verifier: verifier,
+      redirect_uri: redirectUri,
+      client_id: cfg.clientId,
+      client_secret: cfg.clientSecret
+    });
+    if (!tok.refreshToken) throw new Error("Google did not return a refresh token");
+    const email = tok.email ?? await fetchUserEmail(tok.accessToken);
+    return { email, credentials: { kind: "google", refreshToken: tok.refreshToken, accessToken: tok.accessToken, expiresAt: tok.expiresAt } };
+  } finally {
+    server.closeAllConnections();
+    server.close();
+  }
+}
+async function fetchUserEmail(accessToken) {
+  const res = await timedFetch("https://openidconnect.googleapis.com/v1/userinfo", { headers: { Authorization: `Bearer ${accessToken}` } });
+  const json = await res.json().catch(() => ({}));
+  if (!res.ok || typeof json.email !== "string") throw new Error("Could not read Google account email");
+  return json.email;
+}
+
+// ../../packages/core/src/providers/google/provider.ts
+var API = "https://www.googleapis.com/calendar/v3";
+var STATUSES = ["accepted", "declined", "tentative", "needsAction"];
+var toStatus = (s) => STATUSES.includes(s) ? s : "needsAction";
+function mapEvent(g, accountId, calendarId) {
+  const allDay = !!g.start.date;
+  const time = (t) => allDay ? t.date : new Date(t.dateTime).toISOString();
+  const attendees = (g.attendees ?? []).map((a) => ({
+    email: a.email,
+    name: a.displayName,
+    status: toStatus(a.responseStatus),
+    self: a.self || void 0,
+    organizer: a.organizer || void 0
+  }));
+  const self = g.attendees?.find((a) => a.self);
+  return {
+    id: g.id,
+    accountId,
+    calendarId,
+    title: g.summary ?? "",
+    start: time(g.start),
+    end: time(g.end),
+    allDay,
+    location: g.location,
+    description: g.description,
+    organizer: g.organizer?.email ? { email: g.organizer.email, name: g.organizer.displayName } : void 0,
+    attendees,
+    myStatus: self ? toStatus(self.responseStatus) : void 0,
+    etag: g.etag,
+    raw: g,
+    recurringEventId: g.recurringEventId
+  };
+}
+function truncateRecurrence(recurrence, cutoff) {
+  const until = cutoff.date ? new Date(Date.parse(cutoff.date) - 864e5).toISOString().slice(0, 10).replace(/-/g, "") : new Date(Date.parse(cutoff.dateTime) - 1e3).toISOString().replace(/[-:]|\.\d{3}/g, "");
+  return recurrence.map((line) => {
+    if (!line.startsWith("RRULE:")) return line;
+    const parts = line.slice(6).split(";").filter((p) => !/^(COUNT|UNTIL)=/i.test(p));
+    return `RRULE:${[...parts, `UNTIL=${until}`].join(";")}`;
+  });
+}
+var toGTime = (iso2, allDay) => allDay ? { date: iso2.slice(0, 10), dateTime: null, timeZone: null } : { dateTime: iso2, date: null, timeZone: null };
+function createGoogleProviderImpl(ctx) {
+  if (ctx.credentials.kind !== "google") throw new Error("Google provider needs Google credentials");
+  let creds = ctx.credentials;
+  let refreshing;
+  const refresh = () => refreshing ??= (async () => {
+    const { clientId, clientSecret } = getClientConfig();
+    const tok = await postToken({ grant_type: "refresh_token", refresh_token: creds.refreshToken, client_id: clientId, client_secret: clientSecret });
+    creds = { kind: "google", refreshToken: tok.refreshToken ?? creds.refreshToken, accessToken: tok.accessToken, expiresAt: tok.expiresAt };
+    await ctx.saveCredentials(creds);
+    return tok.accessToken;
+  })().finally(() => refreshing = void 0);
+  const token = async () => creds.accessToken && (creds.expiresAt ?? 0) > Date.now() + 6e4 ? creds.accessToken : refresh();
+  async function api(method, path, query = {}, body) {
+    const qs = new URLSearchParams(query).toString();
+    const url = `${API}${path}${qs ? `?${qs}` : ""}`;
+    const send = async (accessToken) => timedFetch(url, {
+      method,
+      headers: { Authorization: `Bearer ${accessToken}`, ...body ? { "Content-Type": "application/json" } : {} },
+      body: body ? JSON.stringify(body) : void 0
+    });
+    let res = await send(await token());
+    if (res.status === 401) res = await send(await refresh());
+    if (res.status === 204 || method === "DELETE" && res.status === 410) return void 0;
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      throw new Error(`Google API ${res.status}: ${err.error?.message ?? res.statusText}`);
+    }
+    return await res.json();
+  }
+  const eventPath = (calendarId, eventId) => `/calendars/${encodeURIComponent(calendarId)}/events${eventId ? `/${encodeURIComponent(eventId)}` : ""}`;
+  const rawOf = (e) => e.raw;
+  const isOrganizer = (e) => {
+    const org = rawOf(e)?.organizer;
+    if (org?.self !== void 0) return org.self;
+    return !e.organizer || e.organizer.email.toLowerCase() === ctx.email.toLowerCase();
+  };
+  const map = (g, calendarId) => mapEvent(g, ctx.accountId, calendarId);
+  return {
+    async listCalendars() {
+      const out = [];
+      let pageToken;
+      do {
+        const page = await api(
+          "GET",
+          "/users/me/calendarList",
+          pageToken ? { pageToken } : {}
+        );
+        for (const c of page.items ?? [])
+          out.push({
+            id: c.id,
+            accountId: ctx.accountId,
+            name: c.summaryOverride ?? c.summary ?? c.id,
+            color: c.backgroundColor ?? "#4285f4",
+            readOnly: c.accessRole !== "owner" && c.accessRole !== "writer"
+          });
+        pageToken = page.nextPageToken;
+      } while (pageToken);
+      return out;
+    },
+    async listEvents(calendarId, range) {
+      const out = [];
+      let pageToken;
+      do {
+        const page = await api("GET", eventPath(calendarId), {
+          singleEvents: "true",
+          timeMin: new Date(range.start).toISOString(),
+          timeMax: new Date(range.end).toISOString(),
+          maxResults: "2500",
+          ...pageToken ? { pageToken } : {}
+        });
+        for (const g of page.items ?? []) if (g.status !== "cancelled") out.push(map(g, calendarId));
+        pageToken = page.nextPageToken;
+      } while (pageToken);
+      return out;
+    },
+    async createEvent(calendarId, input) {
+      const attendees = (input.attendees ?? []).map((email) => ({ email }));
+      const g = await api(
+        "POST",
+        eventPath(calendarId),
+        { sendUpdates: attendees.length ? "all" : "none" },
+        {
+          summary: input.title,
+          start: toGTime(input.start, input.allDay),
+          end: toGTime(input.end, input.allDay),
+          location: input.location,
+          description: input.description,
+          attendees
+        }
+      );
+      return map(g, calendarId);
+    },
+    async updateEvent(event) {
+      const organizer = isOrganizer(event);
+      const body = {
+        summary: event.title,
+        start: toGTime(event.start, event.allDay),
+        end: toGTime(event.end, event.allDay),
+        location: event.location ?? null,
+        description: event.description ?? null
+      };
+      if (organizer) {
+        const prev = new Map((rawOf(event)?.attendees ?? []).map((a) => [a.email.toLowerCase(), a]));
+        body.attendees = event.attendees.map((a) => prev.get(a.email.toLowerCase()) ?? { email: a.email, displayName: a.name });
+      }
+      const g = await api("PATCH", eventPath(event.calendarId, event.id), { sendUpdates: organizer ? "all" : "none" }, body);
+      return map(g, event.calendarId);
+    },
+    async deleteEvent(event, scope = "one") {
+      const q = { sendUpdates: isOrganizer(event) ? "all" : "none" };
+      const series = event.recurringEventId;
+      if (!series || scope === "one") return void await api("DELETE", eventPath(event.calendarId, event.id), q);
+      const cutoff = rawOf(event)?.originalStartTime;
+      if (scope === "following" && cutoff) {
+        const master = await api("GET", eventPath(event.calendarId, series));
+        const first = master.start.dateTime ?? master.start.date;
+        const at3 = cutoff.dateTime ?? cutoff.date;
+        if (Date.parse(at3) > Date.parse(first)) {
+          const recurrence = truncateRecurrence(master.recurrence ?? [], cutoff);
+          return void await api("PATCH", eventPath(event.calendarId, series), q, { recurrence });
+        }
+      }
+      await api("DELETE", eventPath(event.calendarId, series), q);
+    },
+    async respond(event, status) {
+      const attendees = rawOf(event)?.attendees ?? event.attendees.map((a) => ({ email: a.email, displayName: a.name, responseStatus: a.status, self: a.self, organizer: a.organizer }));
+      if (!attendees.some((a) => a.self)) throw new Error("This account is not an attendee of the event");
+      const g = await api(
+        "PATCH",
+        eventPath(event.calendarId, event.id),
+        { sendUpdates: "all" },
+        { attendees: attendees.map((a) => a.self ? { ...a, responseStatus: status } : a) }
+      );
+      return map(g, event.calendarId);
+    }
+  };
+}
+
+// ../../packages/core/src/providers/google/index.ts
+var createGoogleProvider = createGoogleProviderImpl;
+async function googleSignIn(openUrl3) {
+  return runOAuthFlow(openUrl3);
+}
+
+// src/telemetry.ts
+var TELEMETRY_NOTICE = "Anonymous usage stats: 2 events \xB7 opt out: MYSTICALS_TELEMETRY=0";
+var telemetry = () => startTelemetry({ key: true ? "phc_uiJmu94yHJfh6cp5AdjUohhkqzCrysWzKqRZgfdH9iEL" : "", app: "terminal", version, dir: homeDir() });
+
+// src/daemon/crypto.ts
+import { execFileSync, spawnSync } from "child_process";
+import { createCipheriv, createDecipheriv, randomBytes as randomBytes2 } from "crypto";
+import { existsSync as existsSync2, mkdirSync as mkdirSync3, readdirSync, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { dirname, join as join5 } from "path";
+var SERVICE = "mysticals-terminal";
+var ACCOUNT = "master-key";
+var NOT_FOUND = 44;
+var TIMEOUT = 6e4;
+function keychain(service = SERVICE) {
+  return {
+    get() {
+      const r = spawnSync("security", ["find-generic-password", "-s", service, "-a", ACCOUNT, "-w"], { encoding: "utf8", timeout: TIMEOUT });
+      if (r.status === NOT_FOUND) return void 0;
+      if (r.status !== 0) throw new Error(`Keychain read failed: ${r.error?.message ?? r.stderr?.trim()}`);
+      return Buffer.from(r.stdout.trim(), "base64");
+    },
+    set(key3) {
+      const cmd = `add-generic-password -U -s ${service} -a ${ACCOUNT} -w ${key3.toString("base64")}
+`;
+      execFileSync("security", ["-i"], { input: cmd, stdio: ["pipe", "ignore", "pipe"], timeout: TIMEOUT });
+    }
+  };
+}
+var exec = (run, cmd, args, input) => run(cmd, args, { input, encoding: "utf8", timeout: TIMEOUT, windowsHide: true });
+function secretTool(service = SERVICE, run = spawnSync) {
+  const attrs = ["service", service, "account", ACCOUNT];
+  const fail = (what, r) => {
+    throw new Error(
+      `Secret Service ${what} failed (${r.error?.message ?? r.stderr?.trim()}); install libsecret-tools and run a keyring such as gnome-keyring`
+    );
+  };
+  return {
+    get() {
+      const r = exec(run, "secret-tool", ["lookup", ...attrs]);
+      if (r.status === 1 && !r.error && !r.stdout.trim() && !r.stderr.trim()) return void 0;
+      if (r.status !== 0)
+        throw new Error(
+          `Secret Service unavailable (${r.error?.message ?? r.stderr?.trim()}); start or unlock GNOME Keyring or KWallet (and install libsecret-tools)`
+        );
+      return Buffer.from(r.stdout.trim(), "base64");
+    },
+    set(key3) {
+      const r = exec(run, "secret-tool", ["store", "--label=mysticals terminal master key", ...attrs], key3.toString("base64"));
+      if (r.status !== 0) fail("write", r);
+    }
+  };
+}
+var dpapiScript = (op) => `Add-Type -AssemblyName System.Security; $b = [Convert]::FromBase64String([Console]::In.ReadToEnd().Trim()); [Convert]::ToBase64String([Security.Cryptography.ProtectedData]::${op}($b, $null, 'CurrentUser'))`;
+function dpapi(file = join5(homeDir(), "master.key"), run = spawnSync) {
+  const ps = (op, b64) => {
+    const r = exec(run, "powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", dpapiScript(op)], b64);
+    if (r.status !== 0) throw new Error(`DPAPI ${op} failed: ${r.error?.message ?? r.stderr?.trim()}`);
+    return r.stdout.trim();
+  };
+  return {
+    get() {
+      if (!existsSync2(file)) return void 0;
+      return Buffer.from(ps("Unprotect", readFileSync3(file, "utf8").trim()), "base64");
+    },
+    set(key3) {
+      mkdirSync3(dirname(file), { recursive: true, mode: 448 });
+      writeFileSync2(file, ps("Protect", key3.toString("base64")), { mode: 384 });
+    }
+  };
+}
+function platformKeys(platform = process.platform) {
+  if (platform === "darwin") return keychain();
+  if (platform === "linux") return secretTool();
+  if (platform === "win32") return dpapi();
+  return void 0;
+}
+var hasCredentials = (home) => {
+  const dir = join5(home, "accounts");
+  return existsSync2(dir) && readdirSync(dir).some((id2) => existsSync2(join5(dir, id2, "creds.bin")));
+};
+var VERSION = 1;
+var IV = 12;
+var TAG = 16;
+function createCrypto(store = platformKeys(), home) {
+  if (!store) {
+    const unavailable = () => {
+      throw new Error(`Secure storage unavailable: no supported OS key store on ${process.platform}`);
+    };
+    return { encrypt: unavailable, decrypt: unavailable };
+  }
+  const keys = store;
+  let cached2;
+  const key3 = (create) => {
+    if (cached2) return cached2;
+    let k = keys.get();
+    if (!k) {
+      if (!create) throw new Error('Master key missing from the OS key store (service "mysticals-terminal"); re-add your accounts');
+      if (home && hasCredentials(home))
+        throw new Error(
+          `Master key missing from the OS key store but saved credentials exist; unlock the key store, or remove all accounts (or ${join5(home, "accounts")}) to start over`
+        );
+      k = randomBytes2(32);
+      keys.set(k);
+    }
+    if (k.length !== 32) throw new Error("Master key in the OS key store is corrupt");
+    return cached2 = k;
+  };
+  return {
+    encrypt(plain) {
+      const iv = randomBytes2(IV);
+      const c = createCipheriv("aes-256-gcm", key3(true), iv);
+      const body = Buffer.concat([c.update(plain, "utf8"), c.final()]);
+      return Buffer.concat([Buffer.from([VERSION]), iv, c.getAuthTag(), body]);
+    },
+    decrypt(data) {
+      if (data.length < 1 + IV + TAG || data[0] !== VERSION) throw new Error("Unsupported credential format");
+      const d = createDecipheriv("aes-256-gcm", key3(false), data.subarray(1, 1 + IV));
+      d.setAuthTag(data.subarray(1 + IV, 1 + IV + TAG));
+      return Buffer.concat([d.update(data.subarray(1 + IV + TAG)), d.final()]).toString("utf8");
+    }
+  };
+}
+
+// src/daemon/google.ts
+import { execFile } from "child_process";
+var built = {
+  clientId: true ? "199638928915-h7u8l4cbran2rmsalqplc5vlohll8d3l.apps.googleusercontent.com" : "",
+  clientSecret: true ? "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" : ""
+};
+function googleConfig(env = process.env, defaults = built) {
+  const id2 = env.MYSTICALS_GOOGLE_CLIENT_ID;
+  const src = id2 ? { clientId: id2, clientSecret: env.MYSTICALS_GOOGLE_CLIENT_SECRET } : defaults;
+  return { clientId: src.clientId || void 0, clientSecret: src.clientSecret || void 0 };
+}
+function openCommand(url, platform = process.platform) {
+  if (platform === "darwin") return ["open", [url]];
+  if (platform === "win32") return ["rundll32", ["url.dll,FileProtocolHandler", url]];
+  return ["xdg-open", [url]];
+}
+var openUrl = (url) => new Promise((resolve, reject) => {
+  const [file, args] = openCommand(url);
+  execFile(file, args, (e) => e ? reject(e) : resolve());
+});
+
+// src/daemon/notify.ts
+import { execFile as execFile2 } from "child_process";
+var SCRIPT = ["on run argv", "display notification (item 2 of argv) with title (item 1 of argv)", "end run"];
+var TOAST = [
+  "$null = [Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime]",
+  "$x = [Windows.UI.Notifications.ToastNotificationManager]::GetTemplateContent([Windows.UI.Notifications.ToastTemplateType]::ToastText02)",
+  '$t = $x.GetElementsByTagName("text")',
+  "$null = $t.Item(0).AppendChild($x.CreateTextNode($env:MYSTICALS_NOTE_TITLE))",
+  "$null = $t.Item(1).AppendChild($x.CreateTextNode($env:MYSTICALS_NOTE_BODY))",
+  '$id = "{1AC14E77-02E7-4E5D-B744-2EB1AE5198B7}\\WindowsPowerShell\\v1.0\\powershell.exe"',
+  "[Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier($id).Show([Windows.UI.Notifications.ToastNotification]::new($x))"
+].join("; ");
+function bannerCommand(title2, body, platform = process.platform) {
+  if (platform === "darwin") return { file: "osascript", args: [...SCRIPT.flatMap((l) => ["-e", l]), title2, body] };
+  if (platform === "linux") return { file: "notify-send", args: ["--app-name=mysticals", "--", title2, body] };
+  if (platform === "win32")
+    return {
+      file: "powershell.exe",
+      args: ["-NoProfile", "-NonInteractive", "-Command", TOAST],
+      env: { ...process.env, MYSTICALS_NOTE_TITLE: title2, MYSTICALS_NOTE_BODY: body }
+    };
+  return void 0;
+}
+function notify(store, accountId, notes, run = execFile2, platform = process.platform) {
+  if (isMock()) return;
+  const account = store.get(accountId);
+  if (!account) return;
+  const hidden = new Set(store.hiddenCalendars(accountId));
+  const shown = notes.filter((n) => !hidden.has(n.event.calendarId));
+  for (const { title: title2, body } of noteText(shown, account.label)) {
+    const cmd = bannerCommand(title2, body, platform);
+    if (!cmd) return;
+    run(cmd.file, cmd.args, { env: cmd.env, windowsHide: true }, (e) => e && console.error("notification failed", e.message));
+  }
+}
+
+// src/daemon/triggers.ts
+var wakeTriggers = (tickMs = 3e4, slackMs = 6e4) => (fire) => {
+  let last = Date.now();
+  const timer = setInterval(() => {
+    const now = Date.now();
+    if (now - last > tickMs + slackMs) fire();
+    last = now;
+  }, tickMs);
+  timer.unref();
+  return () => clearInterval(timer);
+};
+
+// src/daemon/server.ts
+var alive = (path) => new Promise((resolve) => {
+  const s = createConnection2(path);
+  s.once("connect", () => (s.destroy(), resolve(true)));
+  s.once("error", () => resolve(false));
+});
+function listen(server, path) {
+  return new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(path, () => {
+      server.off("error", reject);
+      resolve();
+    });
+  });
+}
+async function serve(api, path, opts) {
+  const clients = /* @__PURE__ */ new Set();
+  let idle;
+  const armIdle = () => {
+    clearTimeout(idle);
+    idle = setTimeout(opts.onIdle, opts.graceMs ?? 3e3);
+  };
+  const server = createServer2((sock) => {
+    clients.add(sock);
+    clearTimeout(idle);
+    opts.onConnect?.();
+    const send = (msg) => {
+      if (!sock.destroyed) sock.write(encode(msg));
+    };
+    sock.on(
+      "data",
+      lineReader((msg) => {
+        const { id: id2, method, params } = msg ?? {};
+        if (typeof id2 !== "number") return;
+        if (!isMethod(method)) return send({ id: id2, error: `Unknown method: ${String(method)}` });
+        dispatch(api, method, Array.isArray(params) ? params : []).then(
+          (result) => send({ id: id2, result }),
+          (e) => send({ id: id2, error: e instanceof Error ? e.message : String(e) })
+        );
+      })
+    );
+    sock.on("error", () => sock.destroy());
+    sock.on("close", () => {
+      clients.delete(sock);
+      if (clients.size === 0) armIdle();
+    });
+  });
+  try {
+    await listen(server, path);
+  } catch (e) {
+    if (e.code !== "EADDRINUSE" || await alive(path)) throw e;
+    if (process.platform !== "win32") rmSync(path, { force: true });
+    await listen(server, path);
+  }
+  server.on("error", (e) => console.error("daemon socket error", e));
+  if (process.platform !== "win32") chmodSync(path, 384);
+  armIdle();
+  const push = (msg) => {
+    const line = encode(msg);
+    for (const c of clients) if (!c.destroyed) c.write(line);
+  };
+  return {
+    server,
+    push,
+    broadcast: (accountId) => push({ event: "changed", accountId }),
+    clientCount: () => clients.size,
+    close: () => new Promise((resolve) => {
+      clearTimeout(idle);
+      for (const c of clients) c.destroy();
+      server.close(() => resolve());
+    })
+  };
+}
+async function runDaemon() {
+  const home = homeDir();
+  mkdirSync4(home, { recursive: true, mode: 448 });
+  let broadcast = (_accountId) => {
+  };
+  let push = (_msg) => {
+  };
+  let sync;
+  let api;
+  if (isMock()) {
+    api = createMockApi((id2) => broadcast(id2));
+  } else {
+    setClientConfig(googleConfig());
+    const signInBrowser = (url) => (push({ event: "authUrl", url }), openUrl(url).catch(() => {
+    }));
+    const factories = { caldav: createCaldavProvider, google: createGoogleProvider };
+    const store = new AccountStore(home, factories, createCrypto(void 0, home));
+    sync = new SyncEngine(store, (id2) => broadcast(id2), {
+      triggers: wakeTriggers(),
+      onEvents: (id2, notes) => notify(store, id2, notes),
+      onSyncing: (id2) => broadcast(id2)
+      // clients re-read accounts.list for the `syncing` flag
+    });
+    const track = telemetry()?.track;
+    api = createApi(store, sync, {
+      verifyCaldav,
+      googleSignIn: () => googleSignIn(signInBrowser),
+      onChanged: (id2) => broadcast(id2),
+      onAccountAdded: (info) => track?.("account_added", info)
+    });
+  }
+  let daemon;
+  const shutdown = async () => {
+    sync?.stop();
+    await daemon?.close();
+    process.exit(0);
+  };
+  try {
+    daemon = await serve(api, socketPath(home), { onIdle: () => void shutdown(), onConnect: () => void sync?.syncNow() });
+  } catch (e) {
+    if (e.code === "EADDRINUSE") process.exit(0);
+    throw e;
+  }
+  broadcast = daemon.broadcast;
+  push = daemon.push;
+  process.on("SIGTERM", () => void shutdown());
+  process.on("SIGINT", () => void shutdown());
+  sync?.start();
+}
+
+// src/ui/hooks.ts
+import { createContext, useCallback, useContext, useEffect, useState } from "react";
+import { useStdout } from "ink";
+import { addDays as addDays3, addWeeks as addWeeks2, startOfDay as startOfDay2 } from "date-fns";
+
+// ../../packages/core/src/logic/layout.ts
+import {
+  addDays as addDays2,
+  addMonths as addMonths2,
+  addWeeks,
+  format as format3,
+  isSameDay as isSameDay2,
+  parseISO as parseISO4,
+  startOfDay,
+  startOfMonth,
+  startOfWeek
+} from "date-fns";
+var WEEK_STARTS_ON = 1;
+function eventBounds(e) {
+  const start = parseISO4(e.start);
+  let end = parseISO4(e.end);
+  if (end <= start) end = e.allDay ? addDays2(start, 1) : new Date(start.getTime() + 6e4);
+  return { start, end };
+}
+var isPast = (e, now) => eventBounds(e).end.getTime() <= +now;
+function overlapsDay(e, day) {
+  const d0 = startOfDay(day);
+  const { start, end } = eventBounds(e);
+  return start < addDays2(d0, 1) && end > d0;
+}
+function eventsOnDay(events, day) {
+  return events.filter((e) => overlapsDay(e, day)).sort((a, b) => {
+    if (a.allDay !== b.allDay) return a.allDay ? -1 : 1;
+    const x = eventBounds(a), y = eventBounds(b);
+    return x.start.getTime() - y.start.getTime() || y.end.getTime() - x.end.getTime();
+  });
+}
+function packColumns(items, minDur = 0) {
+  const sorted = [...items].sort((a, b) => a.start - b.start || b.end - a.end);
+  const out = [];
+  let cluster = [];
+  let colEnds = [];
+  let clusterEnd = -Infinity;
+  const flush = () => {
+    for (const p of cluster) p.cols = colEnds.length;
+    cluster = [];
+    colEnds = [];
+  };
+  for (const it of sorted) {
+    const end = Math.max(it.end, it.start + minDur);
+    if (it.start >= clusterEnd) flush();
+    let col = colEnds.findIndex((e) => e <= it.start);
+    if (col < 0) col = colEnds.push(end) - 1;
+    else colEnds[col] = end;
+    clusterEnd = Math.max(clusterEnd, end);
+    const p = { ...it, col, cols: 0 };
+    cluster.push(p);
+    out.push(p);
+  }
+  flush();
+  return out;
+}
+var wallMinutes = (d) => d.getHours() * 60 + d.getMinutes();
+function layoutDay(events, day, minDur = 0) {
+  const items = events.filter((e) => !e.allDay && overlapsDay(e, day)).map((e) => {
+    const { start, end } = eventBounds(e);
+    return {
+      item: e,
+      start: isSameDay2(start, day) ? wallMinutes(start) : 0,
+      end: isSameDay2(end, day) ? wallMinutes(end) : 1440
+    };
+  });
+  return packColumns(items, minDur);
+}
+function monthGrid(date) {
+  const first = startOfWeek(startOfMonth(date), { weekStartsOn: WEEK_STARTS_ON });
+  return Array.from({ length: 42 }, (_, i) => addDays2(first, i));
+}
+function viewDays(view, date) {
+  if (view === "month") return monthGrid(date);
+  if (view === "day") return [startOfDay(date)];
+  if (view === "3day") return [0, 1, 2].map((i) => addDays2(startOfDay(date), i));
+  const first = startOfWeek(date, { weekStartsOn: WEEK_STARTS_ON });
+  return Array.from({ length: 7 }, (_, i) => addDays2(first, i));
+}
+function viewRange(view, date) {
+  const days = viewDays(view, date);
+  return { start: days[0].toISOString(), end: addDays2(days[days.length - 1], 1).toISOString() };
+}
+function shiftDate(view, date, dir) {
+  if (view === "day") return addDays2(date, dir);
+  if (view === "3day") return addDays2(date, 3 * dir);
+  if (view === "week") return addWeeks(date, dir);
+  return addMonths2(date, dir);
+}
+function rangeLabel(a, b) {
+  const head = a.getFullYear() !== b.getFullYear() ? "d MMM yyyy" : a.getMonth() !== b.getMonth() ? "d MMM" : "d";
+  return `${format3(a, head)} \u2013 ${format3(b, "d MMM yyyy")}`;
+}
+var ymd = (d) => format3(d, "yyyy-MM-dd");
+
+// ../../packages/core/src/logic/visible.ts
+var key2 = (accountId, calendarId) => `${accountId}/${calendarId}`;
+var visibleEvents = (events, calendars) => {
+  const hidden = new Set(calendars.filter((c) => c.visible === false).map((c) => key2(c.accountId, c.id)));
+  return hidden.size ? events.filter((e) => !hidden.has(key2(e.accountId, e.calendarId))) : events;
+};
+
+// src/ui/hooks.ts
+var ApiContext = createContext(null);
+function useApi() {
+  const api = useContext(ApiContext);
+  if (!api) throw new Error("useApi outside <ApiContext.Provider>");
+  return api;
+}
+var eventKey = (e) => `${e.accountId}/${e.calendarId}/${e.id}`;
+function useLive(load, deps) {
+  const api = useApi();
+  const [state, setState] = useState({});
+  const [bump, setBump] = useState(0);
+  useEffect(() => {
+    let seq = 0;
+    let alive2 = true;
+    const run = () => {
+      const my = ++seq;
+      load(api).then(
+        (data) => alive2 && my === seq && setState({ data }),
+        (e) => alive2 && my === seq && setState((s) => ({ ...s, error: e instanceof Error ? e.message : String(e) }))
+      );
+    };
+    run();
+    const off = api.onChanged(run);
+    return () => {
+      alive2 = false;
+      off();
+    };
+  }, [api, bump, ...deps]);
+  return { ...state, reload: useCallback(() => setBump((b) => b + 1), []) };
+}
+function useDirectory() {
+  const { data, error, reload } = useLive((api) => Promise.all([api.accounts.list(), api.calendars.list()]), []);
+  return { accounts: data?.[0] ?? [], calendars: data?.[1] ?? [], loaded: !!data, error, reload };
+}
+function useEvents(range) {
+  const { data, error, reload } = useLive(
+    async (api) => {
+      const [events, calendars] = await Promise.all([api.events.list(range), api.calendars.list()]);
+      return { events: visibleEvents(events, calendars), for: `${range.start}/${range.end}` };
+    },
+    [range.start, range.end]
+  );
+  return { events: data?.events ?? [], loaded: !!data, loadedFor: data?.for, error, reload };
+}
+var AGENDA_DAYS = 14;
+function navRange({ view, date }) {
+  if (view === "agenda" || view === "2day") {
+    const start = startOfDay2(date);
+    return { start: start.toISOString(), end: addDays3(start, view === "agenda" ? AGENDA_DAYS : 2).toISOString() };
+  }
+  return viewRange(view, date);
+}
+var shiftNav = ({ view, date }, dir) => ({
+  view,
+  date: view === "agenda" ? addWeeks2(date, dir) : view === "2day" ? addDays3(date, 2 * dir) : shiftDate(view, date, dir)
+});
+function useNav(initial = { view: "agenda", date: /* @__PURE__ */ new Date() }) {
+  const [nav, setNav] = useState(initial);
+  return {
+    nav,
+    setView: useCallback((view) => setNav((n) => ({ ...n, view })), []),
+    setDate: useCallback((date) => setNav((n) => ({ ...n, date })), []),
+    shift: useCallback((dir) => setNav((n) => shiftNav(n, dir)), []),
+    today: useCallback(() => setNav((n) => ({ ...n, date: /* @__PURE__ */ new Date() })), [])
+  };
+}
+function useNow(ms = 3e4) {
+  const [now, setNow] = useState(() => /* @__PURE__ */ new Date());
+  useEffect(() => {
+    const t = setInterval(() => setNow(/* @__PURE__ */ new Date()), ms);
+    return () => clearInterval(t);
+  }, [ms]);
+  return now;
+}
+function useTermSize() {
+  const { stdout } = useStdout();
+  const read = () => ({ width: stdout.columns || 80, height: stdout.rows || 24 });
+  const [size, setSize] = useState(read);
+  useEffect(() => {
+    const on = () => setSize(read());
+    stdout.on("resize", on);
+    return () => void stdout.off("resize", on);
+  }, [stdout]);
+  return size;
+}
+
+// src/ui/App.tsx
+import { useEffect as useEffect6, useMemo as useMemo6, useRef as useRef7, useState as useState8 } from "react";
+import { Box as Box11, Text as Text11, useApp, useStdin as useStdin2 } from "ink";
+import { addDays as addDays9, differenceInMinutes as differenceInMinutes3, format as format11, isSameMonth as isSameMonth2, max, set, startOfDay as startOfDay7 } from "date-fns";
+
+// ../../packages/core/src/logic/editor.ts
+import { addDays as addDays4, addHours, format as format4, parseISO as parseISO5, startOfHour } from "date-fns";
+var LOCAL = "yyyy-MM-dd'T'HH:mm";
+var toLocalInput = (iso2) => format4(iso2.length === 10 ? parseISO5(iso2) : new Date(iso2), LOCAL);
+var fromLocalInput = (local) => new Date(local).toISOString();
+var writableCalendars = (calendars, accountId) => calendars.filter((c) => c.accountId === accountId && !c.readOnly);
+var writableAccounts = (accounts, calendars) => accounts.filter((a) => writableCalendars(calendars, a.id).length > 0);
+var soleId = (items) => items.length === 1 ? items[0].id : "";
+var EMAIL = /^[^\s@,;]+@[^\s@,;]+\.[^\s@,;]+$/;
+var splitEmails = (text2) => text2.split(/[\s,;]+/).map((s) => s.trim()).filter(Boolean);
+var isEmail = (s) => EMAIL.test(s);
+function emptyForm(accounts, calendars, prefill = {}, now = /* @__PURE__ */ new Date()) {
+  const accountId = soleId(writableAccounts(accounts, calendars));
+  const start = prefill.start ? toLocalInput(prefill.start) : format4(startOfHour(addHours(now, 1)), LOCAL);
+  let end = prefill.end ? toLocalInput(prefill.end) : format4(addHours(new Date(start), 1), LOCAL);
+  if (prefill.allDay && prefill.end) end = inclusiveEnd(start, end);
+  return {
+    accountId,
+    calendarId: accountId ? soleId(writableCalendars(calendars, accountId)) : "",
+    title: "",
+    start,
+    end,
+    allDay: !!prefill.allDay,
+    location: "",
+    description: "",
+    attendees: []
+  };
+}
+var inclusiveEnd = (startLocal, endLocal) => {
+  const d = format4(addDays4(new Date(endLocal), -1), LOCAL);
+  return d.slice(0, 10) < startLocal.slice(0, 10) ? startLocal : d;
+};
+function formFromEvent(e) {
+  const start = toLocalInput(e.start);
+  const endLocal = toLocalInput(e.end);
+  return {
+    accountId: e.accountId,
+    calendarId: e.calendarId,
+    title: e.title,
+    start,
+    end: e.allDay ? inclusiveEnd(start, endLocal) : endLocal,
+    allDay: e.allDay,
+    location: e.location ?? "",
+    description: e.description ?? "",
+    attendees: e.attendees.filter((a) => !a.self && !a.organizer).map((a) => a.email)
+  };
+}
+function setAllDay(f, allDay) {
+  if (allDay || f.end > f.start) return { ...f, allDay };
+  return { ...f, allDay, end: format4(addHours(new Date(f.start), 1), LOCAL) };
+}
+function moveStart(f, start) {
+  const end = new Date(new Date(f.end).getTime() + new Date(start).getTime() - new Date(f.start).getTime());
+  return { ...f, start, end: format4(end, LOCAL) };
+}
+function times(f) {
+  if (f.allDay) {
+    const start2 = f.start.slice(0, 10);
+    const endIncl = f.end.slice(0, 10);
+    if (endIncl < start2) throw new Error("End date is before start date");
+    return { allDay: true, start: start2, end: format4(addDays4(parseISO5(endIncl), 1), "yyyy-MM-dd") };
+  }
+  const start = fromLocalInput(f.start);
+  const end = fromLocalInput(f.end);
+  if (end <= start) throw new Error("End must be after start");
+  return { allDay: false, start, end };
+}
+function checkEmails(list) {
+  const bad = list.filter((e) => !isEmail(e));
+  if (bad.length) throw new Error(`Invalid email: ${bad.join(", ")}`);
+  return [...new Set(list.map((e) => e.toLowerCase()))];
+}
+function formToInput(f) {
+  if (!f.accountId) throw new Error("Choose an account");
+  if (!f.calendarId) throw new Error("Choose a calendar");
+  const attendees = checkEmails(f.attendees);
+  return {
+    accountId: f.accountId,
+    calendarId: f.calendarId,
+    title: f.title.trim() || "New Event",
+    ...times(f),
+    location: f.location.trim() || void 0,
+    description: f.description.trim() || void 0,
+    ...attendees.length ? { attendees } : {}
+  };
+}
+function applyForm(e, f) {
+  const emails = checkEmails(f.attendees);
+  const keep = e.attendees.filter((a) => a.self || a.organizer);
+  const byEmail = new Map(e.attendees.map((a) => [a.email.toLowerCase(), a]));
+  const invited = emails.filter((m) => !keep.some((a) => a.email.toLowerCase() === m)).map((m) => byEmail.get(m) ?? { email: m, status: "needsAction" });
+  return {
+    ...e,
+    title: f.title.trim() || "New Event",
+    ...times(f),
+    location: f.location.trim() || void 0,
+    description: f.description.trim() || void 0,
+    attendees: [...keep, ...invited]
+  };
+}
+var errorText = (e) => String(e instanceof Error ? e.message : e).replace(/^Error invoking remote method '[^']+': (\w*Error: )?/, "");
+
+// src/ui/mouse.tsx
+import { createContext as createContext2, useCallback as useCallback2, useContext as useContext2, useEffect as useEffect2, useLayoutEffect, useRef } from "react";
+
+// src/ui/theme.ts
+var C = {
+  red: "red",
+  green: "green",
+  yellow: "yellow",
+  blue: "blue",
+  magenta: "magenta",
+  cyan: "cyan",
+  /** Active tab, keycaps, focus. */
+  accent: "magenta",
+  /** Current time: clock labels, now-lines, today. */
+  now: "red",
+  /** Secondary text. */
+  muted: "gray"
+};
+function ansiOf(hex) {
+  const m = /^#?([\da-f]{2})([\da-f]{2})([\da-f]{2})$/i.exec(hex);
+  if (!m) return C.muted;
+  const [r, g, b] = m.slice(1).map((x) => parseInt(x, 16) / 255);
+  const max2 = Math.max(r, g, b);
+  const d = max2 - Math.min(r, g, b);
+  if (d < 0.15) return max2 > 0.8 ? "white" : C.muted;
+  const h = (max2 === r ? ((g - b) / d + 6) % 6 : max2 === g ? (b - r) / d + 2 : (r - g) / d + 4) * 60;
+  if (h < 15 || h >= 345) return "red";
+  if (h < 45) return "yellowBright";
+  if (h < 75) return "yellow";
+  if (h < 165) return "green";
+  if (h < 200) return "cyan";
+  if (h < 250) return "blue";
+  if (h < 300) return "magenta";
+  return "magentaBright";
+}
+
+// src/ui/mouse.tsx
+import { Box, Text, useInput, useStdin } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+var REPORT = /^\[<(\d+);(\d+);(\d+)([Mm])$/;
+var isMouse = (input) => REPORT.test(input);
+function useKeys(handler, options) {
+  const latest = useRef(handler);
+  useLayoutEffect(() => void (latest.current = handler));
+  const stable = useCallback2((input, key3) => {
+    if (!isMouse(input)) latest.current(input, key3);
+  }, []);
+  useInput(stable, options);
+}
+var Regions = createContext2(null);
+function rect(el) {
+  if (!el.yogaNode) return;
+  let x = 0;
+  let y = 0;
+  for (let n = el; n?.yogaNode; n = n.parentNode) {
+    x += n.yogaNode.getComputedLeft();
+    y += n.yogaNode.getComputedTop();
+  }
+  return { x, y, w: el.yogaNode.getComputedWidth(), h: el.yogaNode.getComputedHeight() };
+}
+function Dispatcher({ regions }) {
+  const { isRawModeSupported } = useStdin();
+  useInput((input) => {
+    const m = REPORT.exec(input);
+    if (!m || m[4] !== "M") return;
+    const b = Number(m[1]);
+    const x = Number(m[2]) - 1;
+    const y = Number(m[3]) - 1;
+    const wheel = b & 64 ? (b & 1) === 0 ? -1 : 1 : 0;
+    if (!wheel && (b & ~(4 | 8 | 16)) !== 0) return;
+    let best;
+    for (const r of regions) {
+      const h = r.handlers.current;
+      if (!(wheel ? h.onWheel : h.onClick) || !r.node.current) continue;
+      const box = rect(r.node.current);
+      if (!box || x < box.x || y < box.y || x >= box.x + box.w || y >= box.y + box.h) continue;
+      if (!best || box.w * box.h < best.area) best = { h, area: box.w * box.h };
+    }
+    if (wheel) best?.h.onWheel?.(wheel);
+    else best?.h.onClick?.();
+  }, { isActive: isRawModeSupported === true });
+  return null;
+}
+function MouseProvider({ children }) {
+  const regions = useRef(/* @__PURE__ */ new Set()).current;
+  return /* @__PURE__ */ jsxs(Regions.Provider, { value: regions, children: [
+    /* @__PURE__ */ jsx(Dispatcher, { regions }),
+    children
+  ] });
+}
+function Clickable({ onClick, onWheel, children, ...box }) {
+  const node = useRef(null);
+  const handlers = useRef({});
+  handlers.current = { onClick, onWheel };
+  const regions = useContext2(Regions);
+  useEffect2(() => {
+    if (!regions) return;
+    const r = { node, handlers };
+    regions.add(r);
+    return () => void regions.delete(r);
+  }, [regions]);
+  return /* @__PURE__ */ jsx(Box, { ref: node, ...box, children });
+}
+function Button({ k, label, onPress, color: color2 = C.accent }) {
+  return /* @__PURE__ */ jsx(Clickable, { onClick: onPress, marginRight: 2, flexShrink: 0, children: /* @__PURE__ */ jsxs(Text, { children: [
+    /* @__PURE__ */ jsx(Text, { inverse: true, color: color2, bold: true, children: k }),
+    " ",
+    label
+  ] }) });
+}
+
+// src/ui/views/Agenda.tsx
+import { useMemo, useReducer, useRef as useRef2 } from "react";
+import { Box as Box3, Text as Text3 } from "ink";
+import { addDays as addDays6, differenceInCalendarDays, differenceInMinutes as differenceInMinutes2, format as format7, isSameDay as isSameDay4, startOfDay as startOfDay3 } from "date-fns";
+
+// ../../packages/core/src/logic/details.ts
+import { addDays as addDays5, format as format5, isSameDay as isSameDay3, parseISO as parseISO6 } from "date-fns";
+var same = (a, b) => !!a && !!b && a.trim().toLowerCase() === b.trim().toLowerCase();
+function ownerLine(calendar, label, email) {
+  return { calendar: same(calendar, label) || same(calendar, email) ? void 0 : calendar, label, email: same(email, label) ? void 0 : email };
+}
+function canEdit(e, account, calendar) {
+  if (!account || !calendar || calendar.readOnly) return false;
+  if (e.attendees.length === 0) return true;
+  return same(e.organizer?.email, account.email) || e.attendees.some((a) => a.self && a.organizer);
+}
+var at2 = (iso2, allDay) => (allDay ? parseISO6(iso2) : new Date(iso2)).getTime();
+var pendingInvites = (events, now = /* @__PURE__ */ new Date()) => events.filter((e) => e.myStatus === "needsAction" && at2(e.end, e.allDay) > now.getTime()).sort((a, b) => at2(a.start, a.allDay) - at2(b.start, b.allDay));
+function formatWhen(e) {
+  if (e.allDay) {
+    const s2 = parseISO6(e.start);
+    const last = addDays5(parseISO6(e.end), -1);
+    return last > s2 ? `${format5(s2, "EEE, d MMM")} \u2013 ${format5(last, "EEE, d MMM")} \xB7 all day` : `${format5(s2, "EEE, d MMM")} \xB7 all day`;
+  }
+  const s = new Date(e.start);
+  const t = new Date(e.end);
+  return isSameDay3(s, t) ? `${format5(s, "EEE, d MMM")} \xB7 ${format5(s, "HH:mm")} \u2013 ${format5(t, "HH:mm")}` : `${format5(s, "EEE, d MMM HH:mm")} \u2013 ${format5(t, "EEE, d MMM HH:mm")}`;
+}
+var STATUS_ICON = {
+  accepted: "\u2713",
+  tentative: "?",
+  declined: "\u2715",
+  needsAction: "\u2022"
+};
+var cleanNotes = (s = "") => s.replace(/^@color(hex)?:.*$\n?/gim, "").trim();
+
+// ../../packages/core/src/logic/meeting.ts
+function meetingUrl(location) {
+  return location?.match(/https?:\/\/[^\s<>"]+/i)?.[0].replace(/[.,;:!?)\]}'>]+$/, "");
+}
+
+// ../../packages/core/src/logic/status.ts
+import { differenceInMinutes, format as format6 } from "date-fns";
+function pickNowNext(events, now) {
+  const t = now.getTime();
+  const timed = events.filter((e) => !e.allDay && e.myStatus !== "declined").sort((a, b) => Date.parse(a.start) - Date.parse(b.start));
+  return {
+    current: timed.filter((e) => Date.parse(e.start) <= t && t < Date.parse(e.end)),
+    next: timed.find((e) => Date.parse(e.start) > t)
+  };
+}
+function startsLabel(start, now) {
+  const s = new Date(start);
+  const m = differenceInMinutes(s, now, { roundingMethod: "ceil" });
+  return m <= 60 ? `in ${m}m` : `at ${format6(s, "HH:mm")}`;
+}
+
+// src/ui/screens/EventDetails.tsx
+import { useState as useState2 } from "react";
+import { Box as Box2, Text as Text2 } from "ink";
+import { Fragment, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var REPLY_KEYS = { y: "accepted", n: "declined", m: "tentative" };
+var SCOPE_KEYS = { "1": "one", "2": "following", "3": "all" };
+var STATUS_LABEL = { accepted: "accepted", declined: "declined", tentative: "maybe", needsAction: "not answered" };
+var STATUS_COLOR = { accepted: C.green, declined: C.red, tentative: C.yellow, needsAction: C.muted };
+var openUrl2 = (url) => void openUrl(url).catch(() => {
+});
+function EventDetails({ event: initial, onClose, onEdit }) {
+  const api = useApi();
+  const { accounts, calendars } = useDirectory();
+  const [event, setEvent] = useState2(initial);
+  const [busy, setBusy] = useState2();
+  const [error, setError] = useState2("");
+  const [confirm, setConfirm] = useState2(false);
+  const [showAll, setShowAll] = useState2(false);
+  const manyAttendees = initial.attendees.length > ATTENDEES_SHOWN;
+  const account = accounts.find((a) => a.id === event.accountId);
+  const calendar = calendars.find((c) => c.accountId === event.accountId && c.id === event.calendarId);
+  const editable = canEdit(event, account, calendar);
+  const recurring = !!event.recurringEventId;
+  const url = meetingUrl(event.location);
+  const now = useNow();
+  const run = (label, fn) => {
+    setBusy(label);
+    setError("");
+    fn().then(
+      () => setBusy(void 0),
+      (e) => {
+        setBusy(void 0);
+        setError(errorText(e));
+      }
+    );
+  };
+  const respond = (status) => run("Replying\u2026", async () => setEvent(await api.events.respond(event, status)));
+  const remove = (scope) => run("Deleting\u2026", async () => {
+    await api.events.delete(event, scope);
+    onClose();
+  });
+  useKeys((input, key3) => {
+    if (key3.escape && confirm) return setConfirm(false);
+    if (key3.escape || input === "q") return onClose();
+    if (busy) return;
+    if (confirm) {
+      if (recurring && Object.hasOwn(SCOPE_KEYS, input)) return remove(SCOPE_KEYS[input]);
+      if (!recurring && (input === "y" || key3.return)) return remove("one");
+      if (input === "n") setConfirm(false);
+      return;
+    }
+    if (event.myStatus && Object.hasOwn(REPLY_KEYS, input)) return respond(REPLY_KEYS[input]);
+    if (input === "o" && url) return openUrl2(url);
+    if (input === "e" && editable) return onEdit(event);
+    if (input === "x" && editable) return setConfirm(true);
+    if (input === "a" && manyAttendees) return setShowAll(!showAll);
+  });
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", borderStyle: "round", borderColor: C.muted, paddingX: 1, children: [
+    /* @__PURE__ */ jsx2(EventInfo, { event, account, calendar, now, showAll, onToggleAll: () => setShowAll(!showAll) }),
+    error && /* @__PURE__ */ jsx2(Text2, { color: C.red, children: error }),
+    /* @__PURE__ */ jsx2(Box2, { marginTop: 1, flexWrap: "wrap", children: busy ? /* @__PURE__ */ jsx2(Text2, { color: C.yellow, children: busy }) : confirm && recurring ? /* @__PURE__ */ jsxs2(Fragment, { children: [
+      /* @__PURE__ */ jsx2(Text2, { color: C.red, children: "Delete recurring event: " }),
+      /* @__PURE__ */ jsx2(Button, { k: "1", label: "this event", color: C.red, onPress: () => remove("one") }),
+      /* @__PURE__ */ jsx2(Button, { k: "2", label: "this and following", color: C.red, onPress: () => remove("following") }),
+      /* @__PURE__ */ jsx2(Button, { k: "3", label: "all events", color: C.red, onPress: () => remove("all") }),
+      /* @__PURE__ */ jsx2(Button, { k: "esc", label: "cancel", onPress: () => setConfirm(false) })
+    ] }) : confirm ? /* @__PURE__ */ jsxs2(Fragment, { children: [
+      /* @__PURE__ */ jsx2(Text2, { color: C.red, children: "Delete this event? " }),
+      /* @__PURE__ */ jsx2(Button, { k: "y", label: "yes", color: C.red, onPress: () => remove("one") }),
+      /* @__PURE__ */ jsx2(Button, { k: "n", label: "no", onPress: () => setConfirm(false) })
+    ] }) : /* @__PURE__ */ jsxs2(Fragment, { children: [
+      event.myStatus && /* @__PURE__ */ jsx2(Button, { k: "y", label: "accept", color: C.green, onPress: () => respond("accepted") }),
+      event.myStatus && /* @__PURE__ */ jsx2(Button, { k: "n", label: "decline", color: C.red, onPress: () => respond("declined") }),
+      event.myStatus && /* @__PURE__ */ jsx2(Button, { k: "m", label: "maybe", color: C.yellow, onPress: () => respond("tentative") }),
+      url && /* @__PURE__ */ jsx2(Button, { k: "o", label: "open link", onPress: () => openUrl2(url) }),
+      editable && /* @__PURE__ */ jsx2(Button, { k: "e", label: "edit", onPress: () => onEdit(event) }),
+      editable && /* @__PURE__ */ jsx2(Button, { k: "x", label: "delete", onPress: () => setConfirm(true) }),
+      manyAttendees && /* @__PURE__ */ jsx2(Button, { k: "a", label: showAll ? "fewer attendees" : "all attendees", onPress: () => setShowAll(!showAll) }),
+      /* @__PURE__ */ jsx2(Button, { k: "esc", label: "close", onPress: onClose })
+    ] }) })
+  ] });
+}
+function duration(e) {
+  if (e.allDay) return "";
+  const m = Math.round((Date.parse(e.end) - Date.parse(e.start)) / 6e4);
+  const h = Math.floor(m / 60);
+  return h ? m % 60 ? `${h}h ${m % 60}m` : `${h}h` : `${m}m`;
+}
+function relative(e, now) {
+  if (e.allDay) return "";
+  const { start, end } = eventBounds(e);
+  if (end <= now) return "ended";
+  if (start <= now) return "now";
+  return +start - +now < 24 * 36e5 ? startsLabel(e.start, now) : "";
+}
+var tally = (attendees) => ["accepted", "tentative", "declined", "needsAction"].map((s) => [attendees.filter((a) => a.status === s).length, s]).filter(([n]) => n).map(([n, s]) => `${n} ${STATUS_LABEL[s]}`).join(", ");
+var ATTENDEES_SHOWN = 5;
+function EventInfo({ event, account, calendar, now, showAll, onToggleAll }) {
+  const url = meetingUrl(event.location);
+  const notes = cleanNotes(event.description);
+  const owner = ownerLine(calendar?.name ?? "Calendar", account?.label ?? event.accountId, account?.email);
+  const when2 = [duration(event), relative(event, now)].filter(Boolean).join(" \xB7 ");
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx2(Text2, { bold: true, children: event.title || "Untitled" }),
+    /* @__PURE__ */ jsxs2(Text2, { children: [
+      formatWhen(event),
+      when2 && /* @__PURE__ */ jsxs2(Text2, { color: relative(event, now) === "now" ? C.green : C.muted, children: [
+        " (",
+        when2,
+        ")"
+      ] }),
+      event.recurringEventId && /* @__PURE__ */ jsx2(Text2, { color: C.muted, children: " \u21BB repeats" })
+    ] }),
+    /* @__PURE__ */ jsxs2(Text2, { color: C.muted, children: [
+      /* @__PURE__ */ jsx2(Text2, { color: ansiOf(calendar?.color ?? account?.color ?? ""), children: "\u25CF" }),
+      " ",
+      owner.calendar && `${owner.calendar} in `,
+      /* @__PURE__ */ jsx2(Text2, { bold: true, children: owner.label }),
+      owner.email && ` \xB7 ${owner.email}`,
+      calendar?.readOnly && " \xB7 read-only"
+    ] }),
+    event.location && /* @__PURE__ */ jsxs2(Text2, { children: [
+      "Location: ",
+      event.location
+    ] }),
+    url && url !== event.location && /* @__PURE__ */ jsx2(Clickable, { onClick: () => openUrl2(url), children: /* @__PURE__ */ jsx2(Text2, { color: C.cyan, underline: true, children: url }) }),
+    event.organizer && /* @__PURE__ */ jsxs2(Text2, { children: [
+      "Organizer: ",
+      event.organizer.name ? `${event.organizer.name} <${event.organizer.email}>` : event.organizer.email
+    ] }),
+    event.attendees.length > 0 && /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsxs2(Text2, { color: C.muted, children: [
+        "Attendees (",
+        event.attendees.length,
+        "): ",
+        tally(event.attendees)
+      ] }),
+      (showAll ? event.attendees : event.attendees.slice(0, ATTENDEES_SHOWN)).map((a) => /* @__PURE__ */ jsxs2(Text2, { wrap: "truncate", children: [
+        /* @__PURE__ */ jsx2(Text2, { color: STATUS_COLOR[a.status], children: STATUS_ICON[a.status] }),
+        " ",
+        a.name ?? a.email,
+        a.name && /* @__PURE__ */ jsxs2(Text2, { color: C.muted, children: [
+          " ",
+          a.email
+        ] }),
+        a.self ? " (you)" : "",
+        a.organizer ? " (organizer)" : ""
+      ] }, a.email)),
+      event.attendees.length > ATTENDEES_SHOWN && /* @__PURE__ */ jsx2(Clickable, { onClick: onToggleAll, children: /* @__PURE__ */ jsx2(Text2, { color: C.accent, children: showAll ? "\u25B4 show less" : `\u25BE show ${event.attendees.length - ATTENDEES_SHOWN} more` }) })
+    ] }),
+    notes && /* @__PURE__ */ jsx2(Box2, { marginTop: 1, children: /* @__PURE__ */ jsx2(Text2, { children: notes }) }),
+    event.myStatus && /* @__PURE__ */ jsx2(Box2, { marginTop: 1, children: /* @__PURE__ */ jsxs2(Text2, { children: [
+      "Your reply: ",
+      /* @__PURE__ */ jsxs2(Text2, { bold: true, color: STATUS_COLOR[event.myStatus], children: [
+        STATUS_ICON[event.myStatus],
+        " ",
+        STATUS_LABEL[event.myStatus]
+      ] }),
+      /* @__PURE__ */ jsxs2(Text2, { color: C.muted, children: [
+        " as ",
+        account?.email ?? event.accountId
+      ] })
+    ] }) })
+  ] });
+}
+
+// src/ui/views/Agenda.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function useOwnerOf() {
+  const { accounts, calendars } = useDirectory();
+  return useMemo(() => {
+    const cal = new Map(calendars.map((c) => [`${c.accountId}/${c.id}`, c]));
+    const acc = new Map(accounts.map((a) => [a.id, a]));
+    return {
+      colorOf: (e) => ansiOf(cal.get(`${e.accountId}/${e.calendarId}`)?.color ?? acc.get(e.accountId)?.color ?? ""),
+      accountOf: (e) => acc.get(e.accountId)?.label ?? e.accountId,
+      calendarOf: (e) => cal.get(`${e.accountId}/${e.calendarId}`)?.name ?? ""
+    };
+  }, [accounts, calendars]);
+}
+var useColorOf = () => useOwnerOf().colorOf;
+var clickEvent = (e, selected, { onSelect, onOpen }) => () => selected ? onOpen(e) : onSelect(e);
+function useScroll(first, last, height, total) {
+  const off = useRef2(void 0);
+  const followed = useRef2("");
+  const [, rerender] = useReducer((n) => n + 1, 0);
+  const clamp = (o2) => Math.max(0, Math.min(o2, total - height));
+  let o = off.current ?? first;
+  if (followed.current !== `${first}/${last}`) {
+    followed.current = `${first}/${last}`;
+    if (last >= o + height) o = last - height + 1;
+    if (first < o) o = first;
+  }
+  o = clamp(o);
+  off.current = o;
+  const scrollBy = (rows) => {
+    const next = clamp((off.current ?? 0) + rows);
+    if (next === off.current) return;
+    off.current = next;
+    rerender();
+  };
+  return [o, scrollBy];
+}
+var WHEEL_STEP = 3;
+var rsvpMark = (e) => e.myStatus && e.myStatus !== "accepted" ? `${STATUS_ICON[e.myStatus]} ` : "";
+function place(location = "") {
+  const url = meetingUrl(location);
+  const rest = (url ? location.replace(url, "") : location).replace(/^[\s/|,·-]+|[\s/|,·-]+$/g, "");
+  return rest || (url ? "video call" : "");
+}
+var span = (m) => {
+  const h = Math.floor(m / 60);
+  return h ? m % 60 ? `${h}h ${m % 60}m` : `${h}h` : `${m}m`;
+};
+function busyMinutes(list, day) {
+  const from = +startOfDay3(day);
+  const to = +addDays6(day, 1);
+  const iv = list.filter((e) => !e.allDay && e.myStatus !== "declined").map((e) => [Math.max(+eventBounds(e).start, from), Math.min(+eventBounds(e).end, to)]).sort((a, b) => a[0] - b[0]);
+  let total = 0;
+  let end = -Infinity;
+  for (const [s, t] of iv) {
+    if (t <= end) continue;
+    total += t - Math.max(s, end);
+    end = t;
+  }
+  return Math.round(total / 6e4);
+}
+var overlaps = (e, list) => !e.allDay && e.myStatus !== "declined" && list.some(
+  (o) => o !== e && !o.allDay && o.myStatus !== "declined" && eventBounds(o).start < eventBounds(e).end && eventBounds(e).start < eventBounds(o).end
+);
+function relativeDay(day, now) {
+  const d = differenceInCalendarDays(day, now);
+  return d === 0 ? "today" : d === 1 ? "tomorrow" : d === -1 ? "yesterday" : d > 0 ? `in ${d} days` : `${-d} days ago`;
+}
+function fitParts(parts, w) {
+  const out = [];
+  let left = w;
+  for (const p of parts) {
+    if (left <= 0) break;
+    if (p.text.length <= left) {
+      out.push(p);
+      left -= p.text.length;
+    } else {
+      out.push({ ...p, text: p.text.slice(0, Math.max(left - 1, 0)) + "\u2026" });
+      left = 0;
+    }
+  }
+  if (left > 0) out.push({ text: " ".repeat(left) });
+  return out;
+}
+function Line({ parts, inverse, muted }) {
+  return /* @__PURE__ */ jsx3(Text3, { inverse, color: inverse ? C.accent : void 0, children: parts.map((p, i) => /* @__PURE__ */ jsx3(Text3, { color: inverse ? C.accent : muted ? C.muted : p.color, bold: p.bold || inverse, strikethrough: p.strike, children: p.text }, i)) });
+}
+var TIME_W = 9;
+var linesOf = (r) => "e" in r ? 2 : 1;
+function Agenda({ events, date, now, selectedKey, width, height, onSelect, onOpen, onPickDay }) {
+  const { colorOf, accountOf, calendarOf } = useOwnerOf();
+  const rows = useMemo(() => {
+    const out = [];
+    for (let i = 0; i < AGENDA_DAYS; i++) {
+      const day = addDays6(startOfDay3(date), i);
+      const list = eventsOnDay(events, day);
+      if (!list.length) {
+        const last = out.at(-1);
+        if (last && "free" in last) last.free[1] = day;
+        else out.push({ free: [day, day] });
+        continue;
+      }
+      const items = list.map((e) => ({ day, e }));
+      if (isSameDay4(day, now)) {
+        const next = list.findIndex((e) => eventBounds(e).start > now);
+        items.splice(next < 0 ? items.length : next, 0, { day, nowLine: true });
+      }
+      out.push({ day });
+      items.forEach((it, j) => {
+        if (j > 0 && "e" in it && "e" in items[j - 1]) out.push({ day, divider: true });
+        out.push(it);
+      });
+    }
+    return out;
+  }, [events, date, now]);
+  const offsets = [];
+  let total = 0;
+  for (const r of rows) {
+    offsets.push(total);
+    total += linesOf(r);
+  }
+  const sel = rows.findIndex((r) => "e" in r && eventKey(r.e) === selectedKey);
+  const first = sel > 0 && !("e" in rows[sel - 1]) && !("nowLine" in rows[sel - 1]) && !("divider" in rows[sel - 1]) ? offsets[sel - 1] : offsets[Math.max(sel, 0)] ?? 0;
+  const [top, scrollBy] = useScroll(first, sel >= 0 ? offsets[sel] + 1 : 0, height, total);
+  if (!events.length) return /* @__PURE__ */ jsxs3(Text3, { color: C.muted, children: [
+    "No events in the next ",
+    AGENDA_DAYS,
+    " days"
+  ] });
+  const upNext = events.filter((e) => !e.allDay && eventBounds(e).start > now && isSameDay4(eventBounds(e).start, now)).sort((a, b) => +eventBounds(a).start - +eventBounds(b).start)[0];
+  const lines = [];
+  rows.forEach((r, i) => {
+    const key3 = "free" in r ? `free${ymd(r.free[0])}` : "e" in r ? `${ymd(r.day)}/${eventKey(r.e)}` : "nowLine" in r ? `${ymd(r.day)}/now` : "divider" in r ? `${ymd(r.day)}/d${i}` : ymd(r.day);
+    if ("free" in r) {
+      const [a, b] = r.free;
+      const label = isSameDay4(a, b) ? format7(a, "EEE d MMM") : `${format7(a, "EEE d MMM")} \u2013 ${format7(b, "EEE d MMM")}`;
+      lines.push(
+        /* @__PURE__ */ jsx3(Box3, { width, height: 1, overflow: "hidden", children: /* @__PURE__ */ jsx3(Text3, { color: C.muted, wrap: "truncate", children: ` ${label}  free` }) }, key3)
+      );
+      return;
+    }
+    if ("divider" in r) {
+      lines.push(
+        /* @__PURE__ */ jsx3(Box3, { width, height: 1, overflow: "hidden", children: /* @__PURE__ */ jsx3(Text3, { color: C.muted, dimColor: true, children: " ".repeat(TIME_W) + "\u2500".repeat(Math.max(width - TIME_W - 1, 0)) }) }, key3)
+      );
+      return;
+    }
+    if ("nowLine" in r) {
+      lines.push(
+        /* @__PURE__ */ jsx3(Box3, { width, height: 1, overflow: "hidden", children: /* @__PURE__ */ jsx3(Text3, { color: C.now, bold: true, wrap: "truncate", children: `  ${format7(now, "HH:mm")} ${"\u2500".repeat(width)}` }) }, key3)
+      );
+      return;
+    }
+    if (!("e" in r)) {
+      const today = isSameDay4(r.day, now);
+      const list = eventsOnDay(events, r.day);
+      const busy = busyMinutes(list, r.day);
+      const left = ` ${format7(r.day, "EEE d MMM")}  `;
+      const rel = relativeDay(r.day, now);
+      const right = ` ${list.length} ${list.length === 1 ? "event" : "events"}${busy ? ` \xB7 ${span(busy)} busy` : ""} `;
+      const rule = "\u2500".repeat(Math.max(width - left.length - rel.length - right.length - 1, 1));
+      lines.push(
+        /* @__PURE__ */ jsx3(Clickable, { width, height: 1, onClick: onPickDay && (() => onPickDay(r.day)), children: /* @__PURE__ */ jsxs3(Text3, { wrap: "truncate", children: [
+          /* @__PURE__ */ jsx3(Text3, { bold: true, color: today ? C.now : C.accent, children: left }),
+          /* @__PURE__ */ jsx3(Text3, { color: today ? C.now : C.muted, children: rel }),
+          /* @__PURE__ */ jsx3(Text3, { color: C.muted, children: ` ${rule}${right}` })
+        ] }) }, key3)
+      );
+      return;
+    }
+    const e = r.e;
+    const selected = i === sel;
+    const { start, end } = eventBounds(e);
+    const running = !e.allDay && start <= now && now < end;
+    const past = isPast(e, now) || e.myStatus === "declined";
+    const clockOf = (d, edge) => isSameDay4(d, r.day) ? format7(d, "HH:mm") : +d === +addDays6(r.day, 1) ? "24:00" : edge;
+    const badges = [];
+    if (running) badges.push({ text: `  \u25CF now \xB7 ends in ${span(Math.max(differenceInMinutes2(end, now, { roundingMethod: "ceil" }), 1))}`, color: C.green, bold: true });
+    else if (e === upNext) badges.push({ text: `  ${startsLabel(e.start, now)}`, color: C.yellow });
+    if (e.myStatus === "needsAction") badges.push({ text: "  RSVP", color: C.yellow, bold: true });
+    if (e.myStatus === "tentative") badges.push({ text: "  maybe", color: C.yellow });
+    if (e.myStatus === "declined") badges.push({ text: "  declined", color: C.muted });
+    const dur = e.allDay ? "" : duration(e);
+    const titleW = Math.max(width - TIME_W - 2 - (dur ? dur.length + 2 : 0), 1);
+    const row1 = [
+      { text: (e.allDay ? " all day" : `  ${clockOf(start, "\u2026")}`).padEnd(TIME_W), color: running ? C.green : void 0, bold: running },
+      { text: "\u258C ", color: colorOf(e) },
+      ...fitParts([{ text: `${rsvpMark(e)}${e.title || "(no title)"}`, bold: true, strike: e.myStatus === "declined" }, ...badges], titleW),
+      ...dur ? [{ text: `  ${dur}`, color: C.muted }] : []
+    ];
+    const who = [accountOf(e), calendarOf(e)].filter((x, j, a) => x && a.indexOf(x) === j).join(" \xB7 ");
+    const details = [{ text: who, color: C.muted }];
+    if (e.recurringEventId) details.push({ text: "  \u21BB repeats", color: C.muted });
+    if (overlaps(e, eventsOnDay(events, r.day))) details.push({ text: "  \u26A0 overlaps", color: C.yellow });
+    const where = place(e.location);
+    if (where) details.push({ text: `  ${where}`, color: C.cyan });
+    if (e.attendees.length) details.push({ text: `  ${e.attendees.length} ${e.attendees.length === 1 ? "person" : "people"}`, color: C.muted });
+    const row2 = [
+      { text: `  ${e.allDay ? "" : clockOf(end, "\u2026")}`.padEnd(TIME_W), color: C.muted },
+      { text: "\u258C ", color: colorOf(e) },
+      ...fitParts(details, width - TIME_W - 2)
+    ];
+    const onClick = clickEvent(e, selected, { onSelect, onOpen });
+    lines.push(
+      /* @__PURE__ */ jsx3(Clickable, { width, height: 1, onClick, children: /* @__PURE__ */ jsx3(Line, { parts: row1, inverse: selected, muted: past }) }, key3),
+      /* @__PURE__ */ jsx3(Clickable, { width, height: 1, onClick, children: /* @__PURE__ */ jsx3(Line, { parts: row2, inverse: selected, muted: past }) }, `${key3}/2`)
+    );
+  });
+  return /* @__PURE__ */ jsx3(Clickable, { flexDirection: "column", width, onWheel: (dir) => scrollBy(dir * WHEEL_STEP), children: lines.slice(top, top + height) });
+}
+
+// src/ui/views/Day.tsx
+import { useMemo as useMemo3 } from "react";
+import { addDays as addDays7, startOfDay as startOfDay5 } from "date-fns";
+
+// src/ui/views/TimeGrid.tsx
+import { useMemo as useMemo2 } from "react";
+import { Box as Box5, Text as Text5 } from "ink";
+import { format as format9, isSameDay as isSameDay6 } from "date-fns";
+
+// src/ui/views/Month.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import { format as format8, isSameDay as isSameDay5, isSameMonth, startOfDay as startOfDay4 } from "date-fns";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function fit(items, rows, selected) {
+  if (items.length <= rows) return { shown: items, more: 0 };
+  if (rows === 1 && selected >= 0) return { shown: [items[selected]], more: 0 };
+  const n = Math.max(rows - 1, 0);
+  const from = Math.max(0, Math.min(selected - n + 1, items.length - n));
+  return { shown: items.slice(from, from + n), more: items.length - n };
+}
+function EventLine({ e, day, now, selected, time, onSelect, onOpen }) {
+  const { start, end } = eventBounds(e);
+  const prefix = !time || e.allDay ? "" : start < startOfDay4(day) ? "\u2026     " : `${format8(start, "HH:mm")} `;
+  const live = !e.allDay && start <= now && now < end;
+  return /* @__PURE__ */ jsx4(Clickable, { height: 1, onClick: clickEvent(e, selected, { onSelect, onOpen }), children: /* @__PURE__ */ jsxs4(
+    Text4,
+    {
+      wrap: "truncate-end",
+      inverse: selected,
+      bold: selected,
+      italic: e.myStatus === "needsAction",
+      strikethrough: e.myStatus === "declined",
+      color: selected ? C.accent : isPast(e, now) || e.myStatus === "declined" ? C.muted : live ? C.green : e.allDay ? C.yellow : void 0,
+      children: [
+        prefix,
+        e.title
+      ]
+    }
+  ) });
+}
+function Month({ events, date, now, cursor, selectedKey, width, height, onSelect, onOpen, onPickDay }) {
+  const days = monthGrid(date);
+  const colWidth = Math.max(Math.floor(width / 7), 4);
+  const cellHeight = Math.max(Math.floor((height - 1) / 6), 1);
+  const weeks = [0, 1, 2, 3, 4, 5].map((w) => days.slice(w * 7, w * 7 + 7));
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx4(Box4, { children: weeks[0].map((d) => /* @__PURE__ */ jsx4(Box4, { width: colWidth, children: /* @__PURE__ */ jsx4(Text4, { color: C.accent, bold: true, children: format8(d, "EEE") }) }, d.getDay())) }),
+    weeks.map((week) => /* @__PURE__ */ jsx4(Box4, { height: cellHeight, children: week.map((day) => {
+      const items = eventsOnDay(events, day);
+      const { shown, more } = fit(items, cellHeight - 1, items.findIndex((e) => eventKey(e) === selectedKey));
+      const today = isSameDay5(day, now);
+      const here = !!cursor && isSameDay5(day, cursor);
+      return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", width: colWidth, paddingRight: 1, overflow: "hidden", children: [
+        /* @__PURE__ */ jsx4(Clickable, { height: 1, onClick: onPickDay && (() => onPickDay(day)), children: /* @__PURE__ */ jsxs4(
+          Text4,
+          {
+            bold: today || here,
+            inverse: here,
+            color: today ? C.now : here ? C.accent : isSameMonth(day, date) ? void 0 : C.muted,
+            children: [
+              here ? ` ${format8(day, "d")} ` : format8(day, "d"),
+              cellHeight === 1 && items.length > 0 && /* @__PURE__ */ jsxs4(Text4, { color: C.muted, children: [
+                " \xB7",
+                items.length
+              ] })
+            ]
+          }
+        ) }),
+        shown.map((e) => /* @__PURE__ */ jsx4(EventLine, { e, day, now, selected: eventKey(e) === selectedKey, time: false, onSelect, onOpen }, eventKey(e))),
+        more > 0 && cellHeight > 1 && /* @__PURE__ */ jsxs4(Text4, { color: C.muted, children: [
+          "+",
+          more
+        ] })
+      ] }, day.toISOString());
+    }) }, week[0].toISOString()))
+  ] });
+}
+
+// src/ui/views/TimeGrid.tsx
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+var GUTTER = 6;
+var ALL_DAY_MAX = 3;
+var COMPACT_BELOW = 18;
+function slots(events, day) {
+  return packColumns(
+    layoutDay(events, day).map((p) => {
+      const start = Math.floor(p.start / 60) * 60;
+      return { item: p, start, end: Math.max(Math.ceil(p.end / 60) * 60, start + 60) };
+    })
+  );
+}
+function TimeGrid({ days, events, now, cursor, selectedKey, width, height, onSelect, onOpen, onPickDay }) {
+  const colorOf = useColorOf();
+  const cols = useMemo2(
+    () => days.map((day) => {
+      const on = eventsOnDay(events, day);
+      return { day, count: on.length, allDay: on.filter((e) => e.allDay), placed: slots(events, day) };
+    }),
+    [events, days]
+  );
+  const colW = Math.max(Math.floor((width - GUTTER) / days.length) - 1, 3);
+  const allRows = Math.min(Math.max(0, ...cols.map((c) => c.allDay.length)), ALL_DAY_MAX);
+  const gridH = Math.max(height - 2 - allRows, 1);
+  const sel = cols.flatMap((c) => c.placed).find((p) => eventKey(p.item.item) === selectedKey);
+  const today = days.some((d) => isSameDay6(d, now));
+  const focus = sel ? sel.start / 60 : today ? now.getHours() : 8;
+  const [top, scrollBy] = useScroll(sel ? focus : Math.max(focus - 1, 0), focus, gridH, 24);
+  const bar = /* @__PURE__ */ jsx5(Text5, { color: C.muted, children: "\u2502" });
+  const row = (key3, gutter, cells) => /* @__PURE__ */ jsxs5(Box5, { width, height: 1, overflow: "hidden", children: [
+    gutter,
+    cols.map((c) => /* @__PURE__ */ jsxs5(Box5, { flexShrink: 0, children: [
+      bar,
+      /* @__PURE__ */ jsx5(Box5, { width: colW, flexShrink: 0, overflow: "hidden", children: cells(c) })
+    ] }, c.day.getTime()))
+  ] }, key3);
+  const gutterText = (text2) => /* @__PURE__ */ jsx5(Box5, { width: GUTTER, flexShrink: 0, children: /* @__PURE__ */ jsx5(Text5, { color: C.muted, children: text2 }) });
+  const hourCells = (placed, day, h, nowLine) => {
+    const out = [];
+    let pos = 0;
+    const gap = (to) => {
+      if (to <= pos) return;
+      out.push(
+        /* @__PURE__ */ jsx5(Box5, { width: to - pos, flexShrink: 0, children: /* @__PURE__ */ jsx5(Text5, { color: C.now, children: (nowLine ? "\u2500" : " ").repeat(to - pos) }) }, `g${pos}`)
+      );
+      pos = to;
+    };
+    const segs = placed.filter((p) => p.start < (h + 1) * 60 && p.end > h * 60).sort((a, b) => a.col - b.col);
+    for (const p of segs) {
+      const e = p.item.item;
+      const x = Math.floor(p.col * colW / p.cols);
+      const w = Math.floor((p.col + 1) * colW / p.cols) - x;
+      if (w < 1) continue;
+      gap(x);
+      const k = eventKey(e);
+      const selected = k === selectedKey;
+      const first = p.start / 60;
+      const { start, end } = eventBounds(e);
+      const from = isSameDay6(start, day) ? format9(start, "HH:mm") : "\u2026";
+      const title2 = `${rsvpMark(e)}${e.title || "(no title)"}`;
+      const where = place(e.location);
+      const lines = colW < COMPACT_BELOW ? [p.end - p.start > 60 || start.getMinutes() === 0 ? title2 : `:${format9(start, "mm")} ${title2}`, `${from}\u2013${isSameDay6(end, day) ? format9(end, "HH:mm") : "\u2026"}`, where] : [`${from} ${title2}`, [where, duration(e)].filter(Boolean).join(" \xB7 ")];
+      const text2 = lines[h - first] ?? "";
+      const inner = p.col < p.cols - 1 && w > 1 ? w - 1 : w;
+      const past = isPast(e, now) || e.myStatus === "declined";
+      out.push(
+        /* @__PURE__ */ jsx5(Clickable, { width: w, flexShrink: 0, onClick: clickEvent(e, selected, { onSelect, onOpen }), children: /* @__PURE__ */ jsx5(
+          Text5,
+          {
+            inverse: true,
+            color: selected ? C.accent : past ? C.muted : colorOf(e),
+            bold: selected || h === first,
+            italic: e.myStatus === "needsAction",
+            strikethrough: e.myStatus === "declined",
+            children: (" " + text2).slice(0, inner).padEnd(inner)
+          }
+        ) }, k)
+      );
+      pos = x + w;
+    }
+    gap(colW);
+    return out;
+  };
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", width, children: [
+    row("head", gutterText(""), (c) => {
+      const isToday = isSameDay6(c.day, now);
+      const here = !!cursor && isSameDay6(c.day, cursor) && days.length > 1;
+      return /* @__PURE__ */ jsx5(Clickable, { height: 1, width: colW, onClick: onPickDay && (() => onPickDay(c.day)), children: /* @__PURE__ */ jsxs5(Text5, { wrap: "truncate", children: [
+        /* @__PURE__ */ jsx5(Text5, { bold: true, inverse: here, color: isToday ? C.now : C.accent, children: ` ${format9(c.day, "EEE d")} ` }),
+        c.count > 0 && /* @__PURE__ */ jsxs5(Text5, { color: C.muted, children: [
+          "\xB7",
+          c.count
+        ] })
+      ] }) });
+    }),
+    Array.from(
+      { length: allRows },
+      (_, i) => row(`all${i}`, gutterText(i === 0 ? "all" : ""), (c) => {
+        const { shown, more } = fit(c.allDay, allRows, c.allDay.findIndex((e2) => eventKey(e2) === selectedKey));
+        const e = shown[i];
+        if (!e) return i === shown.length && more > 0 ? /* @__PURE__ */ jsxs5(Text5, { color: C.muted, children: [
+          " +",
+          more,
+          " more"
+        ] }) : null;
+        const selected = eventKey(e) === selectedKey;
+        return /* @__PURE__ */ jsx5(Clickable, { height: 1, width: colW, onClick: clickEvent(e, selected, { onSelect, onOpen }), children: /* @__PURE__ */ jsxs5(Text5, { wrap: "truncate", inverse: selected, color: selected ? C.accent : C.yellow, bold: selected, children: [
+          /* @__PURE__ */ jsx5(Text5, { color: selected ? C.accent : colorOf(e), children: " \u25CF" }),
+          " ",
+          rsvpMark(e),
+          e.title || "(no title)"
+        ] }) });
+      })
+    ),
+    /* @__PURE__ */ jsx5(Box5, { width, height: 1, overflow: "hidden", children: /* @__PURE__ */ jsx5(Text5, { color: C.muted, children: "\u2500".repeat(GUTTER) + ("\u253C" + "\u2500".repeat(colW)).repeat(days.length) }) }),
+    /* @__PURE__ */ jsx5(Clickable, { flexDirection: "column", width, onWheel: (dir) => scrollBy(dir), children: Array.from({ length: Math.min(gridH, 24) }, (_, i) => {
+      const h = top + i;
+      const current = today && h === now.getHours();
+      const gutter = /* @__PURE__ */ jsx5(Box5, { width: GUTTER, flexShrink: 0, children: /* @__PURE__ */ jsx5(Text5, { color: current ? C.now : C.muted, bold: current, children: current ? format9(now, "HH:mm") : `${String(h).padStart(2, "0")}:00` }) });
+      return row(`h${h}`, gutter, (c) => hourCells(c.placed, c.day, h, current && isSameDay6(c.day, now)));
+    }) })
+  ] });
+}
+
+// src/ui/views/Day.tsx
+import { jsx as jsx6 } from "react/jsx-runtime";
+function useDays(date, n) {
+  const t = startOfDay5(date).getTime();
+  return useMemo3(() => Array.from({ length: n }, (_, i) => addDays7(t, i)), [t, n]);
+}
+var Day = (p) => /* @__PURE__ */ jsx6(TimeGrid, { ...p, days: useDays(p.date, 1) });
+var TwoDay = (p) => /* @__PURE__ */ jsx6(TimeGrid, { ...p, days: useDays(p.date, 2) });
+
+// src/ui/views/Week.tsx
+import { useMemo as useMemo4 } from "react";
+import { jsx as jsx7 } from "react/jsx-runtime";
+function Week(p) {
+  const t = p.date.getTime();
+  const days = useMemo4(() => viewDays("week", new Date(t)), [t]);
+  return /* @__PURE__ */ jsx7(TimeGrid, { ...p, days });
+}
+
+// src/ui/screens/EventEditor.tsx
+import { useEffect as useEffect3, useRef as useRef3, useState as useState3 } from "react";
+import { Box as Box6, Text as Text6 } from "ink";
+import { format as format10, isValid, parse as parse2 } from "date-fns";
+import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
+var LABELS = {
+  title: "Title",
+  account: "Account",
+  calendar: "Calendar",
+  allDay: "All-day",
+  startDate: "Start date",
+  startTime: "Start time",
+  endDate: "End date",
+  endTime: "End time",
+  location: "Location",
+  description: "Notes",
+  attendees: "Invitees"
+};
+var HINTS = {
+  startDate: "YYYY-MM-DD",
+  startTime: "HH:mm",
+  endDate: "YYYY-MM-DD",
+  endTime: "HH:mm",
+  attendees: "a@x.com, b@y.com",
+  title: "New Event"
+};
+function toLocal(date, time) {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(date) || !/^\d{2}:\d{2}$/.test(time)) return;
+  const d = parse2(`${date}T${time}`, "yyyy-MM-dd'T'HH:mm", /* @__PURE__ */ new Date());
+  return isValid(d) && format10(d, "yyyy-MM-dd'T'HH:mm") === `${date}T${time}` ? `${date}T${time}` : void 0;
+}
+var timeTexts = (f) => ({
+  startDate: f.start.slice(0, 10),
+  startTime: f.start.slice(11),
+  endDate: f.end.slice(0, 10),
+  endTime: f.end.slice(11)
+});
+var textsFrom = (f) => ({
+  title: f.title,
+  location: f.location,
+  description: f.description,
+  attendees: f.attendees.join(", "),
+  ...timeTexts(f)
+});
+var fieldsFor = (form, editing) => [
+  "title",
+  ...editing ? [] : ["account", "calendar"],
+  "allDay",
+  "startDate",
+  ...form.allDay ? [] : ["startTime"],
+  "endDate",
+  ...form.allDay ? [] : ["endTime"],
+  "location",
+  "description",
+  "attendees"
+];
+function EventEditor({ event, initialStart, onClose }) {
+  const api = useApi();
+  const { accounts, calendars, loaded } = useDirectory();
+  const [state, setState] = useState3();
+  const latest = useRef3(void 0);
+  const update = (patch) => {
+    if (!latest.current) return;
+    latest.current = { ...latest.current, ...patch };
+    setState(latest.current);
+  };
+  const [error, setError] = useState3("");
+  const [saving, setSaving] = useState3(false);
+  const busy = useRef3(false);
+  const alive2 = useRef3(true);
+  useEffect3(() => () => void (alive2.current = false), []);
+  useEffect3(() => {
+    if (latest.current || !loaded) return;
+    const form2 = event ? formFromEvent(event) : emptyForm(accounts, calendars, {}, initialStart);
+    latest.current = { form: form2, texts: textsFrom(form2), focus: 0 };
+    setState(latest.current);
+  }, [loaded]);
+  const choices = writableAccounts(accounts, calendars);
+  const save = async () => {
+    if (!latest.current || busy.current) return;
+    const { form: form2, texts: texts2 } = latest.current;
+    setError("");
+    const start = toLocal(texts2.startDate, form2.allDay ? form2.start.slice(11) : texts2.startTime);
+    const end = toLocal(texts2.endDate, form2.allDay ? form2.end.slice(11) : texts2.endTime);
+    if (!start) return setError(`Invalid start (use YYYY-MM-DD${form2.allDay ? "" : " and HH:mm"})`);
+    if (!end) return setError(`Invalid end (use YYYY-MM-DD${form2.allDay ? "" : " and HH:mm"})`);
+    const f = {
+      ...form2,
+      title: texts2.title,
+      location: texts2.location,
+      description: texts2.description,
+      attendees: splitEmails(texts2.attendees),
+      start,
+      end
+    };
+    let request;
+    try {
+      request = event ? api.events.update(applyForm(event, f)) : api.events.create(formToInput(f));
+    } catch (e) {
+      return setError(errorText(e));
+    }
+    busy.current = true;
+    setSaving(true);
+    try {
+      await request;
+      if (alive2.current) onClose();
+    } catch (e) {
+      busy.current = false;
+      if (alive2.current) {
+        setError(errorText(e));
+        setSaving(false);
+      }
+    }
+  };
+  const cycle2 = (items, id2, dir) => {
+    if (!items.length) return "";
+    const i = items.findIndex((x) => x.id === id2);
+    return items[i < 0 ? dir > 0 ? 0 : items.length - 1 : (i + dir + items.length) % items.length].id;
+  };
+  const pick = ({ form: form2, texts: texts2 }, field, dir) => {
+    if (field === "account") {
+      const accountId = cycle2(choices, form2.accountId, dir);
+      update({ form: { ...form2, accountId, calendarId: soleId(writableCalendars(calendars, accountId)) } });
+    } else if (field === "calendar") {
+      update({ form: { ...form2, calendarId: cycle2(writableCalendars(calendars, form2.accountId), form2.calendarId, dir) } });
+    } else if (field === "allDay") {
+      const f = setAllDay(form2, !form2.allDay);
+      update({ form: f, texts: { ...texts2, ...timeTexts(f) } });
+    }
+  };
+  const edit = ({ form: form2, texts: texts2 }, field, value2) => {
+    const next = { ...texts2, [field]: value2 };
+    if (field === "startDate" || field === "startTime") {
+      const start = toLocal(next.startDate, form2.allDay ? form2.start.slice(11) : next.startTime);
+      if (start) {
+        const f = moveStart(form2, start);
+        return update({ form: f, texts: { ...next, endDate: f.end.slice(0, 10), endTime: f.end.slice(11) } });
+      }
+    } else if (field === "endDate" || field === "endTime") {
+      const end = toLocal(next.endDate, form2.allDay ? form2.end.slice(11) : next.endTime);
+      if (end) return update({ form: { ...form2, end }, texts: next });
+    }
+    update({ texts: next });
+  };
+  const clickField = (f) => {
+    const s = latest.current;
+    if (!s || busy.current) return;
+    const i = fieldsFor(s.form, !!event).indexOf(f);
+    if (i < 0) return;
+    if (i === s.focus && (f === "account" || f === "calendar" || f === "allDay")) return pick(s, f, 1);
+    update({ focus: i });
+  };
+  useKeys((input, key3) => {
+    if (key3.escape) return onClose();
+    const s = latest.current;
+    if (!s || busy.current) return;
+    if (key3.ctrl && input === "s") return void save();
+    const fields2 = fieldsFor(s.form, !!event);
+    const i = Math.min(s.focus, fields2.length - 1);
+    const field = fields2[i];
+    const move = (dir) => update({ focus: (i + dir + fields2.length) % fields2.length });
+    if (key3.tab) return move(key3.shift ? -1 : 1);
+    if (key3.downArrow) return move(1);
+    if (key3.upArrow) return move(-1);
+    if (key3.return) return i === fields2.length - 1 ? void save() : move(1);
+    if (field === "account" || field === "calendar" || field === "allDay") {
+      if (key3.leftArrow) pick(s, field, -1);
+      else if (key3.rightArrow || input === " ") pick(s, field, 1);
+      return;
+    }
+    if (key3.backspace || key3.delete) return edit(s, field, s.texts[field].slice(0, -1));
+    if (key3.ctrl || key3.meta || !input) return;
+    const printable = input.replace(/[\u0000-\u001f\u007f]/g, "");
+    if (printable) edit(s, field, s.texts[field] + printable);
+  });
+  if (!state) return /* @__PURE__ */ jsx8(Text6, { color: C.muted, children: "Loading\u2026" });
+  const { form, texts } = state;
+  const fields = fieldsFor(form, !!event);
+  const current = fields[Math.min(state.focus, fields.length - 1)];
+  const account = accounts.find((a) => a.id === form.accountId);
+  const calendar = calendars.find((c) => c.accountId === form.accountId && c.id === form.calendarId);
+  const value = (f) => {
+    switch (f) {
+      case "account":
+        if (event) return { text: account ? `${account.label} \xB7 ${account.email}` : form.accountId };
+        return account ? { text: `${account.label} \xB7 ${account.email}` } : { text: "\u2039 choose account \u203A", dim: true };
+      case "calendar":
+        if (event) return { text: calendar?.name ?? form.calendarId };
+        if (!form.accountId) return { text: "choose an account first", dim: true };
+        return calendar ? { text: calendar.name } : { text: "\u2039 choose calendar \u203A", dim: true };
+      case "allDay":
+        return { text: form.allDay ? "[x]" : "[ ]" };
+      default:
+        return texts[f] ? { text: texts[f] } : { text: HINTS[f] ?? "", dim: true };
+    }
+  };
+  const rows = event ? ["title", "account", "calendar", ...fields.slice(1)] : fields;
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", borderStyle: "round", borderColor: C.muted, paddingX: 1, children: [
+    /* @__PURE__ */ jsx8(Text6, { bold: true, children: event ? "Edit event" : "New event" }),
+    rows.map((f) => {
+      const on = f === current;
+      const v = value(f);
+      const picker = !event && (f === "account" || f === "calendar");
+      return /* @__PURE__ */ jsxs6(Clickable, { onClick: () => clickField(f), children: [
+        /* @__PURE__ */ jsxs6(Text6, { color: on ? C.cyan : void 0, children: [
+          on ? "\u203A " : "  ",
+          LABELS[f].padEnd(11)
+        ] }),
+        /* @__PURE__ */ jsx8(Text6, { color: v.dim ? C.muted : void 0, inverse: on && !v.dim && !picker, children: v.text }),
+        on && picker && /* @__PURE__ */ jsx8(Text6, { color: C.muted, children: "  \u2190/\u2192 or click" })
+      ] }, f);
+    }),
+    /* @__PURE__ */ jsx8(Box6, { marginTop: 1, children: /* @__PURE__ */ jsx8(Text6, { color: C.muted, children: account ? `Organizer: ${account.email}` : "Choose which account this event belongs to." }) }),
+    error && /* @__PURE__ */ jsx8(Text6, { color: C.red, children: error }),
+    saving ? /* @__PURE__ */ jsx8(Text6, { color: C.yellow, children: "Saving\u2026" }) : /* @__PURE__ */ jsxs6(Box6, { flexWrap: "wrap", children: [
+      /* @__PURE__ */ jsx8(Box6, { marginRight: 2, children: /* @__PURE__ */ jsx8(Text6, { color: C.muted, children: "tab/\u2191\u2193 move \xB7 \u2190/\u2192/space pick" }) }),
+      /* @__PURE__ */ jsx8(Button, { k: "ctrl+s", label: "save", color: C.green, onPress: () => void save() }),
+      /* @__PURE__ */ jsx8(Button, { k: "esc", label: "cancel", onPress: onClose })
+    ] })
+  ] });
+}
+
+// src/ui/screens/Accounts.tsx
+import { useEffect as useEffect4, useRef as useRef5, useState as useState5 } from "react";
+import { Box as Box8, Text as Text8, useStdout as useStdout2 } from "ink";
+
+// src/ui/screens/AddCaldav.tsx
+import { useRef as useRef4, useState as useState4 } from "react";
+import { Box as Box7, Text as Text7 } from "ink";
+import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
+var PALETTE2 = ["#bd93f9", "#50fa7b", "#8be9fd", "#ff79c6", "#ffb86c", "#f1fa8c"];
+var PRESETS2 = [
+  { id: "privateemail", name: "Namecheap Private Email", url: "https://dav.privateemail.com/dav.php/" },
+  { id: "icloud", name: "iCloud", url: "https://caldav.icloud.com/" },
+  { id: "fastmail", name: "Fastmail", url: "https://caldav.fastmail.com/" },
+  { id: "custom", name: "Custom", url: "" }
+];
+var PERSONAL_DOMAINS = /^(gmail|googlemail|icloud|me|mac|outlook|hotmail|live|yahoo|fastmail|proton|protonmail|aol|gmx|ukr)\./i;
+function suggestLabel(email) {
+  const domain = email.split("@")[1] ?? "";
+  if (!domain) return "";
+  return PERSONAL_DOMAINS.test(domain) ? "Personal" : "Work";
+}
+function editText(value, input, key3) {
+  if (key3.backspace || key3.delete) return value.slice(0, -1);
+  if (key3.ctrl || key3.meta || key3.escape || key3.return || key3.tab || key3.upArrow || key3.downArrow) return void 0;
+  if (key3.leftArrow || key3.rightArrow) return void 0;
+  return input ? value + input : void 0;
+}
+var cycle = (list, cur, dir) => list[(list.indexOf(cur) + dir + list.length) % list.length];
+var FIELDS = ["provider", "serverUrl", "username", "password", "label", "color"];
+var NAMES = {
+  provider: "Provider",
+  serverUrl: "Server URL",
+  username: "Email",
+  password: "App password",
+  label: "Label",
+  color: "Colour"
+};
+function useKeyState(init) {
+  const ref = useRef4(init);
+  const [, bump] = useState4(0);
+  return [
+    () => ref.current,
+    (next) => {
+      ref.current = next;
+      bump((n) => n + 1);
+    }
+  ];
+}
+var INITIAL = {
+  field: "provider",
+  preset: PRESETS2[0].id,
+  serverUrl: PRESETS2[0].url,
+  username: "",
+  password: "",
+  label: "",
+  labelTouched: false,
+  color: PALETTE2[0],
+  busy: false,
+  error: ""
+};
+function AddCaldav({ onBack, onDone }) {
+  const api = useApi();
+  const [get, set2] = useKeyState(INITIAL);
+  const patch = (p) => set2({ ...get(), ...p });
+  const submit = () => {
+    const v2 = get();
+    const input = {
+      serverUrl: v2.serverUrl.trim(),
+      username: v2.username.trim(),
+      password: v2.password,
+      label: v2.label.trim() || v2.username.trim(),
+      color: v2.color
+    };
+    if (!input.serverUrl || !input.username || !input.password)
+      return patch({ error: "Server URL, email and app password are required" });
+    patch({ busy: true, error: "" });
+    api.accounts.addCaldav(input).then(onDone, (e) => patch({ error: errorText(e), busy: false }));
+  };
+  const clickField = (f) => {
+    const v2 = get();
+    if (v2.busy) return;
+    if (f !== v2.field) return patch({ field: f });
+    if (f === "color") patch({ color: cycle(PALETTE2, v2.color, 1) });
+    if (f === "provider") {
+      const p = cycle(PRESETS2, PRESETS2.find((x) => x.id === v2.preset), 1);
+      patch({ preset: p.id, serverUrl: p.url });
+    }
+  };
+  useKeys((input, key3) => {
+    const v2 = get();
+    if (v2.busy) return;
+    if (key3.escape) return onBack();
+    if (key3.return) return submit();
+    if (key3.tab || key3.downArrow) return patch({ field: cycle(FIELDS, v2.field, key3.shift ? -1 : 1) });
+    if (key3.upArrow) return patch({ field: cycle(FIELDS, v2.field, -1) });
+    const { field } = v2;
+    if (field === "provider" || field === "color") {
+      const dir = key3.leftArrow || input === "h" ? -1 : key3.rightArrow || input === "l" || input === " " ? 1 : 0;
+      if (!dir) return;
+      if (field === "color") return patch({ color: cycle(PALETTE2, v2.color, dir) });
+      const p = cycle(PRESETS2, PRESETS2.find((x) => x.id === v2.preset), dir);
+      return patch({ preset: p.id, serverUrl: p.url });
+    }
+    const next = editText(v2[field], input, key3);
+    if (next === void 0) return;
+    patch({
+      [field]: next,
+      ...field === "username" && !v2.labelTouched && { label: suggestLabel(next) },
+      ...field === "serverUrl" && { preset: "custom" },
+      ...field === "label" && { labelTouched: true }
+    });
+  });
+  const v = get();
+  const shown = (f) => {
+    if (f === "provider") return `\u2039 ${PRESETS2.find((p) => p.id === v.preset).name} \u203A`;
+    if (f === "color") return /* @__PURE__ */ jsxs7(Text7, { color: ansiOf(v.color), children: [
+      "\u2039 \u25CF ",
+      v.color,
+      " \u203A"
+    ] });
+    if (f === "password") return "\u2022".repeat(v.password.length);
+    return v[f] || /* @__PURE__ */ jsx9(Text7, { color: C.muted, children: f === "serverUrl" ? "https://caldav.example.com/" : f === "username" ? "you@company.com" : "Work" });
+  };
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx9(Text7, { bold: true, children: "Add CalDAV account" }),
+    /* @__PURE__ */ jsx9(Text7, { color: C.muted, children: "Each account is isolated: events and invitations are only sent from the account they belong to." }),
+    FIELDS.map((f) => /* @__PURE__ */ jsx9(Clickable, { onClick: () => clickField(f), children: /* @__PURE__ */ jsxs7(Text7, { children: [
+      /* @__PURE__ */ jsx9(Text7, { color: f === v.field ? C.cyan : void 0, children: `${f === v.field ? "\u203A" : " "} ${NAMES[f].padEnd(13)}` }),
+      shown(f),
+      f === v.field && f !== "provider" && f !== "color" ? /* @__PURE__ */ jsx9(Text7, { color: C.cyan, children: "\u258F" }) : null
+    ] }) }, f)),
+    /* @__PURE__ */ jsx9(Text7, { color: C.muted, children: "Check your provider's docs if connection fails." }),
+    v.busy && /* @__PURE__ */ jsx9(Text7, { color: C.yellow, children: "Verifying\u2026" }),
+    v.error && /* @__PURE__ */ jsx9(Text7, { color: C.red, children: v.error }),
+    /* @__PURE__ */ jsxs7(Box7, { flexWrap: "wrap", children: [
+      /* @__PURE__ */ jsx9(Box7, { marginRight: 2, children: /* @__PURE__ */ jsx9(Text7, { color: C.muted, children: "tab/\u2191\u2193 field  \u2190\u2192 change provider/colour" }) }),
+      /* @__PURE__ */ jsx9(Button, { k: "enter", label: "add account", color: C.green, onPress: () => !get().busy && submit() }),
+      /* @__PURE__ */ jsx9(Button, { k: "esc", label: "back", onPress: () => !get().busy && onBack() })
+    ] })
+  ] });
+}
+
+// src/ui/screens/Accounts.tsx
+import { Fragment as Fragment2, jsx as jsx10, jsxs as jsxs8 } from "react/jsx-runtime";
+function Accounts({ onClose }) {
+  const api = useApi();
+  const { accounts, calendars, loaded, error: loadError } = useDirectory();
+  const [getCursor, setCursor] = useKeyState(0);
+  const [getMode, setMode] = useKeyState({ kind: "list" });
+  const mode = getMode();
+  const [message, setMessage] = useState5();
+  const [authUrl, setAuthUrl] = useState5();
+  useEffect4(() => api.onAuthUrl(setAuthUrl), [api]);
+  const { stdout } = useStdout2();
+  const copyAuthUrl = () => {
+    if (!authUrl) return;
+    stdout.write(`\x1B]52;c;${Buffer.from(authUrl).toString("base64")}\x07`);
+    say("Sign-in link sent to the clipboard (needs a terminal with OSC 52 clipboard support)");
+  };
+  const googleSession = useRef5(0);
+  const alive2 = useRef5(true);
+  useEffect4(() => () => void (alive2.current = false), []);
+  const rows = accounts.flatMap((account) => [
+    { account },
+    ...calendars.filter((c) => c.accountId === account.id).map((calendar) => ({ account, calendar }))
+  ]);
+  const current = () => {
+    const idx2 = Math.min(getCursor(), Math.max(rows.length - 1, 0));
+    return { idx: idx2, row: rows[idx2] };
+  };
+  const { idx } = current();
+  const say = (text2, error = false) => {
+    if (alive2.current) setMessage({ text: text2, error });
+  };
+  const run = (pending, done, fn) => {
+    say(pending);
+    fn().then(
+      () => say(done),
+      (e) => say(errorText(e), true)
+    );
+  };
+  const addGoogle = () => {
+    const s = ++googleSession.current;
+    setMode({ kind: "google" });
+    setMessage(void 0);
+    setAuthUrl(void 0);
+    api.accounts.addGoogle().then(
+      (a) => s === googleSession.current && (setMode({ kind: "list" }), say(`Added ${a.label}`)),
+      (e) => s === googleSession.current && (setMode({ kind: "list" }), say(errorText(e), true))
+    );
+  };
+  const move = (dir) => setCursor(Math.max(Math.min(current().idx + dir, rows.length - 1), 0));
+  const act = (input) => {
+    const { row: row2 } = current();
+    if (input === "R") return run("Syncing all\u2026", "Synced all", () => api.sync.now());
+    if (input === "g") return addGoogle();
+    if (input === "a") return setMode({ kind: "caldav" });
+    if (!row2) return;
+    const a = row2.account;
+    const c = row2.calendar;
+    if (input === " " && c) {
+      return run(
+        "Saving\u2026",
+        `${c.name} ${c.visible === false ? "shown" : "hidden"}`,
+        () => api.calendars.setVisible(a.id, c.id, c.visible === false)
+      );
+    }
+    if (input === "r") return run(`Syncing ${a.label}\u2026`, `Synced ${a.label}`, () => api.sync.now(a.id));
+    if (input === "e") return setMode({ kind: "rename", account: a, value: a.label });
+    if (input === "c") {
+      const color2 = cycle(PALETTE2, a.color, 1);
+      return run("Saving\u2026", `${a.label} colour changed`, () => api.accounts.update(a.id, { color: color2 }));
+    }
+    if (input === "x") return setMode({ kind: "confirm", account: a });
+  };
+  const confirmRemove = (yes) => {
+    const mode2 = getMode();
+    if (mode2.kind !== "confirm") return;
+    if (yes) run(`Removing ${mode2.account.label}\u2026`, `Removed ${mode2.account.label}`, () => api.accounts.remove(mode2.account.id));
+    setMode({ kind: "list" });
+  };
+  const listing = () => getMode().kind === "list";
+  const click = (i) => {
+    if (!listing()) return;
+    if (i === current().idx && rows[i]?.calendar) return act(" ");
+    setCursor(i);
+  };
+  useKeys(
+    (input, key3) => {
+      const mode2 = getMode();
+      if (mode2.kind === "google") {
+        if (key3.escape || input === "q") {
+          googleSession.current++;
+          setMode({ kind: "list" });
+        }
+        if (input === "c") copyAuthUrl();
+        return;
+      }
+      if (mode2.kind === "confirm") return confirmRemove(input.toLowerCase() === "y");
+      if (mode2.kind === "rename") {
+        if (key3.escape) return setMode({ kind: "list" });
+        if (key3.return) {
+          const next = mode2.value.trim();
+          if (next && next !== mode2.account.label) {
+            const id2 = mode2.account.id;
+            run("Saving\u2026", `Renamed to ${next}`, () => api.accounts.update(id2, { label: next }));
+          }
+          return setMode({ kind: "list" });
+        }
+        const value = editText(mode2.value, input, key3);
+        if (value !== void 0) setMode({ ...mode2, value });
+        return;
+      }
+      if (key3.escape || input === "q") return onClose();
+      if (input === "j" || key3.downArrow) return move(1);
+      if (input === "k" || key3.upArrow) return move(-1);
+      act(input);
+    },
+    { isActive: mode.kind !== "caldav" }
+  );
+  if (mode.kind === "caldav") {
+    return /* @__PURE__ */ jsx10(Box8, { flexDirection: "column", borderStyle: "round", borderColor: C.muted, paddingX: 1, children: /* @__PURE__ */ jsx10(
+      AddCaldav,
+      {
+        onBack: () => setMode({ kind: "list" }),
+        onDone: () => {
+          setMode({ kind: "list" });
+          say("Account added");
+        }
+      }
+    ) });
+  }
+  const button = (k, label, input = k) => /* @__PURE__ */ jsx10(Button, { k, label, onPress: () => listing() && act(input) });
+  const row = rows[idx];
+  return /* @__PURE__ */ jsxs8(Clickable, { flexDirection: "column", borderStyle: "round", borderColor: C.muted, paddingX: 1, onWheel: (dir) => listing() && move(dir), children: [
+    /* @__PURE__ */ jsx10(Text8, { bold: true, children: "Accounts & calendars" }),
+    /* @__PURE__ */ jsx10(Text8, { color: C.muted, children: "Accounts sync automatically every 2 minutes." }),
+    loaded && !accounts.length && /* @__PURE__ */ jsx10(Text8, { color: C.muted, children: "No accounts yet. Press g (Google) or a (CalDAV) to add one." }),
+    rows.map((r, i) => {
+      const sel = i === idx;
+      const mark = /* @__PURE__ */ jsx10(Text8, { color: C.cyan, children: sel ? "\u203A " : "  " });
+      if (r.calendar) {
+        const c = r.calendar;
+        return /* @__PURE__ */ jsx10(Clickable, { onClick: () => click(i), children: /* @__PURE__ */ jsxs8(Text8, { inverse: sel, children: [
+          mark,
+          "    ",
+          c.visible === false ? "[ ]" : "[x]",
+          " ",
+          /* @__PURE__ */ jsx10(Text8, { color: ansiOf(c.color), children: "\u25CF" }),
+          " ",
+          c.name,
+          c.readOnly && /* @__PURE__ */ jsx10(Text8, { color: C.muted, children: " (read-only)" })
+        ] }) }, `${c.accountId}/${c.id}`);
+      }
+      const a = r.account;
+      const renaming = mode.kind === "rename" && mode.account.id === a.id;
+      return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsx10(Clickable, { onClick: () => click(i), children: /* @__PURE__ */ jsxs8(Text8, { inverse: sel && !renaming, children: [
+          mark,
+          /* @__PURE__ */ jsx10(Text8, { color: ansiOf(a.color), children: "\u25CF" }),
+          " ",
+          renaming ? /* @__PURE__ */ jsxs8(Text8, { color: C.cyan, children: [
+            mode.value,
+            "\u258F"
+          ] }) : /* @__PURE__ */ jsx10(Text8, { bold: true, children: a.label }),
+          " ",
+          /* @__PURE__ */ jsxs8(Text8, { color: C.muted, children: [
+            a.email,
+            " \xB7 ",
+            a.kind === "google" ? "Google" : "CalDAV"
+          ] })
+        ] }) }),
+        a.error && /* @__PURE__ */ jsx10(Text8, { color: C.red, children: `    Last sync failed: ${a.error}` })
+      ] }, a.id);
+    }),
+    mode.kind === "confirm" && /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsxs8(Text8, { color: C.red, bold: true, children: [
+        "Remove ",
+        mode.account.label,
+        " (",
+        mode.account.email,
+        ")? [y/N]"
+      ] }),
+      /* @__PURE__ */ jsxs8(Text8, { children: [
+        "Removes local data and credentials for ",
+        mode.account.email,
+        ". Nothing is deleted on the server."
+      ] }),
+      /* @__PURE__ */ jsxs8(Box8, { children: [
+        /* @__PURE__ */ jsx10(Button, { k: "y", label: "remove", color: C.red, onPress: () => confirmRemove(true) }),
+        /* @__PURE__ */ jsx10(Button, { k: "n", label: "keep", onPress: () => confirmRemove(false) })
+      ] })
+    ] }),
+    mode.kind === "google" && /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx10(Text8, { color: C.yellow, children: "Opening browser \u2014 finish sign-in there\u2026 (esc to stop waiting)" }),
+      authUrl && /* @__PURE__ */ jsxs8(Fragment2, { children: [
+        /* @__PURE__ */ jsx10(Text8, { color: C.muted, children: "No browser? Open this link yourself (c copies it):" }),
+        /* @__PURE__ */ jsx10(Text8, { children: authUrl }),
+        /* @__PURE__ */ jsx10(Text8, { color: C.muted, children: `Over SSH, forward its port first: ssh -L ${loopbackPort(authUrl)}:127.0.0.1:${loopbackPort(authUrl)} <host>` })
+      ] })
+    ] }),
+    mode.kind === "rename" && /* @__PURE__ */ jsx10(Text8, { color: C.muted, children: "enter save  esc cancel" }),
+    loadError && /* @__PURE__ */ jsx10(Text8, { color: C.red, children: loadError }),
+    message && /* @__PURE__ */ jsx10(Text8, { color: message.error ? C.red : C.green, children: message.text }),
+    mode.kind === "list" && /* @__PURE__ */ jsxs8(Box8, { marginTop: 1, flexWrap: "wrap", children: [
+      /* @__PURE__ */ jsx10(Box8, { marginRight: 2, children: /* @__PURE__ */ jsx10(Text8, { color: C.muted, children: "j/k move" }) }),
+      row?.calendar && button("space", "show/hide", " "),
+      row && button("r", "sync"),
+      button("R", "sync all"),
+      row && button("e", "rename"),
+      row && button("c", "colour"),
+      row && button("x", "remove"),
+      button("g", "add Google"),
+      button("a", "add CalDAV"),
+      /* @__PURE__ */ jsx10(Button, { k: "esc", label: "close", onPress: onClose })
+    ] })
+  ] });
+}
+var loopbackPort = (authUrl) => {
+  try {
+    return new URL(new URL(authUrl).searchParams.get("redirect_uri") ?? "").port;
+  } catch {
+    return "?";
+  }
+};
+
+// src/ui/screens/Invites.tsx
+import { useMemo as useMemo5, useRef as useRef6, useState as useState6 } from "react";
+import { Box as Box9, Text as Text9 } from "ink";
+import { addDays as addDays8, startOfDay as startOfDay6 } from "date-fns";
+import { jsx as jsx11, jsxs as jsxs9 } from "react/jsx-runtime";
+var INVITE_DAYS = 60;
+function useUpcoming(now) {
+  const day = startOfDay6(now).getTime();
+  const range = useMemo5(() => ({ start: new Date(day).toISOString(), end: addDays8(day, INVITE_DAYS).toISOString() }), [day]);
+  return useEvents(range);
+}
+var REPLY = { y: "accepted", n: "declined", m: "tentative" };
+function Invites({ onClose }) {
+  const api = useApi();
+  const [now] = useState6(() => /* @__PURE__ */ new Date());
+  const { events, loaded } = useUpcoming(now);
+  const invites = useMemo5(() => pendingInvites(events, now), [events, now]);
+  const { accounts } = useDirectory();
+  const [idx, setIdx] = useState6(0);
+  const [rows, setRows] = useState6({});
+  const busy = useRef6(/* @__PURE__ */ new Set());
+  const [error, setError] = useState6("");
+  const sel = Math.min(idx, Math.max(invites.length - 1, 0));
+  const reply = (e, status) => {
+    const k = eventKey(e);
+    if (busy.current.has(k)) return;
+    busy.current.add(k);
+    setError("");
+    setRows((r) => ({ ...r, [k]: "sending\u2026" }));
+    api.events.respond(e, status).then(
+      () => setRows((r) => ({ ...r, [k]: "sent" })),
+      (err) => {
+        busy.current.delete(k);
+        setRows(({ [k]: _, ...r }) => r);
+        setError(errorText(err));
+      }
+    );
+  };
+  const move = (dir) => setIdx(Math.max(Math.min(sel + dir, invites.length - 1), 0));
+  const replySelected = (status) => void (invites[sel] && reply(invites[sel], status));
+  useKeys((input, key3) => {
+    if (key3.escape || input === "q") return onClose();
+    if (input === "j" || key3.downArrow) return move(1);
+    if (input === "k" || key3.upArrow) return move(-1);
+    if (Object.hasOwn(REPLY, input)) replySelected(REPLY[input]);
+  });
+  return /* @__PURE__ */ jsxs9(Clickable, { flexDirection: "column", borderStyle: "round", borderColor: C.muted, paddingX: 1, onWheel: move, children: [
+    /* @__PURE__ */ jsx11(Text9, { bold: true, children: "Invitations" }),
+    !loaded ? /* @__PURE__ */ jsx11(Text9, { color: C.muted, children: "Loading\u2026" }) : invites.length === 0 ? /* @__PURE__ */ jsx11(Text9, { color: C.muted, children: "No pending invites" }) : invites.map((e, i) => {
+      const a = accounts.find((x) => x.id === e.accountId);
+      const o = ownerLine(void 0, a?.label ?? e.accountId, a?.email);
+      return /* @__PURE__ */ jsx11(Clickable, { height: 1, onClick: () => setIdx(i), children: /* @__PURE__ */ jsxs9(Text9, { wrap: "truncate", inverse: i === sel, children: [
+        i === sel ? "\u25B8 " : "  ",
+        /* @__PURE__ */ jsx11(Text9, { bold: true, children: e.title || "Untitled" }),
+        " ",
+        /* @__PURE__ */ jsx11(Text9, { color: C.muted, children: formatWhen(e) }),
+        " ",
+        /* @__PURE__ */ jsx11(Text9, { color: ansiOf(a?.color ?? ""), children: "\u25CF" }),
+        " ",
+        o.label,
+        o.email ? ` \xB7 ${o.email}` : "",
+        rows[eventKey(e)] ? /* @__PURE__ */ jsxs9(Text9, { color: C.yellow, children: [
+          " ",
+          rows[eventKey(e)]
+        ] }) : null
+      ] }) }, eventKey(e));
+    }),
+    error ? /* @__PURE__ */ jsx11(Text9, { color: C.red, children: error }) : null,
+    /* @__PURE__ */ jsxs9(Box9, { marginTop: 1, flexWrap: "wrap", children: [
+      invites.length > 0 && /* @__PURE__ */ jsx11(Button, { k: "y", label: "accept", color: C.green, onPress: () => replySelected("accepted") }),
+      invites.length > 0 && /* @__PURE__ */ jsx11(Button, { k: "n", label: "decline", color: C.red, onPress: () => replySelected("declined") }),
+      invites.length > 0 && /* @__PURE__ */ jsx11(Button, { k: "m", label: "maybe", color: C.yellow, onPress: () => replySelected("tentative") }),
+      /* @__PURE__ */ jsx11(Box9, { marginRight: 2, children: /* @__PURE__ */ jsx11(Text9, { color: C.muted, children: "j/k move" }) }),
+      /* @__PURE__ */ jsx11(Button, { k: "esc", label: "close", onPress: onClose })
+    ] })
+  ] });
+}
+
+// src/ui/StatusLine.tsx
+import { useEffect as useEffect5, useState as useState7 } from "react";
+import { Box as Box10, Text as Text10 } from "ink";
+import { Fragment as Fragment3, jsx as jsx12, jsxs as jsxs10 } from "react/jsx-runtime";
+var DAY_MS = 24 * 36e5;
+var noop = () => {
+};
+var FRAMES = "\u280B\u2819\u2839\u2838\u283C\u2834\u2826\u2827\u2807\u280F";
+function Spinner() {
+  const [i, setI] = useState7(0);
+  useEffect5(() => {
+    const t = setInterval(() => setI((n) => (n + 1) % FRAMES.length), 100);
+    return () => clearInterval(t);
+  }, []);
+  return /* @__PURE__ */ jsx12(Text10, { color: C.accent, children: FRAMES[i] });
+}
+function StatusLine({ now, message, update, width, onOpen, onInvites, onAccounts, onHelp, onNew, onSync, onQuit }) {
+  const { events } = useUpcoming(now);
+  const { accounts } = useDirectory();
+  const failed = accounts.filter((a) => a.error);
+  const syncing = accounts.filter((a) => a.syncing);
+  const { current, next } = pickNowNext(events, now);
+  const soon = next && Date.parse(next.start) - now.getTime() < DAY_MS ? next : void 0;
+  const invites = pendingInvites(events, now).length;
+  const parts = [];
+  if (syncing.length) parts.push([/* @__PURE__ */ jsxs10(Fragment3, { children: [
+    /* @__PURE__ */ jsx12(Spinner, {}),
+    " ",
+    /* @__PURE__ */ jsxs10(Text10, { color: C.muted, children: [
+      "syncing ",
+      syncing.map((a) => a.label).join(", ")
+    ] })
+  ] }), onAccounts]);
+  for (const e of current) parts.push([/* @__PURE__ */ jsxs10(Fragment3, { children: [
+    /* @__PURE__ */ jsx12(Text10, { color: C.green, bold: true, children: "now" }),
+    " ",
+    e.title || "Untitled"
+  ] }), onOpen && (() => onOpen(e))]);
+  if (soon) parts.push([/* @__PURE__ */ jsxs10(Fragment3, { children: [
+    /* @__PURE__ */ jsx12(Text10, { color: C.cyan, bold: true, children: "next" }),
+    " ",
+    soon.title || "Untitled",
+    " ",
+    /* @__PURE__ */ jsx12(Text10, { color: C.yellow, children: startsLabel(soon.start, now) })
+  ] }), onOpen && (() => onOpen(soon))]);
+  if (invites) parts.push([/* @__PURE__ */ jsxs10(Text10, { color: C.yellow, children: [
+    invites === 1 ? "1 invite" : `${invites} invites`,
+    " (i)"
+  ] }), onInvites]);
+  if (failed.length) parts.push([/* @__PURE__ */ jsxs10(Text10, { color: C.red, children: [
+    "\u26A0 ",
+    failed.map((a) => a.label).join(", "),
+    " sync failed (s)"
+  ] }), onAccounts]);
+  if (message) parts.push([message]);
+  if (!parts.length) parts.push([/* @__PURE__ */ jsx12(Text10, { color: C.muted, children: "nothing on in the next 24h" })]);
+  if (update) parts.push([/* @__PURE__ */ jsxs10(Text10, { color: C.yellow, children: [
+    "\u2191 ",
+    update,
+    " available \xB7 npm i -g mysticals"
+  ] })]);
+  return /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", width, height: 2, children: [
+    /* @__PURE__ */ jsx12(Box10, { width, height: 1, overflow: "hidden", children: parts.map(([p, onClick], i) => /* @__PURE__ */ jsx12(Clickable, { flexShrink: 0, onClick, children: /* @__PURE__ */ jsxs10(Text10, { children: [
+      i > 0 && /* @__PURE__ */ jsx12(Text10, { color: C.muted, children: " \xB7 " }),
+      p
+    ] }) }, i)) }),
+    /* @__PURE__ */ jsxs10(Box10, { width, height: 1, overflow: "hidden", children: [
+      /* @__PURE__ */ jsx12(Button, { k: "n", label: "new", onPress: onNew ?? noop }),
+      /* @__PURE__ */ jsx12(Button, { k: "r", label: "sync", onPress: onSync ?? noop }),
+      /* @__PURE__ */ jsx12(Button, { k: "i", label: "invites", onPress: onInvites ?? noop }),
+      /* @__PURE__ */ jsx12(Button, { k: "s", label: "accounts", onPress: onAccounts ?? noop }),
+      /* @__PURE__ */ jsx12(Button, { k: "?", label: "help", onPress: onHelp ?? noop }),
+      /* @__PURE__ */ jsx12(Button, { k: "q", label: "quit", onPress: onQuit ?? noop })
+    ] })
+  ] });
+}
+
+// src/ui/App.tsx
+import { Fragment as Fragment4, jsx as jsx13, jsxs as jsxs11 } from "react/jsx-runtime";
+var VIEWS = { agenda: Agenda, day: Day, "2day": TwoDay, week: Week, month: Month };
+var VIEW_KEYS = { a: "agenda", d: "day", "2": "2day", w: "week", m: "month" };
+var VIEW_LABEL = { agenda: "Agenda", day: "Day", "2day": "2 Days", week: "Week", month: "Month" };
+var HELP = [
+  ["a d 2 w m", "agenda / day / 2 days / week / month"],
+  ["\u2190 \u2192", "previous / next day (agenda: event); also h l"],
+  ["\u2191 \u2193", "previous / next event of the day (month: any day)"],
+  ["j k", "next / previous event"],
+  ["\u21E7\u2190 \u21E7\u2192", "previous / next page (also H L)"],
+  ["t", "today"],
+  ["enter", "open selected event"],
+  ["n", "new event"],
+  ["i", "invites"],
+  ["s", "accounts & calendars"],
+  ["r", "sync now"],
+  ["?", "this help"],
+  ["q", "quit"],
+  ["click", "tabs, buttons, events (click again to open), day headers"],
+  ["wheel", "scroll the list / hours"],
+  process.platform === "darwin" ? ["\u2325 drag", "select text (Shift in some terminals)"] : ["\u21E7 drag", "select text"]
+];
+function Help({ onClose }) {
+  useKeys(() => onClose());
+  return /* @__PURE__ */ jsxs11(Clickable, { flexDirection: "column", borderStyle: "round", borderColor: C.accent, paddingX: 1, onClick: onClose, children: [
+    /* @__PURE__ */ jsx13(Text11, { bold: true, color: C.accent, children: "Keys" }),
+    HELP.map(([k, d]) => /* @__PURE__ */ jsxs11(Text11, { children: [
+      /* @__PURE__ */ jsx13(Text11, { color: C.cyan, children: k.padEnd(10) }),
+      " ",
+      d
+    ] }, k)),
+    /* @__PURE__ */ jsx13(Text11, { color: C.muted, children: "any key or click to close" })
+  ] });
+}
+var TABS = ["agenda", "day", "2day", "week", "month"];
+var PANE_MIN_WIDTH = 100;
+function Header({ nav, width, onView, onShift, onToday }) {
+  return /* @__PURE__ */ jsxs11(Box11, { width, height: 1, overflow: "hidden", children: [
+    TABS.map((v) => /* @__PURE__ */ jsx13(Clickable, { flexShrink: 0, onClick: () => onView(v), children: /* @__PURE__ */ jsx13(Text11, { inverse: v === nav.view, color: v === nav.view ? C.accent : C.muted, bold: v === nav.view, children: ` ${VIEW_LABEL[v]} ` }) }, v)),
+    /* @__PURE__ */ jsxs11(Box11, { flexShrink: 0, marginX: 1, children: [
+      /* @__PURE__ */ jsx13(Clickable, { onClick: () => onShift(-1), children: /* @__PURE__ */ jsx13(Text11, { color: C.cyan, children: " \u2039 " }) }),
+      /* @__PURE__ */ jsx13(Clickable, { onClick: onToday, children: /* @__PURE__ */ jsx13(Text11, { color: C.muted, children: "today" }) }),
+      /* @__PURE__ */ jsx13(Clickable, { onClick: () => onShift(1), children: /* @__PURE__ */ jsx13(Text11, { color: C.cyan, children: " \u203A " }) })
+    ] }),
+    /* @__PURE__ */ jsx13(Box11, { flexGrow: 1, flexShrink: 1, children: /* @__PURE__ */ jsx13(Text11, { bold: true, wrap: "truncate", children: title(nav) }) })
+  ] });
+}
+function Preview({ event, selected, now, width, height, onOpen }) {
+  const { accounts, calendars } = useDirectory();
+  const account = event && accounts.find((a) => a.id === event.accountId);
+  const calendar = event && calendars.find((c) => c.accountId === event.accountId && c.id === event.calendarId);
+  const [showAll, setShowAll] = useState8(false);
+  return /* @__PURE__ */ jsx13(
+    Clickable,
+    {
+      width,
+      height,
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: selected ? C.accent : C.muted,
+      paddingX: 1,
+      overflow: "hidden",
+      onClick: event && (() => onOpen(event)),
+      children: event ? /* @__PURE__ */ jsxs11(Fragment4, { children: [
+        /* @__PURE__ */ jsx13(Text11, { color: C.muted, children: selected ? "Selected \xB7 enter or click to open" : "Up next \xB7 \u2190/\u2192 to select" }),
+        /* @__PURE__ */ jsx13(EventInfo, { event, account, calendar, now, showAll, onToggleAll: () => setShowAll(!showAll) })
+      ] }) : /* @__PURE__ */ jsx13(Text11, { color: C.muted, children: "Nothing ahead in this range" })
+    }
+  );
+}
+function FirstSync({ pending, width, height, children }) {
+  return pending ? /* @__PURE__ */ jsx13(FirstSyncCheck, { width, height, children }) : /* @__PURE__ */ jsx13(Fragment4, { children });
+}
+function FirstSyncCheck({ width, height, children }) {
+  const first = useDirectory().accounts.filter((a) => a.syncing && !a.synced);
+  if (!first.length) return /* @__PURE__ */ jsx13(Fragment4, { children });
+  return /* @__PURE__ */ jsx13(Box11, { width, height, alignItems: "center", justifyContent: "center", children: /* @__PURE__ */ jsxs11(Text11, { children: [
+    /* @__PURE__ */ jsx13(Spinner, {}),
+    " First sync of ",
+    first.map((a) => a.label).join(", "),
+    "\u2026"
+  ] }) });
+}
+function title({ view, date }) {
+  if (view === "month") return format11(date, "MMMM yyyy");
+  if (view === "day") return format11(date, "EEE d MMM yyyy");
+  const days = view === "agenda" ? [date, addDays9(date, AGENDA_DAYS - 1)] : view === "2day" ? [date, addDays9(date, 1)] : viewDays(view, date);
+  return rangeLabel(days[0], days[days.length - 1]);
+}
+var chronological = (a, b) => eventBounds(a).start.getTime() - eventBounds(b).start.getTime() || Number(b.allDay) - Number(a.allDay);
+function App(props) {
+  return /* @__PURE__ */ jsx13(MouseProvider, { children: /* @__PURE__ */ jsx13(Shell, { ...props }) });
+}
+function Shell({ initialNav, updateCheck, notice }) {
+  const api = useApi();
+  const { exit } = useApp();
+  const { isRawModeSupported } = useStdin2();
+  const { nav, setView, setDate, shift, today } = useNav(initialNav);
+  const range = useMemo6(() => navRange(nav), [nav]);
+  const { events, loadedFor, error } = useEvents(range);
+  const now = useNow();
+  const { width, height } = useTermSize();
+  const [selectedKey, setSelectedKey] = useState8();
+  const [overlay, setOverlay] = useState8();
+  const [message, setMessage] = useState8(notice);
+  const [update, setUpdate] = useState8();
+  useEffect6(() => void updateCheck?.then(setUpdate), [updateCheck]);
+  const ordered2 = useMemo6(() => [...events].sort(chronological), [events]);
+  const selectedIdx = ordered2.findIndex((e) => eventKey(e) === selectedKey);
+  const close = () => setOverlay(void 0);
+  const [cursorAt, setCursor] = useState8(() => startOfDay7(nav.date));
+  const onPageOf = ({ view, date }, day) => {
+    if (view === "month") return isSameMonth2(day, date);
+    const r = navRange({ view, date });
+    return day >= new Date(r.start) && day < new Date(r.end);
+  };
+  const cursor = onPageOf(nav, cursorAt) ? cursorAt : startOfDay7(nav.date);
+  const grid = nav.view !== "agenda";
+  const live = useRef7({ cursor, ...nav });
+  const rendered = useRef7("");
+  const snapshot = `${+cursor}|${nav.view}|${+nav.date}|${selectedKey}`;
+  if (snapshot !== rendered.current) {
+    rendered.current = snapshot;
+    Object.assign(live.current, { cursor, ...nav, key: selectedKey });
+  }
+  const choose = (e) => {
+    live.current.key = e && eventKey(e);
+    setSelectedKey(live.current.key);
+  };
+  const select = (e) => {
+    choose(e);
+    if (!e) return;
+    live.current.cursor = max([startOfDay7(eventBounds(e).start), startOfDay7(new Date(range.start))]);
+    setCursor(live.current.cursor);
+  };
+  const pickOn = (list, day, minute) => {
+    const on = eventsOnDay(list, day);
+    if (minute === void 0) return on[0];
+    const at3 = (e) => e.allDay ? Infinity : Math.max(differenceInMinutes3(eventBounds(e).start, day), 0);
+    return on.reduce((best, e) => !best || Math.abs(at3(e) - minute) < Math.abs(at3(best) - minute) ? e : best, void 0);
+  };
+  const pending = useRef7(void 0);
+  useEffect6(() => {
+    const p = pending.current;
+    const want = navRange(live.current);
+    if (!p || loadedFor !== `${want.start}/${want.end}`) return;
+    pending.current = void 0;
+    if ("day" in p) return choose(pickOn(ordered2, p.day, p.minute));
+    const at3 = (e) => eventBounds(e).start.getTime();
+    const next = p.dir > 0 ? ordered2.find((e) => at3(e) > p.from) : [...ordered2].reverse().find((e) => at3(e) < p.from);
+    select(next ?? ordered2[p.dir > 0 ? 0 : ordered2.length - 1]);
+  }, [ordered2]);
+  const move = (dir) => {
+    const i = ordered2.findIndex((e) => eventKey(e) === live.current.key);
+    if (i >= 0 && i + dir >= 0 && i + dir < ordered2.length) return select(ordered2[i + dir]);
+    if (i < 0 && ordered2.length) return select(ordered2[dir > 0 ? 0 : ordered2.length - 1]);
+    pending.current = { dir, from: i >= 0 ? eventBounds(ordered2[i]).start.getTime() : dir > 0 ? -Infinity : Infinity };
+    live.current.date = shiftNav(live.current, dir).date;
+    shift(dir);
+  };
+  const stepDay = (n) => {
+    const { cursor: from, view, date, key: key3 } = live.current;
+    const sel = ordered2.find((e) => eventKey(e) === key3);
+    const minute = sel ? sel.allDay ? void 0 : Math.max(differenceInMinutes3(eventBounds(sel).start, from), 0) : live.current.minute;
+    const day = addDays9(from, n);
+    const nextDate = onPageOf({ view, date }, day) ? date : view === "2day" && n > 0 ? addDays9(day, -1) : day;
+    Object.assign(live.current, { cursor: day, date: nextDate, minute });
+    setCursor(day);
+    if (+nextDate !== +date) setDate(nextDate);
+    if (+nextDate === +nav.date && view === nav.view) return choose(pickOn(events, day, minute));
+    choose();
+    pending.current = { day, minute };
+  };
+  const stepInDay = (dir) => {
+    const on = eventsOnDay(events, live.current.cursor);
+    const i = on.findIndex((e2) => eventKey(e2) === live.current.key);
+    const e = i < 0 ? on[dir > 0 ? 0 : on.length - 1] : on[Math.min(Math.max(i + dir, 0), on.length - 1)];
+    if (e) choose(e);
+  };
+  const newStart = () => grid ? set(cursor, { hours: now.getHours(), minutes: now.getMinutes() }) : nav.date;
+  const syncNow = () => {
+    setMessage(void 0);
+    api.sync.now().then(
+      () => setMessage("Synced"),
+      (e) => setMessage(`Sync failed: ${errorText(e)}`)
+    );
+  };
+  const openDay = (day) => {
+    setDate(day);
+    setCursor(startOfDay7(day));
+    setView("day");
+  };
+  const goToday = () => {
+    setCursor(startOfDay7(/* @__PURE__ */ new Date()));
+    today();
+  };
+  useKeys(
+    (input, key3) => {
+      if (Object.hasOwn(VIEW_KEYS, input)) {
+        live.current.view = VIEW_KEYS[input];
+        return setView(live.current.view);
+      }
+      if (input === "H" || key3.shift && key3.leftArrow) return shift(-1);
+      if (input === "L" || key3.shift && key3.rightArrow) return shift(1);
+      if (input === "t") return goToday();
+      if (input === "j") return move(1);
+      if (input === "k") return move(-1);
+      const dir = input === "l" || key3.rightArrow ? 1 : input === "h" || key3.leftArrow ? -1 : 0;
+      const vdir = key3.downArrow ? 1 : key3.upArrow ? -1 : 0;
+      const view = live.current.view;
+      if (view === "agenda" && (dir || vdir)) return move(dir || vdir);
+      if (dir) return stepDay(dir);
+      if (vdir) return view === "month" ? move(vdir) : stepInDay(vdir);
+      if (key3.return) {
+        const sel = ordered2.find((e) => eventKey(e) === live.current.key);
+        return sel && setOverlay({ kind: "details", event: sel });
+      }
+      if (input === "n") return setOverlay({ kind: "editor", initialStart: newStart() });
+      if (input === "i") return setOverlay({ kind: "invites" });
+      if (input === "s") return setOverlay({ kind: "accounts" });
+      if (input === "r") return syncNow();
+      if (input === "?") return setOverlay({ kind: "help" });
+      if (input === "q") return exit();
+    },
+    { isActive: !overlay && isRawModeSupported === true }
+  );
+  const ViewComponent = VIEWS[nav.view];
+  const bodyHeight = Math.max(height - 3, 1);
+  const paneWidth = !overlay && (nav.view === "agenda" || nav.view === "day" || nav.view === "2day") && width >= PANE_MIN_WIDTH ? Math.min(56, Math.floor(width * 0.4)) : 0;
+  const previewed = selectedIdx >= 0 ? ordered2[selectedIdx] : ordered2.find((e) => eventBounds(e).end > now);
+  const body = () => {
+    switch (overlay?.kind) {
+      case "details":
+        return /* @__PURE__ */ jsx13(EventDetails, { event: overlay.event, onClose: close, onEdit: (event) => setOverlay({ kind: "editor", event }) });
+      case "editor":
+        return /* @__PURE__ */ jsx13(EventEditor, { event: overlay.event, initialStart: overlay.initialStart, onClose: close });
+      case "accounts":
+        return /* @__PURE__ */ jsx13(Accounts, { onClose: close });
+      case "invites":
+        return /* @__PURE__ */ jsx13(Invites, { onClose: close });
+      case "help":
+        return /* @__PURE__ */ jsx13(Help, { onClose: close });
+      default:
+        return /* @__PURE__ */ jsxs11(FirstSync, { pending: !events.length, width, height: bodyHeight, children: [
+          /* @__PURE__ */ jsx13(
+            ViewComponent,
+            {
+              events,
+              date: nav.date,
+              now,
+              selectedKey: selectedIdx >= 0 ? selectedKey : void 0,
+              cursor: grid ? cursor : void 0,
+              onSelect: select,
+              onOpen: (event) => setOverlay({ kind: "details", event }),
+              onPickDay: openDay,
+              width: width - paneWidth,
+              height: bodyHeight
+            }
+          ),
+          paneWidth > 0 && /* @__PURE__ */ jsx13(
+            Preview,
+            {
+              event: previewed,
+              selected: selectedIdx >= 0,
+              now,
+              width: paneWidth,
+              height: bodyHeight,
+              onOpen: (event) => setOverlay({ kind: "details", event })
+            },
+            previewed && eventKey(previewed)
+          )
+        ] });
+    }
+  };
+  return /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", width, height, children: [
+    /* @__PURE__ */ jsx13(
+      Header,
+      {
+        nav,
+        width,
+        onView: (v) => !overlay && setView(v),
+        onShift: (dir) => !overlay && shift(dir),
+        onToday: () => !overlay && goToday()
+      }
+    ),
+    /* @__PURE__ */ jsx13(Box11, { flexDirection: overlay ? "column" : "row", height: bodyHeight, children: body() }),
+    /* @__PURE__ */ jsx13(
+      StatusLine,
+      {
+        nav,
+        events,
+        now,
+        message: error ? `Error: ${error}` : message,
+        update,
+        width,
+        onOpen: (event) => !overlay && setOverlay({ kind: "details", event }),
+        onInvites: () => !overlay && setOverlay({ kind: "invites" }),
+        onAccounts: () => !overlay && setOverlay({ kind: "accounts" }),
+        onHelp: () => !overlay && setOverlay({ kind: "help" }),
+        onNew: () => !overlay && setOverlay({ kind: "editor", initialStart: newStart() }),
+        onSync: syncNow,
+        onQuit: () => !overlay && exit()
+      }
+    )
+  ] });
+}
+
+// src/update.ts
+import { mkdir as mkdir2, readFile, writeFile as writeFile2 } from "fs/promises";
+import { join as join6 } from "path";
+var DAY_MS2 = 24 * 36e5;
+function isNewer(a, b) {
+  const pa = a.split(".").map((n) => parseInt(n, 10) || 0);
+  const pb = b.split(".").map((n) => parseInt(n, 10) || 0);
+  for (let i = 0; i < 3; i++) if ((pa[i] ?? 0) !== (pb[i] ?? 0)) return (pa[i] ?? 0) > (pb[i] ?? 0);
+  return false;
+}
+async function cached(file) {
+  try {
+    const c = JSON.parse(await readFile(file, "utf8"));
+    return typeof c.checkedAt === "number" && Date.now() - c.checkedAt < DAY_MS2 ? c : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function checkUpdate(signal, current = version) {
+  const registry = process.env.MYSTICALS_UPDATE_REGISTRY;
+  if (isMock() && !registry) return void 0;
+  const file = join6(homeDir(), "update-check.json");
+  try {
+    let latest = (await cached(file))?.latest;
+    if (latest === void 0) {
+      const res = await fetch(`${registry || "https://registry.npmjs.org"}/mysticals/latest`, {
+        signal: AbortSignal.any([AbortSignal.timeout(3e3), ...signal ? [signal] : []])
+      });
+      if (!res.ok) return void 0;
+      const v = (await res.json()).version;
+      if (typeof v !== "string") return void 0;
+      latest = v;
+      await mkdir2(homeDir(), { recursive: true });
+      await writeFile2(file, JSON.stringify({ checkedAt: Date.now(), latest }));
+    }
+    return isNewer(latest, current) ? latest : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/cli.ts
+var HELP2 = `mysticals ${version} \u2014 isolated multi-account calendar for the terminal
+
+Usage: mysticals [--help | --version]
+
+All open mysticals windows share one background daemon (accounts, sync, notifications);
+it stops a few seconds after the last window closes.
+
+Environment:
+  MYSTICALS_HOME   data directory (default: mysticals-terminal in ~/Library/Application Support
+                   on macOS, %APPDATA% on Windows, $XDG_DATA_HOME or ~/.local/share on Linux)
+  MYSTICALS_MOCK=1 demo mode with fake accounts; nothing real is touched
+                   (PowerShell: $env:MYSTICALS_MOCK=1; mysticals  cmd: set "MYSTICALS_MOCK=1" && mysticals)
+  MYSTICALS_TELEMETRY=0 (or DO_NOT_TRACK=1) turns off the anonymous usage stats
+                   (app installed, account added; no personal data)
+
+Press ? inside the app for keys.`;
+var leaveScreen = () => {
+};
+async function main(argv) {
+  if (argv.includes("--help") || argv.includes("-h")) return void console.log(HELP2);
+  if (argv.includes("--version") || argv.includes("-v")) return void console.log(version);
+  if (argv.includes("--daemon")) return runDaemon();
+  if (argv.length) {
+    console.error(`Unknown argument: ${argv[0]}
+
+${HELP2}`);
+    process.exit(2);
+  }
+  const notice = telemetry()?.installed ? TELEMETRY_NOTICE : void 0;
+  const api = await connect();
+  const stopUpdate = new AbortController();
+  if (process.stdin.isTTY && process.stdout.isTTY) {
+    process.stdout.write("\x1B[?1049h\x1B[H\x1B[?1000h\x1B[?1006h");
+    leaveScreen = () => void process.stdout.write("\x1B[?1006l\x1B[?1000l\x1B[?1049l");
+    process.on("exit", leaveScreen);
+    for (const s of ["SIGTERM", "SIGHUP"]) process.on(s, () => process.exit(0));
+  }
+  const app = render(createElement(ApiContext.Provider, { value: api }, createElement(App, { updateCheck: checkUpdate(stopUpdate.signal), notice })));
+  if (!process.stdin.isTTY) process.stdin.on("end", () => app.unmount()).resume();
+  await app.waitUntilExit();
+  stopUpdate.abort();
+  api.close();
+}
+main(process.argv.slice(2)).catch((e) => {
+  leaveScreen();
+  console.error(e instanceof Error ? e.message : e);
+  process.exit(1);
+});