circal-mcp 0.1.0

package/dist/circal-mcp.mjs

@@ -0,0 +1,4467 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/.pnpm/react@19.2.8/node_modules/react/cjs/react.production.js
+var require_react_production = __commonJS({
+  "node_modules/.pnpm/react@19.2.8/node_modules/react/cjs/react.production.js"(exports) {
+    "use strict";
+    var REACT_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("react.transitional.element");
+    var REACT_PORTAL_TYPE = /* @__PURE__ */ Symbol.for("react.portal");
+    var REACT_FRAGMENT_TYPE = /* @__PURE__ */ Symbol.for("react.fragment");
+    var REACT_STRICT_MODE_TYPE = /* @__PURE__ */ Symbol.for("react.strict_mode");
+    var REACT_PROFILER_TYPE = /* @__PURE__ */ Symbol.for("react.profiler");
+    var REACT_CONSUMER_TYPE = /* @__PURE__ */ Symbol.for("react.consumer");
+    var REACT_CONTEXT_TYPE = /* @__PURE__ */ Symbol.for("react.context");
+    var REACT_FORWARD_REF_TYPE = /* @__PURE__ */ Symbol.for("react.forward_ref");
+    var REACT_SUSPENSE_TYPE = /* @__PURE__ */ Symbol.for("react.suspense");
+    var REACT_MEMO_TYPE = /* @__PURE__ */ Symbol.for("react.memo");
+    var REACT_LAZY_TYPE = /* @__PURE__ */ Symbol.for("react.lazy");
+    var REACT_ACTIVITY_TYPE = /* @__PURE__ */ Symbol.for("react.activity");
+    var MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
+    function getIteratorFn(maybeIterable) {
+      if (null === maybeIterable || "object" !== typeof maybeIterable) return null;
+      maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
+      return "function" === typeof maybeIterable ? maybeIterable : null;
+    }
+    var ReactNoopUpdateQueue = {
+      isMounted: function() {
+        return false;
+      },
+      enqueueForceUpdate: function() {
+      },
+      enqueueReplaceState: function() {
+      },
+      enqueueSetState: function() {
+      }
+    };
+    var assign = Object.assign;
+    var emptyObject = {};
+    function Component(props, context, updater) {
+      this.props = props;
+      this.context = context;
+      this.refs = emptyObject;
+      this.updater = updater || ReactNoopUpdateQueue;
+    }
+    Component.prototype.isReactComponent = {};
+    Component.prototype.setState = function(partialState, callback) {
+      if ("object" !== typeof partialState && "function" !== typeof partialState && null != partialState)
+        throw Error(
+          "takes an object of state variables to update or a function which returns an object of state variables."
+        );
+      this.updater.enqueueSetState(this, partialState, callback, "setState");
+    };
+    Component.prototype.forceUpdate = function(callback) {
+      this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
+    };
+    function ComponentDummy() {
+    }
+    ComponentDummy.prototype = Component.prototype;
+    function PureComponent(props, context, updater) {
+      this.props = props;
+      this.context = context;
+      this.refs = emptyObject;
+      this.updater = updater || ReactNoopUpdateQueue;
+    }
+    var pureComponentPrototype = PureComponent.prototype = new ComponentDummy();
+    pureComponentPrototype.constructor = PureComponent;
+    assign(pureComponentPrototype, Component.prototype);
+    pureComponentPrototype.isPureReactComponent = true;
+    var isArrayImpl = Array.isArray;
+    function noop() {
+    }
+    var ReactSharedInternals = { H: null, A: null, T: null, S: null };
+    var hasOwnProperty = Object.prototype.hasOwnProperty;
+    function ReactElement(type, key, props) {
+      var refProp = props.ref;
+      return {
+        $$typeof: REACT_ELEMENT_TYPE,
+        type,
+        key,
+        ref: void 0 !== refProp ? refProp : null,
+        props
+      };
+    }
+    function cloneAndReplaceKey(oldElement, newKey) {
+      return ReactElement(oldElement.type, newKey, oldElement.props);
+    }
+    function isValidElement(object) {
+      return "object" === typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
+    }
+    function escape(key) {
+      var escaperLookup = { "=": "=0", ":": "=2" };
+      return "$" + key.replace(/[=:]/g, function(match) {
+        return escaperLookup[match];
+      });
+    }
+    var userProvidedKeyEscapeRegex = /\/+/g;
+    function getElementKey(element, index) {
+      return "object" === typeof element && null !== element && null != element.key ? escape("" + element.key) : index.toString(36);
+    }
+    function resolveThenable(thenable) {
+      switch (thenable.status) {
+        case "fulfilled":
+          return thenable.value;
+        case "rejected":
+          throw thenable.reason;
+        default:
+          switch ("string" === typeof thenable.status ? thenable.then(noop, noop) : (thenable.status = "pending", thenable.then(
+            function(fulfilledValue) {
+              "pending" === thenable.status && (thenable.status = "fulfilled", thenable.value = fulfilledValue);
+            },
+            function(error) {
+              "pending" === thenable.status && (thenable.status = "rejected", thenable.reason = error);
+            }
+          )), thenable.status) {
+            case "fulfilled":
+              return thenable.value;
+            case "rejected":
+              throw thenable.reason;
+          }
+      }
+      throw thenable;
+    }
+    function mapIntoArray(children, array2, escapedPrefix, nameSoFar, callback) {
+      var type = typeof children;
+      if ("undefined" === type || "boolean" === type) children = null;
+      var invokeCallback = false;
+      if (null === children) invokeCallback = true;
+      else
+        switch (type) {
+          case "bigint":
+          case "string":
+          case "number":
+            invokeCallback = true;
+            break;
+          case "object":
+            switch (children.$$typeof) {
+              case REACT_ELEMENT_TYPE:
+              case REACT_PORTAL_TYPE:
+                invokeCallback = true;
+                break;
+              case REACT_LAZY_TYPE:
+                return invokeCallback = children._init, mapIntoArray(
+                  invokeCallback(children._payload),
+                  array2,
+                  escapedPrefix,
+                  nameSoFar,
+                  callback
+                );
+            }
+        }
+      if (invokeCallback)
+        return callback = callback(children), invokeCallback = "" === nameSoFar ? "." + getElementKey(children, 0) : nameSoFar, isArrayImpl(callback) ? (escapedPrefix = "", null != invokeCallback && (escapedPrefix = invokeCallback.replace(userProvidedKeyEscapeRegex, "$&/") + "/"), mapIntoArray(callback, array2, escapedPrefix, "", function(c) {
+          return c;
+        })) : null != callback && (isValidElement(callback) && (callback = cloneAndReplaceKey(
+          callback,
+          escapedPrefix + (null == callback.key || children && children.key === callback.key ? "" : ("" + callback.key).replace(
+            userProvidedKeyEscapeRegex,
+            "$&/"
+          ) + "/") + invokeCallback
+        )), array2.push(callback)), 1;
+      invokeCallback = 0;
+      var nextNamePrefix = "" === nameSoFar ? "." : nameSoFar + ":";
+      if (isArrayImpl(children))
+        for (var i = 0; i < children.length; i++)
+          nameSoFar = children[i], type = nextNamePrefix + getElementKey(nameSoFar, i), invokeCallback += mapIntoArray(
+            nameSoFar,
+            array2,
+            escapedPrefix,
+            type,
+            callback
+          );
+      else if (i = getIteratorFn(children), "function" === typeof i)
+        for (children = i.call(children), i = 0; !(nameSoFar = children.next()).done; )
+          nameSoFar = nameSoFar.value, type = nextNamePrefix + getElementKey(nameSoFar, i++), invokeCallback += mapIntoArray(
+            nameSoFar,
+            array2,
+            escapedPrefix,
+            type,
+            callback
+          );
+      else if ("object" === type) {
+        if ("function" === typeof children.then)
+          return mapIntoArray(
+            resolveThenable(children),
+            array2,
+            escapedPrefix,
+            nameSoFar,
+            callback
+          );
+        array2 = String(children);
+        throw Error(
+          "Objects are not valid as a React child (found: " + ("[object Object]" === array2 ? "object with keys {" + Object.keys(children).join(", ") + "}" : array2) + "). If you meant to render a collection of children, use an array instead."
+        );
+      }
+      return invokeCallback;
+    }
+    function mapChildren(children, func, context) {
+      if (null == children) return children;
+      var result = [], count = 0;
+      mapIntoArray(children, result, "", "", function(child) {
+        return func.call(context, child, count++);
+      });
+      return result;
+    }
+    function lazyInitializer(payload) {
+      if (-1 === payload._status) {
+        var ctor = payload._result;
+        ctor = ctor();
+        ctor.then(
+          function(moduleObject) {
+            if (0 === payload._status || -1 === payload._status)
+              payload._status = 1, payload._result = moduleObject;
+          },
+          function(error) {
+            if (0 === payload._status || -1 === payload._status)
+              payload._status = 2, payload._result = error;
+          }
+        );
+        -1 === payload._status && (payload._status = 0, payload._result = ctor);
+      }
+      if (1 === payload._status) return payload._result.default;
+      throw payload._result;
+    }
+    var reportGlobalError = "function" === typeof reportError ? reportError : function(error) {
+      if ("object" === typeof window && "function" === typeof window.ErrorEvent) {
+        var event = new window.ErrorEvent("error", {
+          bubbles: true,
+          cancelable: true,
+          message: "object" === typeof error && null !== error && "string" === typeof error.message ? String(error.message) : String(error),
+          error
+        });
+        if (!window.dispatchEvent(event)) return;
+      } else if ("object" === typeof process && "function" === typeof process.emit) {
+        process.emit("uncaughtException", error);
+        return;
+      }
+      console.error(error);
+    };
+    var Children = {
+      map: mapChildren,
+      forEach: function(children, forEachFunc, forEachContext) {
+        mapChildren(
+          children,
+          function() {
+            forEachFunc.apply(this, arguments);
+          },
+          forEachContext
+        );
+      },
+      count: function(children) {
+        var n = 0;
+        mapChildren(children, function() {
+          n++;
+        });
+        return n;
+      },
+      toArray: function(children) {
+        return mapChildren(children, function(child) {
+          return child;
+        }) || [];
+      },
+      only: function(children) {
+        if (!isValidElement(children))
+          throw Error(
+            "React.Children.only expected to receive a single React element child."
+          );
+        return children;
+      }
+    };
+    exports.Activity = REACT_ACTIVITY_TYPE;
+    exports.Children = Children;
+    exports.Component = Component;
+    exports.Fragment = REACT_FRAGMENT_TYPE;
+    exports.Profiler = REACT_PROFILER_TYPE;
+    exports.PureComponent = PureComponent;
+    exports.StrictMode = REACT_STRICT_MODE_TYPE;
+    exports.Suspense = REACT_SUSPENSE_TYPE;
+    exports.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = ReactSharedInternals;
+    exports.__COMPILER_RUNTIME = {
+      __proto__: null,
+      c: function(size) {
+        return ReactSharedInternals.H.useMemoCache(size);
+      }
+    };
+    exports.cache = function(fn) {
+      return function() {
+        return fn.apply(null, arguments);
+      };
+    };
+    exports.cacheSignal = function() {
+      return null;
+    };
+    exports.cloneElement = function(element, config, children) {
+      if (null === element || void 0 === element)
+        throw Error(
+          "The argument must be a React element, but you passed " + element + "."
+        );
+      var props = assign({}, element.props), key = element.key;
+      if (null != config)
+        for (propName in void 0 !== config.key && (key = "" + config.key), config)
+          !hasOwnProperty.call(config, propName) || "key" === propName || "__self" === propName || "__source" === propName || "ref" === propName && void 0 === config.ref || (props[propName] = config[propName]);
+      var propName = arguments.length - 2;
+      if (1 === propName) props.children = children;
+      else if (1 < propName) {
+        for (var childArray = Array(propName), i = 0; i < propName; i++)
+          childArray[i] = arguments[i + 2];
+        props.children = childArray;
+      }
+      return ReactElement(element.type, key, props);
+    };
+    exports.createContext = function(defaultValue) {
+      defaultValue = {
+        $$typeof: REACT_CONTEXT_TYPE,
+        _currentValue: defaultValue,
+        _currentValue2: defaultValue,
+        _threadCount: 0,
+        Provider: null,
+        Consumer: null
+      };
+      defaultValue.Provider = defaultValue;
+      defaultValue.Consumer = {
+        $$typeof: REACT_CONSUMER_TYPE,
+        _context: defaultValue
+      };
+      return defaultValue;
+    };
+    exports.createElement = function(type, config, children) {
+      var propName, props = {}, key = null;
+      if (null != config)
+        for (propName in void 0 !== config.key && (key = "" + config.key), config)
+          hasOwnProperty.call(config, propName) && "key" !== propName && "__self" !== propName && "__source" !== propName && (props[propName] = config[propName]);
+      var childrenLength = arguments.length - 2;
+      if (1 === childrenLength) props.children = children;
+      else if (1 < childrenLength) {
+        for (var childArray = Array(childrenLength), i = 0; i < childrenLength; i++)
+          childArray[i] = arguments[i + 2];
+        props.children = childArray;
+      }
+      if (type && type.defaultProps)
+        for (propName in childrenLength = type.defaultProps, childrenLength)
+          void 0 === props[propName] && (props[propName] = childrenLength[propName]);
+      return ReactElement(type, key, props);
+    };
+    exports.createRef = function() {
+      return { current: null };
+    };
+    exports.forwardRef = function(render) {
+      return { $$typeof: REACT_FORWARD_REF_TYPE, render };
+    };
+    exports.isValidElement = isValidElement;
+    exports.lazy = function(ctor) {
+      return {
+        $$typeof: REACT_LAZY_TYPE,
+        _payload: { _status: -1, _result: ctor },
+        _init: lazyInitializer
+      };
+    };
+    exports.memo = function(type, compare) {
+      return {
+        $$typeof: REACT_MEMO_TYPE,
+        type,
+        compare: void 0 === compare ? null : compare
+      };
+    };
+    exports.startTransition = function(scope) {
+      var prevTransition = ReactSharedInternals.T, currentTransition = {};
+      ReactSharedInternals.T = currentTransition;
+      try {
+        var returnValue = scope(), onStartTransitionFinish = ReactSharedInternals.S;
+        null !== onStartTransitionFinish && onStartTransitionFinish(currentTransition, returnValue);
+        "object" === typeof returnValue && null !== returnValue && "function" === typeof returnValue.then && returnValue.then(noop, reportGlobalError);
+      } catch (error) {
+        reportGlobalError(error);
+      } finally {
+        null !== prevTransition && null !== currentTransition.types && (prevTransition.types = currentTransition.types), ReactSharedInternals.T = prevTransition;
+      }
+    };
+    exports.unstable_useCacheRefresh = function() {
+      return ReactSharedInternals.H.useCacheRefresh();
+    };
+    exports.use = function(usable) {
+      return ReactSharedInternals.H.use(usable);
+    };
+    exports.useActionState = function(action, initialState, permalink) {
+      return ReactSharedInternals.H.useActionState(action, initialState, permalink);
+    };
+    exports.useCallback = function(callback, deps) {
+      return ReactSharedInternals.H.useCallback(callback, deps);
+    };
+    exports.useContext = function(Context) {
+      return ReactSharedInternals.H.useContext(Context);
+    };
+    exports.useDebugValue = function() {
+    };
+    exports.useDeferredValue = function(value, initialValue) {
+      return ReactSharedInternals.H.useDeferredValue(value, initialValue);
+    };
+    exports.useEffect = function(create, deps) {
+      return ReactSharedInternals.H.useEffect(create, deps);
+    };
+    exports.useEffectEvent = function(callback) {
+      return ReactSharedInternals.H.useEffectEvent(callback);
+    };
+    exports.useId = function() {
+      return ReactSharedInternals.H.useId();
+    };
+    exports.useImperativeHandle = function(ref, create, deps) {
+      return ReactSharedInternals.H.useImperativeHandle(ref, create, deps);
+    };
+    exports.useInsertionEffect = function(create, deps) {
+      return ReactSharedInternals.H.useInsertionEffect(create, deps);
+    };
+    exports.useLayoutEffect = function(create, deps) {
+      return ReactSharedInternals.H.useLayoutEffect(create, deps);
+    };
+    exports.useMemo = function(create, deps) {
+      return ReactSharedInternals.H.useMemo(create, deps);
+    };
+    exports.useOptimistic = function(passthrough, reducer) {
+      return ReactSharedInternals.H.useOptimistic(passthrough, reducer);
+    };
+    exports.useReducer = function(reducer, initialArg, init) {
+      return ReactSharedInternals.H.useReducer(reducer, initialArg, init);
+    };
+    exports.useRef = function(initialValue) {
+      return ReactSharedInternals.H.useRef(initialValue);
+    };
+    exports.useState = function(initialState) {
+      return ReactSharedInternals.H.useState(initialState);
+    };
+    exports.useSyncExternalStore = function(subscribe, getSnapshot, getServerSnapshot) {
+      return ReactSharedInternals.H.useSyncExternalStore(
+        subscribe,
+        getSnapshot,
+        getServerSnapshot
+      );
+    };
+    exports.useTransition = function() {
+      return ReactSharedInternals.H.useTransition();
+    };
+    exports.version = "19.2.8";
+  }
+});
+
+// node_modules/.pnpm/react@19.2.8/node_modules/react/cjs/react.development.js
+var require_react_development = __commonJS({
+  "node_modules/.pnpm/react@19.2.8/node_modules/react/cjs/react.development.js"(exports, module) {
+    "use strict";
+    "production" !== process.env.NODE_ENV && (function() {
+      function defineDeprecationWarning(methodName, info) {
+        Object.defineProperty(Component.prototype, methodName, {
+          get: function() {
+            console.warn(
+              "%s(...) is deprecated in plain JavaScript React classes. %s",
+              info[0],
+              info[1]
+            );
+          }
+        });
+      }
+      function getIteratorFn(maybeIterable) {
+        if (null === maybeIterable || "object" !== typeof maybeIterable)
+          return null;
+        maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
+        return "function" === typeof maybeIterable ? maybeIterable : null;
+      }
+      function warnNoop(publicInstance, callerName) {
+        publicInstance = (publicInstance = publicInstance.constructor) && (publicInstance.displayName || publicInstance.name) || "ReactClass";
+        var warningKey = publicInstance + "." + callerName;
+        didWarnStateUpdateForUnmountedComponent[warningKey] || (console.error(
+          "Can't call %s on a component that is not yet mounted. This is a no-op, but it might indicate a bug in your application. Instead, assign to `this.state` directly or define a `state = {};` class property with the desired state in the %s component.",
+          callerName,
+          publicInstance
+        ), didWarnStateUpdateForUnmountedComponent[warningKey] = true);
+      }
+      function Component(props, context, updater) {
+        this.props = props;
+        this.context = context;
+        this.refs = emptyObject;
+        this.updater = updater || ReactNoopUpdateQueue;
+      }
+      function ComponentDummy() {
+      }
+      function PureComponent(props, context, updater) {
+        this.props = props;
+        this.context = context;
+        this.refs = emptyObject;
+        this.updater = updater || ReactNoopUpdateQueue;
+      }
+      function noop() {
+      }
+      function testStringCoercion(value) {
+        return "" + value;
+      }
+      function checkKeyStringCoercion(value) {
+        try {
+          testStringCoercion(value);
+          var JSCompiler_inline_result = false;
+        } catch (e) {
+          JSCompiler_inline_result = true;
+        }
+        if (JSCompiler_inline_result) {
+          JSCompiler_inline_result = console;
+          var JSCompiler_temp_const = JSCompiler_inline_result.error;
+          var JSCompiler_inline_result$jscomp$0 = "function" === typeof Symbol && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
+          JSCompiler_temp_const.call(
+            JSCompiler_inline_result,
+            "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+            JSCompiler_inline_result$jscomp$0
+          );
+          return testStringCoercion(value);
+        }
+      }
+      function getComponentNameFromType(type) {
+        if (null == type) return null;
+        if ("function" === typeof type)
+          return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
+        if ("string" === typeof type) return type;
+        switch (type) {
+          case REACT_FRAGMENT_TYPE:
+            return "Fragment";
+          case REACT_PROFILER_TYPE:
+            return "Profiler";
+          case REACT_STRICT_MODE_TYPE:
+            return "StrictMode";
+          case REACT_SUSPENSE_TYPE:
+            return "Suspense";
+          case REACT_SUSPENSE_LIST_TYPE:
+            return "SuspenseList";
+          case REACT_ACTIVITY_TYPE:
+            return "Activity";
+        }
+        if ("object" === typeof type)
+          switch ("number" === typeof type.tag && console.error(
+            "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
+          ), type.$$typeof) {
+            case REACT_PORTAL_TYPE:
+              return "Portal";
+            case REACT_CONTEXT_TYPE:
+              return type.displayName || "Context";
+            case REACT_CONSUMER_TYPE:
+              return (type._context.displayName || "Context") + ".Consumer";
+            case REACT_FORWARD_REF_TYPE:
+              var innerType = type.render;
+              type = type.displayName;
+              type || (type = innerType.displayName || innerType.name || "", type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef");
+              return type;
+            case REACT_MEMO_TYPE:
+              return innerType = type.displayName || null, null !== innerType ? innerType : getComponentNameFromType(type.type) || "Memo";
+            case REACT_LAZY_TYPE:
+              innerType = type._payload;
+              type = type._init;
+              try {
+                return getComponentNameFromType(type(innerType));
+              } catch (x) {
+              }
+          }
+        return null;
+      }
+      function getTaskName(type) {
+        if (type === REACT_FRAGMENT_TYPE) return "<>";
+        if ("object" === typeof type && null !== type && type.$$typeof === REACT_LAZY_TYPE)
+          return "<...>";
+        try {
+          var name = getComponentNameFromType(type);
+          return name ? "<" + name + ">" : "<...>";
+        } catch (x) {
+          return "<...>";
+        }
+      }
+      function getOwner() {
+        var dispatcher = ReactSharedInternals.A;
+        return null === dispatcher ? null : dispatcher.getOwner();
+      }
+      function UnknownOwner() {
+        return Error("react-stack-top-frame");
+      }
+      function hasValidKey(config) {
+        if (hasOwnProperty.call(config, "key")) {
+          var getter = Object.getOwnPropertyDescriptor(config, "key").get;
+          if (getter && getter.isReactWarning) return false;
+        }
+        return void 0 !== config.key;
+      }
+      function defineKeyPropWarningGetter(props, displayName) {
+        function warnAboutAccessingKey() {
+          specialPropKeyWarningShown || (specialPropKeyWarningShown = true, console.error(
+            "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
+            displayName
+          ));
+        }
+        warnAboutAccessingKey.isReactWarning = true;
+        Object.defineProperty(props, "key", {
+          get: warnAboutAccessingKey,
+          configurable: true
+        });
+      }
+      function elementRefGetterWithDeprecationWarning() {
+        var componentName = getComponentNameFromType(this.type);
+        didWarnAboutElementRef[componentName] || (didWarnAboutElementRef[componentName] = true, console.error(
+          "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
+        ));
+        componentName = this.props.ref;
+        return void 0 !== componentName ? componentName : null;
+      }
+      function ReactElement(type, key, props, owner, debugStack, debugTask) {
+        var refProp = props.ref;
+        type = {
+          $$typeof: REACT_ELEMENT_TYPE,
+          type,
+          key,
+          props,
+          _owner: owner
+        };
+        null !== (void 0 !== refProp ? refProp : null) ? Object.defineProperty(type, "ref", {
+          enumerable: false,
+          get: elementRefGetterWithDeprecationWarning
+        }) : Object.defineProperty(type, "ref", { enumerable: false, value: null });
+        type._store = {};
+        Object.defineProperty(type._store, "validated", {
+          configurable: false,
+          enumerable: false,
+          writable: true,
+          value: 0
+        });
+        Object.defineProperty(type, "_debugInfo", {
+          configurable: false,
+          enumerable: false,
+          writable: true,
+          value: null
+        });
+        Object.defineProperty(type, "_debugStack", {
+          configurable: false,
+          enumerable: false,
+          writable: true,
+          value: debugStack
+        });
+        Object.defineProperty(type, "_debugTask", {
+          configurable: false,
+          enumerable: false,
+          writable: true,
+          value: debugTask
+        });
+        Object.freeze && (Object.freeze(type.props), Object.freeze(type));
+        return type;
+      }
+      function cloneAndReplaceKey(oldElement, newKey) {
+        newKey = ReactElement(
+          oldElement.type,
+          newKey,
+          oldElement.props,
+          oldElement._owner,
+          oldElement._debugStack,
+          oldElement._debugTask
+        );
+        oldElement._store && (newKey._store.validated = oldElement._store.validated);
+        return newKey;
+      }
+      function validateChildKeys(node) {
+        isValidElement(node) ? node._store && (node._store.validated = 1) : "object" === typeof node && null !== node && node.$$typeof === REACT_LAZY_TYPE && ("fulfilled" === node._payload.status ? isValidElement(node._payload.value) && node._payload.value._store && (node._payload.value._store.validated = 1) : node._store && (node._store.validated = 1));
+      }
+      function isValidElement(object) {
+        return "object" === typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
+      }
+      function escape(key) {
+        var escaperLookup = { "=": "=0", ":": "=2" };
+        return "$" + key.replace(/[=:]/g, function(match) {
+          return escaperLookup[match];
+        });
+      }
+      function getElementKey(element, index) {
+        return "object" === typeof element && null !== element && null != element.key ? (checkKeyStringCoercion(element.key), escape("" + element.key)) : index.toString(36);
+      }
+      function resolveThenable(thenable) {
+        switch (thenable.status) {
+          case "fulfilled":
+            return thenable.value;
+          case "rejected":
+            throw thenable.reason;
+          default:
+            switch ("string" === typeof thenable.status ? thenable.then(noop, noop) : (thenable.status = "pending", thenable.then(
+              function(fulfilledValue) {
+                "pending" === thenable.status && (thenable.status = "fulfilled", thenable.value = fulfilledValue);
+              },
+              function(error) {
+                "pending" === thenable.status && (thenable.status = "rejected", thenable.reason = error);
+              }
+            )), thenable.status) {
+              case "fulfilled":
+                return thenable.value;
+              case "rejected":
+                throw thenable.reason;
+            }
+        }
+        throw thenable;
+      }
+      function mapIntoArray(children, array2, escapedPrefix, nameSoFar, callback) {
+        var type = typeof children;
+        if ("undefined" === type || "boolean" === type) children = null;
+        var invokeCallback = false;
+        if (null === children) invokeCallback = true;
+        else
+          switch (type) {
+            case "bigint":
+            case "string":
+            case "number":
+              invokeCallback = true;
+              break;
+            case "object":
+              switch (children.$$typeof) {
+                case REACT_ELEMENT_TYPE:
+                case REACT_PORTAL_TYPE:
+                  invokeCallback = true;
+                  break;
+                case REACT_LAZY_TYPE:
+                  return invokeCallback = children._init, mapIntoArray(
+                    invokeCallback(children._payload),
+                    array2,
+                    escapedPrefix,
+                    nameSoFar,
+                    callback
+                  );
+              }
+          }
+        if (invokeCallback) {
+          invokeCallback = children;
+          callback = callback(invokeCallback);
+          var childKey = "" === nameSoFar ? "." + getElementKey(invokeCallback, 0) : nameSoFar;
+          isArrayImpl(callback) ? (escapedPrefix = "", null != childKey && (escapedPrefix = childKey.replace(userProvidedKeyEscapeRegex, "$&/") + "/"), mapIntoArray(callback, array2, escapedPrefix, "", function(c) {
+            return c;
+          })) : null != callback && (isValidElement(callback) && (null != callback.key && (invokeCallback && invokeCallback.key === callback.key || checkKeyStringCoercion(callback.key)), escapedPrefix = cloneAndReplaceKey(
+            callback,
+            escapedPrefix + (null == callback.key || invokeCallback && invokeCallback.key === callback.key ? "" : ("" + callback.key).replace(
+              userProvidedKeyEscapeRegex,
+              "$&/"
+            ) + "/") + childKey
+          ), "" !== nameSoFar && null != invokeCallback && isValidElement(invokeCallback) && null == invokeCallback.key && invokeCallback._store && !invokeCallback._store.validated && (escapedPrefix._store.validated = 2), callback = escapedPrefix), array2.push(callback));
+          return 1;
+        }
+        invokeCallback = 0;
+        childKey = "" === nameSoFar ? "." : nameSoFar + ":";
+        if (isArrayImpl(children))
+          for (var i = 0; i < children.length; i++)
+            nameSoFar = children[i], type = childKey + getElementKey(nameSoFar, i), invokeCallback += mapIntoArray(
+              nameSoFar,
+              array2,
+              escapedPrefix,
+              type,
+              callback
+            );
+        else if (i = getIteratorFn(children), "function" === typeof i)
+          for (i === children.entries && (didWarnAboutMaps || console.warn(
+            "Using Maps as children is not supported. Use an array of keyed ReactElements instead."
+          ), didWarnAboutMaps = true), children = i.call(children), i = 0; !(nameSoFar = children.next()).done; )
+            nameSoFar = nameSoFar.value, type = childKey + getElementKey(nameSoFar, i++), invokeCallback += mapIntoArray(
+              nameSoFar,
+              array2,
+              escapedPrefix,
+              type,
+              callback
+            );
+        else if ("object" === type) {
+          if ("function" === typeof children.then)
+            return mapIntoArray(
+              resolveThenable(children),
+              array2,
+              escapedPrefix,
+              nameSoFar,
+              callback
+            );
+          array2 = String(children);
+          throw Error(
+            "Objects are not valid as a React child (found: " + ("[object Object]" === array2 ? "object with keys {" + Object.keys(children).join(", ") + "}" : array2) + "). If you meant to render a collection of children, use an array instead."
+          );
+        }
+        return invokeCallback;
+      }
+      function mapChildren(children, func, context) {
+        if (null == children) return children;
+        var result = [], count = 0;
+        mapIntoArray(children, result, "", "", function(child) {
+          return func.call(context, child, count++);
+        });
+        return result;
+      }
+      function lazyInitializer(payload) {
+        if (-1 === payload._status) {
+          var ioInfo = payload._ioInfo;
+          null != ioInfo && (ioInfo.start = ioInfo.end = performance.now());
+          ioInfo = payload._result;
+          var thenable = ioInfo();
+          thenable.then(
+            function(moduleObject) {
+              if (0 === payload._status || -1 === payload._status) {
+                payload._status = 1;
+                payload._result = moduleObject;
+                var _ioInfo = payload._ioInfo;
+                null != _ioInfo && (_ioInfo.end = performance.now());
+                void 0 === thenable.status && (thenable.status = "fulfilled", thenable.value = moduleObject);
+              }
+            },
+            function(error) {
+              if (0 === payload._status || -1 === payload._status) {
+                payload._status = 2;
+                payload._result = error;
+                var _ioInfo2 = payload._ioInfo;
+                null != _ioInfo2 && (_ioInfo2.end = performance.now());
+                void 0 === thenable.status && (thenable.status = "rejected", thenable.reason = error);
+              }
+            }
+          );
+          ioInfo = payload._ioInfo;
+          if (null != ioInfo) {
+            ioInfo.value = thenable;
+            var displayName = thenable.displayName;
+            "string" === typeof displayName && (ioInfo.name = displayName);
+          }
+          -1 === payload._status && (payload._status = 0, payload._result = thenable);
+        }
+        if (1 === payload._status)
+          return ioInfo = payload._result, void 0 === ioInfo && console.error(
+            "lazy: Expected the result of a dynamic import() call. Instead received: %s\n\nYour code should look like: \n  const MyComponent = lazy(() => import('./MyComponent'))\n\nDid you accidentally put curly braces around the import?",
+            ioInfo
+          ), "default" in ioInfo || console.error(
+            "lazy: Expected the result of a dynamic import() call. Instead received: %s\n\nYour code should look like: \n  const MyComponent = lazy(() => import('./MyComponent'))",
+            ioInfo
+          ), ioInfo.default;
+        throw payload._result;
+      }
+      function resolveDispatcher() {
+        var dispatcher = ReactSharedInternals.H;
+        null === dispatcher && console.error(
+          "Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:\n1. You might have mismatching versions of React and the renderer (such as React DOM)\n2. You might be breaking the Rules of Hooks\n3. You might have more than one copy of React in the same app\nSee https://react.dev/link/invalid-hook-call for tips about how to debug and fix this problem."
+        );
+        return dispatcher;
+      }
+      function releaseAsyncTransition() {
+        ReactSharedInternals.asyncTransitions--;
+      }
+      function enqueueTask(task) {
+        if (null === enqueueTaskImpl)
+          try {
+            var requireString = ("require" + Math.random()).slice(0, 7);
+            enqueueTaskImpl = (module && module[requireString]).call(
+              module,
+              "timers"
+            ).setImmediate;
+          } catch (_err) {
+            enqueueTaskImpl = function(callback) {
+              false === didWarnAboutMessageChannel && (didWarnAboutMessageChannel = true, "undefined" === typeof MessageChannel && console.error(
+                "This browser does not have a MessageChannel implementation, so enqueuing tasks via await act(async () => ...) will fail. Please file an issue at https://github.com/facebook/react/issues if you encounter this warning."
+              ));
+              var channel = new MessageChannel();
+              channel.port1.onmessage = callback;
+              channel.port2.postMessage(void 0);
+            };
+          }
+        return enqueueTaskImpl(task);
+      }
+      function aggregateErrors(errors) {
+        return 1 < errors.length && "function" === typeof AggregateError ? new AggregateError(errors) : errors[0];
+      }
+      function popActScope(prevActQueue, prevActScopeDepth) {
+        prevActScopeDepth !== actScopeDepth - 1 && console.error(
+          "You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. "
+        );
+        actScopeDepth = prevActScopeDepth;
+      }
+      function recursivelyFlushAsyncActWork(returnValue, resolve, reject) {
+        var queue = ReactSharedInternals.actQueue;
+        if (null !== queue)
+          if (0 !== queue.length)
+            try {
+              flushActQueue(queue);
+              enqueueTask(function() {
+                return recursivelyFlushAsyncActWork(returnValue, resolve, reject);
+              });
+              return;
+            } catch (error) {
+              ReactSharedInternals.thrownErrors.push(error);
+            }
+          else ReactSharedInternals.actQueue = null;
+        0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve(returnValue);
+      }
+      function flushActQueue(queue) {
+        if (!isFlushing) {
+          isFlushing = true;
+          var i = 0;
+          try {
+            for (; i < queue.length; i++) {
+              var callback = queue[i];
+              do {
+                ReactSharedInternals.didUsePromise = false;
+                var continuation = callback(false);
+                if (null !== continuation) {
+                  if (ReactSharedInternals.didUsePromise) {
+                    queue[i] = callback;
+                    queue.splice(0, i);
+                    return;
+                  }
+                  callback = continuation;
+                } else break;
+              } while (1);
+            }
+            queue.length = 0;
+          } catch (error) {
+            queue.splice(0, i + 1), ReactSharedInternals.thrownErrors.push(error);
+          } finally {
+            isFlushing = false;
+          }
+        }
+      }
+      "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+      var REACT_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = /* @__PURE__ */ Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = /* @__PURE__ */ Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = /* @__PURE__ */ Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = /* @__PURE__ */ Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = /* @__PURE__ */ Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = /* @__PURE__ */ Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = /* @__PURE__ */ Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = /* @__PURE__ */ Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = /* @__PURE__ */ Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = /* @__PURE__ */ Symbol.for("react.memo"), REACT_LAZY_TYPE = /* @__PURE__ */ Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = /* @__PURE__ */ Symbol.for("react.activity"), MAYBE_ITERATOR_SYMBOL = Symbol.iterator, didWarnStateUpdateForUnmountedComponent = {}, ReactNoopUpdateQueue = {
+        isMounted: function() {
+          return false;
+        },
+        enqueueForceUpdate: function(publicInstance) {
+          warnNoop(publicInstance, "forceUpdate");
+        },
+        enqueueReplaceState: function(publicInstance) {
+          warnNoop(publicInstance, "replaceState");
+        },
+        enqueueSetState: function(publicInstance) {
+          warnNoop(publicInstance, "setState");
+        }
+      }, assign = Object.assign, emptyObject = {};
+      Object.freeze(emptyObject);
+      Component.prototype.isReactComponent = {};
+      Component.prototype.setState = function(partialState, callback) {
+        if ("object" !== typeof partialState && "function" !== typeof partialState && null != partialState)
+          throw Error(
+            "takes an object of state variables to update or a function which returns an object of state variables."
+          );
+        this.updater.enqueueSetState(this, partialState, callback, "setState");
+      };
+      Component.prototype.forceUpdate = function(callback) {
+        this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
+      };
+      var deprecatedAPIs = {
+        isMounted: [
+          "isMounted",
+          "Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks."
+        ],
+        replaceState: [
+          "replaceState",
+          "Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)."
+        ]
+      };
+      for (fnName in deprecatedAPIs)
+        deprecatedAPIs.hasOwnProperty(fnName) && defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);
+      ComponentDummy.prototype = Component.prototype;
+      deprecatedAPIs = PureComponent.prototype = new ComponentDummy();
+      deprecatedAPIs.constructor = PureComponent;
+      assign(deprecatedAPIs, Component.prototype);
+      deprecatedAPIs.isPureReactComponent = true;
+      var isArrayImpl = Array.isArray, REACT_CLIENT_REFERENCE = /* @__PURE__ */ Symbol.for("react.client.reference"), ReactSharedInternals = {
+        H: null,
+        A: null,
+        T: null,
+        S: null,
+        actQueue: null,
+        asyncTransitions: 0,
+        isBatchingLegacy: false,
+        didScheduleLegacyUpdate: false,
+        didUsePromise: false,
+        thrownErrors: [],
+        getCurrentStack: null,
+        recentlyCreatedOwnerStacks: 0
+      }, hasOwnProperty = Object.prototype.hasOwnProperty, createTask = console.createTask ? console.createTask : function() {
+        return null;
+      };
+      deprecatedAPIs = {
+        react_stack_bottom_frame: function(callStackForError) {
+          return callStackForError();
+        }
+      };
+      var specialPropKeyWarningShown, didWarnAboutOldJSXRuntime;
+      var didWarnAboutElementRef = {};
+      var unknownOwnerDebugStack = deprecatedAPIs.react_stack_bottom_frame.bind(
+        deprecatedAPIs,
+        UnknownOwner
+      )();
+      var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
+      var didWarnAboutMaps = false, userProvidedKeyEscapeRegex = /\/+/g, reportGlobalError = "function" === typeof reportError ? reportError : function(error) {
+        if ("object" === typeof window && "function" === typeof window.ErrorEvent) {
+          var event = new window.ErrorEvent("error", {
+            bubbles: true,
+            cancelable: true,
+            message: "object" === typeof error && null !== error && "string" === typeof error.message ? String(error.message) : String(error),
+            error
+          });
+          if (!window.dispatchEvent(event)) return;
+        } else if ("object" === typeof process && "function" === typeof process.emit) {
+          process.emit("uncaughtException", error);
+          return;
+        }
+        console.error(error);
+      }, didWarnAboutMessageChannel = false, enqueueTaskImpl = null, actScopeDepth = 0, didWarnNoAwaitAct = false, isFlushing = false, queueSeveralMicrotasks = "function" === typeof queueMicrotask ? function(callback) {
+        queueMicrotask(function() {
+          return queueMicrotask(callback);
+        });
+      } : enqueueTask;
+      deprecatedAPIs = Object.freeze({
+        __proto__: null,
+        c: function(size) {
+          return resolveDispatcher().useMemoCache(size);
+        }
+      });
+      var fnName = {
+        map: mapChildren,
+        forEach: function(children, forEachFunc, forEachContext) {
+          mapChildren(
+            children,
+            function() {
+              forEachFunc.apply(this, arguments);
+            },
+            forEachContext
+          );
+        },
+        count: function(children) {
+          var n = 0;
+          mapChildren(children, function() {
+            n++;
+          });
+          return n;
+        },
+        toArray: function(children) {
+          return mapChildren(children, function(child) {
+            return child;
+          }) || [];
+        },
+        only: function(children) {
+          if (!isValidElement(children))
+            throw Error(
+              "React.Children.only expected to receive a single React element child."
+            );
+          return children;
+        }
+      };
+      exports.Activity = REACT_ACTIVITY_TYPE;
+      exports.Children = fnName;
+      exports.Component = Component;
+      exports.Fragment = REACT_FRAGMENT_TYPE;
+      exports.Profiler = REACT_PROFILER_TYPE;
+      exports.PureComponent = PureComponent;
+      exports.StrictMode = REACT_STRICT_MODE_TYPE;
+      exports.Suspense = REACT_SUSPENSE_TYPE;
+      exports.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = ReactSharedInternals;
+      exports.__COMPILER_RUNTIME = deprecatedAPIs;
+      exports.act = function(callback) {
+        var prevActQueue = ReactSharedInternals.actQueue, prevActScopeDepth = actScopeDepth;
+        actScopeDepth++;
+        var queue = ReactSharedInternals.actQueue = null !== prevActQueue ? prevActQueue : [], didAwaitActCall = false;
+        try {
+          var result = callback();
+        } catch (error) {
+          ReactSharedInternals.thrownErrors.push(error);
+        }
+        if (0 < ReactSharedInternals.thrownErrors.length)
+          throw popActScope(prevActQueue, prevActScopeDepth), callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
+        if (null !== result && "object" === typeof result && "function" === typeof result.then) {
+          var thenable = result;
+          queueSeveralMicrotasks(function() {
+            didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = true, console.error(
+              "You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);"
+            ));
+          });
+          return {
+            then: function(resolve, reject) {
+              didAwaitActCall = true;
+              thenable.then(
+                function(returnValue) {
+                  popActScope(prevActQueue, prevActScopeDepth);
+                  if (0 === prevActScopeDepth) {
+                    try {
+                      flushActQueue(queue), enqueueTask(function() {
+                        return recursivelyFlushAsyncActWork(
+                          returnValue,
+                          resolve,
+                          reject
+                        );
+                      });
+                    } catch (error$0) {
+                      ReactSharedInternals.thrownErrors.push(error$0);
+                    }
+                    if (0 < ReactSharedInternals.thrownErrors.length) {
+                      var _thrownError = aggregateErrors(
+                        ReactSharedInternals.thrownErrors
+                      );
+                      ReactSharedInternals.thrownErrors.length = 0;
+                      reject(_thrownError);
+                    }
+                  } else resolve(returnValue);
+                },
+                function(error) {
+                  popActScope(prevActQueue, prevActScopeDepth);
+                  0 < ReactSharedInternals.thrownErrors.length ? (error = aggregateErrors(
+                    ReactSharedInternals.thrownErrors
+                  ), ReactSharedInternals.thrownErrors.length = 0, reject(error)) : reject(error);
+                }
+              );
+            }
+          };
+        }
+        var returnValue$jscomp$0 = result;
+        popActScope(prevActQueue, prevActScopeDepth);
+        0 === prevActScopeDepth && (flushActQueue(queue), 0 !== queue.length && queueSeveralMicrotasks(function() {
+          didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = true, console.error(
+            "A component suspended inside an `act` scope, but the `act` call was not awaited. When testing React components that depend on asynchronous data, you must await the result:\n\nawait act(() => ...)"
+          ));
+        }), ReactSharedInternals.actQueue = null);
+        if (0 < ReactSharedInternals.thrownErrors.length)
+          throw callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
+        return {
+          then: function(resolve, reject) {
+            didAwaitActCall = true;
+            0 === prevActScopeDepth ? (ReactSharedInternals.actQueue = queue, enqueueTask(function() {
+              return recursivelyFlushAsyncActWork(
+                returnValue$jscomp$0,
+                resolve,
+                reject
+              );
+            })) : resolve(returnValue$jscomp$0);
+          }
+        };
+      };
+      exports.cache = function(fn) {
+        return function() {
+          return fn.apply(null, arguments);
+        };
+      };
+      exports.cacheSignal = function() {
+        return null;
+      };
+      exports.captureOwnerStack = function() {
+        var getCurrentStack = ReactSharedInternals.getCurrentStack;
+        return null === getCurrentStack ? null : getCurrentStack();
+      };
+      exports.cloneElement = function(element, config, children) {
+        if (null === element || void 0 === element)
+          throw Error(
+            "The argument must be a React element, but you passed " + element + "."
+          );
+        var props = assign({}, element.props), key = element.key, owner = element._owner;
+        if (null != config) {
+          var JSCompiler_inline_result;
+          a: {
+            if (hasOwnProperty.call(config, "ref") && (JSCompiler_inline_result = Object.getOwnPropertyDescriptor(
+              config,
+              "ref"
+            ).get) && JSCompiler_inline_result.isReactWarning) {
+              JSCompiler_inline_result = false;
+              break a;
+            }
+            JSCompiler_inline_result = void 0 !== config.ref;
+          }
+          JSCompiler_inline_result && (owner = getOwner());
+          hasValidKey(config) && (checkKeyStringCoercion(config.key), key = "" + config.key);
+          for (propName in config)
+            !hasOwnProperty.call(config, propName) || "key" === propName || "__self" === propName || "__source" === propName || "ref" === propName && void 0 === config.ref || (props[propName] = config[propName]);
+        }
+        var propName = arguments.length - 2;
+        if (1 === propName) props.children = children;
+        else if (1 < propName) {
+          JSCompiler_inline_result = Array(propName);
+          for (var i = 0; i < propName; i++)
+            JSCompiler_inline_result[i] = arguments[i + 2];
+          props.children = JSCompiler_inline_result;
+        }
+        props = ReactElement(
+          element.type,
+          key,
+          props,
+          owner,
+          element._debugStack,
+          element._debugTask
+        );
+        for (key = 2; key < arguments.length; key++)
+          validateChildKeys(arguments[key]);
+        return props;
+      };
+      exports.createContext = function(defaultValue) {
+        defaultValue = {
+          $$typeof: REACT_CONTEXT_TYPE,
+          _currentValue: defaultValue,
+          _currentValue2: defaultValue,
+          _threadCount: 0,
+          Provider: null,
+          Consumer: null
+        };
+        defaultValue.Provider = defaultValue;
+        defaultValue.Consumer = {
+          $$typeof: REACT_CONSUMER_TYPE,
+          _context: defaultValue
+        };
+        defaultValue._currentRenderer = null;
+        defaultValue._currentRenderer2 = null;
+        return defaultValue;
+      };
+      exports.createElement = function(type, config, children) {
+        for (var i = 2; i < arguments.length; i++)
+          validateChildKeys(arguments[i]);
+        i = {};
+        var key = null;
+        if (null != config)
+          for (propName in didWarnAboutOldJSXRuntime || !("__self" in config) || "key" in config || (didWarnAboutOldJSXRuntime = true, console.warn(
+            "Your app (or one of its dependencies) is using an outdated JSX transform. Update to the modern JSX transform for faster performance: https://react.dev/link/new-jsx-transform"
+          )), hasValidKey(config) && (checkKeyStringCoercion(config.key), key = "" + config.key), config)
+            hasOwnProperty.call(config, propName) && "key" !== propName && "__self" !== propName && "__source" !== propName && (i[propName] = config[propName]);
+        var childrenLength = arguments.length - 2;
+        if (1 === childrenLength) i.children = children;
+        else if (1 < childrenLength) {
+          for (var childArray = Array(childrenLength), _i = 0; _i < childrenLength; _i++)
+            childArray[_i] = arguments[_i + 2];
+          Object.freeze && Object.freeze(childArray);
+          i.children = childArray;
+        }
+        if (type && type.defaultProps)
+          for (propName in childrenLength = type.defaultProps, childrenLength)
+            void 0 === i[propName] && (i[propName] = childrenLength[propName]);
+        key && defineKeyPropWarningGetter(
+          i,
+          "function" === typeof type ? type.displayName || type.name || "Unknown" : type
+        );
+        var propName = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+        return ReactElement(
+          type,
+          key,
+          i,
+          getOwner(),
+          propName ? Error("react-stack-top-frame") : unknownOwnerDebugStack,
+          propName ? createTask(getTaskName(type)) : unknownOwnerDebugTask
+        );
+      };
+      exports.createRef = function() {
+        var refObject = { current: null };
+        Object.seal(refObject);
+        return refObject;
+      };
+      exports.forwardRef = function(render) {
+        null != render && render.$$typeof === REACT_MEMO_TYPE ? console.error(
+          "forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...))."
+        ) : "function" !== typeof render ? console.error(
+          "forwardRef requires a render function but was given %s.",
+          null === render ? "null" : typeof render
+        ) : 0 !== render.length && 2 !== render.length && console.error(
+          "forwardRef render functions accept exactly two parameters: props and ref. %s",
+          1 === render.length ? "Did you forget to use the ref parameter?" : "Any additional parameter will be undefined."
+        );
+        null != render && null != render.defaultProps && console.error(
+          "forwardRef render functions do not support defaultProps. Did you accidentally pass a React component?"
+        );
+        var elementType = { $$typeof: REACT_FORWARD_REF_TYPE, render }, ownName;
+        Object.defineProperty(elementType, "displayName", {
+          enumerable: false,
+          configurable: true,
+          get: function() {
+            return ownName;
+          },
+          set: function(name) {
+            ownName = name;
+            render.name || render.displayName || (Object.defineProperty(render, "name", { value: name }), render.displayName = name);
+          }
+        });
+        return elementType;
+      };
+      exports.isValidElement = isValidElement;
+      exports.lazy = function(ctor) {
+        ctor = { _status: -1, _result: ctor };
+        var lazyType = {
+          $$typeof: REACT_LAZY_TYPE,
+          _payload: ctor,
+          _init: lazyInitializer
+        }, ioInfo = {
+          name: "lazy",
+          start: -1,
+          end: -1,
+          value: null,
+          owner: null,
+          debugStack: Error("react-stack-top-frame"),
+          debugTask: console.createTask ? console.createTask("lazy()") : null
+        };
+        ctor._ioInfo = ioInfo;
+        lazyType._debugInfo = [{ awaited: ioInfo }];
+        return lazyType;
+      };
+      exports.memo = function(type, compare) {
+        null == type && console.error(
+          "memo: The first argument must be a component. Instead received: %s",
+          null === type ? "null" : typeof type
+        );
+        compare = {
+          $$typeof: REACT_MEMO_TYPE,
+          type,
+          compare: void 0 === compare ? null : compare
+        };
+        var ownName;
+        Object.defineProperty(compare, "displayName", {
+          enumerable: false,
+          configurable: true,
+          get: function() {
+            return ownName;
+          },
+          set: function(name) {
+            ownName = name;
+            type.name || type.displayName || (Object.defineProperty(type, "name", { value: name }), type.displayName = name);
+          }
+        });
+        return compare;
+      };
+      exports.startTransition = function(scope) {
+        var prevTransition = ReactSharedInternals.T, currentTransition = {};
+        currentTransition._updatedFibers = /* @__PURE__ */ new Set();
+        ReactSharedInternals.T = currentTransition;
+        try {
+          var returnValue = scope(), onStartTransitionFinish = ReactSharedInternals.S;
+          null !== onStartTransitionFinish && onStartTransitionFinish(currentTransition, returnValue);
+          "object" === typeof returnValue && null !== returnValue && "function" === typeof returnValue.then && (ReactSharedInternals.asyncTransitions++, returnValue.then(releaseAsyncTransition, releaseAsyncTransition), returnValue.then(noop, reportGlobalError));
+        } catch (error) {
+          reportGlobalError(error);
+        } finally {
+          null === prevTransition && currentTransition._updatedFibers && (scope = currentTransition._updatedFibers.size, currentTransition._updatedFibers.clear(), 10 < scope && console.warn(
+            "Detected a large number of updates inside startTransition. If this is due to a subscription please re-write it to use React provided hooks. Otherwise concurrent mode guarantees are off the table."
+          )), null !== prevTransition && null !== currentTransition.types && (null !== prevTransition.types && prevTransition.types !== currentTransition.types && console.error(
+            "We expected inner Transitions to have transferred the outer types set and that you cannot add to the outer Transition while inside the inner.This is a bug in React."
+          ), prevTransition.types = currentTransition.types), ReactSharedInternals.T = prevTransition;
+        }
+      };
+      exports.unstable_useCacheRefresh = function() {
+        return resolveDispatcher().useCacheRefresh();
+      };
+      exports.use = function(usable) {
+        return resolveDispatcher().use(usable);
+      };
+      exports.useActionState = function(action, initialState, permalink) {
+        return resolveDispatcher().useActionState(
+          action,
+          initialState,
+          permalink
+        );
+      };
+      exports.useCallback = function(callback, deps) {
+        return resolveDispatcher().useCallback(callback, deps);
+      };
+      exports.useContext = function(Context) {
+        var dispatcher = resolveDispatcher();
+        Context.$$typeof === REACT_CONSUMER_TYPE && console.error(
+          "Calling useContext(Context.Consumer) is not supported and will cause bugs. Did you mean to call useContext(Context) instead?"
+        );
+        return dispatcher.useContext(Context);
+      };
+      exports.useDebugValue = function(value, formatterFn) {
+        return resolveDispatcher().useDebugValue(value, formatterFn);
+      };
+      exports.useDeferredValue = function(value, initialValue) {
+        return resolveDispatcher().useDeferredValue(value, initialValue);
+      };
+      exports.useEffect = function(create, deps) {
+        null == create && console.warn(
+          "React Hook useEffect requires an effect callback. Did you forget to pass a callback to the hook?"
+        );
+        return resolveDispatcher().useEffect(create, deps);
+      };
+      exports.useEffectEvent = function(callback) {
+        return resolveDispatcher().useEffectEvent(callback);
+      };
+      exports.useId = function() {
+        return resolveDispatcher().useId();
+      };
+      exports.useImperativeHandle = function(ref, create, deps) {
+        return resolveDispatcher().useImperativeHandle(ref, create, deps);
+      };
+      exports.useInsertionEffect = function(create, deps) {
+        null == create && console.warn(
+          "React Hook useInsertionEffect requires an effect callback. Did you forget to pass a callback to the hook?"
+        );
+        return resolveDispatcher().useInsertionEffect(create, deps);
+      };
+      exports.useLayoutEffect = function(create, deps) {
+        null == create && console.warn(
+          "React Hook useLayoutEffect requires an effect callback. Did you forget to pass a callback to the hook?"
+        );
+        return resolveDispatcher().useLayoutEffect(create, deps);
+      };
+      exports.useMemo = function(create, deps) {
+        return resolveDispatcher().useMemo(create, deps);
+      };
+      exports.useOptimistic = function(passthrough, reducer) {
+        return resolveDispatcher().useOptimistic(passthrough, reducer);
+      };
+      exports.useReducer = function(reducer, initialArg, init) {
+        return resolveDispatcher().useReducer(reducer, initialArg, init);
+      };
+      exports.useRef = function(initialValue) {
+        return resolveDispatcher().useRef(initialValue);
+      };
+      exports.useState = function(initialState) {
+        return resolveDispatcher().useState(initialState);
+      };
+      exports.useSyncExternalStore = function(subscribe, getSnapshot, getServerSnapshot) {
+        return resolveDispatcher().useSyncExternalStore(
+          subscribe,
+          getSnapshot,
+          getServerSnapshot
+        );
+      };
+      exports.useTransition = function() {
+        return resolveDispatcher().useTransition();
+      };
+      exports.version = "19.2.8";
+      "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+    })();
+  }
+});
+
+// node_modules/.pnpm/react@19.2.8/node_modules/react/index.js
+var require_react = __commonJS({
+  "node_modules/.pnpm/react@19.2.8/node_modules/react/index.js"(exports, module) {
+    "use strict";
+    if (process.env.NODE_ENV === "production") {
+      module.exports = require_react_production();
+    } else {
+      module.exports = require_react_development();
+    }
+  }
+});
+
+// mcp/index.ts
+import { McpServer } from "@modelcontextprotocol/server";
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
+
+// mcp/file.ts
+import { randomBytes } from "node:crypto";
+import { readFile, rename, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+
+// src/lib/time.ts
+var MINUTES_PER_DAY = 1440;
+var DAY_MS = 864e5;
+var WEEKDAYS = [
+  "Sunday",
+  "Monday",
+  "Tuesday",
+  "Wednesday",
+  "Thursday",
+  "Friday",
+  "Saturday"
+];
+var MONTHS = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+function startOfDay(d) {
+  const out = new Date(d);
+  out.setHours(0, 0, 0, 0);
+  return out;
+}
+function addDays(d, n) {
+  const out = new Date(d);
+  out.setDate(out.getDate() + n);
+  return out;
+}
+function daysInMonth(year, month) {
+  return new Date(year, month + 1, 0).getDate();
+}
+function isSameDay(a, b) {
+  return a.getFullYear() === b.getFullYear() && a.getMonth() === b.getMonth() && a.getDate() === b.getDate();
+}
+function daysBetween(from, to) {
+  return Math.round((startOfDay(to).getTime() - startOfDay(from).getTime()) / 864e5);
+}
+function dayKey(d) {
+  const m = `${d.getMonth() + 1}`.padStart(2, "0");
+  const day = `${d.getDate()}`.padStart(2, "0");
+  return `${d.getFullYear()}-${m}-${day}`;
+}
+function fromDayKey(key) {
+  const [y, m, d] = key.split("-").map(Number);
+  return new Date(y, (m ?? 1) - 1, d ?? 1);
+}
+function minutesOfDay(d) {
+  return d.getHours() * 60 + d.getMinutes() + d.getSeconds() / 60;
+}
+function atMinutes(day, minutes) {
+  const out = startOfDay(day);
+  out.setMinutes(Math.round(minutes));
+  return out;
+}
+function isZone(value) {
+  if (!value) return false;
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: value });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var ZONE_FORMATTERS = /* @__PURE__ */ new Map();
+function zoneFormatter(zone) {
+  let fmt = ZONE_FORMATTERS.get(zone);
+  if (!fmt) {
+    fmt = new Intl.DateTimeFormat("en-US", {
+      timeZone: zone,
+      hourCycle: "h23",
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit"
+    });
+    ZONE_FORMATTERS.set(zone, fmt);
+  }
+  return fmt;
+}
+function zoneParts(at, zone) {
+  const out = {};
+  for (const part of zoneFormatter(zone).formatToParts(at)) {
+    if (part.type !== "literal") out[part.type] = Number(part.value);
+  }
+  return {
+    year: out.year ?? at.getFullYear(),
+    month: out.month ?? at.getMonth() + 1,
+    day: out.day ?? at.getDate(),
+    // `hourCycle: "h23"` still emits 24 for midnight in some engines.
+    hour: (out.hour ?? at.getHours()) % 24,
+    minute: out.minute ?? at.getMinutes(),
+    second: out.second ?? at.getSeconds()
+  };
+}
+function zoneOffset(at, zone) {
+  const p = zoneParts(at, zone);
+  const asUtc = Date.UTC(p.year, p.month - 1, p.day, p.hour, p.minute, p.second);
+  return Math.round((asUtc - Math.floor(at.getTime() / 1e3) * 1e3) / 6e4);
+}
+function zonedToUtc(year, month, day, hour, minute, zone, second = 0) {
+  const naive = Date.UTC(year, month - 1, day, hour, minute, second);
+  const before = naive - zoneOffset(new Date(naive - DAY_MS), zone) * 6e4;
+  const after = naive - zoneOffset(new Date(naive + DAY_MS), zone) * 6e4;
+  const reads = (at) => {
+    const p = zoneParts(new Date(at), zone);
+    return p.year === year && p.month === month && p.day === day && p.hour === hour && p.minute === minute && p.second === second;
+  };
+  if (reads(before)) return before;
+  if (reads(after)) return after;
+  return before;
+}
+function wallClockIn(at, zone) {
+  const p = zoneParts(new Date(at), zone);
+  return new Date(p.year, p.month - 1, p.day, p.hour, p.minute, p.second);
+}
+function instantOfWall(wall, zone) {
+  return zonedToUtc(
+    wall.getFullYear(),
+    wall.getMonth() + 1,
+    wall.getDate(),
+    wall.getHours(),
+    wall.getMinutes(),
+    zone,
+    wall.getSeconds()
+  );
+}
+function zoneCity(zone) {
+  const last = zone.split("/").pop() ?? zone;
+  return last.replace(/_/g, " ");
+}
+function zoneRegion(zone) {
+  const parts = zone.split("/");
+  return parts.length > 1 ? parts.slice(0, -1).join("/").replace(/_/g, " ") : "";
+}
+function zoneLabel(zone) {
+  const region = zoneRegion(zone);
+  return region ? `${zoneCity(zone)} \xB7 ${region}` : zoneCity(zone);
+}
+function localZone() {
+  return Intl.DateTimeFormat().resolvedOptions().timeZone;
+}
+function splitTime(d, clock = "12h") {
+  const minutes = `${d.getMinutes()}`.padStart(2, "0");
+  if (clock === "24h") {
+    return { time: `${`${d.getHours()}`.padStart(2, "0")}:${minutes}`, suffix: "" };
+  }
+  const h = d.getHours();
+  return { time: `${h % 12 || 12}:${minutes}`, suffix: h < 12 ? "AM" : "PM" };
+}
+function formatTime(d, clock = "12h") {
+  const { time, suffix } = splitTime(d, clock);
+  return suffix ? `${time} ${suffix}` : time;
+}
+function formatTimeShort(d, clock = "12h") {
+  if (clock === "24h") return formatTime(d, clock);
+  const h = d.getHours() % 12 || 12;
+  const suffix = d.getHours() < 12 ? "AM" : "PM";
+  return d.getMinutes() === 0 ? `${h} ${suffix}` : `${h}:${`${d.getMinutes()}`.padStart(2, "0")} ${suffix}`;
+}
+function formatDuration(minutes) {
+  const m = Math.max(0, Math.round(minutes));
+  if (m < 60) return `${m}m`;
+  const h = Math.floor(m / 60);
+  const rem = m % 60;
+  return rem === 0 ? `${h}h` : `${h}h ${rem}m`;
+}
+function parseClock(value) {
+  const match = /^\s*(\d{1,2})(?::?(\d{2}))?\s*(?:([ap])\.?m?\.?)?\s*$/i.exec(value);
+  if (!match) return null;
+  let hours = Number(match[1]);
+  const minutes = match[2] ? Number(match[2]) : 0;
+  const meridiem = match[3]?.toLowerCase();
+  if (minutes > 59) return null;
+  if (meridiem) {
+    if (hours < 1 || hours > 12) return null;
+    hours = hours % 12 + (meridiem === "p" ? 12 : 0);
+  } else if (hours > 23) {
+    return null;
+  }
+  return hours * 60 + minutes;
+}
+function snap(minutes, step = 15) {
+  return Math.round(minutes / step) * step;
+}
+
+// src/lib/utils.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/lib/recur.ts
+var FREQUENCIES = [
+  "never",
+  "secondly",
+  "minutely",
+  "hourly",
+  "daily",
+  "weekly",
+  "monthly",
+  "yearly"
+];
+var UNITS = {
+  never: "",
+  secondly: "second",
+  minutely: "minute",
+  hourly: "hour",
+  daily: "day",
+  weekly: "week",
+  monthly: "month",
+  yearly: "year"
+};
+function repeatUnit(repeat, n) {
+  return n === 1 ? UNITS[repeat] : `${UNITS[repeat]}s`;
+}
+var NEVER = {
+  repeat: "never",
+  interval: 1,
+  until: 0,
+  wkst: 1,
+  byMonth: [],
+  byWeekNo: [],
+  byYearDay: [],
+  byMonthDay: [],
+  byDay: [],
+  byHour: [],
+  byMinute: [],
+  bySecond: [],
+  bySetPos: [],
+  exdates: [],
+  rdates: []
+};
+function recurrenceOf(source) {
+  return {
+    repeat: source.repeat,
+    interval: source.interval,
+    until: source.until,
+    wkst: source.wkst,
+    byMonth: [...source.byMonth],
+    byWeekNo: [...source.byWeekNo],
+    byYearDay: [...source.byYearDay],
+    byMonthDay: [...source.byMonthDay],
+    byDay: source.byDay.map((d) => ({ ...d })),
+    byHour: [...source.byHour],
+    byMinute: [...source.byMinute],
+    bySecond: [...source.bySecond],
+    bySetPos: [...source.bySetPos],
+    exdates: [...source.exdates],
+    rdates: [...source.rdates]
+  };
+}
+function repeats(rule) {
+  return rule.repeat !== "never" || rule.rdates.length > 0;
+}
+var UNSIGNED_RANGE = {
+  byMonth: [1, 12],
+  byHour: [0, 23],
+  byMinute: [0, 59],
+  bySecond: [0, 60]
+};
+var SIGNED_MAX = {
+  byWeekNo: 53,
+  byYearDay: 366,
+  byMonthDay: 31,
+  bySetPos: 366
+};
+var MAX_INTERVAL = 999;
+var WEEKDAY_MAX = 6;
+var NTH_MAX = 5;
+var DATE_KEY = /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2})?$/;
+function unsignedInts(v, [lo, hi]) {
+  return Array.isArray(v) ? [...new Set(v.filter((n) => Number.isInteger(n) && n >= lo && n <= hi))] : [];
+}
+function signedInts(v, max) {
+  return Array.isArray(v) ? [
+    ...new Set(
+      v.filter((n) => Number.isInteger(n) && n !== 0 && n >= -max && n <= max)
+    )
+  ] : [];
+}
+function dateKeys(v) {
+  return Array.isArray(v) ? [...new Set(v.filter((k) => typeof k === "string" && DATE_KEY.test(k)))] : [];
+}
+function readRecurrence(value) {
+  if (!isRecord(value)) return { ...NEVER };
+  const dates = { exdates: dateKeys(value.exdates), rdates: dateKeys(value.rdates) };
+  const { repeat, interval, until, wkst } = value;
+  if (!FREQUENCIES.includes(repeat) || repeat === "never") {
+    return { ...NEVER, ...dates };
+  }
+  const byDay = Array.isArray(value.byDay) ? value.byDay.filter(
+    (d) => isRecord(d) && Number.isInteger(d.day) && d.day >= 0 && d.day <= WEEKDAY_MAX && Number.isInteger(d.nth) && d.nth >= -NTH_MAX && d.nth <= NTH_MAX
+  ).map((d) => ({ day: d.day, nth: d.nth })) : [];
+  return {
+    repeat,
+    interval: typeof interval === "number" && Number.isFinite(interval) ? Math.min(MAX_INTERVAL, Math.max(1, Math.trunc(interval))) : NEVER.interval,
+    until: typeof until === "number" && Number.isFinite(until) && until > 0 ? until : NEVER.until,
+    wkst: Number.isInteger(wkst) && wkst >= 0 && wkst <= WEEKDAY_MAX ? wkst : NEVER.wkst,
+    byMonth: unsignedInts(value.byMonth, UNSIGNED_RANGE.byMonth),
+    byWeekNo: signedInts(value.byWeekNo, SIGNED_MAX.byWeekNo),
+    byYearDay: signedInts(value.byYearDay, SIGNED_MAX.byYearDay),
+    byMonthDay: signedInts(value.byMonthDay, SIGNED_MAX.byMonthDay),
+    byDay,
+    byHour: unsignedInts(value.byHour, UNSIGNED_RANGE.byHour),
+    byMinute: unsignedInts(value.byMinute, UNSIGNED_RANGE.byMinute),
+    bySecond: unsignedInts(value.bySecond, UNSIGNED_RANGE.bySecond),
+    bySetPos: signedInts(value.bySetPos, SIGNED_MAX.bySetPos),
+    ...dates
+  };
+}
+var pad = (n) => String(n).padStart(2, "0");
+function instantKey(at) {
+  const d = at instanceof Date ? at : new Date(at);
+  return `${dayKey(d)}T${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+}
+function keyToInstant(key, seed) {
+  const m = /^(\d{4})-(\d{2})-(\d{2})(?:T(\d{2}):(\d{2}):(\d{2}))?$/.exec(key);
+  if (!m) return null;
+  const [y, mo, d] = [Number(m[1]), Number(m[2]), Number(m[3])];
+  if (m[4] === void 0) {
+    return new Date(y, mo - 1, d, seed.getHours(), seed.getMinutes(), seed.getSeconds()).getTime();
+  }
+  return new Date(y, mo - 1, d, Number(m[4]), Number(m[5]), Number(m[6])).getTime();
+}
+var HOUR_MS = 36e5;
+var MINUTE_MS = 6e4;
+var SECOND_MS = 1e3;
+var MAX_INSTANTS = 512;
+var isLeap = (y) => new Date(y, 1, 29).getMonth() === 1;
+var daysInYear = (y) => isLeap(y) ? 366 : 365;
+function weekStart(d, wkst) {
+  const day = startOfDay(d);
+  return addDays(day, -((day.getDay() - wkst + 7) % 7));
+}
+function monthDayOf(y, m, day) {
+  const total = daysInMonth(y, m);
+  const date = day > 0 ? day : total + 1 + day;
+  return date >= 1 && date <= total ? new Date(y, m, date) : null;
+}
+function weekNoStart(year, n, wkst) {
+  const firstWeek = (y) => {
+    const jan1 = new Date(y, 0, 1);
+    const into = (jan1.getDay() - wkst + 7) % 7;
+    return addDays(jan1, into > 3 ? 7 - into : -into);
+  };
+  const start = firstWeek(year);
+  const total = Math.round(daysBetween(start, firstWeek(year + 1)) / 7);
+  const index = n > 0 ? n : total + 1 + n;
+  return index >= 1 && index <= total ? addDays(start, (index - 1) * 7) : null;
+}
+function weekdaysIn(from, to, day) {
+  const out = [];
+  let cursor = addDays(from, (day - from.getDay() + 7) % 7);
+  while (cursor < to) {
+    out.push(cursor);
+    cursor = addDays(cursor, 7);
+  }
+  return out;
+}
+function byDayWithin(rules, from, to) {
+  const out = [];
+  for (const rule of rules) {
+    const all = weekdaysIn(from, to, rule.day);
+    if (rule.nth === 0) out.push(...all);
+    else {
+      const hit = rule.nth > 0 ? all[rule.nth - 1] : all[all.length + rule.nth];
+      if (hit) out.push(hit);
+    }
+  }
+  return out;
+}
+var sortDates = (dates) => [...new Map(dates.map((d) => [d.getTime(), d])).values()].sort(
+  (a, b) => a.getTime() - b.getTime()
+);
+function inMonths(rule, d) {
+  return rule.byMonth.length === 0 || rule.byMonth.includes(d.getMonth() + 1);
+}
+function onMonthDays(rule, d) {
+  if (rule.byMonthDay.length === 0) return true;
+  const total = daysInMonth(d.getFullYear(), d.getMonth());
+  return rule.byMonthDay.some((n) => (n > 0 ? n : total + 1 + n) === d.getDate());
+}
+function onWeekdays(rule, d) {
+  return rule.byDay.length === 0 || rule.byDay.some((w) => w.day === d.getDay());
+}
+function onYearDays(rule, d) {
+  if (rule.byYearDay.length === 0) return true;
+  const len = daysInYear(d.getFullYear());
+  const doy = daysBetween(new Date(d.getFullYear(), 0, 1), d) + 1;
+  return rule.byYearDay.some((n) => (n > 0 ? n : len + 1 + n) === doy);
+}
+function daysOfPeriod(rule, seed, period) {
+  const y = period.getFullYear();
+  if (rule.repeat === "daily") {
+    const d = startOfDay(period);
+    return inMonths(rule, d) && onMonthDays(rule, d) && onWeekdays(rule, d) ? [d] : [];
+  }
+  if (rule.repeat === "weekly") {
+    const from = weekStart(period, rule.wkst);
+    const to = addDays(from, 7);
+    const days = rule.byDay.length > 0 ? byDayWithin(rule.byDay, from, to) : [seedDayIn(seed, from)];
+    return sortDates(days.filter((d) => inMonths(rule, d)));
+  }
+  if (rule.repeat === "monthly") {
+    if (!inMonths(rule, period)) return [];
+    const m = period.getMonth();
+    const from = new Date(y, m, 1);
+    const to = new Date(y, m + 1, 1);
+    const fromMonthDay = rule.byMonthDay.map((n) => monthDayOf(y, m, n)).filter((d) => d !== null);
+    const fromWeekday = rule.byDay.length > 0 ? byDayWithin(rule.byDay, from, to) : [];
+    if (rule.byMonthDay.length > 0 && rule.byDay.length > 0) {
+      const wanted = new Set(fromWeekday.map((d) => d.getTime()));
+      return sortDates(fromMonthDay.filter((d) => wanted.has(d.getTime())));
+    }
+    if (rule.byMonthDay.length > 0) return sortDates(fromMonthDay);
+    if (rule.byDay.length > 0) return sortDates(fromWeekday);
+    const own = monthDayOf(y, m, seed.getDate());
+    return own ? [own] : [];
+  }
+  return yearlyDays(rule, seed, y);
+}
+function seedDayIn(seed, from) {
+  return addDays(from, (seed.getDay() - from.getDay() + 7) % 7);
+}
+function yearlyDays(rule, seed, y) {
+  const months = rule.byMonth.length > 0 ? rule.byMonth.map((m) => m - 1) : null;
+  if (rule.byYearDay.length > 0) {
+    const len = daysInYear(y);
+    const days = rule.byYearDay.map((n) => n > 0 ? n : len + 1 + n).filter((n) => n >= 1 && n <= len).map((n) => new Date(y, 0, n));
+    return sortDates(days.filter((d) => inMonths(rule, d) && onWeekdays(rule, d)));
+  }
+  if (rule.byWeekNo.length > 0) {
+    const wanted = rule.byDay.length > 0 ? rule.byDay.map((w) => w.day) : [seed.getDay()];
+    const days = [];
+    for (const n of rule.byWeekNo) {
+      const from = weekNoStart(y, n, rule.wkst);
+      if (!from) continue;
+      for (let i = 0; i < 7; i++) {
+        const d = addDays(from, i);
+        if (wanted.includes(d.getDay())) days.push(d);
+      }
+    }
+    return sortDates(days.filter((d) => inMonths(rule, d)));
+  }
+  if (rule.byDay.length > 0 && rule.byMonthDay.length === 0 && months === null) {
+    return sortDates(byDayWithin(rule.byDay, new Date(y, 0, 1), new Date(y + 1, 0, 1)));
+  }
+  if (rule.byDay.length > 0 || rule.byMonthDay.length > 0) {
+    const list2 = months ?? [...Array(12).keys()];
+    const days = [];
+    for (const m of list2) {
+      days.push(
+        ...daysOfPeriod({ ...rule, repeat: "monthly", byMonth: [] }, seed, new Date(y, m, 1))
+      );
+    }
+    return sortDates(days);
+  }
+  const list = months ?? [seed.getMonth()];
+  return sortDates(list.map((m) => monthDayOf(y, m, seed.getDate())).filter((d) => !!d));
+}
+function clockOf(rule, seed) {
+  const hours = rule.byHour.length > 0 ? rule.byHour : [seed.getHours()];
+  const minutes = rule.byMinute.length > 0 ? rule.byMinute : [seed.getMinutes()];
+  const seconds = rule.bySecond.length > 0 ? rule.bySecond : [seed.getSeconds()];
+  const out = [];
+  for (const h of hours) for (const m of minutes) for (const s of seconds) out.push({ h, m, s });
+  return out;
+}
+function applySetPos(rule, instants) {
+  if (rule.bySetPos.length === 0) return instants;
+  const picked = rule.bySetPos.map((n) => n > 0 ? instants[n - 1] : instants[instants.length + n]).filter((t) => t !== void 0);
+  return [...new Set(picked)].sort((a, b) => a - b);
+}
+function onInterval(rule, seed, period) {
+  const every = Math.max(1, Math.trunc(rule.interval));
+  if (every === 1) return true;
+  switch (rule.repeat) {
+    case "daily":
+      return daysBetween(seed, period) % every === 0;
+    case "weekly":
+      return Math.round(daysBetween(weekStart(seed, rule.wkst), weekStart(period, rule.wkst)) / 7) % every === 0;
+    case "monthly":
+      return ((period.getFullYear() - seed.getFullYear()) * 12 + period.getMonth() - seed.getMonth()) % every === 0;
+    default:
+      return (period.getFullYear() - seed.getFullYear()) % every === 0;
+  }
+}
+function periodInstants(rule, seed, period) {
+  if (!onInterval(rule, seed, period)) return [];
+  const clock = clockOf(rule, seed);
+  const out = [];
+  for (const day of daysOfPeriod(rule, seed, period)) {
+    for (const { h, m, s } of clock) {
+      out.push(new Date(day.getFullYear(), day.getMonth(), day.getDate(), h, m, s).getTime());
+    }
+  }
+  out.sort((a, b) => a - b);
+  return applySetPos(rule, out);
+}
+function periodsOver(rule, from, to) {
+  const first = startOfDay(new Date(from));
+  const last = startOfDay(new Date(to - 1));
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (d) => {
+    if (!seen.has(d.getTime())) {
+      seen.add(d.getTime());
+      out.push(d);
+    }
+  };
+  for (let d = first; d <= last; d = addDays(d, 1)) {
+    switch (rule.repeat) {
+      case "daily":
+        push(d);
+        break;
+      case "weekly":
+        push(weekStart(d, rule.wkst));
+        break;
+      case "monthly":
+        push(new Date(d.getFullYear(), d.getMonth(), 1));
+        break;
+      default:
+        push(new Date(d.getFullYear(), 0, 1));
+    }
+  }
+  return out;
+}
+function subDailyInstants(rule, seed, from, to) {
+  const unit = rule.repeat === "hourly" ? HOUR_MS : rule.repeat === "minutely" ? MINUTE_MS : SECOND_MS;
+  const step = unit * Math.max(1, Math.trunc(rule.interval));
+  const seedMs = seed.getTime();
+  if (to <= seedMs) return [];
+  const out = [];
+  const first = Math.max(0, Math.ceil((from - seedMs) / step));
+  for (let k = first; out.length < MAX_INSTANTS; k++) {
+    const base = seedMs + k * step;
+    if (base >= to) break;
+    for (const t of subDailyClock(rule, base)) {
+      if (t < from || t >= to) continue;
+      const d = new Date(t);
+      if (!inMonths(rule, d) || !onYearDays(rule, d)) continue;
+      if (!onMonthDays(rule, d) || !onWeekdays(rule, d)) continue;
+      if (rule.byHour.length > 0 && !rule.byHour.includes(d.getHours())) continue;
+      if (rule.repeat !== "hourly" && rule.byMinute.length > 0) {
+        if (!rule.byMinute.includes(d.getMinutes())) continue;
+      }
+      if (rule.repeat === "secondly" && rule.bySecond.length > 0) {
+        if (!rule.bySecond.includes(d.getSeconds())) continue;
+      }
+      out.push(t);
+    }
+  }
+  return applySetPos(
+    rule,
+    [...new Set(out)].sort((a, b) => a - b)
+  );
+}
+function subDailyClock(rule, base) {
+  const d = new Date(base);
+  const minutes = rule.repeat === "hourly" && rule.byMinute.length > 0 ? rule.byMinute : [null];
+  const seconds = rule.repeat !== "secondly" && rule.bySecond.length > 0 ? rule.bySecond : [null];
+  const out = [];
+  for (const m of minutes) {
+    for (const s of seconds) {
+      const at = new Date(d);
+      if (m !== null) at.setMinutes(m);
+      if (s !== null) at.setSeconds(s);
+      out.push(at.getTime());
+    }
+  }
+  return out;
+}
+function excluded(rule, at) {
+  if (rule.exdates.length === 0) return false;
+  const d = new Date(at);
+  return rule.exdates.includes(dayKey(d)) || rule.exdates.includes(instantKey(d));
+}
+function startsBetween(rule, seedMs, from, to) {
+  const seed = new Date(seedMs);
+  const found = /* @__PURE__ */ new Set();
+  if (rule.repeat === "never" && seedMs >= from && seedMs < to) found.add(seedMs);
+  for (const key of rule.rdates) {
+    const at = keyToInstant(key, seed);
+    if (at !== null && at >= from && at < to) found.add(at);
+  }
+  if (rule.repeat !== "never") {
+    const generated = rule.repeat === "hourly" || rule.repeat === "minutely" || rule.repeat === "secondly" ? subDailyInstants(rule, seed, from, to) : periodsOver(rule, from, to).flatMap((p) => periodInstants(rule, seed, p));
+    for (const at of generated) {
+      if (at < seedMs || at < from || at >= to) continue;
+      if (rule.until > 0 && at > rule.until) continue;
+      found.add(at);
+    }
+  }
+  return [...found].filter((at) => !excluded(rule, at)).sort((a, b) => a - b).slice(0, MAX_INSTANTS);
+}
+var ZONE_SLACK = 3 * 60 * 6e4;
+function startsBetweenIn(rule, seedMs, from, to, zone) {
+  if (!isZone(zone)) return startsBetween(rule, seedMs, from, to);
+  const wallSeed = wallClockIn(seedMs, zone).getTime();
+  const wallFrom = wallClockIn(from - ZONE_SLACK, zone).getTime();
+  const wallTo = wallClockIn(to + ZONE_SLACK, zone).getTime();
+  const wallRule = rule.until > 0 ? { ...rule, until: wallClockIn(rule.until, zone).getTime() } : rule;
+  return startsBetween(wallRule, wallSeed, wallFrom, wallTo).map((wallAt) => instantOfWall(new Date(wallAt), zone)).filter((at) => at >= from && at < to).sort((a, b) => a - b);
+}
+function splitRule(rule, seedMs, at) {
+  const seed = new Date(seedMs);
+  const bound = at - 1;
+  const before = (key) => {
+    const instant = keyToInstant(key, seed);
+    return instant === null || instant <= bound;
+  };
+  return {
+    head: {
+      until: rule.until > 0 ? Math.min(rule.until, bound) : bound,
+      exdates: rule.exdates.filter(before),
+      rdates: rule.rdates.filter(before)
+    },
+    tail: {
+      exdates: rule.exdates.filter((k) => !before(k)),
+      rdates: rule.rdates.filter((k) => !before(k))
+    }
+  };
+}
+
+// src/lib/fuzzy.ts
+var MATCH = 10;
+var RUN = 9;
+var WORD_START = 12;
+var LEAD = 6;
+var GAP = 1;
+var GAP_CAP = 12;
+var LENGTH = 0.2;
+var TYPO = 40;
+var TYPO_MIN = 4;
+var WORD_BREAK = /[\s\-_/:.,(–—]/;
+function scan(text, query, start = 0) {
+  let score = 0;
+  let at = start;
+  let previous = -2;
+  let run = 0;
+  for (const character of query) {
+    if (character === " ") continue;
+    const found = text.indexOf(character, at);
+    if (found === -1) return null;
+    score += MATCH;
+    if (found === previous + 1) score += RUN * ++run;
+    else {
+      run = 0;
+      score -= Math.min(found - at, GAP_CAP) * GAP;
+    }
+    if (found === 0) score += WORD_START + LEAD;
+    else if (WORD_BREAK.test(text[found - 1])) score += WORD_START;
+    previous = found;
+    at = found + 1;
+  }
+  return score - text.length * LENGTH;
+}
+function bestScan(text, query) {
+  const first = query.replace(/\s+/g, "")[0];
+  if (!first) return null;
+  let best = null;
+  let tried = false;
+  for (let i = text.indexOf(first); i !== -1; i = text.indexOf(first, i + 1)) {
+    if (tried && i !== 0 && !WORD_BREAK.test(text[i - 1])) continue;
+    tried = true;
+    const score = scan(text, query, i);
+    if (score !== null && (best === null || score > best)) best = score;
+  }
+  return best;
+}
+function fuzzyScore(text, query) {
+  const wanted = query.trim().toLowerCase();
+  if (!wanted) return 0;
+  if (!text) return null;
+  const haystack = text.toLowerCase();
+  const clean = bestScan(haystack, wanted);
+  if (clean !== null) return clean;
+  const letters = wanted.replace(/\s+/g, "");
+  if (letters.length < TYPO_MIN) return null;
+  let best = null;
+  for (let i = 0; i < wanted.length; i++) {
+    if (wanted[i] === " ") continue;
+    const score = bestScan(haystack, wanted.slice(0, i) + wanted.slice(i + 1));
+    if (score !== null && (best === null || score > best)) best = score;
+  }
+  return best === null ? null : best - TYPO;
+}
+
+// src/lib/events.ts
+var ICON_MAX = 16;
+function overridesIn(events) {
+  const out = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (!event.seriesId || !event.seriesKey) continue;
+    const keys = out.get(event.seriesId);
+    if (keys) keys.add(event.seriesKey);
+    else out.set(event.seriesId, /* @__PURE__ */ new Set([event.seriesKey]));
+  }
+  return out;
+}
+var DAY_MS2 = 864e5;
+var MAX_SPAN_MS = 366 * DAY_MS2;
+var DENSE = /* @__PURE__ */ new Set(["secondly", "minutely", "hourly"]);
+function lookbackCap(repeat) {
+  if (repeat === "never") return Infinity;
+  return DENSE.has(repeat) ? DAY_MS2 : MAX_SPAN_MS;
+}
+function occurrencesOn(events, calendars, day) {
+  const hidden = new Set(calendars.filter((c) => !c.visible).map((c) => c.id));
+  const dayStart = startOfDay(day);
+  const dayEnd = addDays(dayStart, 1);
+  const replaced = overridesIn(events);
+  const out = [];
+  for (const event of events) {
+    if (hidden.has(event.calendarId)) continue;
+    const duration = Math.max(event.end - event.start, 0);
+    const span = Math.max(duration, 1);
+    const from = dayStart.getTime() - Math.min(span, lookbackCap(event.repeat));
+    const skip = replaced.get(event.id);
+    for (const at of startsBetweenIn(event, event.start, from, dayEnd.getTime(), event.tzid)) {
+      if (skip?.has(instantKey(at))) continue;
+      const start = new Date(at);
+      const end = new Date(at + duration);
+      if (at + span <= dayStart.getTime() || start >= dayEnd) continue;
+      const continuesBefore = start < dayStart;
+      const continuesAfter = end > dayEnd;
+      const firstDay = startOfDay(start);
+      const lastDay = startOfDay(new Date(Math.max(at, at + duration - 1)));
+      out.push({
+        key: `${event.id}@${instantKey(start)}`,
+        event,
+        start,
+        end,
+        startMin: continuesBefore ? 0 : minutesOfDay(start),
+        // `>=`, not `continuesAfter`: an event ending *exactly* at midnight ends
+        // this day at 1440 rather than the next one at 0. `minutesOfDay` would
+        // say 0, which is a negative duration everywhere it is measured and an
+        // arc drawn backwards round the whole face.
+        endMin: end >= dayEnd ? MINUTES_PER_DAY : minutesOfDay(end),
+        continuesBefore,
+        continuesAfter,
+        dayIndex: daysBetween(firstDay, dayStart) + 1,
+        dayCount: daysBetween(firstDay, lastDay) + 1,
+        // A tick is per occurrence, so it is looked up per occurrence. The
+        // list is empty on everything that is not a task, which is almost
+        // every event in the store.
+        done: event.doneKeys.length > 0 && event.doneKeys.includes(instantKey(start)),
+        lane: 0
+      });
+    }
+  }
+  out.sort((a, b) => a.start.getTime() - b.start.getTime() || a.end.getTime() - b.end.getTime());
+  return out;
+}
+function packLanes(occurrences, pad2 = 6) {
+  const laneEnds = [];
+  return occurrences.map((occ) => {
+    if (occ.event.allDay) return occ;
+    if (occ.event.task) return occ;
+    let lane = laneEnds.findIndex((end) => end <= occ.startMin + pad2);
+    if (lane === -1) lane = laneEnds.length;
+    laneEnds[lane] = occ.endMin;
+    return { ...occ, lane };
+  });
+}
+function dayAgenda(events, calendars, day) {
+  const all = occurrencesOn(events, calendars, day);
+  const allDay = all.filter((o) => o.event.allDay);
+  const timed = packLanes(all.filter((o) => !o.event.allDay));
+  return { timed, allDay, all: [...allDay, ...timed] };
+}
+function toggleDoneKey(keys, at) {
+  const key = instantKey(at);
+  return keys.includes(key) ? keys.filter((k) => k !== key) : [...keys, key];
+}
+var DEFAULT_WAKING = { from: 8 * 60, to: 22 * 60 };
+function freeGaps(occurrences, minMinutes, from, to) {
+  const busy = occurrences.filter((o) => !o.event.allDay).map((o) => ({ start: Math.max(o.startMin, from), end: Math.min(o.endMin, to) })).filter((b) => b.end > b.start).sort((a, b) => a.start - b.start);
+  const gaps = [];
+  let cursor = from;
+  for (const block of busy) {
+    if (block.start - cursor >= minMinutes) gaps.push({ start: cursor, end: block.start });
+    cursor = Math.max(cursor, block.end);
+  }
+  if (to - cursor >= minMinutes) gaps.push({ start: cursor, end: to });
+  return gaps;
+}
+function dayLoad(occurrences, waking) {
+  if (!occurrences.some((occ) => !occ.event.allDay)) return null;
+  const idle = (from, to) => freeGaps(occurrences, 1, from, to).reduce((sum, gap) => sum + (gap.end - gap.start), 0);
+  return {
+    booked: MINUTES_PER_DAY - idle(0, MINUTES_PER_DAY),
+    free: idle(waking.from, waking.to)
+  };
+}
+var FIELD_PENALTY = { location: 30, notes: 45 };
+var penalise = (score, cost) => score === null ? null : score - cost;
+function scoreEvent(event, query) {
+  const scores = [
+    fuzzyScore(event.title, query),
+    penalise(fuzzyScore(event.location, query), FIELD_PENALTY.location),
+    penalise(fuzzyScore(event.notes, query), FIELD_PENALTY.notes)
+  ].filter((score) => score !== null);
+  return scores.length > 0 ? Math.max(...scores) : null;
+}
+var PALETTE = [
+  "#7ce3d8",
+  // aqua
+  "#8ecbff",
+  // sky
+  "#a5a8ff",
+  // periwinkle
+  "#c79bff",
+  // violet
+  "#ff9edb",
+  // orchid
+  "#ff9fb4",
+  // rose
+  "#ffb185",
+  // tangerine
+  "#ffdf8c",
+  // butter
+  "#c6ef8f",
+  // pear
+  "#8bf0b8"
+  // mint
+];
+var ORPHAN_COLOR = PALETTE[0];
+function spanLabel(occ) {
+  return occ.dayCount > 1 ? `Day ${occ.dayIndex}/${occ.dayCount}` : null;
+}
+
+// src/lib/ics.ts
+var encoder = new TextEncoder();
+function fnv1a(source) {
+  let h = 2166136261;
+  for (let i = 0; i < source.length; i++) {
+    h ^= source.charCodeAt(i);
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h.toString(36);
+}
+
+// src/lib/places.ts
+var COORDS = {
+  "Africa/Abidjan": [5.32, -4.03],
+  "Africa/Accra": [5.55, -0.22],
+  "Africa/Addis_Ababa": [9.03, 38.7],
+  "Africa/Algiers": [36.78, 3.05],
+  "Africa/Asmara": [15.33, 38.88],
+  "Africa/Bamako": [12.65, -8],
+  "Africa/Bangui": [4.37, 18.58],
+  "Africa/Banjul": [13.47, -16.65],
+  "Africa/Bissau": [11.85, -15.58],
+  "Africa/Blantyre": [-15.78, 35],
+  "Africa/Brazzaville": [-4.27, 15.28],
+  "Africa/Bujumbura": [-3.38, 29.37],
+  "Africa/Cairo": [30.05, 31.25],
+  "Africa/Casablanca": [33.65, -7.58],
+  "Africa/Ceuta": [35.88, -5.32],
+  "Africa/Conakry": [9.52, -13.72],
+  "Africa/Dakar": [14.67, -17.43],
+  "Africa/Dar_es_Salaam": [-6.8, 39.28],
+  "Africa/Djibouti": [11.6, 43.15],
+  "Africa/Douala": [4.05, 9.7],
+  "Africa/El_Aaiun": [27.15, -13.2],
+  "Africa/Freetown": [8.5, -13.25],
+  "Africa/Gaborone": [-24.65, 25.92],
+  "Africa/Harare": [-17.83, 31.05],
+  "Africa/Johannesburg": [-26.25, 28],
+  "Africa/Juba": [4.85, 31.62],
+  "Africa/Kampala": [0.32, 32.42],
+  "Africa/Khartoum": [15.6, 32.53],
+  "Africa/Kigali": [-1.95, 30.07],
+  "Africa/Kinshasa": [-4.3, 15.3],
+  "Africa/Lagos": [6.45, 3.4],
+  "Africa/Libreville": [0.38, 9.45],
+  "Africa/Lome": [6.13, 1.22],
+  "Africa/Luanda": [-8.8, 13.23],
+  "Africa/Lubumbashi": [-11.67, 27.47],
+  "Africa/Lusaka": [-15.42, 28.28],
+  "Africa/Malabo": [3.75, 8.78],
+  "Africa/Maputo": [-25.97, 32.58],
+  "Africa/Maseru": [-29.47, 27.5],
+  "Africa/Mbabane": [-26.3, 31.1],
+  "Africa/Mogadishu": [2.07, 45.37],
+  "Africa/Monrovia": [6.3, -10.78],
+  "Africa/Nairobi": [-1.28, 36.82],
+  "Africa/Ndjamena": [12.12, 15.05],
+  "Africa/Niamey": [13.52, 2.12],
+  "Africa/Nouakchott": [18.1, -15.95],
+  "Africa/Ouagadougou": [12.37, -1.52],
+  "Africa/Porto-Novo": [6.48, 2.62],
+  "Africa/Sao_Tome": [0.33, 6.73],
+  "Africa/Tripoli": [32.9, 13.18],
+  "Africa/Tunis": [36.8, 10.18],
+  "Africa/Windhoek": [-22.57, 17.1],
+  "America/Adak": [51.88, -176.66],
+  "America/Anchorage": [61.22, -149.9],
+  "America/Anguilla": [18.2, -63.07],
+  "America/Antigua": [17.05, -61.8],
+  "America/Araguaina": [-7.2, -48.2],
+  "America/Argentina/Buenos_Aires": [-34.6, -58.45],
+  "America/Argentina/Catamarca": [-28.47, -65.78],
+  "America/Argentina/Cordoba": [-31.4, -64.18],
+  "America/Argentina/Jujuy": [-24.18, -65.3],
+  "America/Argentina/La_Rioja": [-29.43, -66.85],
+  "America/Argentina/Mendoza": [-32.88, -68.82],
+  "America/Argentina/Rio_Gallegos": [-51.63, -69.22],
+  "America/Argentina/Salta": [-24.78, -65.42],
+  "America/Argentina/San_Juan": [-31.53, -68.52],
+  "America/Argentina/San_Luis": [-33.32, -66.35],
+  "America/Argentina/Tucuman": [-26.82, -65.22],
+  "America/Argentina/Ushuaia": [-54.8, -68.3],
+  "America/Aruba": [12.5, -69.97],
+  "America/Asuncion": [-25.27, -57.67],
+  "America/Atikokan": [48.76, -91.62],
+  "America/Bahia": [-12.98, -38.52],
+  "America/Bahia_Banderas": [20.8, -105.25],
+  "America/Barbados": [13.1, -59.62],
+  "America/Belem": [-1.45, -48.48],
+  "America/Belize": [17.5, -88.2],
+  "America/Blanc-Sablon": [51.42, -57.12],
+  "America/Boa_Vista": [2.82, -60.67],
+  "America/Bogota": [4.6, -74.08],
+  "America/Boise": [43.61, -116.2],
+  "America/Cambridge_Bay": [69.11, -105.05],
+  "America/Campo_Grande": [-20.45, -54.62],
+  "America/Cancun": [21.08, -86.77],
+  "America/Caracas": [10.5, -66.93],
+  "America/Cayenne": [4.93, -52.33],
+  "America/Cayman": [19.3, -81.38],
+  "America/Chicago": [41.85, -87.65],
+  "America/Chihuahua": [28.63, -106.08],
+  "America/Ciudad_Juarez": [31.73, -106.48],
+  "America/Costa_Rica": [9.93, -84.08],
+  "America/Coyhaique": [-45.57, -72.07],
+  "America/Creston": [49.1, -116.52],
+  "America/Cuiaba": [-15.58, -56.08],
+  "America/Curacao": [12.18, -69],
+  "America/Danmarkshavn": [76.77, -18.67],
+  "America/Dawson": [64.07, -139.42],
+  "America/Dawson_Creek": [55.77, -120.23],
+  "America/Denver": [39.74, -104.98],
+  "America/Detroit": [42.33, -83.05],
+  "America/Dominica": [15.3, -61.4],
+  "America/Edmonton": [53.55, -113.47],
+  "America/Eirunepe": [-6.67, -69.87],
+  "America/El_Salvador": [13.7, -89.2],
+  "America/Fort_Nelson": [58.8, -122.7],
+  "America/Fortaleza": [-3.72, -38.5],
+  "America/Glace_Bay": [46.2, -59.95],
+  "America/Goose_Bay": [53.33, -60.42],
+  "America/Grand_Turk": [21.47, -71.13],
+  "America/Grenada": [12.05, -61.75],
+  "America/Guadeloupe": [16.23, -61.53],
+  "America/Guatemala": [14.63, -90.52],
+  "America/Guayaquil": [-2.17, -79.83],
+  "America/Guyana": [6.8, -58.17],
+  "America/Halifax": [44.65, -63.6],
+  "America/Havana": [23.13, -82.37],
+  "America/Hermosillo": [29.07, -110.97],
+  "America/Indiana/Indianapolis": [39.77, -86.16],
+  "America/Indiana/Knox": [41.3, -86.62],
+  "America/Indiana/Marengo": [38.38, -86.34],
+  "America/Indiana/Petersburg": [38.49, -87.28],
+  "America/Indiana/Tell_City": [37.95, -86.76],
+  "America/Indiana/Vevay": [38.75, -85.07],
+  "America/Indiana/Vincennes": [38.68, -87.53],
+  "America/Indiana/Winamac": [41.05, -86.6],
+  "America/Inuvik": [68.35, -133.72],
+  "America/Iqaluit": [63.73, -68.47],
+  "America/Jamaica": [17.97, -76.79],
+  "America/Juneau": [58.3, -134.42],
+  "America/Kentucky/Louisville": [38.25, -85.76],
+  "America/Kentucky/Monticello": [36.83, -84.85],
+  "America/Kralendijk": [12.15, -68.28],
+  "America/La_Paz": [-16.5, -68.15],
+  "America/Lima": [-12.05, -77.05],
+  "America/Los_Angeles": [34.05, -118.24],
+  "America/Lower_Princes": [18.05, -63.05],
+  "America/Maceio": [-9.67, -35.72],
+  "America/Managua": [12.15, -86.28],
+  "America/Manaus": [-3.13, -60.02],
+  "America/Marigot": [18.07, -63.08],
+  "America/Martinique": [14.6, -61.08],
+  "America/Matamoros": [25.83, -97.5],
+  "America/Mazatlan": [23.22, -106.42],
+  "America/Menominee": [45.11, -87.61],
+  "America/Merida": [20.97, -89.62],
+  "America/Metlakatla": [55.13, -131.58],
+  "America/Mexico_City": [19.4, -99.15],
+  "America/Miquelon": [47.05, -56.33],
+  "America/Moncton": [46.1, -64.78],
+  "America/Monterrey": [25.67, -100.32],
+  "America/Montevideo": [-34.91, -56.21],
+  "America/Montserrat": [16.72, -62.22],
+  "America/Nassau": [25.08, -77.35],
+  "America/New_York": [40.71, -74.01],
+  "America/Nome": [64.5, -165.41],
+  "America/Noronha": [-3.85, -32.42],
+  "America/North_Dakota/Beulah": [47.26, -101.78],
+  "America/North_Dakota/Center": [47.12, -101.3],
+  "America/North_Dakota/New_Salem": [46.84, -101.41],
+  "America/Nuuk": [64.18, -51.73],
+  "America/Ojinaga": [29.57, -104.42],
+  "America/Panama": [8.97, -79.53],
+  "America/Paramaribo": [5.83, -55.17],
+  "America/Phoenix": [33.45, -112.07],
+  "America/Port-au-Prince": [18.53, -72.33],
+  "America/Port_of_Spain": [10.65, -61.52],
+  "America/Porto_Velho": [-8.77, -63.9],
+  "America/Puerto_Rico": [18.47, -66.11],
+  "America/Punta_Arenas": [-53.15, -70.92],
+  "America/Rankin_Inlet": [62.82, -92.08],
+  "America/Recife": [-8.05, -34.9],
+  "America/Regina": [50.4, -104.65],
+  "America/Resolute": [74.7, -94.83],
+  "America/Rio_Branco": [-9.97, -67.8],
+  "America/Santarem": [-2.43, -54.87],
+  "America/Santiago": [-33.45, -70.67],
+  "America/Santo_Domingo": [18.47, -69.9],
+  "America/Sao_Paulo": [-23.53, -46.62],
+  "America/Scoresbysund": [70.48, -21.97],
+  "America/Sitka": [57.18, -135.3],
+  "America/St_Barthelemy": [17.88, -62.85],
+  "America/St_Johns": [47.57, -52.72],
+  "America/St_Kitts": [17.3, -62.72],
+  "America/St_Lucia": [14.02, -61],
+  "America/St_Thomas": [18.35, -64.93],
+  "America/St_Vincent": [13.15, -61.23],
+  "America/Swift_Current": [50.28, -107.83],
+  "America/Tegucigalpa": [14.1, -87.22],
+  "America/Thule": [76.57, -68.78],
+  "America/Tijuana": [32.53, -117.02],
+  "America/Toronto": [43.65, -79.38],
+  "America/Tortola": [18.45, -64.62],
+  "America/Vancouver": [49.27, -123.12],
+  "America/Whitehorse": [60.72, -135.05],
+  "America/Winnipeg": [49.88, -97.15],
+  "America/Yakutat": [59.55, -139.73],
+  "Antarctica/Casey": [-66.28, 110.52],
+  "Antarctica/Davis": [-68.58, 77.97],
+  "Antarctica/DumontDUrville": [-66.67, 140.02],
+  "Antarctica/Macquarie": [-54.5, 158.95],
+  "Antarctica/Mawson": [-67.6, 62.88],
+  "Antarctica/McMurdo": [-77.83, 166.6],
+  "Antarctica/Palmer": [-64.8, -64.1],
+  "Antarctica/Rothera": [-67.57, -68.13],
+  "Antarctica/Syowa": [-69.01, 39.59],
+  "Antarctica/Troll": [-72.01, 2.53],
+  "Antarctica/Vostok": [-78.4, 106.9],
+  "Arctic/Longyearbyen": [78, 16],
+  "Asia/Aden": [12.75, 45.2],
+  "Asia/Almaty": [43.25, 76.95],
+  "Asia/Amman": [31.95, 35.93],
+  "Asia/Anadyr": [64.75, 177.48],
+  "Asia/Aqtau": [44.52, 50.27],
+  "Asia/Aqtobe": [50.28, 57.17],
+  "Asia/Ashgabat": [37.95, 58.38],
+  "Asia/Atyrau": [47.12, 51.93],
+  "Asia/Baghdad": [33.35, 44.42],
+  "Asia/Bahrain": [26.38, 50.58],
+  "Asia/Baku": [40.38, 49.85],
+  "Asia/Bangkok": [13.75, 100.52],
+  "Asia/Barnaul": [53.37, 83.75],
+  "Asia/Beirut": [33.88, 35.5],
+  "Asia/Bishkek": [42.9, 74.6],
+  "Asia/Brunei": [4.93, 114.92],
+  "Asia/Chita": [52.05, 113.47],
+  "Asia/Colombo": [6.93, 79.85],
+  "Asia/Damascus": [33.5, 36.3],
+  "Asia/Dhaka": [23.72, 90.42],
+  "Asia/Dili": [-8.55, 125.58],
+  "Asia/Dubai": [25.3, 55.3],
+  "Asia/Dushanbe": [38.58, 68.8],
+  "Asia/Famagusta": [35.12, 33.95],
+  "Asia/Gaza": [31.5, 34.47],
+  "Asia/Hebron": [31.53, 35.09],
+  "Asia/Ho_Chi_Minh": [10.75, 106.67],
+  "Asia/Hong_Kong": [22.28, 114.15],
+  "Asia/Hovd": [48.02, 91.65],
+  "Asia/Irkutsk": [52.27, 104.33],
+  "Asia/Jakarta": [-6.17, 106.8],
+  "Asia/Jayapura": [-2.53, 140.7],
+  "Asia/Jerusalem": [31.78, 35.22],
+  "Asia/Kabul": [34.52, 69.2],
+  "Asia/Kamchatka": [53.02, 158.65],
+  "Asia/Karachi": [24.87, 67.05],
+  "Asia/Kathmandu": [27.72, 85.32],
+  "Asia/Khandyga": [62.66, 135.55],
+  "Asia/Kolkata": [22.53, 88.37],
+  "Asia/Krasnoyarsk": [56.02, 92.83],
+  "Asia/Kuala_Lumpur": [3.17, 101.7],
+  "Asia/Kuching": [1.55, 110.33],
+  "Asia/Kuwait": [29.33, 47.98],
+  "Asia/Macau": [22.2, 113.54],
+  "Asia/Magadan": [59.57, 150.8],
+  "Asia/Makassar": [-5.12, 119.4],
+  "Asia/Manila": [14.59, 120.97],
+  "Asia/Muscat": [23.6, 58.58],
+  "Asia/Nicosia": [35.17, 33.37],
+  "Asia/Novokuznetsk": [53.75, 87.12],
+  "Asia/Novosibirsk": [55.03, 82.92],
+  "Asia/Omsk": [55, 73.4],
+  "Asia/Oral": [51.22, 51.35],
+  "Asia/Phnom_Penh": [11.55, 104.92],
+  "Asia/Pontianak": [-0.03, 109.33],
+  "Asia/Pyongyang": [39.02, 125.75],
+  "Asia/Qatar": [25.28, 51.53],
+  "Asia/Qostanay": [53.2, 63.62],
+  "Asia/Qyzylorda": [44.8, 65.47],
+  "Asia/Riyadh": [24.63, 46.72],
+  "Asia/Sakhalin": [46.97, 142.7],
+  "Asia/Samarkand": [39.67, 66.8],
+  "Asia/Seoul": [37.55, 126.97],
+  "Asia/Shanghai": [31.23, 121.47],
+  "Asia/Singapore": [1.28, 103.85],
+  "Asia/Srednekolymsk": [67.47, 153.72],
+  "Asia/Taipei": [25.05, 121.5],
+  "Asia/Tashkent": [41.33, 69.3],
+  "Asia/Tbilisi": [41.72, 44.82],
+  "Asia/Tehran": [35.67, 51.43],
+  "Asia/Thimphu": [27.47, 89.65],
+  "Asia/Tokyo": [35.65, 139.74],
+  "Asia/Tomsk": [56.5, 84.97],
+  "Asia/Ulaanbaatar": [47.92, 106.88],
+  "Asia/Urumqi": [43.8, 87.58],
+  "Asia/Ust-Nera": [64.56, 143.23],
+  "Asia/Vientiane": [17.97, 102.6],
+  "Asia/Vladivostok": [43.17, 131.93],
+  "Asia/Yakutsk": [62, 129.67],
+  "Asia/Yangon": [16.78, 96.17],
+  "Asia/Yekaterinburg": [56.85, 60.6],
+  "Asia/Yerevan": [40.18, 44.5],
+  "Atlantic/Azores": [37.73, -25.67],
+  "Atlantic/Bermuda": [32.28, -64.77],
+  "Atlantic/Canary": [28.1, -15.4],
+  "Atlantic/Cape_Verde": [14.92, -23.52],
+  "Atlantic/Faroe": [62.02, -6.77],
+  "Atlantic/Madeira": [32.63, -16.9],
+  "Atlantic/Reykjavik": [64.15, -21.85],
+  "Atlantic/South_Georgia": [-54.27, -36.53],
+  "Atlantic/St_Helena": [-15.92, -5.7],
+  "Atlantic/Stanley": [-51.7, -57.85],
+  "Australia/Adelaide": [-34.92, 138.58],
+  "Australia/Brisbane": [-27.47, 153.03],
+  "Australia/Broken_Hill": [-31.95, 141.45],
+  "Australia/Darwin": [-12.47, 130.83],
+  "Australia/Eucla": [-31.72, 128.87],
+  "Australia/Hobart": [-42.88, 147.32],
+  "Australia/Lindeman": [-20.27, 149],
+  "Australia/Lord_Howe": [-31.55, 159.08],
+  "Australia/Melbourne": [-37.82, 144.97],
+  "Australia/Perth": [-31.95, 115.85],
+  "Australia/Sydney": [-33.87, 151.22],
+  "Europe/Amsterdam": [52.37, 4.9],
+  "Europe/Andorra": [42.5, 1.52],
+  "Europe/Astrakhan": [46.35, 48.05],
+  "Europe/Athens": [37.97, 23.72],
+  "Europe/Belgrade": [44.83, 20.5],
+  "Europe/Berlin": [52.5, 13.37],
+  "Europe/Bratislava": [48.15, 17.12],
+  "Europe/Brussels": [50.83, 4.33],
+  "Europe/Bucharest": [44.43, 26.1],
+  "Europe/Budapest": [47.5, 19.08],
+  "Europe/Busingen": [47.7, 8.68],
+  "Europe/Chisinau": [47, 28.83],
+  "Europe/Copenhagen": [55.67, 12.58],
+  "Europe/Dublin": [53.33, -6.25],
+  "Europe/Gibraltar": [36.13, -5.35],
+  "Europe/Guernsey": [49.45, -2.54],
+  "Europe/Helsinki": [60.17, 24.97],
+  "Europe/Isle_of_Man": [54.15, -4.47],
+  "Europe/Istanbul": [41.02, 28.97],
+  "Europe/Jersey": [49.18, -2.11],
+  "Europe/Kaliningrad": [54.72, 20.5],
+  "Europe/Kirov": [58.6, 49.65],
+  "Europe/Kyiv": [50.43, 30.52],
+  "Europe/Lisbon": [38.72, -9.13],
+  "Europe/Ljubljana": [46.05, 14.52],
+  "Europe/London": [51.51, -0.13],
+  "Europe/Luxembourg": [49.6, 6.15],
+  "Europe/Madrid": [40.4, -3.68],
+  "Europe/Malta": [35.9, 14.52],
+  "Europe/Mariehamn": [60.1, 19.95],
+  "Europe/Minsk": [53.9, 27.57],
+  "Europe/Monaco": [43.7, 7.38],
+  "Europe/Moscow": [55.76, 37.62],
+  "Europe/Oslo": [59.92, 10.75],
+  "Europe/Paris": [48.87, 2.33],
+  "Europe/Podgorica": [42.43, 19.27],
+  "Europe/Prague": [50.08, 14.43],
+  "Europe/Riga": [56.95, 24.1],
+  "Europe/Rome": [41.9, 12.48],
+  "Europe/Samara": [53.2, 50.15],
+  "Europe/San_Marino": [43.92, 12.47],
+  "Europe/Sarajevo": [43.87, 18.42],
+  "Europe/Saratov": [51.57, 46.03],
+  "Europe/Simferopol": [44.95, 34.1],
+  "Europe/Skopje": [41.98, 21.43],
+  "Europe/Sofia": [42.68, 23.32],
+  "Europe/Stockholm": [59.33, 18.05],
+  "Europe/Tallinn": [59.42, 24.75],
+  "Europe/Tirane": [41.33, 19.83],
+  "Europe/Ulyanovsk": [54.33, 48.4],
+  "Europe/Vaduz": [47.15, 9.52],
+  "Europe/Vatican": [41.9, 12.45],
+  "Europe/Vienna": [48.22, 16.33],
+  "Europe/Vilnius": [54.68, 25.32],
+  "Europe/Volgograd": [48.73, 44.42],
+  "Europe/Warsaw": [52.25, 21],
+  "Europe/Zagreb": [45.8, 15.97],
+  "Europe/Zurich": [47.38, 8.53],
+  "Indian/Antananarivo": [-18.92, 47.52],
+  "Indian/Chagos": [-7.33, 72.42],
+  "Indian/Christmas": [-10.42, 105.72],
+  "Indian/Cocos": [-12.17, 96.92],
+  "Indian/Comoro": [-11.68, 43.27],
+  "Indian/Kerguelen": [-49.35, 70.22],
+  "Indian/Mahe": [-4.67, 55.47],
+  "Indian/Maldives": [4.17, 73.5],
+  "Indian/Mauritius": [-20.17, 57.5],
+  "Indian/Mayotte": [-12.78, 45.23],
+  "Indian/Reunion": [-20.87, 55.47],
+  "Pacific/Apia": [-13.83, -171.73],
+  "Pacific/Auckland": [-36.87, 174.77],
+  "Pacific/Bougainville": [-6.22, 155.57],
+  "Pacific/Chatham": [-43.95, -176.55],
+  "Pacific/Chuuk": [7.42, 151.78],
+  "Pacific/Easter": [-27.15, -109.43],
+  "Pacific/Efate": [-17.67, 168.42],
+  "Pacific/Fakaofo": [-9.37, -171.23],
+  "Pacific/Fiji": [-18.13, 178.42],
+  "Pacific/Funafuti": [-8.52, 179.22],
+  "Pacific/Galapagos": [-0.9, -89.6],
+  "Pacific/Gambier": [-23.13, -134.95],
+  "Pacific/Guadalcanal": [-9.53, 160.2],
+  "Pacific/Guam": [13.47, 144.75],
+  "Pacific/Honolulu": [21.31, -157.86],
+  "Pacific/Kanton": [-2.78, -171.72],
+  "Pacific/Kiritimati": [1.87, -157.33],
+  "Pacific/Kosrae": [5.32, 162.98],
+  "Pacific/Kwajalein": [9.08, 167.33],
+  "Pacific/Majuro": [7.15, 171.2],
+  "Pacific/Marquesas": [-9, -139.5],
+  "Pacific/Midway": [28.22, -177.37],
+  "Pacific/Nauru": [-0.52, 166.92],
+  "Pacific/Niue": [-19.02, -169.92],
+  "Pacific/Norfolk": [-29.05, 167.97],
+  "Pacific/Noumea": [-22.27, 166.45],
+  "Pacific/Pago_Pago": [-14.27, -170.7],
+  "Pacific/Palau": [7.33, 134.48],
+  "Pacific/Pitcairn": [-25.07, -130.08],
+  "Pacific/Pohnpei": [6.97, 158.22],
+  "Pacific/Port_Moresby": [-9.5, 147.17],
+  "Pacific/Rarotonga": [-21.23, -159.77],
+  "Pacific/Saipan": [15.2, 145.75],
+  "Pacific/Tahiti": [-17.53, -149.57],
+  "Pacific/Tarawa": [1.42, 173],
+  "Pacific/Tongatapu": [-21.13, -175.2],
+  "Pacific/Wake": [19.28, 166.62],
+  "Pacific/Wallis": [-13.3, -176.17]
+};
+var ALIASES = {
+  "Africa/Asmera": "Africa/Asmara",
+  "America/Buenos_Aires": "America/Argentina/Buenos_Aires",
+  "America/Catamarca": "America/Argentina/Catamarca",
+  "America/Coral_Harbour": "America/Atikokan",
+  "America/Cordoba": "America/Argentina/Cordoba",
+  "America/Godthab": "America/Nuuk",
+  "America/Indianapolis": "America/Indiana/Indianapolis",
+  "America/Jujuy": "America/Argentina/Jujuy",
+  "America/Louisville": "America/Kentucky/Louisville",
+  "America/Mendoza": "America/Argentina/Mendoza",
+  "Asia/Calcutta": "Asia/Kolkata",
+  "Asia/Katmandu": "Asia/Kathmandu",
+  "Asia/Rangoon": "Asia/Yangon",
+  "Asia/Saigon": "Asia/Ho_Chi_Minh",
+  "Atlantic/Faeroe": "Atlantic/Faroe",
+  "Europe/Kiev": "Europe/Kyiv",
+  "Pacific/Enderbury": "Pacific/Kanton",
+  "Pacific/Ponape": "Pacific/Pohnpei",
+  "Pacific/Truk": "Pacific/Chuuk"
+};
+function placeForZone(zone) {
+  const coords = COORDS[zone] ?? COORDS[ALIASES[zone]];
+  if (!coords) return null;
+  return { zone, lat: coords[0], lon: coords[1], label: zoneLabel(zone) };
+}
+var PLACE_OPTIONS = Object.keys(COORDS).map((zone) => ({ value: zone, label: zoneLabel(zone) })).sort((a, b) => a.label.localeCompare(b.label));
+
+// src/lib/store.ts
+var import_react2 = __toESM(require_react(), 1);
+
+// src/lib/notify.ts
+var import_react = __toESM(require_react(), 1);
+
+// src/lib/mutate.ts
+function applyUpdate(events, id, patch) {
+  return events.map((e) => e.id === id ? { ...e, ...patch } : e);
+}
+function applyToggleDone(events, id, at) {
+  return events.map((e) => e.id === id ? { ...e, doneKeys: toggleDoneKey(e.doneKeys, at) } : e);
+}
+function applyRemove(events, id) {
+  return events.filter((e) => e.id !== id && e.seriesId !== id);
+}
+function applySplit(events, id, at, tail, mintId) {
+  const original = events.find((e) => e.id === id);
+  if (!original) return { events, created: null };
+  const split = splitRule(original, original.start, at);
+  const created = { ...tail, ...split.tail, seriesId: "", seriesKey: "", id: mintId() };
+  const seed = new Date(original.start);
+  const detached = (e) => e.seriesId === id && (keyToInstant(e.seriesKey, seed) ?? -Infinity) >= at;
+  return {
+    events: [
+      ...events.map(
+        (e) => e.id === id ? { ...e, ...split.head } : detached(e) ? { ...e, seriesId: created.id } : e
+      ),
+      created
+    ],
+    created
+  };
+}
+function applyTruncate(events, id, at) {
+  const original = events.find((e) => e.id === id);
+  if (!original) return events;
+  const split = splitRule(original, original.start, at);
+  const seed = new Date(original.start);
+  return events.filter((e) => !(e.seriesId === id && (keyToInstant(e.seriesKey, seed) ?? -Infinity) >= at)).map((e) => e.id === id ? { ...e, ...split.head } : e);
+}
+
+// src/lib/quickadd.ts
+var WEEKDAYS_LOWER = WEEKDAYS.map((w) => w.toLowerCase());
+var MONTHS_LOWER = MONTHS.map((m) => m.toLowerCase());
+var DEFAULT_DURATION = 60;
+var DATE_WORDS = 3;
+var REPEAT_WORDS = 3;
+var OFFSET_WORDS = 3;
+var FILLER = /* @__PURE__ */ new Set(["at", "on", "from", "for", "@"]);
+function parseOffset(raw) {
+  const query = raw.trim().toLowerCase();
+  if (query === "now") return 0;
+  const relative = /^in\s+(.+)$/.exec(query);
+  if (!relative) return null;
+  const minutes = parseDurationToken(relative[1].replace(/^an?\s+/, "1 "));
+  return minutes !== null && minutes > 0 ? minutes : null;
+}
+function parseDate(raw, reference) {
+  const query = raw.trim().toLowerCase();
+  if (!query) return null;
+  const base = startOfDay(reference);
+  if (query === "today") return base;
+  if (query === "tomorrow") return addDays(base, 1);
+  if (query === "yesterday") return addDays(base, -1);
+  const weekdayIndex = WEEKDAYS_LOWER.findIndex((w) => w === query || w.slice(0, 3) === query);
+  if (weekdayIndex !== -1) {
+    const delta = (weekdayIndex - base.getDay() + 7) % 7 || 7;
+    return addDays(base, delta);
+  }
+  const iso = /^(\d{4})-(\d{2})-(\d{2})$/.exec(query);
+  if (iso) {
+    const year = Number(iso[1]);
+    const month = Number(iso[2]) - 1;
+    const dom = Number(iso[3]);
+    if (month >= 0 && month < 12 && dom >= 1 && dom <= daysInMonth(year, month)) {
+      return new Date(year, month, dom);
+    }
+    return null;
+  }
+  const resolveMonthDay = (monthStr, domStr) => {
+    const monthIndex = MONTHS_LOWER.findIndex((m) => m === monthStr || m.slice(0, 3) === monthStr);
+    const dom = Number(domStr);
+    if (monthIndex === -1 || dom < 1 || dom > daysInMonth(reference.getFullYear(), monthIndex))
+      return null;
+    const year = reference.getFullYear();
+    const candidate = new Date(year, monthIndex, dom);
+    return candidate.getTime() < base.getTime() ? new Date(year + 1, monthIndex, dom) : candidate;
+  };
+  const monthDay = /^([a-z]+)\s+(\d{1,2})$/.exec(query);
+  if (monthDay) {
+    const resolved = resolveMonthDay(monthDay[1], monthDay[2]);
+    if (resolved) return resolved;
+  }
+  const dayMonth = /^(\d{1,2})\s+([a-z]+)$/.exec(query);
+  if (dayMonth) {
+    const resolved = resolveMonthDay(dayMonth[2], dayMonth[1]);
+    if (resolved) return resolved;
+  }
+  const relative = /^([+-])(\d+)$/.exec(query);
+  if (relative) {
+    return addDays(base, Number(relative[2]) * (relative[1] === "-" ? -1 : 1));
+  }
+  const inDays = /^in\s+(\d+)\s+days?$/.exec(query);
+  if (inDays) return addDays(base, Number(inDays[1]));
+  const bareDay = /^(\d{1,2})$/.exec(query);
+  if (bareDay) {
+    const dom = Number(bareDay[1]);
+    if (dom < 1 || dom > 31) return null;
+    let year = reference.getFullYear();
+    let month = reference.getMonth();
+    if (dom > daysInMonth(year, month)) return null;
+    let candidate = new Date(year, month, dom);
+    if (candidate.getTime() < base.getTime()) {
+      month += 1;
+      if (month > 11) {
+        month = 0;
+        year += 1;
+      }
+      if (dom > daysInMonth(year, month)) return null;
+      candidate = new Date(year, month, dom);
+    }
+    return candidate;
+  }
+  return null;
+}
+function parseDurationToken(raw) {
+  const query = raw.trim().toLowerCase();
+  if (!query) return null;
+  const hours = /^(\d{1,2})\s*(?:h|hr|hrs|hour|hours)\s*(\d{1,2})?\s*(?:m|min|mins)?$/.exec(query);
+  if (hours) return Number(hours[1]) * 60 + Number(hours[2] ?? 0);
+  const minutes = /^(\d{1,3})\s*(?:m|min|mins|minute|minutes)$/.exec(query);
+  if (minutes) return Number(minutes[1]);
+  return null;
+}
+function parseSpan(token) {
+  const range = /^(.+?)[-–—](.+)$/.exec(token);
+  if (range) {
+    const from = parseClock(range[1]);
+    const to = parseClock(range[2]);
+    if (from === null || to === null) return null;
+    return { startMin: from, endMin: to > from ? to : to + MINUTES_PER_DAY };
+  }
+  const at = parseClock(token);
+  return at === null ? null : { startMin: at, endMin: null };
+}
+var WEEKDAY_NUMBERS = new Map(
+  WEEKDAYS_LOWER.flatMap((name, index) => [
+    [name, index],
+    [name.slice(0, 3), index]
+  ])
+);
+var FREQUENCY_WORDS = {
+  hourly: { repeat: "hourly", interval: 1, byDay: [] },
+  daily: { repeat: "daily", interval: 1, byDay: [] },
+  weekly: { repeat: "weekly", interval: 1, byDay: [] },
+  biweekly: { repeat: "weekly", interval: 2, byDay: [] },
+  fortnightly: { repeat: "weekly", interval: 2, byDay: [] },
+  monthly: { repeat: "monthly", interval: 1, byDay: [] },
+  yearly: { repeat: "yearly", interval: 1, byDay: [] },
+  annually: { repeat: "yearly", interval: 1, byDay: [] }
+};
+var UNIT_WORDS = {
+  hour: "hourly",
+  hours: "hourly",
+  day: "daily",
+  days: "daily",
+  week: "weekly",
+  weeks: "weekly",
+  month: "monthly",
+  months: "monthly",
+  year: "yearly",
+  years: "yearly"
+};
+var WORKING_WEEK = [1, 2, 3, 4, 5];
+var WEEKEND = [6, 0];
+var weekdays = (days, interval = 1) => ({
+  repeat: "weekly",
+  interval,
+  byDay: days.map((day) => ({ day, nth: 0 }))
+});
+function parseRepeat(raw) {
+  const query = raw.trim().toLowerCase();
+  if (!query) return null;
+  const named = FREQUENCY_WORDS[query];
+  if (named) return named;
+  if (query === "weekdays") return weekdays(WORKING_WEEK);
+  if (query === "weekends") return weekdays(WEEKEND);
+  const every = /^every\s+(.+)$/.exec(query);
+  if (!every) return null;
+  const rest = every[1];
+  if (rest === "weekday" || rest === "weekdays") return weekdays(WORKING_WEEK);
+  if (rest === "weekend" || rest === "weekends") return weekdays(WEEKEND);
+  const repeated = /^(other|\d{1,2})\s+(.+)$/.exec(rest);
+  if (repeated) {
+    const interval = repeated[1] === "other" ? 2 : Number(repeated[1]);
+    if (interval < 1) return null;
+    const unit2 = UNIT_WORDS[repeated[2]];
+    if (unit2) return { repeat: unit2, interval, byDay: [] };
+    const day = WEEKDAY_NUMBERS.get(repeated[2]);
+    return day === void 0 ? null : weekdays([day], interval);
+  }
+  const unit = UNIT_WORDS[rest];
+  if (unit) return { repeat: unit, interval: 1, byDay: [] };
+  const days = [];
+  for (const name of rest.split(/[,/]/)) {
+    const day = WEEKDAY_NUMBERS.get(name.trim());
+    if (day === void 0) return null;
+    days.push(day);
+  }
+  return days.length > 0 ? weekdays(days) : null;
+}
+function defaultStart(on, durationMin, now = /* @__PURE__ */ new Date()) {
+  const start = isSameDay(on, now) ? snap(minutesOfDay(now) + 7.5, 15) : 9 * 60;
+  return Math.min(start, Math.max(0, MINUTES_PER_DAY - durationMin));
+}
+function parseQuickAdd(input, reference, now = /* @__PURE__ */ new Date(), fallbackDuration = DEFAULT_DURATION) {
+  const tokens = input.trim().replace(/(\d)\s*[-–—]\s*(\d)/g, "$1-$2").split(/\s+/).filter(Boolean);
+  if (tokens.length === 0) return null;
+  let end = tokens.length;
+  const phrase = (from, to) => tokens.slice(from, to).join(" ");
+  function claim(words, read) {
+    for (let n = Math.min(words, end); n >= 1; n--) {
+      const value = read(phrase(end - n, end));
+      if (value !== null) {
+        end -= n;
+        while (end > 0 && FILLER.has(tokens[end - 1].toLowerCase())) end -= 1;
+        return value;
+      }
+    }
+    return null;
+  }
+  let day = startOfDay(reference);
+  let dated = false;
+  let span = null;
+  let duration = null;
+  let repeat = null;
+  let offset = null;
+  while (end > 0) {
+    if (offset === null && span === null) {
+      const value = claim(OFFSET_WORDS, parseOffset);
+      if (value !== null) {
+        offset = value;
+        continue;
+      }
+    }
+    if (repeat === null) {
+      const value = claim(REPEAT_WORDS, parseRepeat);
+      if (value !== null) {
+        repeat = value;
+        continue;
+      }
+    }
+    if (duration === null) {
+      const value = claim(2, (p) => {
+        const minutes = parseDurationToken(p);
+        return minutes !== null && minutes > 0 ? minutes : null;
+      });
+      if (value !== null) {
+        duration = value;
+        continue;
+      }
+    }
+    if (span === null) {
+      const value = claim(2, parseSpan);
+      if (value !== null) {
+        span = value;
+        continue;
+      }
+    }
+    if (!dated) {
+      const value = claim(DATE_WORDS, (p) => parseDate(p, reference));
+      if (value !== null) {
+        day = startOfDay(value);
+        dated = true;
+        continue;
+      }
+    }
+    break;
+  }
+  if (duration === null) {
+    for (let words = Math.min(2, end - 1); words >= 1; words--) {
+      const minutes = parseDurationToken(phrase(0, words));
+      if (minutes !== null && minutes > 0) {
+        duration = minutes;
+        tokens.splice(0, words);
+        end -= words;
+        break;
+      }
+    }
+  }
+  const title = phrase(0, end).trim();
+  if (!title) return null;
+  if (!dated && span === null && duration === null && repeat === null && offset === null) {
+    return null;
+  }
+  const fromNow = offset === null ? null : snap(minutesOfDay(now) + offset, 15);
+  if (fromNow !== null && !dated) {
+    day = addDays(startOfDay(now), Math.floor(fromNow / MINUTES_PER_DAY));
+  }
+  if (!dated && repeat && repeat.byDay.length > 0) {
+    const wanted = new Set(repeat.byDay.map((w) => w.day));
+    for (let step = 0; step < 7 && !wanted.has(day.getDay()); step++) day = addDays(day, 1);
+  }
+  let startMin;
+  let endMin;
+  if (span) {
+    startMin = span.startMin;
+    endMin = span.endMin ?? startMin + (duration ?? fallbackDuration);
+  } else if (fromNow !== null) {
+    startMin = fromNow % MINUTES_PER_DAY;
+    endMin = startMin + (duration ?? fallbackDuration);
+  } else if (duration !== null) {
+    startMin = defaultStart(day, duration, now);
+    endMin = startMin + duration;
+  } else {
+    startMin = 0;
+    endMin = MINUTES_PER_DAY;
+  }
+  return {
+    title,
+    day,
+    startMin,
+    endMin,
+    allDay: endMin - startMin >= MINUTES_PER_DAY,
+    repeat
+  };
+}
+
+// src/lib/store.ts
+var DEFAULT_SETTINGS = {
+  // The 0–23 face. It is the one that matches the instrument: a revolution is
+  // a day here, not half of one, so an hour has exactly one place on it and
+  // `13` is where `13` is. AM/PM is a preference, and it is one click away.
+  clock: "24h",
+  secondZone: "",
+  showZoneName: true,
+  showZoneOffset: true,
+  // Off: the captions describe a ring that is already there, but a band is
+  // another ring, and chrome does not get to appear unasked.
+  zoneDaylight: false,
+  zoneMoonlight: false,
+  place: null,
+  // Both on, because the band *is* the track: with one half off the ring
+  // simply stops at dusk (or at dawn), and an incomplete ring reads as a
+  // rendering fault rather than as a choice.
+  daylight: true,
+  moonlight: true,
+  // Always, which is the one default here that a switch does not have to earn.
+  // The glyph budget means a label only appears where the sweep can hold one,
+  // so it cannot crowd the face — and the dial's own argument is legibility,
+  // which an unlabelled ring of four coloured ticks loses. Hiding the fix
+  // behind an off switch would concede the point.
+  arcLabels: "always",
+  // Off, and it is the one mark decision with a default worth arguing about:
+  // see `markOf`. A calendar's glyph repeated down every arc of the day is
+  // decoration, so it is asked for rather than assumed.
+  inheritMarks: false,
+  // Off. The ring is already the picture of a day's load; the line under the
+  // card is the same fact in words, and words earn their place by being asked
+  // for.
+  totals: false,
+  totalsAt: "center",
+  // On: the drag is the one gesture in the app with a granularity you cannot
+  // see mid-move, and a detent you have to look at is not a detent. Both are
+  // heard only as the result of a deliberate drag, and never on load.
+  tickSound: true,
+  tickHaptics: true,
+  // Unknown, and it stays unknown until asked for: a birth date is the one
+  // piece of the user in this app, so nothing invents one.
+  birth: "",
+  // Eighty. High enough to be a life rather than a countdown, round enough to
+  // read as the estimate it is.
+  lifeExpectancy: 80,
+  // On. Three or four marks on thirty thousand dots is a constellation rather
+  // than furniture, and the alternative is a field with no landmarks in it at
+  // all: the decade rules name the rows, and nothing names a day.
+  milestones: true,
+  // On. The grid's one weakness was always that a dot is four pixels, and a
+  // magnifier that only appears while you are pointing costs the picture
+  // nothing when you are not.
+  lifeLoupe: true,
+  // The default is an instruction rather than an observation, which is what
+  // saves it from being a fortune cookie: a ring returns you to the same
+  // angle, and this is the one thing to do about that.
+  yearQuote: "don't end up in the same place",
+  // Never, until asked for. Everything else in this file appears because the
+  // user did something; a mode that arrives on a timer is the one thing that
+  // could appear because they did not.
+  ambientAfter: 0,
+  // On, and it is the reason the mode is worth having: a face that does not
+  // know it is night is a lamp. Costs nothing where no place is set — there is
+  // no curve to follow, so it does not dim.
+  ambientDim: true,
+  // Both on, for the same reason the working face's pair is: the band *is*
+  // the track, and with one half off the ring stops at dusk. Here it is also
+  // the whole picture — ambient is the mode that is nothing but the rim.
+  ambientDaylight: true,
+  ambientMoonlight: true,
+  // Off. A second place's numerals are a working reference — you look them up
+  // — and this face is not looked *up*.
+  ambientZoneRing: false,
+  // Off, for the reason `arcLabels` defaults to `always`: the argument is
+  // legibility, and at this distance the label is the illegible part.
+  ambientArcLabels: "off",
+  // Off. It is the only thing in this app that draws something the calendar
+  // does not contain, so it has to be asked for by name.
+  moon: false,
+  // Off, and it is the one default here that is a promise rather than a
+  // preference: nothing in circal has ever interrupted anybody, and the first
+  // thing that can must be switched on deliberately.
+  remind: false,
+  // Ten minutes. Long enough to walk somewhere, short enough that the thing
+  // is still the next thing when it lands.
+  remindLead: 10,
+  // An hour, which is what `DEFAULT_DURATION` has always been and what a
+  // VEVENT with no DTEND is read as. This setting exists to be *changed* — a
+  // day of thirty-minute meetings is a real working life — not to have a new
+  // opinion by default.
+  defaultDuration: DEFAULT_DURATION,
+  // The first calendar that is not a subscription, whichever that turns out
+  // to be. Naming one here would be naming a seed calendar, and the seed is
+  // not something a returning user still has.
+  defaultCalendar: "",
+  // Monday, which is what the app has always drawn and what most of the
+  // world already expects — ISO 8601's own answer, and the one that needed
+  // no setting until this one arrived to make it a choice rather than an
+  // assumption.
+  weekStart: 1,
+  // `DEFAULT_WAKING`'s own pair: this setting exists to replace the constant,
+  // not to disagree with it on day one.
+  wakingFrom: DEFAULT_WAKING.from,
+  wakingTo: DEFAULT_WAKING.to
+};
+var DEFAULT_CALENDARS = [
+  { id: "personal", name: "Personal", color: PALETTE[0], icon: "house", visible: true },
+  { id: "work", name: "Work", color: PALETTE[3], icon: "briefcase", visible: true },
+  { id: "family", name: "Family", color: PALETTE[5], icon: "users", visible: true }
+];
+function newId() {
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function defaultCalendarId(calendars, preferred) {
+  const named = preferred ? calendars.find((c) => c.id === preferred && !c.feed) : void 0;
+  return named?.id ?? calendars.find((c) => !c.feed)?.id ?? DEFAULT_CALENDARS[0].id;
+}
+function draftEvent(day, startMin, endMin, calendarId, repeat = "never") {
+  const base = startOfDay(day).getTime();
+  const span = endMin - startMin;
+  const allDay = span >= MINUTES_PER_DAY;
+  const days = Math.round(span / MINUTES_PER_DAY);
+  return {
+    title: "",
+    calendarId,
+    start: allDay ? base : base + startMin * 6e4,
+    end: allDay ? addDays(startOfDay(day), days).getTime() : base + endMin * 6e4,
+    allDay,
+    tzid: "",
+    location: "",
+    url: "",
+    notes: "",
+    ...NEVER,
+    repeat,
+    seriesId: "",
+    seriesKey: "",
+    color: "",
+    icon: "",
+    task: false,
+    doneKeys: []
+  };
+}
+
+// src/lib/backup.ts
+function readSettings(value) {
+  if (!isRecord(value)) return DEFAULT_SETTINGS;
+  const place = value.place;
+  return {
+    // A face the backup did not name is the current default, not the old one:
+    // there are exactly two spellings and both are written out by every
+    // version that has ever had the setting.
+    clock: value.clock === "12h" || value.clock === "24h" ? value.clock : DEFAULT_SETTINGS.clock,
+    secondZone: typeof value.secondZone === "string" ? value.secondZone : "",
+    // The dial switches read absent-as-on: a backup written before they
+    // existed came from a dial that was showing all of them.
+    showZoneName: value.showZoneName !== false,
+    showZoneOffset: value.showZoneOffset !== false,
+    // Except the second zone's two halves, off unless asked for — absent
+    // means they were never switched on.
+    zoneDaylight: value.zoneDaylight === true,
+    zoneMoonlight: value.zoneMoonlight === true,
+    // Re-derived from the zone rather than trusted: a backup carries a name we
+    // can look up, and the table is the authority on where that place is.
+    place: isRecord(place) && typeof place.zone === "string" ? placeForZone(place.zone) : null,
+    daylight: value.daylight !== false,
+    // `night` is what the dark half was called before it was split off.
+    moonlight: value.moonlight !== void 0 ? value.moonlight !== false : value.night !== false,
+    // Absent means the backup predates the labels, and the label default is
+    // on: a dial whose arcs are anonymous is not what anybody chose. `sane()`
+    // is what pins the value to a mode the panel can show.
+    arcLabels: typeof value.arcLabels === "string" ? value.arcLabels : DEFAULT_SETTINGS.arcLabels,
+    // Off unless the backup says so — the same reading its default takes, and
+    // an inherited mark arriving unasked would remark every arc on the face.
+    inheritMarks: value.inheritMarks === true,
+    // Off unless the backup says otherwise: absent means it was written
+    // before the line existed, and it is not a line to arrive unasked.
+    totals: value.totals === true,
+    totalsAt: typeof value.totalsAt === "string" ? value.totalsAt : DEFAULT_SETTINGS.totalsAt,
+    // Same reading as the dial switches: a backup from before the detents
+    // existed came from a build where every step was silent by omission, not
+    // by choice, and the default is on.
+    tickSound: value.tickSound !== false,
+    tickHaptics: value.tickHaptics !== false,
+    // The life span. Anything unreadable resets to "never asked", which shows
+    // the prompt again rather than drawing a grid around a date we guessed.
+    birth: typeof value.birth === "string" ? value.birth : "",
+    lifeExpectancy: typeof value.lifeExpectancy === "number" && Number.isFinite(value.lifeExpectancy) ? value.lifeExpectancy : DEFAULT_SETTINGS.lifeExpectancy,
+    // Marks on the grid, read absent-as-on like the dial switches: a backup
+    // written before they existed came from a build where every life was
+    // unmarked by omission rather than by choice.
+    milestones: value.milestones !== false,
+    // Same reading for the loupe, and the same reason: a file written before
+    // it existed is not a file that turned it off.
+    lifeLoupe: value.lifeLoupe !== false,
+    // A line the user wrote, so an absent one is the default rather than
+    // silence — a blank centre is a thing to choose, not to inherit from a
+    // file. `sane()` trims it and pins the length.
+    yearQuote: typeof value.yearQuote === "string" ? value.yearQuote : DEFAULT_SETTINGS.yearQuote,
+    // Ambient. A backup from before the mode came from a build with no mode,
+    // so every one of these reads as the default rather than as a choice —
+    // and the one that could act on its own, the timer, defaults to never.
+    // `sane()` pins the delay and the label mode to values the panel can show.
+    ambientAfter: typeof value.ambientAfter === "number" ? value.ambientAfter : DEFAULT_SETTINGS.ambientAfter,
+    ambientDim: value.ambientDim !== false,
+    ambientDaylight: value.ambientDaylight !== false,
+    ambientMoonlight: value.ambientMoonlight !== false,
+    ambientZoneRing: value.ambientZoneRing === true,
+    ambientArcLabels: typeof value.ambientArcLabels === "string" ? value.ambientArcLabels : DEFAULT_SETTINGS.ambientArcLabels,
+    // Both of these appear because the user asked for them, so an absent one
+    // is off rather than on — the opposite reading from the dial switches
+    // above, and for the opposite reason: one is a thing the face already
+    // drew, these are things that were never there. `sane()` pins the lead.
+    // A file written while the moon had two registers carries the string
+    // `moonPhase` instead, and either register is a moon that was asked for.
+    moon: value.moon === true || typeof value.moonPhase === "string" && value.moonPhase !== "off",
+    remind: value.remind === true,
+    remindLead: typeof value.remindLead === "number" ? value.remindLead : DEFAULT_SETTINGS.remindLead,
+    // What a new event starts as. `sane()` clamps the length; the calendar is
+    // an id and is deliberately not checked against the backup's own
+    // calendars — `defaultCalendarId` resolves it at the moment it is used,
+    // and a restore that dropped it would silently reset a preference over a
+    // calendar the user is about to re-import.
+    defaultDuration: typeof value.defaultDuration === "number" ? value.defaultDuration : DEFAULT_SETTINGS.defaultDuration,
+    defaultCalendar: typeof value.defaultCalendar === "string" ? value.defaultCalendar : "",
+    // Types only: `sane()` is what pins an illegal weekday or an inverted
+    // waking window to the defaults, same as every other bounded field here.
+    weekStart: value.weekStart === 0 || value.weekStart === 1 || value.weekStart === 6 ? value.weekStart : DEFAULT_SETTINGS.weekStart,
+    wakingFrom: typeof value.wakingFrom === "number" ? value.wakingFrom : DEFAULT_SETTINGS.wakingFrom,
+    wakingTo: typeof value.wakingTo === "number" ? value.wakingTo : DEFAULT_SETTINGS.wakingTo
+  };
+}
+var INSTANT_KEY = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$/;
+function readDoneKeys(value) {
+  return Array.isArray(value) ? [...new Set(value.filter((k) => typeof k === "string" && INSTANT_KEY.test(k)))] : [];
+}
+function derivedId(value, start, end) {
+  const text = (key) => typeof value[key] === "string" ? value[key] : "";
+  return `${start}-${fnv1a([start, end, text("title"), text("location"), text("seriesKey")].join("|"))}`;
+}
+function readEvent(value) {
+  if (!isRecord(value)) return null;
+  const { id, title, calendarId, start, end } = value;
+  if (typeof start !== "number" || typeof end !== "number") return null;
+  if (!Number.isFinite(start) || !Number.isFinite(end)) return null;
+  const task = value.task === true;
+  if (task ? end < start : end <= start) return null;
+  return {
+    // Derived from the record's own fields, never minted: `Math.random()` gave
+    // a different id every read, so the same backup imported twice was two
+    // copies of every event with no way left to tell that they were one. The
+    // same fix, and the same hash, `ics.ts` already uses for a VEVENT that
+    // arrives with no UID.
+    id: typeof id === "string" && id ? id : derivedId(value, start, end),
+    title: typeof title === "string" ? title : "Untitled",
+    calendarId: typeof calendarId === "string" ? calendarId : "",
+    start,
+    end,
+    allDay: value.allDay === true,
+    // An unknown zone must not come back as a zone, and a dropped one
+    // degrades to floating — which is what the app did with every event
+    // before this field existed, so the failure mode is not a new one.
+    tzid: typeof value.tzid === "string" && isZone(value.tzid) ? value.tzid : "",
+    location: typeof value.location === "string" ? value.location : "",
+    url: typeof value.url === "string" ? value.url : "",
+    notes: typeof value.notes === "string" ? value.notes : "",
+    // What a legal rule is lives in `recur.ts`: this file had its own copy of
+    // every RFC bound and the store had a third, and the three did not agree.
+    ...readRecurrence(value),
+    seriesId: typeof value.seriesId === "string" ? value.seriesId : "",
+    seriesKey: typeof value.seriesKey === "string" ? value.seriesKey : "",
+    color: typeof value.color === "string" ? value.color : "",
+    icon: typeof value.icon === "string" ? value.icon.slice(0, ICON_MAX) : "",
+    task,
+    // The same instant-key check EXDATE gets, and the same reason: a key this
+    // does not spell matches no occurrence, so it is a row of dead weight that
+    // survives every future export.
+    doneKeys: readDoneKeys(value.doneKeys)
+  };
+}
+function readCalendar(value) {
+  if (!isRecord(value)) return null;
+  const { id, name, color, icon } = value;
+  if (typeof id !== "string" || !id) return null;
+  const feedUrl = isRecord(value.feed) && typeof value.feed.url === "string" ? value.feed.url : "";
+  return {
+    id,
+    name: typeof name === "string" && name ? name : id,
+    color: typeof color === "string" && color ? color : "#8ecbff",
+    // Length is the whole check. An icon name this build does not carry
+    // renders as the dot rather than as nothing, so an unknown one is worth
+    // keeping — a backup restored into an older build and back again should
+    // not lose the mark — but an unbounded string here is a paste.
+    icon: typeof icon === "string" ? icon.slice(0, ICON_MAX) : "",
+    visible: value.visible !== false,
+    ...feedUrl ? { feed: { url: feedUrl, fetchedAt: 0, error: "" } } : {}
+  };
+}
+function readBackup(parsed) {
+  if (!isRecord(parsed) || parsed.app !== "circal") return { ok: false, reason: "not-circal" };
+  const events = (Array.isArray(parsed.events) ? parsed.events : []).map(readEvent).filter((e) => e !== null);
+  const calendars = (Array.isArray(parsed.calendars) ? parsed.calendars : []).map(readCalendar).filter((c) => c !== null);
+  if (calendars.length === 0) return { ok: false, reason: "no-calendars" };
+  const known = new Set(calendars.map((c) => c.id));
+  const fallback = calendars[0].id;
+  const seriesIds = new Set(events.map((e) => e.id));
+  return {
+    ok: true,
+    events: events.map((e) => {
+      const parented = known.has(e.calendarId) ? e : { ...e, calendarId: fallback };
+      return e.seriesId && !seriesIds.has(e.seriesId) ? { ...parented, seriesId: "", seriesKey: "" } : parented;
+    }),
+    calendars,
+    settings: readSettings(parsed.settings)
+  };
+}
+
+// src/lib/mirror.ts
+var MIRROR_VERSION = 1;
+function settled(calendars) {
+  return calendars.map(
+    (c) => c.feed ? { ...c, feed: { ...c.feed, fetchedAt: 0, error: "" } } : c
+  );
+}
+function serialiseMirror(s, rev, zone = localZone()) {
+  const file = {
+    app: "circal",
+    version: MIRROR_VERSION,
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    zone,
+    rev,
+    events: s.events,
+    calendars: settled(s.calendars),
+    settings: s.settings
+  };
+  return `${JSON.stringify(file, null, 2)}
+`;
+}
+function readMirrorFile(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  const read = readBackup(parsed);
+  if (!read.ok) return null;
+  const envelope = parsed;
+  return {
+    events: read.events,
+    calendars: read.calendars,
+    settings: read.settings,
+    rev: typeof envelope.rev === "number" && Number.isFinite(envelope.rev) ? envelope.rev : 0,
+    // A plain `.json` backup has no zone. Absent means "written by something
+    // that did not say", which the reader treats as agreeing with it — the
+    // alternative is refusing to open every backup ever exported.
+    zone: typeof envelope.zone === "string" ? envelope.zone : ""
+  };
+}
+
+// mcp/file.ts
+var RefusalError = class extends Error {
+};
+function resolveFilePath(argv2, env) {
+  const flagIndex = argv2.indexOf("--file");
+  const flagValue = flagIndex >= 0 ? argv2[flagIndex + 1] : void 0;
+  const path2 = flagValue || env.CIRCAL_FILE;
+  if (!path2) {
+    throw new Error(
+      "circal-mcp needs a mirror file to read and write. Set the CIRCAL_FILE environment variable or pass --file <path> on the command line. Neither was given."
+    );
+  }
+  return path2;
+}
+async function readMirror(path2) {
+  const text = await readFile(path2, "utf8");
+  const contents = readMirrorFile(text);
+  if (!contents) {
+    throw new Error(`${path2} is not a circal mirror file (or a circal .json backup).`);
+  }
+  return contents;
+}
+async function atomicWrite(path2, body) {
+  const tmp = join(dirname(path2), `.circal-mcp-${randomBytes(6).toString("hex")}.tmp`);
+  await writeFile(tmp, body, "utf8");
+  await rename(tmp, path2);
+}
+function zoneWarning(contents) {
+  const here = localZone();
+  if (contents.zone === "" || contents.zone === here) return null;
+  return `Warning: this file was last written from ${contents.zone}, this server is running in ${here}. Day boundaries may disagree.`;
+}
+function assertZoneAllowsMutation(contents, env) {
+  const here = localZone();
+  if (contents.zone === "" || contents.zone === here) return;
+  if (env.CIRCAL_ALLOW_ZONE_MISMATCH === "1") return;
+  throw new RefusalError(
+    `Refusing to write: the file's zone (${contents.zone}) does not match this server's (${here}) \u2014 a write here could land on the wrong day there. Set CIRCAL_ALLOW_ZONE_MISMATCH=1 to write anyway.`
+  );
+}
+async function loadForRead(ctx2) {
+  const contents = await readMirror(ctx2.path);
+  return { contents, warning: zoneWarning(contents) };
+}
+async function casWriteOnce(ctx2, mutate) {
+  for (let attempt = 0; attempt < 2; attempt++) {
+    const before = await readMirror(ctx2.path);
+    assertZoneAllowsMutation(before, ctx2.env);
+    const { result, summary } = mutate(before);
+    const after = await readMirror(ctx2.path);
+    if (after.rev !== before.rev) {
+      if (attempt === 1) {
+        throw new Error(
+          `The file moved under this write: read at rev ${before.rev}, still found rev ${after.rev} after retrying once. Something else is writing it \u2014 try again.`
+        );
+      }
+      continue;
+    }
+    await atomicWrite(ctx2.path, serialiseMirror(result, after.rev + 1, after.zone || localZone()));
+    return summary;
+  }
+  throw new Error("unreachable");
+}
+var writeQueue = Promise.resolve();
+function casWrite(ctx2, mutate) {
+  const run = writeQueue.then(() => casWriteOnce(ctx2, mutate));
+  writeQueue = run.then(
+    () => void 0,
+    () => void 0
+  );
+  return run;
+}
+
+// mcp/find.ts
+import { readFile as readFile2, readdir, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join as join2 } from "node:path";
+var SKIP_DIR_NAMES = { node_modules: true, Library: true, ".git": true };
+var MAX_FILE_BYTES = 32 * 1024 * 1024;
+function roots(home) {
+  return [
+    home,
+    join2(home, "Documents"),
+    join2(home, "Desktop"),
+    join2(home, "Downloads"),
+    join2(home, "Library", "Mobile Documents", "com~apple~CloudDocs"),
+    // iCloud Drive (Documents)
+    join2(home, "Dropbox"),
+    join2(home, "Sync")
+  ];
+}
+async function jsonFilesUnder(root) {
+  const found = [];
+  const top = await listDir(root);
+  for (const entry of top) {
+    if (entry.name.startsWith(".")) continue;
+    const full = join2(root, entry.name);
+    if (entry.isFile()) {
+      if (entry.name.toLowerCase().endsWith(".json")) found.push(full);
+      continue;
+    }
+    if (!entry.isDirectory() || SKIP_DIR_NAMES[entry.name]) continue;
+    for (const sub of await listDir(full)) {
+      if (sub.name.startsWith(".") || !sub.isFile()) continue;
+      if (sub.name.toLowerCase().endsWith(".json")) found.push(join2(full, sub.name));
+    }
+  }
+  return found;
+}
+async function listDir(path2) {
+  try {
+    return await readdir(path2, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+async function asMirror(path2) {
+  try {
+    const info = await stat(path2);
+    if (!info.isFile() || info.size > MAX_FILE_BYTES) return null;
+    const text = await readFile2(path2, "utf8");
+    const contents = readMirrorFile(text);
+    return contents ? { path: path2, contents } : null;
+  } catch {
+    return null;
+  }
+}
+async function runFind(home = homedir()) {
+  const searchRoots = roots(home);
+  const candidates = /* @__PURE__ */ new Set();
+  for (const root of searchRoots) {
+    for (const path2 of await jsonFilesUnder(root)) candidates.add(path2);
+  }
+  const hits = [];
+  for (const path2 of [...candidates].sort()) {
+    const hit = await asMirror(path2);
+    if (hit) hits.push(hit);
+  }
+  if (hits.length === 0) {
+    console.log("No circal mirror file found.\n");
+    console.log("Searched these locations (their own files, and one level of subdirectories):");
+    for (const root of searchRoots) console.log(`  ${root}`);
+    console.log(
+      "\nTurn the mirror on from circal's Settings panel to create a file, then run this again."
+    );
+    return;
+  }
+  console.log(`Found ${hits.length} circal mirror file${hits.length === 1 ? "" : "s"}:
+`);
+  for (const hit of hits) {
+    const zone = hit.contents.zone || "not recorded";
+    console.log(`  ${hit.path}`);
+    console.log(
+      `    events: ${hit.contents.events.length}, calendars: ${hit.contents.calendars.length}, zone: ${zone}, rev: ${hit.contents.rev}`
+    );
+  }
+  const first = hits[0].path;
+  const config = JSON.stringify(
+    { mcpServers: { circal: { command: "npx", args: ["-y", "circal-mcp", "--file", first] } } },
+    null,
+    2
+  );
+  console.log(
+    "\nPaste this into your client's MCP config. Swap the path below if this picked up the wrong file.\n"
+  );
+  console.log("Claude Desktop (claude_desktop_config.json) / Cursor (.cursor/mcp.json):\n");
+  console.log(config);
+  console.log("\nClaude Code:\n");
+  console.log(`  claude mcp add circal -- npx -y circal-mcp --file ${first}`);
+}
+
+// mcp/tools.ts
+import * as z from "zod/v4";
+
+// src/lib/describe.ts
+var POSITIONS = ["", "first", "second", "third", "fourth", "fifth"];
+function ordinal(n) {
+  const tens = n % 100;
+  const suffix = tens >= 11 && tens <= 13 ? "th" : ["th", "st", "nd", "rd"][n % 10] ?? "th";
+  return `${n}${suffix}`;
+}
+function positionWord(n) {
+  if (n > 0) return POSITIONS[n] ?? ordinal(n);
+  return n === -1 ? "last" : `${POSITIONS[-n] ?? ordinal(-n)} from last`;
+}
+function monthDayWord(n) {
+  return n > 0 ? ordinal(n) : `${ordinal(-n)} from last`;
+}
+function joinWords(items) {
+  if (items.length < 2) return items[0] ?? "";
+  return `${items.slice(0, -1).join(", ")} and ${items[items.length - 1]}`;
+}
+function describeRule(rule) {
+  const every = rule.interval > 1 ? `${rule.interval} ` : "";
+  const parts = [`Every ${every}${repeatUnit(rule.repeat, rule.interval)}`];
+  if (rule.byMonth.length > 0) {
+    parts.push(`in ${joinWords(rule.byMonth.map((m) => MONTHS[m - 1].slice(0, 3)))}`);
+  }
+  if (rule.byWeekNo.length > 0) {
+    parts.push(
+      `in week${rule.byWeekNo.length > 1 ? "s" : ""} ${joinWords(rule.byWeekNo.map(String))}`
+    );
+  }
+  if (rule.byYearDay.length > 0) {
+    parts.push(`on the ${joinWords(rule.byYearDay.map(monthDayWord))} day of the year`);
+  }
+  const days = rule.byDay.map(
+    (w) => w.nth === 0 ? WEEKDAYS[w.day].slice(0, 3) : `${positionWord(w.nth)} ${WEEKDAYS[w.day].slice(0, 3)}`
+  );
+  const dates = rule.byMonthDay.map(monthDayWord);
+  if (rule.bySetPos.length > 0 && days.length + dates.length > 0) {
+    const pick = joinWords(rule.bySetPos.map(positionWord));
+    parts.push(`on the ${pick} of ${joinWords([...dates, ...days])}`);
+  } else {
+    if (dates.length > 0) parts.push(`on the ${joinWords(dates)}`);
+    if (days.length > 0) parts.push(`on ${joinWords(days)}`);
+    if (rule.bySetPos.length > 0) {
+      parts.push(`keeping the ${joinWords(rule.bySetPos.map(positionWord))}`);
+    }
+  }
+  if (rule.byHour.length > 0 || rule.byMinute.length > 0 || rule.bySecond.length > 0) {
+    parts.push("at set times");
+  }
+  if (rule.until > 0) {
+    const until = new Date(rule.until);
+    parts.push(
+      `until ${until.getDate()} ${MONTHS[until.getMonth()].slice(0, 3)} ${until.getFullYear()}`
+    );
+  }
+  return parts.join(" ");
+}
+
+// mcp/domain.ts
+var DATE_KEY_RE = /^\d{4}-\d{2}-\d{2}$/;
+function assertDateKey(value, field = "date") {
+  if (!DATE_KEY_RE.test(value)) {
+    throw new RefusalError(`"${field}" must be YYYY-MM-DD, local \u2014 got "${value}"`);
+  }
+}
+function parseDay(value, field = "date") {
+  assertDateKey(value, field);
+  return fromDayKey(value);
+}
+function parseTime(value, field) {
+  const minutes = parseClock(value);
+  if (minutes === null) {
+    throw new RefusalError(
+      `could not read "${field}": "${value}" is not a time \u2014 try "14:30" or "2:30pm"`
+    );
+  }
+  return minutes;
+}
+function resolveInstant(event, occurrence) {
+  if (!occurrence) return event.start;
+  const at = keyToInstant(occurrence, new Date(event.start));
+  if (at === null) {
+    throw new RefusalError(`"${occurrence}" is not a date or instant this app understands`);
+  }
+  return at;
+}
+function requireScope(event, scope) {
+  if (!repeats(event)) return "all";
+  if (scope !== "one" && scope !== "future" && scope !== "all") {
+    throw new RefusalError(
+      `"${event.title || "Untitled"}" repeats \u2014 say which occurrences with "scope": "one" (just this occurrence), "future" (this one and everything after), or "all" (the whole series). "one" and "future" also need "occurrence" (a date or instant).`
+    );
+  }
+  return scope;
+}
+function resolveCalendar(calendarId, calendars, settings) {
+  if (calendarId) {
+    const found2 = calendars.find((c) => c.id === calendarId);
+    if (!found2) throw new RefusalError(`no calendar with id "${calendarId}"`);
+    if (found2.feed) {
+      throw new RefusalError(
+        `"${found2.name}" is a subscription \u2014 its events are pulled from a feed, never written to`
+      );
+    }
+    return found2;
+  }
+  const id = defaultCalendarId(calendars, settings.defaultCalendar);
+  const found = calendars.find((c) => c.id === id);
+  if (!found) throw new RefusalError("there is no calendar to put this on \u2014 create one first");
+  return found;
+}
+function refuseIfFeed(event, calendars) {
+  const calendar = calendars.find((c) => c.id === event.calendarId);
+  if (calendar?.feed) {
+    throw new RefusalError(
+      `"${calendar.name}" is a subscription \u2014 "${event.title || "Untitled"}" is pulled from a feed and is read-only, the same as it is in the editor`
+    );
+  }
+}
+function buildRecurrence(input) {
+  if (!input) return { ...NEVER };
+  const until = input.until ? addDays(fromDayKey(input.until), 1).getTime() - 1 : 0;
+  return readRecurrence({ ...input, until, exdates: [], rdates: [] });
+}
+function resolveSpanForCreate(input, day, defaultDuration) {
+  if (input.task === true) {
+    if (input.start === void 0) throw new RefusalError('a task needs "start" (HH:MM)');
+    const at = atMinutes(day, parseTime(input.start, "start")).getTime();
+    return { start: at, end: at, allDay: false, task: true };
+  }
+  const noTimeGiven = input.start === void 0 && input.end === void 0 && input.duration === void 0;
+  const allDay = input.allDay === true || input.allDay === void 0 && noTimeGiven;
+  if (allDay) {
+    const days = input.end ? Math.max(1, daysBetween(day, fromDayKey(input.end)) + 1) : 1;
+    return {
+      start: startOfDay(day).getTime(),
+      end: addDays(startOfDay(day), days).getTime(),
+      allDay: true,
+      task: false
+    };
+  }
+  if (input.start === void 0) throw new RefusalError('a timed event needs "start" (HH:MM)');
+  const startMin = parseTime(input.start, "start");
+  const endMin = input.end !== void 0 ? parseTime(input.end, "end") : startMin + (input.duration ?? defaultDuration);
+  return {
+    start: atMinutes(day, startMin).getTime(),
+    end: atMinutes(day, endMin).getTime(),
+    allDay: false,
+    task: false
+  };
+}
+function resolveSpanForPatch(input, base, anchorMs) {
+  const day = input.date ? parseDay(input.date) : startOfDay(new Date(anchorMs));
+  const task = input.task ?? base.task;
+  if (task) {
+    const startMin2 = input.start !== void 0 ? parseTime(input.start, "start") : minutesOfDay(new Date(anchorMs));
+    const at = atMinutes(day, startMin2).getTime();
+    return { start: at, end: at, allDay: false, task: true };
+  }
+  const allDay = input.allDay ?? base.allDay;
+  if (allDay) {
+    const baseDays = Math.max(
+      1,
+      daysBetween(startOfDay(new Date(base.start)), startOfDay(new Date(base.end)))
+    );
+    const days = input.end ? Math.max(1, daysBetween(day, fromDayKey(input.end)) + 1) : baseDays;
+    return {
+      start: startOfDay(day).getTime(),
+      end: addDays(startOfDay(day), days).getTime(),
+      allDay: true,
+      task: false
+    };
+  }
+  const baseDurationMin = Math.max(1, Math.round((base.end - base.start) / 6e4));
+  const startMin = input.start !== void 0 ? parseTime(input.start, "start") : minutesOfDay(new Date(anchorMs));
+  const endMin = input.end !== void 0 ? parseTime(input.end, "end") : startMin + (input.duration ?? baseDurationMin);
+  return {
+    start: atMinutes(day, startMin).getTime(),
+    end: atMinutes(day, endMin).getTime(),
+    allDay: false,
+    task: false
+  };
+}
+function validate(draft) {
+  const validated = readEvent({ ...draft, id: "pending" });
+  if (!validated)
+    throw new RefusalError("the assembled event failed validation (check start, end and task)");
+  const { id: _drop, ...rest } = validated;
+  return rest;
+}
+function buildEventRecord(input, calendars, settings) {
+  if (!input.date) throw new RefusalError('an event needs "date" (YYYY-MM-DD)');
+  const day = parseDay(input.date);
+  const calendar = resolveCalendar(input.calendarId, calendars, settings);
+  const span = resolveSpanForCreate(input, day, settings.defaultDuration);
+  return validate({
+    title: input.title ?? "",
+    calendarId: calendar.id,
+    start: span.start,
+    end: span.end,
+    allDay: span.allDay,
+    tzid: "",
+    location: input.location ?? "",
+    url: input.url ?? "",
+    notes: input.notes ?? "",
+    ...buildRecurrence(input.recurrence),
+    seriesId: "",
+    seriesKey: "",
+    color: input.color ?? "",
+    icon: input.icon ?? "",
+    task: span.task,
+    doneKeys: []
+  });
+}
+function applyPatchToEvent(base, input, calendars, settings, anchorMs = base.start) {
+  const calendar = input.calendarId !== void 0 ? resolveCalendar(input.calendarId, calendars, settings) : calendars.find((c) => c.id === base.calendarId) ?? resolveCalendar(void 0, calendars, settings);
+  const span = resolveSpanForPatch(input, base, anchorMs);
+  return validate({
+    title: input.title ?? base.title,
+    calendarId: calendar.id,
+    start: span.start,
+    end: span.end,
+    allDay: span.allDay,
+    tzid: base.tzid,
+    location: input.location ?? base.location,
+    url: input.url ?? base.url,
+    notes: input.notes ?? base.notes,
+    ...input.recurrence ? buildRecurrence(input.recurrence) : recurrenceOf(base),
+    seriesId: base.seriesId,
+    seriesKey: base.seriesKey,
+    color: input.color ?? base.color,
+    icon: input.icon ?? base.icon,
+    task: span.task,
+    doneKeys: base.doneKeys
+  });
+}
+function calendarName(calendars, id) {
+  return calendars.find((c) => c.id === id)?.name ?? "\u2014";
+}
+function eventSummaryLine(event, calendars, clock) {
+  const when = event.task ? `${dayKey(new Date(event.start))} ${formatTimeShort(new Date(event.start), clock)}` : event.allDay ? `${dayKey(new Date(event.start))} \u2013 ${dayKey(addDays(new Date(event.end), -1))} (all day)` : `${dayKey(new Date(event.start))} ${formatTimeShort(new Date(event.start), clock)}\u2013${formatTimeShort(new Date(event.end), clock)}`;
+  return `${event.title || "Untitled"} \u2014 [${calendarName(calendars, event.calendarId)}] \u2014 ${when} \u2014 id=${event.id}`;
+}
+function occurrenceLine(occ, calendars, clock) {
+  const when = occ.event.allDay ? "all day" : occ.event.task ? `${occ.start.toISOString()} (${formatTimeShort(occ.start, clock)})` : `${occ.start.toISOString()} (${formatTimeShort(occ.start, clock)}) \u2013 ${occ.end.toISOString()} (${formatTimeShort(occ.end, clock)})`;
+  const span = spanLabel(occ);
+  const bits = [
+    occ.event.title || "Untitled",
+    `[${calendarName(calendars, occ.event.calendarId)}]`,
+    when,
+    ...span ? [span] : [],
+    ...occ.event.task ? [occ.done ? "done" : "open"] : [],
+    `id=${occ.event.id}`,
+    `occurrence=${dayKey(occ.start)}`
+  ];
+  return bits.join("  \xB7  ");
+}
+function listDay(contents, date) {
+  assertDateKey(date);
+  const day = fromDayKey(date);
+  const agenda = dayAgenda(contents.events, contents.calendars, day);
+  const clock = contents.settings.clock;
+  return [
+    `${date} \u2014 ${agenda.all.length} occurrence${agenda.all.length === 1 ? "" : "s"}`,
+    "",
+    "All day:",
+    ...agenda.allDay.length ? agenda.allDay.map((o) => `  ${occurrenceLine(o, contents.calendars, clock)}`) : ["  (none)"],
+    "",
+    "Timed:",
+    ...agenda.timed.length ? agenda.timed.map((o) => `  ${occurrenceLine(o, contents.calendars, clock)}`) : ["  (none)"]
+  ].join("\n");
+}
+var MAX_RANGE_DAYS = 366;
+var MAX_RANGE_OCCURRENCES = 500;
+function listRange(contents, from, to) {
+  assertDateKey(from, "from");
+  assertDateKey(to, "to");
+  const fromDay = fromDayKey(from);
+  const toDay = fromDayKey(to);
+  const span = daysBetween(fromDay, toDay) + 1;
+  if (span < 1) throw new RefusalError('"to" must not be before "from"');
+  if (span > MAX_RANGE_DAYS) {
+    throw new RefusalError(`the range is capped at ${MAX_RANGE_DAYS} days \u2014 asked for ${span}`);
+  }
+  const clock = contents.settings.clock;
+  const lines = [];
+  let count = 0;
+  let truncated = false;
+  for (let i = 0; i < span && !truncated; i++) {
+    const day = addDays(fromDay, i);
+    const occs = occurrencesOn(contents.events, contents.calendars, day);
+    if (occs.length === 0) continue;
+    lines.push(`${dayKey(day)}:`);
+    for (const occ of occs) {
+      if (count >= MAX_RANGE_OCCURRENCES) {
+        truncated = true;
+        break;
+      }
+      lines.push(`  ${occurrenceLine(occ, contents.calendars, clock)}`);
+      count++;
+    }
+  }
+  const header = `${from} to ${to} (${span} days) \u2014 ${count} occurrence${count === 1 ? "" : "s"}` + (truncated ? `, capped at ${MAX_RANGE_OCCURRENCES}` : "");
+  return [header, ...lines.length ? lines : ["(nothing)"]].join("\n");
+}
+function searchEvents(contents, query, limit = 20) {
+  const clock = contents.settings.clock;
+  const scored = contents.events.map((event) => ({ event, score: scoreEvent(event, query) })).filter((s) => s.score !== null).sort((a, b) => b.score - a.score).slice(0, Math.max(0, limit));
+  return [
+    `"${query}" \u2014 ${scored.length} match${scored.length === 1 ? "" : "es"}`,
+    ...scored.length ? scored.map(({ event }) => eventSummaryLine(event, contents.calendars, clock)) : ["(none)"]
+  ].join("\n");
+}
+function freeSlots(contents, date, minutes, from, to) {
+  assertDateKey(date);
+  const day = fromDayKey(date);
+  const occs = occurrencesOn(contents.events, contents.calendars, day);
+  const fromMin = from !== void 0 ? parseTime(from, "from") : contents.settings.wakingFrom ?? DEFAULT_WAKING.from;
+  const toMin = to !== void 0 ? parseTime(to, "to") : contents.settings.wakingTo ?? DEFAULT_WAKING.to;
+  const clock = contents.settings.clock;
+  const gaps = freeGaps(occs, minutes, fromMin, toMin);
+  const load = dayLoad(occs, { from: fromMin, to: toMin });
+  return [
+    `${date} \u2014 free ${formatDuration(minutes)}+ slots between ${formatTimeShort(atMinutes(day, fromMin), clock)} and ${formatTimeShort(atMinutes(day, toMin), clock)}`,
+    ...gaps.length ? gaps.map(
+      (g) => `  ${formatTimeShort(atMinutes(day, g.start), clock)}\u2013${formatTimeShort(atMinutes(day, g.end), clock)} (${formatDuration(g.end - g.start)})`
+    ) : ["  (none)"],
+    load ? `Booked ${formatDuration(load.booked)}, free ${formatDuration(load.free)} of the window.` : "Nothing booked today."
+  ].join("\n");
+}
+function listCalendars(contents) {
+  return contents.calendars.map(
+    (c) => `${c.name} \u2014 id=${c.id} \u2014 ${c.color}${c.feed ? " \u2014 subscription (read-only)" : ""}${c.visible ? "" : " \u2014 hidden"}`
+  ).join("\n");
+}
+function describeEvent(contents, id) {
+  const event = contents.events.find((e) => e.id === id);
+  if (!event) throw new RefusalError(`no event with id "${id}"`);
+  const calendar = contents.calendars.find((c) => c.id === event.calendarId);
+  const clock = contents.settings.clock;
+  return [
+    `${event.title || "Untitled"}  (id=${event.id})`,
+    `Calendar: ${calendarName(contents.calendars, event.calendarId)}${calendar?.feed ? " (subscription, read-only)" : ""}`,
+    event.task ? `Task at ${dayKey(new Date(event.start))} ${formatTimeShort(new Date(event.start), clock)}` : event.allDay ? `All day, ${dayKey(new Date(event.start))} to ${dayKey(addDays(new Date(event.end), -1))}` : `${dayKey(new Date(event.start))} ${formatTimeShort(new Date(event.start), clock)}\u2013${formatTimeShort(new Date(event.end), clock)}`,
+    `Repeats: ${repeats(event) ? describeRule(event) : "never"}`,
+    ...event.location ? [`Location: ${event.location}`] : [],
+    ...event.url ? [`URL: ${event.url}`] : [],
+    ...event.notes ? [`Notes: ${event.notes}`] : [],
+    ...event.seriesId ? [`Overrides one occurrence of id=${event.seriesId} (${event.seriesKey})`] : [],
+    ...event.task ? [
+      `Done: ${event.doneKeys.length} occurrence${event.doneKeys.length === 1 ? "" : "s"} ticked`
+    ] : []
+  ].join("\n");
+}
+function performQuickAdd(contents, text, date) {
+  if (!text.trim()) throw new RefusalError('"text" is empty');
+  const reference = date ? parseDay(date) : startOfDay(/* @__PURE__ */ new Date());
+  const parsed = parseQuickAdd(text, reference, /* @__PURE__ */ new Date(), contents.settings.defaultDuration);
+  if (!parsed) {
+    throw new RefusalError(
+      `could not read "${text}" as an event \u2014 name something beyond a bare title, e.g. "lunch tomorrow 1pm 45m" or "gym every monday 7am"`
+    );
+  }
+  const calendar = resolveCalendar(void 0, contents.calendars, contents.settings);
+  const record = validate({
+    ...draftEvent(parsed.day, parsed.startMin, parsed.endMin, calendar.id),
+    title: parsed.title,
+    ...parsed.repeat
+  });
+  const event = { ...record, id: newId() };
+  return {
+    mutated: {
+      events: [...contents.events, event],
+      calendars: contents.calendars,
+      settings: contents.settings
+    },
+    message: `Created ${eventSummaryLine(event, contents.calendars, contents.settings.clock)}`
+  };
+}
+function performCreateEvent(contents, input) {
+  const record = buildEventRecord(input, contents.calendars, contents.settings);
+  const event = { ...record, id: newId() };
+  return {
+    mutated: {
+      events: [...contents.events, event],
+      calendars: contents.calendars,
+      settings: contents.settings
+    },
+    message: `Created ${eventSummaryLine(event, contents.calendars, contents.settings.clock)}`
+  };
+}
+function performUpdateEvent(contents, id, scopeArg, occurrence, patch) {
+  const original = contents.events.find((e) => e.id === id);
+  if (!original) throw new RefusalError(`no event with id "${id}"`);
+  refuseIfFeed(original, contents.calendars);
+  const scope = requireScope(original, scopeArg);
+  const clock = contents.settings.clock;
+  if (scope === "all") {
+    const record2 = applyPatchToEvent(original, patch, contents.calendars, contents.settings);
+    const events = applyUpdate(contents.events, original.id, record2);
+    const updated = events.find((e) => e.id === original.id);
+    return {
+      mutated: { events, calendars: contents.calendars, settings: contents.settings },
+      message: `Updated ${eventSummaryLine(updated, contents.calendars, clock)}`
+    };
+  }
+  const at = resolveOccurrenceRequired(original, occurrence, scope);
+  if (scope === "one") {
+    const record2 = applyPatchToEvent(original, patch, contents.calendars, contents.settings, at);
+    const override = {
+      ...record2,
+      ...NEVER,
+      seriesId: original.id,
+      seriesKey: instantKey(at),
+      id: newId()
+    };
+    return {
+      mutated: {
+        events: [...contents.events, override],
+        calendars: contents.calendars,
+        settings: contents.settings
+      },
+      message: `Updated one occurrence: ${eventSummaryLine(override, contents.calendars, clock)}`
+    };
+  }
+  const record = applyPatchToEvent(original, patch, contents.calendars, contents.settings, at);
+  const split = applySplit(contents.events, original.id, at, record, newId);
+  if (!split.created) throw new RefusalError(`no event with id "${id}"`);
+  return {
+    mutated: { events: split.events, calendars: contents.calendars, settings: contents.settings },
+    message: `Updated from ${dayKey(new Date(at))} on: ${eventSummaryLine(split.created, contents.calendars, clock)}`
+  };
+}
+function performDeleteEvent(contents, id, scopeArg, occurrence) {
+  const original = contents.events.find((e) => e.id === id);
+  if (!original) throw new RefusalError(`no event with id "${id}"`);
+  refuseIfFeed(original, contents.calendars);
+  const scope = requireScope(original, scopeArg);
+  const title = original.title || "Untitled";
+  if (scope === "all") {
+    return {
+      mutated: {
+        events: applyRemove(contents.events, original.id),
+        calendars: contents.calendars,
+        settings: contents.settings
+      },
+      message: `Deleted "${title}" (the whole series).`
+    };
+  }
+  const at = resolveOccurrenceRequired(original, occurrence, scope);
+  if (scope === "one") {
+    const events = applyUpdate(contents.events, original.id, {
+      exdates: [...original.exdates, instantKey(at)]
+    });
+    return {
+      mutated: { events, calendars: contents.calendars, settings: contents.settings },
+      message: `Deleted "${title}" on ${dayKey(new Date(at))} only \u2014 the series continues.`
+    };
+  }
+  return {
+    mutated: {
+      events: applyTruncate(contents.events, original.id, at),
+      calendars: contents.calendars,
+      settings: contents.settings
+    },
+    message: `Deleted "${title}" from ${dayKey(new Date(at))} on.`
+  };
+}
+function performToggleDone(contents, id, occurrence) {
+  const original = contents.events.find((e) => e.id === id);
+  if (!original) throw new RefusalError(`no event with id "${id}"`);
+  if (!original.task) throw new RefusalError(`"${original.title || "Untitled"}" is not a task`);
+  refuseIfFeed(original, contents.calendars);
+  const at = resolveInstant(original, occurrence);
+  const wasDone = original.doneKeys.includes(instantKey(at));
+  const events = applyToggleDone(contents.events, original.id, at);
+  return {
+    mutated: { events, calendars: contents.calendars, settings: contents.settings },
+    message: `${wasDone ? "Reopened" : "Completed"} "${original.title || "Untitled"}" on ${dayKey(new Date(at))}.`
+  };
+}
+function performCreateCalendar(contents, name, color, icon) {
+  const trimmed = name.trim();
+  if (!trimmed) throw new RefusalError('a calendar needs a "name"');
+  const calendar = readCalendar({
+    id: newId(),
+    name: trimmed,
+    color: color || PALETTE[contents.calendars.length * 3 % PALETTE.length],
+    icon: icon ?? "",
+    visible: true
+  });
+  if (!calendar) throw new RefusalError("the assembled calendar failed validation");
+  return {
+    mutated: {
+      events: contents.events,
+      calendars: [...contents.calendars, calendar],
+      settings: contents.settings
+    },
+    message: `Created calendar "${calendar.name}" \u2014 id=${calendar.id}`
+  };
+}
+function resolveOccurrenceRequired(event, occurrence, scope) {
+  if (!occurrence) {
+    throw new RefusalError(
+      `scope "${scope}" needs "occurrence" (a YYYY-MM-DD date or full instant)`
+    );
+  }
+  return resolveInstant(event, occurrence);
+}
+
+// mcp/tools.ts
+function textResult(text) {
+  return { content: [{ type: "text", text }] };
+}
+function withWarning(text, warning) {
+  return warning ? `${warning}
+
+${text}` : text;
+}
+async function guarded(run) {
+  try {
+    return textResult(await run());
+  } catch (error) {
+    if (!(error instanceof Error)) throw error;
+    return { content: [{ type: "text", text: error.message }], isError: true };
+  }
+}
+var DATE_KEY_RE2 = /^\d{4}-\d{2}-\d{2}$/;
+var DATE_KEY_MESSAGE = "must be YYYY-MM-DD, local";
+function dateKey(description) {
+  return z.string().regex(DATE_KEY_RE2, DATE_KEY_MESSAGE).describe(description);
+}
+var RECURRENCE_DESCRIPTION = "Replaces the event's whole recurrence rule, exceptions included. Omit entirely for a one-off event on create, or to leave an existing rule untouched on update.";
+var recurrenceSchema = z.strictObject({
+  repeat: z.enum(["daily", "weekly", "monthly", "yearly"]),
+  interval: z.number().int().min(1).describe("Every Nth period; 1 = every one.").optional(),
+  until: dateKey(
+    "YYYY-MM-DD, local, inclusive \u2014 the last day an occurrence may start. Omit for no end."
+  ).optional(),
+  wkst: z.number().int().min(0).max(6).describe("Week-start weekday, 0=Sunday..6=Saturday.").optional(),
+  byDay: z.array(
+    z.strictObject({
+      day: z.number().int().min(0).max(6),
+      nth: z.number().int().min(-5).max(5).optional()
+    })
+  ).describe(
+    "Which weekdays, for a weekly or monthly rule. day: 0=Sunday..6=Saturday. nth (monthly only): 1st..5th from the start of the month, negative from the end, 0 or omitted = every one."
+  ).optional(),
+  byMonthDay: z.array(z.number().int().min(-31).max(31)).describe("Days of the month, 1-31 or negative counted from the end.").optional(),
+  byMonth: z.array(z.number().int().min(1).max(12)).optional(),
+  byWeekNo: z.array(z.number().int().min(-53).max(53)).optional(),
+  byYearDay: z.array(z.number().int().min(-366).max(366)).optional(),
+  bySetPos: z.array(z.number().int()).describe("Which of the period's own occurrences to keep, e.g. -1 = the last one.").optional()
+}).describe(RECURRENCE_DESCRIPTION);
+function eventFieldsShape() {
+  return {
+    title: z.string().optional(),
+    date: dateKey("YYYY-MM-DD, local.").optional(),
+    start: z.string().describe("HH:MM, 24-hour local clock. Required for a timed event or a task.").optional(),
+    end: z.string().describe(
+      "HH:MM for a timed event, or YYYY-MM-DD (inclusive) for a multi-day all-day event. Alternative to duration."
+    ).optional(),
+    duration: z.number().describe("Minutes \u2014 an alternative to end, for a timed event.").optional(),
+    allDay: z.boolean().describe("Forces an all-day event. Inferred when start, end and duration are all omitted.").optional(),
+    task: z.boolean().describe("A dated to-do (one moment, not a span) rather than an event.").optional(),
+    calendarId: z.string().describe(
+      "Defaults to the user's default calendar. Must not be a subscription \u2014 those are read-only."
+    ).optional(),
+    color: z.string().describe("#rrggbb. Empty follows the calendar's own colour.").optional(),
+    icon: z.string().describe("A Phosphor icon name or one emoji. Empty follows the calendar's own mark.").optional(),
+    location: z.string().optional(),
+    url: z.string().optional(),
+    notes: z.string().optional(),
+    recurrence: recurrenceSchema.optional()
+  };
+}
+var createEventFieldsSchema = z.strictObject({
+  ...eventFieldsShape(),
+  date: dateKey("YYYY-MM-DD, local.")
+});
+var patchEventFieldsSchema = z.strictObject(eventFieldsShape());
+var SCOPE_DESCRIPTION = 'Required when the target event repeats: "one" (just this occurrence), "future" (this one and everything after), or "all" (the whole series). Ignored when the event does not repeat.';
+var OCCURRENCE_DESCRIPTION = 'Which occurrence, as a YYYY-MM-DD date or a full "YYYY-MM-DDTHH:mm:ss" instant. Required with scope "one" or "future".';
+var scopeSchema = z.enum(["one", "future", "all"]).describe(SCOPE_DESCRIPTION);
+var occurrenceSchema = z.string().describe(OCCURRENCE_DESCRIPTION);
+function registerTools(server, ctx2) {
+  server.registerTool(
+    "list_day",
+    {
+      description: "The agenda for one local day: recurrence expanded, all-day and timed occurrences listed separately, each with its id (for update_event/delete_event/toggle_done), its occurrence key, and \u2014 for a multi-day span \u2014 its Day N/M position.",
+      inputSchema: z.strictObject({ date: dateKey("YYYY-MM-DD, local.") }),
+      annotations: { readOnlyHint: true }
+    },
+    async ({ date }) => guarded(async () => {
+      const { contents, warning } = await loadForRead(ctx2);
+      return withWarning(listDay(contents, date), warning);
+    })
+  );
+  server.registerTool(
+    "list_range",
+    {
+      description: `The agenda across several local days, one section per day that has something on it. Capped at ${MAX_RANGE_DAYS} days of span and ${MAX_RANGE_OCCURRENCES} occurrences total \u2014 a wide range may come back truncated, which the response says.`,
+      inputSchema: z.strictObject({
+        from: dateKey("YYYY-MM-DD, local, inclusive."),
+        to: dateKey("YYYY-MM-DD, local, inclusive.")
+      }),
+      annotations: { readOnlyHint: true }
+    },
+    async ({ from, to }) => guarded(async () => {
+      const { contents, warning } = await loadForRead(ctx2);
+      return withWarning(listRange(contents, from, to), warning);
+    })
+  );
+  server.registerTool(
+    "search",
+    {
+      description: "Ranked title/location/notes search over the user's own events (never a subscription's).",
+      inputSchema: z.strictObject({
+        query: z.string(),
+        limit: z.number().int().min(1).describe("Default 20.").optional()
+      }),
+      annotations: { readOnlyHint: true }
+    },
+    async ({ query, limit }) => guarded(async () => {
+      const { contents, warning } = await loadForRead(ctx2);
+      return withWarning(searchEvents(contents, query, limit), warning);
+    })
+  );
+  server.registerTool(
+    "free_slots",
+    {
+      description: "Gaps of at least `minutes` on one day, inside a window that defaults to the user's own waking hours setting. Also reports the day's booked and free minutes across that window.",
+      inputSchema: z.strictObject({
+        date: dateKey("YYYY-MM-DD, local."),
+        minutes: z.number().describe("Minimum slot length, in minutes."),
+        from: z.string().describe("HH:MM, local. Defaults to the user's waking-hours start.").optional(),
+        to: z.string().describe("HH:MM, local. Defaults to the user's waking-hours end.").optional()
+      }),
+      annotations: { readOnlyHint: true }
+    },
+    async ({ date, minutes, from, to }) => guarded(async () => {
+      const { contents, warning } = await loadForRead(ctx2);
+      return withWarning(freeSlots(contents, date, minutes, from, to), warning);
+    })
+  );
+  server.registerTool(
+    "list_calendars",
+    {
+      description: "Every calendar: id, name, colour, whether it is a read-only subscription, and visibility.",
+      inputSchema: z.strictObject({}),
+      annotations: { readOnlyHint: true }
+    },
+    async () => guarded(async () => {
+      const { contents, warning } = await loadForRead(ctx2);
+      return withWarning(listCalendars(contents), warning);
+    })
+  );
+  server.registerTool(
+    "describe_event",
+    {
+      description: "One event in full, including its recurrence rendered as an English sentence.",
+      inputSchema: z.strictObject({ id: z.string() }),
+      annotations: { readOnlyHint: true }
+    },
+    async ({ id }) => guarded(async () => {
+      const { contents, warning } = await loadForRead(ctx2);
+      return withWarning(describeEvent(contents, id), warning);
+    })
+  );
+  server.registerTool(
+    "quick_add",
+    {
+      description: `Creates an event from one line of text, through circal's own quick-add grammar \u2014 the same parser the app's own command palette uses. Understands things like "lunch tomorrow 1pm 45m" and "gym every monday 7am". Returns the resolved event for confirmation.`,
+      inputSchema: z.strictObject({
+        text: z.string(),
+        date: dateKey(
+          'YYYY-MM-DD, local \u2014 what "tomorrow" etc. is relative to. Defaults to today.'
+        ).optional()
+      }),
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
+    },
+    async ({ text, date }) => guarded(
+      () => casWrite(ctx2, (contents) => {
+        const outcome = performQuickAdd(contents, text, date);
+        return { result: outcome.mutated, summary: outcome.message };
+      })
+    )
+  );
+  server.registerTool(
+    "create_event",
+    {
+      description: "Creates an event from explicit fields, for anything quick_add's grammar cannot spell \u2014 a full recurrence, a specific calendar, notes. Every field is validated the same way an imported backup is.",
+      inputSchema: createEventFieldsSchema,
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
+    },
+    async (input) => guarded(
+      () => casWrite(ctx2, (contents) => {
+        const outcome = performCreateEvent(contents, input);
+        return { result: outcome.mutated, summary: outcome.message };
+      })
+    )
+  );
+  server.registerTool(
+    "update_event",
+    {
+      description: "Patches an existing event. Every field in `patch` is optional and left alone when omitted. " + SCOPE_DESCRIPTION,
+      inputSchema: z.strictObject({
+        id: z.string(),
+        scope: scopeSchema.optional(),
+        occurrence: occurrenceSchema.optional(),
+        patch: patchEventFieldsSchema
+      }),
+      annotations: { destructiveHint: true, idempotentHint: false }
+    },
+    async ({ id, scope, occurrence, patch }) => guarded(
+      () => casWrite(ctx2, (contents) => {
+        const outcome = performUpdateEvent(contents, id, scope, occurrence, patch);
+        return { result: outcome.mutated, summary: outcome.message };
+      })
+    )
+  );
+  server.registerTool(
+    "delete_event",
+    {
+      description: `Deletes an event, or one occurrence, or a series' tail. ${SCOPE_DESCRIPTION}`,
+      inputSchema: z.strictObject({
+        id: z.string(),
+        scope: scopeSchema.optional(),
+        occurrence: occurrenceSchema.optional()
+      }),
+      annotations: { destructiveHint: true, idempotentHint: false }
+    },
+    async ({ id, scope, occurrence }) => guarded(
+      () => casWrite(ctx2, (contents) => {
+        const outcome = performDeleteEvent(contents, id, scope, occurrence);
+        return { result: outcome.mutated, summary: outcome.message };
+      })
+    )
+  );
+  server.registerTool(
+    "toggle_done",
+    {
+      description: "Ticks a task off, or back on, one occurrence at a time \u2014 never the whole series at once.",
+      inputSchema: z.strictObject({
+        id: z.string(),
+        occurrence: z.string().describe("YYYY-MM-DD or a full instant. Required for a repeating task.").optional()
+      }),
+      annotations: { destructiveHint: false, idempotentHint: false }
+    },
+    async ({ id, occurrence }) => guarded(
+      () => casWrite(ctx2, (contents) => {
+        const outcome = performToggleDone(contents, id, occurrence);
+        return { result: outcome.mutated, summary: outcome.message };
+      })
+    )
+  );
+  server.registerTool(
+    "create_calendar",
+    {
+      description: "Adds a calendar of the user's own \u2014 never a subscription; those come from the app's Settings.",
+      inputSchema: z.strictObject({
+        name: z.string(),
+        color: z.string().describe("#rrggbb. Defaults to the next palette colour.").optional(),
+        icon: z.string().describe("A Phosphor icon name or one emoji.").optional()
+      }),
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false }
+    },
+    async ({ name, color, icon }) => guarded(
+      () => casWrite(ctx2, (contents) => {
+        const outcome = performCreateCalendar(contents, name, color, icon);
+        return { result: outcome.mutated, summary: outcome.message };
+      })
+    )
+  );
+}
+
+// mcp/index.ts
+var HELP = `circal-mcp \u2014 reads and writes circal's mirror file over stdio (MCP)
+
+Usage:
+  circal-mcp --file <path>   Start the server against a mirror file
+  circal-mcp --find          Search common locations for a mirror file and
+                              print a ready-to-paste client config (read-only,
+                              does not start the server)
+  circal-mcp --help          Print this message
+
+Environment:
+  CIRCAL_FILE                 Mirror file path, same as --file
+  CIRCAL_ALLOW_ZONE_MISMATCH   Set to 1 to allow writes when this process's
+                              zone does not match the file's recorded zone
+`;
+var argv = process.argv.slice(2);
+if (argv.includes("--help") || argv.includes("-h")) {
+  console.log(HELP);
+  process.exit(0);
+}
+if (argv.includes("--find")) {
+  await runFind();
+  process.exit(0);
+}
+var path;
+try {
+  path = resolveFilePath(argv, process.env);
+} catch (error) {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`${message} Run \`circal-mcp --find\` to search common locations for one.`);
+  process.exit(1);
+}
+var ctx = { path, env: process.env };
+function createServer() {
+  const server = new McpServer({ name: "circal", version: "1.0.0" });
+  registerTools(server, ctx);
+  return server;
+}
+void serveStdio(createServer);
+console.error("circal MCP server running on stdio");
+/*! Bundled license information:
+
+react/cjs/react.production.js:
+  (**
+   * @license React
+   * react.production.js
+   *
+   * Copyright (c) Meta Platforms, Inc. and affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   *)
+
+react/cjs/react.development.js:
+  (**
+   * @license React
+   * react.development.js
+   *
+   * Copyright (c) Meta Platforms, Inc. and affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   *)
+*/