@dam-agents/cli 0.2.3-rc2 → 0.2.4-rc1

package/dist/bin.js

@@ -1898,8 +1898,8 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {boolean} [combine] - if `true` or omitted, an optional value can be specified directly after the flag.
        * @return {Command} `this` command for chaining
        */
-      combineFlagAndOptionalValue(combine = true) {
-        this._combineFlagAndOptionalValue = !!combine;
+      combineFlagAndOptionalValue(combine2 = true) {
+        this._combineFlagAndOptionalValue = !!combine2;
         return this;
       }
       /**
@@ -2048,18 +2048,18 @@ Expecting one of '${allowedValues.join("', '")}'`);
        *
        * @private
        */
-      _prepareUserArgs(argv, parseOptions) {
+      _prepareUserArgs(argv, parseOptions2) {
         if (argv !== void 0 && !Array.isArray(argv)) {
           throw new Error("first parameter to parse must be array or undefined");
         }
-        parseOptions = parseOptions || {};
-        if (argv === void 0 && parseOptions.from === void 0) {
+        parseOptions2 = parseOptions2 || {};
+        if (argv === void 0 && parseOptions2.from === void 0) {
           if (process10.versions?.electron) {
-            parseOptions.from = "electron";
+            parseOptions2.from = "electron";
           }
           const execArgv = process10.execArgv ?? [];
           if (execArgv.includes("-e") || execArgv.includes("--eval") || execArgv.includes("-p") || execArgv.includes("--print")) {
-            parseOptions.from = "eval";
+            parseOptions2.from = "eval";
           }
         }
         if (argv === void 0) {
@@ -2067,7 +2067,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         }
         this.rawArgs = argv.slice();
         let userArgs;
-        switch (parseOptions.from) {
+        switch (parseOptions2.from) {
           case void 0:
           case "node":
             this._scriptPath = argv[1];
@@ -2089,7 +2089,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
             break;
           default:
             throw new Error(
-              `unexpected parse option { from: '${parseOptions.from}' }`
+              `unexpected parse option { from: '${parseOptions2.from}' }`
             );
         }
         if (!this._name && this._scriptPath)
@@ -2119,9 +2119,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [parseOptions.from] - where the args are from: 'node', 'user', 'electron'
        * @return {Command} `this` command for chaining
        */
-      parse(argv, parseOptions) {
+      parse(argv, parseOptions2) {
         this._prepareForParse();
-        const userArgs = this._prepareUserArgs(argv, parseOptions);
+        const userArgs = this._prepareUserArgs(argv, parseOptions2);
         this._parseCommand([], userArgs);
         return this;
       }
@@ -2145,9 +2145,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} parseOptions.from - where the args are from: 'node', 'user', 'electron'
        * @return {Promise}
        */
-      async parseAsync(argv, parseOptions) {
+      async parseAsync(argv, parseOptions2) {
         this._prepareForParse();
-        const userArgs = this._prepareUserArgs(argv, parseOptions);
+        const userArgs = this._prepareUserArgs(argv, parseOptions2);
         await this._parseCommand([], userArgs);
         return this;
       }
@@ -7341,7 +7341,7 @@ var require_b4a = __commonJS({
     function from(value, encodingOrOffset, length) {
       return Buffer.from(value, encodingOrOffset, length);
     }
-    function includes(buffer, value, byteOffset, encoding) {
+    function includes2(buffer, value, byteOffset, encoding) {
       return toBuffer(buffer).includes(value, byteOffset, encoding);
     }
     function indexOf(buffer, value, byfeOffset, encoding) {
@@ -7430,7 +7430,7 @@ var require_b4a = __commonJS({
       equals,
       fill,
       from,
-      includes,
+      includes: includes2,
       indexOf,
       lastIndexOf,
       swap16,
@@ -10896,9 +10896,9 @@ function wrapFetchWithTermsGate(host, baseFetch) {
   return (async (input, init) => {
     const response = await inner(input, init);
     if (response.status === 412) {
-      const clone2 = response.clone();
+      const clone3 = response.clone();
       try {
-        const body = await clone2.json();
+        const body = await clone3.json();
         if (body.error === "terms_stale") {
           throw new TermsStaleAtTransportError(host);
         }
@@ -13809,15 +13809,15 @@ var $ZodDate = /* @__PURE__ */ $constructor("$ZodDate", (inst, def) => {
       }
     }
     const input = payload.value;
-    const isDate = input instanceof Date;
-    const isValidDate = isDate && !Number.isNaN(input.getTime());
-    if (isValidDate)
+    const isDate2 = input instanceof Date;
+    const isValidDate2 = isDate2 && !Number.isNaN(input.getTime());
+    if (isValidDate2)
       return payload;
     payload.issues.push({
       expected: "date",
       code: "invalid_type",
       input,
-      ...isDate ? { received: "Invalid Date" } : {},
+      ...isDate2 ? { received: "Invalid Date" } : {},
       inst
     });
     return payload;
@@ -13863,14 +13863,14 @@ var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
   };
 });
 function handlePropertyResult(result, final, key, input, isOptionalIn, isOptionalOut) {
-  const isPresent = key in input;
+  const isPresent2 = key in input;
   if (result.issues.length) {
-    if (isOptionalIn && isOptionalOut && !isPresent) {
+    if (isOptionalIn && isOptionalOut && !isPresent2) {
       return;
     }
     final.issues.push(...prefixIssues(key, result.issues));
   }
-  if (!isPresent && !isOptionalIn) {
+  if (!isPresent2 && !isOptionalIn) {
     if (!result.issues.length) {
       final.issues.push({
         code: "invalid_type",
@@ -13882,7 +13882,7 @@ function handlePropertyResult(result, final, key, input, isOptionalIn, isOptiona
     return;
   }
   if (result.value === void 0) {
-    if (isPresent) {
+    if (isPresent2) {
       final.value[key] = void 0;
     }
   } else {
@@ -14503,9 +14503,9 @@ function handleTupleResult(result, final, index) {
 function handleTupleResults(itemResults, final, items, input, optoutStart) {
   for (let i = 0; i < items.length; i++) {
     const r = itemResults[i];
-    const isPresent = i < input.length;
+    const isPresent2 = i < input.length;
     if (r.issues.length) {
-      if (!isPresent && i >= optoutStart) {
+      if (!isPresent2 && i >= optoutStart) {
         final.value.length = i;
         break;
       }
@@ -21920,12 +21920,12 @@ function _uppercase(params) {
   });
 }
 // @__NO_SIDE_EFFECTS__
-function _includes(includes, params) {
+function _includes(includes2, params) {
   return new $ZodCheckIncludes({
     check: "string_format",
     format: "includes",
     ...normalizeParams(params),
-    includes
+    includes: includes2
   });
 }
 // @__NO_SIDE_EFFECTS__
@@ -25475,10 +25475,13 @@ var skillSourceSeedSchema = external_exports.object({
   name: external_exports.string(),
   gitUrl: external_exports.string()
 });
+var templateCategorySchema = external_exports.enum(["harness", "preconfigured"]).default("harness");
 var templateSpecSchema = external_exports.object({
   version: external_exports.string(),
   image: external_exports.string(),
   description: external_exports.string().optional(),
+  category: templateCategorySchema,
+  experimental: external_exports.boolean().optional(),
   mounts: external_exports.array(mountSchema).optional(),
   init: external_exports.string().optional(),
   env: external_exports.array(envVarConfigMapSchema).optional(),
@@ -25670,6 +25673,3049 @@ var scheduleStatusSchema = external_exports.object({
   lastResult: external_exports.string().optional()
 });
 
+// ../../node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/index.js
+var esm_exports = {};
+__export(esm_exports, {
+  ALL_WEEKDAYS: () => ALL_WEEKDAYS,
+  Frequency: () => Frequency,
+  RRule: () => RRule,
+  RRuleSet: () => RRuleSet,
+  Weekday: () => Weekday,
+  datetime: () => datetime3,
+  rrulestr: () => rrulestr
+});
+
+// ../../node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/weekday.js
+var ALL_WEEKDAYS = [
+  "MO",
+  "TU",
+  "WE",
+  "TH",
+  "FR",
+  "SA",
+  "SU"
+];
+var Weekday = (
+  /** @class */
+  (function() {
+    function Weekday2(weekday, n) {
+      if (n === 0)
+        throw new Error("Can't create weekday with n == 0");
+      this.weekday = weekday;
+      this.n = n;
+    }
+    Weekday2.fromStr = function(str) {
+      return new Weekday2(ALL_WEEKDAYS.indexOf(str));
+    };
+    Weekday2.prototype.nth = function(n) {
+      return this.n === n ? this : new Weekday2(this.weekday, n);
+    };
+    Weekday2.prototype.equals = function(other) {
+      return this.weekday === other.weekday && this.n === other.n;
+    };
+    Weekday2.prototype.toString = function() {
+      var s = ALL_WEEKDAYS[this.weekday];
+      if (this.n)
+        s = (this.n > 0 ? "+" : "") + String(this.n) + s;
+      return s;
+    };
+    Weekday2.prototype.getJsWeekday = function() {
+      return this.weekday === 6 ? 0 : this.weekday + 1;
+    };
+    return Weekday2;
+  })()
+);
+
+// ../../node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/helpers.js
+var isPresent = function(value) {
+  return value !== null && value !== void 0;
+};
+var isNumber = function(value) {
+  return typeof value === "number";
+};
+var isWeekdayStr = function(value) {
+  return typeof value === "string" && ALL_WEEKDAYS.includes(value);
+};
+var isArray = Array.isArray;
+var range = function(start, end) {
+  if (end === void 0) {
+    end = start;
+  }
+  if (arguments.length === 1) {
+    end = start;
+    start = 0;
+  }
+  var rang = [];
+  for (var i = start; i < end; i++)
+    rang.push(i);
+  return rang;
+};
+var repeat = function(value, times) {
+  var i = 0;
+  var array2 = [];
+  if (isArray(value)) {
+    for (; i < times; i++)
+      array2[i] = [].concat(value);
+  } else {
+    for (; i < times; i++)
+      array2[i] = value;
+  }
+  return array2;
+};
+var toArray = function(item) {
+  if (isArray(item)) {
+    return item;
+  }
+  return [item];
+};
+function padStart(item, targetLength, padString) {
+  if (padString === void 0) {
+    padString = " ";
+  }
+  var str = String(item);
+  targetLength = targetLength >> 0;
+  if (str.length > targetLength) {
+    return String(str);
+  }
+  targetLength = targetLength - str.length;
+  if (targetLength > padString.length) {
+    padString += repeat(padString, targetLength / padString.length);
+  }
+  return padString.slice(0, targetLength) + String(str);
+}
+var split = function(str, sep, num) {
+  var splits = str.split(sep);
+  return num ? splits.slice(0, num).concat([splits.slice(num).join(sep)]) : splits;
+};
+var pymod = function(a, b2) {
+  var r = a % b2;
+  return r * b2 < 0 ? r + b2 : r;
+};
+var divmod = function(a, b2) {
+  return { div: Math.floor(a / b2), mod: pymod(a, b2) };
+};
+var empty = function(obj) {
+  return !isPresent(obj) || obj.length === 0;
+};
+var notEmpty = function(obj) {
+  return !empty(obj);
+};
+var includes = function(arr, val) {
+  return notEmpty(arr) && arr.indexOf(val) !== -1;
+};
+
+// ../../node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/dateutil.js
+var datetime3 = function(y, m, d2, h2, i, s) {
+  if (h2 === void 0) {
+    h2 = 0;
+  }
+  if (i === void 0) {
+    i = 0;
+  }
+  if (s === void 0) {
+    s = 0;
+  }
+  return new Date(Date.UTC(y, m - 1, d2, h2, i, s));
+};
+var MONTH_DAYS = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+var ONE_DAY = 1e3 * 60 * 60 * 24;
+var MAXYEAR = 9999;
+var ORDINAL_BASE = datetime3(1970, 1, 1);
+var PY_WEEKDAYS = [6, 0, 1, 2, 3, 4, 5];
+var isLeapYear = function(year) {
+  return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
+};
+var isDate = function(value) {
+  return value instanceof Date;
+};
+var isValidDate = function(value) {
+  return isDate(value) && !isNaN(value.getTime());
+};
+var daysBetween = function(date1, date22) {
+  var date1ms = date1.getTime();
+  var date2ms = date22.getTime();
+  var differencems = date1ms - date2ms;
+  return Math.round(differencems / ONE_DAY);
+};
+var toOrdinal = function(date5) {
+  return daysBetween(date5, ORDINAL_BASE);
+};
+var fromOrdinal = function(ordinal) {
+  return new Date(ORDINAL_BASE.getTime() + ordinal * ONE_DAY);
+};
+var getMonthDays = function(date5) {
+  var month = date5.getUTCMonth();
+  return month === 1 && isLeapYear(date5.getUTCFullYear()) ? 29 : MONTH_DAYS[month];
+};
+var getWeekday = function(date5) {
+  return PY_WEEKDAYS[date5.getUTCDay()];
+};
+var monthRange = function(year, month) {
+  var date5 = datetime3(year, month + 1, 1);
+  return [getWeekday(date5), getMonthDays(date5)];
+};
+var combine = function(date5, time3) {
+  time3 = time3 || date5;
+  return new Date(Date.UTC(date5.getUTCFullYear(), date5.getUTCMonth(), date5.getUTCDate(), time3.getHours(), time3.getMinutes(), time3.getSeconds(), time3.getMilliseconds()));
+};
+var clone2 = function(date5) {
+  var dolly = new Date(date5.getTime());
+  return dolly;
+};
+var cloneDates = function(dates) {
+  var clones = [];
+  for (var i = 0; i < dates.length; i++) {
+    clones.push(clone2(dates[i]));
+  }
+  return clones;
+};
+var sort = function(dates) {
+  dates.sort(function(a, b2) {
+    return a.getTime() - b2.getTime();
+  });
+};
+var timeToUntilString = function(time3, utc) {
+  if (utc === void 0) {
+    utc = true;
+  }
+  var date5 = new Date(time3);
+  return [
+    padStart(date5.getUTCFullYear().toString(), 4, "0"),
+    padStart(date5.getUTCMonth() + 1, 2, "0"),
+    padStart(date5.getUTCDate(), 2, "0"),
+    "T",
+    padStart(date5.getUTCHours(), 2, "0"),
+    padStart(date5.getUTCMinutes(), 2, "0"),
+    padStart(date5.getUTCSeconds(), 2, "0"),
+    utc ? "Z" : ""
+  ].join("");
+};
+var untilStringToDate = function(until) {
+  var re = /^(\d{4})(\d{2})(\d{2})(T(\d{2})(\d{2})(\d{2})Z?)?$/;
+  var bits = re.exec(until);
+  if (!bits)
+    throw new Error("Invalid UNTIL value: ".concat(until));
+  return new Date(Date.UTC(parseInt(bits[1], 10), parseInt(bits[2], 10) - 1, parseInt(bits[3], 10), parseInt(bits[5], 10) || 0, parseInt(bits[6], 10) || 0, parseInt(bits[7], 10) || 0));
+};
+var dateTZtoISO8601 = function(date5, timeZone) {
+  var dateStr = date5.toLocaleString("sv-SE", { timeZone });
+  return dateStr.replace(" ", "T") + "Z";
+};
+var dateInTimeZone = function(date5, timeZone) {
+  var localTimeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  var dateInLocalTZ = new Date(dateTZtoISO8601(date5, localTimeZone));
+  var dateInTargetTZ = new Date(dateTZtoISO8601(date5, timeZone !== null && timeZone !== void 0 ? timeZone : "UTC"));
+  var tzOffset = dateInTargetTZ.getTime() - dateInLocalTZ.getTime();
+  return new Date(date5.getTime() - tzOffset);
+};
+
+// ../../node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/iterresult.js
+var IterResult = (
+  /** @class */
+  (function() {
+    function IterResult2(method, args) {
+      this.minDate = null;
+      this.maxDate = null;
+      this._result = [];
+      this.total = 0;
+      this.method = method;
+      this.args = args;
+      if (method === "between") {
+        this.maxDate = args.inc ? args.before : new Date(args.before.getTime() - 1);
+        this.minDate = args.inc ? args.after : new Date(args.after.getTime() + 1);
+      } else if (method === "before") {
+        this.maxDate = args.inc ? args.dt : new Date(args.dt.getTime() - 1);
+      } else if (method === "after") {
+        this.minDate = args.inc ? args.dt : new Date(args.dt.getTime() + 1);
+      }
+    }
+    IterResult2.prototype.accept = function(date5) {
+      ++this.total;
+      var tooEarly = this.minDate && date5 < this.minDate;
+      var tooLate = this.maxDate && date5 > this.maxDate;
+      if (this.method === "between") {
+        if (tooEarly)
+          return true;
+        if (tooLate)
+          return false;
+      } else if (this.method === "before") {
+        if (tooLate)
+          return false;
+      } else if (this.method === "after") {
+        if (tooEarly)
+          return true;
+        this.add(date5);
+        return false;
+      }
+      return this.add(date5);
+    };
+    IterResult2.prototype.add = function(date5) {
+      this._result.push(date5);
+      return true;
+    };
+    IterResult2.prototype.getValue = function() {
+      var res = this._result;
+      switch (this.method) {
+        case "all":
+        case "between":
+          return res;
+        case "before":
+        case "after":
+        default:
+          return res.length ? res[res.length - 1] : null;
+      }
+    };
+    IterResult2.prototype.clone = function() {
+      return new IterResult2(this.method, this.args);
+    };
+    return IterResult2;
+  })()
+);
+var iterresult_default = IterResult;
+
+// ../../node_modules/.pnpm/tslib@2.8.1/node_modules/tslib/tslib.es6.mjs
+var extendStatics = function(d2, b2) {
+  extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d3, b3) {
+    d3.__proto__ = b3;
+  } || function(d3, b3) {
+    for (var p2 in b3) if (Object.prototype.hasOwnProperty.call(b3, p2)) d3[p2] = b3[p2];
+  };
+  return extendStatics(d2, b2);
+};
+function __extends(d2, b2) {
+  if (typeof b2 !== "function" && b2 !== null)
+    throw new TypeError("Class extends value " + String(b2) + " is not a constructor or null");
+  extendStatics(d2, b2);
+  function __() {
+    this.constructor = d2;
+  }
+  d2.prototype = b2 === null ? Object.create(b2) : (__.prototype = b2.prototype, new __());
+}
+var __assign = function() {
+  __assign = Object.assign || function __assign2(t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+      for (var p2 in s) if (Object.prototype.hasOwnProperty.call(s, p2)) t[p2] = s[p2];
+    }
+    return t;
+  };
+  return __assign.apply(this, arguments);
+};
+function __spreadArray(to, from, pack) {
+  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
+    }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from));
+}
+
+// ../../node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/callbackiterresult.js
+var CallbackIterResult = (
+  /** @class */
+  (function(_super) {
+    __extends(CallbackIterResult2, _super);
+    function CallbackIterResult2(method, args, iterator) {
+      var _this = _super.call(this, method, args) || this;
+      _this.iterator = iterator;
+      return _this;
+    }
+    CallbackIterResult2.prototype.add = function(date5) {
+      if (this.iterator(date5, this._result.length)) {
+        this._result.push(date5);
+        return true;
+      }
+      return false;
+    };
+    return CallbackIterResult2;
+  })(iterresult_default)
+);
+var callbackiterresult_default = CallbackIterResult;
+
+// ../../node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/nlp/i18n.js
+var ENGLISH = {
+  dayNames: [
+    "Sunday",
+    "Monday",
+    "Tuesday",
+    "Wednesday",
+    "Thursday",
+    "Friday",
+    "Saturday"
+  ],
+  monthNames: [
+    "January",
+    "February",
+    "March",
+    "April",
+    "May",
+    "June",
+    "July",
+    "August",
+    "September",
+    "October",
+    "November",
+    "December"
+  ],
+  tokens: {
+    SKIP: /^[ \r\n\t]+|^\.$/,
+    number: /^[1-9][0-9]*/,
+    numberAsText: /^(one|two|three)/i,
+    every: /^every/i,
+    "day(s)": /^days?/i,
+    "weekday(s)": /^weekdays?/i,
+    "week(s)": /^weeks?/i,
+    "hour(s)": /^hours?/i,
+    "minute(s)": /^minutes?/i,
+    "month(s)": /^months?/i,
+    "year(s)": /^years?/i,
+    on: /^(on|in)/i,
+    at: /^(at)/i,
+    the: /^the/i,
+    first: /^first/i,
+    second: /^second/i,
+    third: /^third/i,
+    nth: /^([1-9][0-9]*)(\.|th|nd|rd|st)/i,
+    last: /^last/i,
+    for: /^for/i,
+    "time(s)": /^times?/i,
+    until: /^(un)?til/i,
+    monday: /^mo(n(day)?)?/i,
+    tuesday: /^tu(e(s(day)?)?)?/i,
+    wednesday: /^we(d(n(esday)?)?)?/i,
+    thursday: /^th(u(r(sday)?)?)?/i,
+    friday: /^fr(i(day)?)?/i,
+    saturday: /^sa(t(urday)?)?/i,
+    sunday: /^su(n(day)?)?/i,
+    january: /^jan(uary)?/i,
+    february: /^feb(ruary)?/i,
+    march: /^mar(ch)?/i,
+    april: /^apr(il)?/i,
+    may: /^may/i,
+    june: /^june?/i,
+    july: /^july?/i,
+    august: /^aug(ust)?/i,
+    september: /^sep(t(ember)?)?/i,
+    october: /^oct(ober)?/i,
+    november: /^nov(ember)?/i,
+    december: /^dec(ember)?/i,
+    comma: /^(,\s*|(and|or)\s*)+/i
+  }
+};
+var i18n_default = ENGLISH;
+
+// ../../node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/nlp/totext.js
+var contains = function(arr, val) {
+  return arr.indexOf(val) !== -1;
+};
+var defaultGetText = function(id) {
+  return id.toString();
+};
+var defaultDateFormatter = function(year, month, day) {
+  return "".concat(month, " ").concat(day, ", ").concat(year);
+};
+var ToText = (
+  /** @class */
+  (function() {
+    function ToText2(rrule, gettext, language, dateFormatter) {
+      if (gettext === void 0) {
+        gettext = defaultGetText;
+      }
+      if (language === void 0) {
+        language = i18n_default;
+      }
+      if (dateFormatter === void 0) {
+        dateFormatter = defaultDateFormatter;
+      }
+      this.text = [];
+      this.language = language || i18n_default;
+      this.gettext = gettext;
+      this.dateFormatter = dateFormatter;
+      this.rrule = rrule;
+      this.options = rrule.options;
+      this.origOptions = rrule.origOptions;
+      if (this.origOptions.bymonthday) {
+        var bymonthday = [].concat(this.options.bymonthday);
+        var bynmonthday = [].concat(this.options.bynmonthday);
+        bymonthday.sort(function(a, b2) {
+          return a - b2;
+        });
+        bynmonthday.sort(function(a, b2) {
+          return b2 - a;
+        });
+        this.bymonthday = bymonthday.concat(bynmonthday);
+        if (!this.bymonthday.length)
+          this.bymonthday = null;
+      }
+      if (isPresent(this.origOptions.byweekday)) {
+        var byweekday = !isArray(this.origOptions.byweekday) ? [this.origOptions.byweekday] : this.origOptions.byweekday;
+        var days = String(byweekday);
+        this.byweekday = {
+          allWeeks: byweekday.filter(function(weekday) {
+            return !weekday.n;
+          }),
+          someWeeks: byweekday.filter(function(weekday) {
+            return Boolean(weekday.n);
+          }),
+          isWeekdays: days.indexOf("MO") !== -1 && days.indexOf("TU") !== -1 && days.indexOf("WE") !== -1 && days.indexOf("TH") !== -1 && days.indexOf("FR") !== -1 && days.indexOf("SA") === -1 && days.indexOf("SU") === -1,
+          isEveryDay: days.indexOf("MO") !== -1 && days.indexOf("TU") !== -1 && days.indexOf("WE") !== -1 && days.indexOf("TH") !== -1 && days.indexOf("FR") !== -1 && days.indexOf("SA") !== -1 && days.indexOf("SU") !== -1
+        };
+        var sortWeekDays = function(a, b2) {
+          return a.weekday - b2.weekday;
+        };
+        this.byweekday.allWeeks.sort(sortWeekDays);
+        this.byweekday.someWeeks.sort(sortWeekDays);
+        if (!this.byweekday.allWeeks.length)
+          this.byweekday.allWeeks = null;
+        if (!this.byweekday.someWeeks.length)
+          this.byweekday.someWeeks = null;
+      } else {
+        this.byweekday = null;
+      }
+    }
+    ToText2.isFullyConvertible = function(rrule) {
+      var canConvert = true;
+      if (!(rrule.options.freq in ToText2.IMPLEMENTED))
+        return false;
+      if (rrule.origOptions.until && rrule.origOptions.count)
+        return false;
+      for (var key in rrule.origOptions) {
+        if (contains(["dtstart", "tzid", "wkst", "freq"], key))
+          return true;
+        if (!contains(ToText2.IMPLEMENTED[rrule.options.freq], key))
+          return false;
+      }
+      return canConvert;
+    };
+    ToText2.prototype.isFullyConvertible = function() {
+      return ToText2.isFullyConvertible(this.rrule);
+    };
+    ToText2.prototype.toString = function() {
+      var gettext = this.gettext;
+      if (!(this.options.freq in ToText2.IMPLEMENTED)) {
+        return gettext("RRule error: Unable to fully convert this rrule to text");
+      }
+      this.text = [gettext("every")];
+      this[RRule.FREQUENCIES[this.options.freq]]();
+      if (this.options.until) {
+        this.add(gettext("until"));
+        var until = this.options.until;
+        this.add(this.dateFormatter(until.getUTCFullYear(), this.language.monthNames[until.getUTCMonth()], until.getUTCDate()));
+      } else if (this.options.count) {
+        this.add(gettext("for")).add(this.options.count.toString()).add(this.plural(this.options.count) ? gettext("times") : gettext("time"));
+      }
+      if (!this.isFullyConvertible())
+        this.add(gettext("(~ approximate)"));
+      return this.text.join("");
+    };
+    ToText2.prototype.HOURLY = function() {
+      var gettext = this.gettext;
+      if (this.options.interval !== 1)
+        this.add(this.options.interval.toString());
+      this.add(this.plural(this.options.interval) ? gettext("hours") : gettext("hour"));
+    };
+    ToText2.prototype.MINUTELY = function() {
+      var gettext = this.gettext;
+      if (this.options.interval !== 1)
+        this.add(this.options.interval.toString());
+      this.add(this.plural(this.options.interval) ? gettext("minutes") : gettext("minute"));
+    };
+    ToText2.prototype.DAILY = function() {
+      var gettext = this.gettext;
+      if (this.options.interval !== 1)
+        this.add(this.options.interval.toString());
+      if (this.byweekday && this.byweekday.isWeekdays) {
+        this.add(this.plural(this.options.interval) ? gettext("weekdays") : gettext("weekday"));
+      } else {
+        this.add(this.plural(this.options.interval) ? gettext("days") : gettext("day"));
+      }
+      if (this.origOptions.bymonth) {
+        this.add(gettext("in"));
+        this._bymonth();
+      }
+      if (this.bymonthday) {
+        this._bymonthday();
+      } else if (this.byweekday) {
+        this._byweekday();
+      } else if (this.origOptions.byhour) {
+        this._byhour();
+      }
+    };
+    ToText2.prototype.WEEKLY = function() {
+      var gettext = this.gettext;
+      if (this.options.interval !== 1) {
+        this.add(this.options.interval.toString()).add(this.plural(this.options.interval) ? gettext("weeks") : gettext("week"));
+      }
+      if (this.byweekday && this.byweekday.isWeekdays) {
+        if (this.options.interval === 1) {
+          this.add(this.plural(this.options.interval) ? gettext("weekdays") : gettext("weekday"));
+        } else {
+          this.add(gettext("on")).add(gettext("weekdays"));
+        }
+      } else if (this.byweekday && this.byweekday.isEveryDay) {
+        this.add(this.plural(this.options.interval) ? gettext("days") : gettext("day"));
+      } else {
+        if (this.options.interval === 1)
+          this.add(gettext("week"));
+        if (this.origOptions.bymonth) {
+          this.add(gettext("in"));
+          this._bymonth();
+        }
+        if (this.bymonthday) {
+          this._bymonthday();
+        } else if (this.byweekday) {
+          this._byweekday();
+        }
+        if (this.origOptions.byhour) {
+          this._byhour();
+        }
+      }
+    };
+    ToText2.prototype.MONTHLY = function() {
+      var gettext = this.gettext;
+      if (this.origOptions.bymonth) {
+        if (this.options.interval !== 1) {
+          this.add(this.options.interval.toString()).add(gettext("months"));
+          if (this.plural(this.options.interval))
+            this.add(gettext("in"));
+        } else {
+        }
+        this._bymonth();
+      } else {
+        if (this.options.interval !== 1) {
+          this.add(this.options.interval.toString());
+        }
+        this.add(this.plural(this.options.interval) ? gettext("months") : gettext("month"));
+      }
+      if (this.bymonthday) {
+        this._bymonthday();
+      } else if (this.byweekday && this.byweekday.isWeekdays) {
+        this.add(gettext("on")).add(gettext("weekdays"));
+      } else if (this.byweekday) {
+        this._byweekday();
+      }
+    };
+    ToText2.prototype.YEARLY = function() {
+      var gettext = this.gettext;
+      if (this.origOptions.bymonth) {
+        if (this.options.interval !== 1) {
+          this.add(this.options.interval.toString());
+          this.add(gettext("years"));
+        } else {
+        }
+        this._bymonth();
+      } else {
+        if (this.options.interval !== 1) {
+          this.add(this.options.interval.toString());
+        }
+        this.add(this.plural(this.options.interval) ? gettext("years") : gettext("year"));
+      }
+      if (this.bymonthday) {
+        this._bymonthday();
+      } else if (this.byweekday) {
+        this._byweekday();
+      }
+      if (this.options.byyearday) {
+        this.add(gettext("on the")).add(this.list(this.options.byyearday, this.nth, gettext("and"))).add(gettext("day"));
+      }
+      if (this.options.byweekno) {
+        this.add(gettext("in")).add(this.plural(this.options.byweekno.length) ? gettext("weeks") : gettext("week")).add(this.list(this.options.byweekno, void 0, gettext("and")));
+      }
+    };
+    ToText2.prototype._bymonthday = function() {
+      var gettext = this.gettext;
+      if (this.byweekday && this.byweekday.allWeeks) {
+        this.add(gettext("on")).add(this.list(this.byweekday.allWeeks, this.weekdaytext, gettext("or"))).add(gettext("the")).add(this.list(this.bymonthday, this.nth, gettext("or")));
+      } else {
+        this.add(gettext("on the")).add(this.list(this.bymonthday, this.nth, gettext("and")));
+      }
+    };
+    ToText2.prototype._byweekday = function() {
+      var gettext = this.gettext;
+      if (this.byweekday.allWeeks && !this.byweekday.isWeekdays) {
+        this.add(gettext("on")).add(this.list(this.byweekday.allWeeks, this.weekdaytext));
+      }
+      if (this.byweekday.someWeeks) {
+        if (this.byweekday.allWeeks)
+          this.add(gettext("and"));
+        this.add(gettext("on the")).add(this.list(this.byweekday.someWeeks, this.weekdaytext, gettext("and")));
+      }
+    };
+    ToText2.prototype._byhour = function() {
+      var gettext = this.gettext;
+      this.add(gettext("at")).add(this.list(this.origOptions.byhour, void 0, gettext("and")));
+    };
+    ToText2.prototype._bymonth = function() {
+      this.add(this.list(this.options.bymonth, this.monthtext, this.gettext("and")));
+    };
+    ToText2.prototype.nth = function(n) {
+      n = parseInt(n.toString(), 10);
+      var nth;
+      var gettext = this.gettext;
+      if (n === -1)
+        return gettext("last");
+      var npos = Math.abs(n);
+      switch (npos) {
+        case 1:
+        case 21:
+        case 31:
+          nth = npos + gettext("st");
+          break;
+        case 2:
+        case 22:
+          nth = npos + gettext("nd");
+          break;
+        case 3:
+        case 23:
+          nth = npos + gettext("rd");
+          break;
+        default:
+          nth = npos + gettext("th");
+      }
+      return n < 0 ? nth + " " + gettext("last") : nth;
+    };
+    ToText2.prototype.monthtext = function(m) {
+      return this.language.monthNames[m - 1];
+    };
+    ToText2.prototype.weekdaytext = function(wday) {
+      var weekday = isNumber(wday) ? (wday + 1) % 7 : wday.getJsWeekday();
+      return (wday.n ? this.nth(wday.n) + " " : "") + this.language.dayNames[weekday];
+    };
+    ToText2.prototype.plural = function(n) {
+      return n % 100 !== 1;
+    };
+    ToText2.prototype.add = function(s) {
+      this.text.push(" ");
+      this.text.push(s);
+      return this;
+    };
+    ToText2.prototype.list = function(arr, callback, finalDelim, delim) {
+      var _this = this;
+      if (delim === void 0) {
+        delim = ",";
+      }
+      if (!isArray(arr)) {
+        arr = [arr];
+      }
+      var delimJoin = function(array2, delimiter, finalDelimiter) {
+        var list = "";
+        for (var i = 0; i < array2.length; i++) {
+          if (i !== 0) {
+            if (i === array2.length - 1) {
+              list += " " + finalDelimiter + " ";
+            } else {
+              list += delimiter + " ";
+            }
+          }
+          list += array2[i];
+        }
+        return list;
+      };
+      callback = callback || function(o) {
+        return o.toString();
+      };
+      var realCallback = function(arg) {
+        return callback && callback.call(_this, arg);
+      };
+      if (finalDelim) {
+        return delimJoin(arr.map(realCallback), delim, finalDelim);
+      } else {
+        return arr.map(realCallback).join(delim + " ");
+      }
+    };
+    return ToText2;
+  })()
+);
+var totext_default = ToText;
+
+// ../../node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/nlp/parsetext.js
+var Parser = (
+  /** @class */
+  (function() {
+    function Parser2(rules) {
+      this.done = true;
+      this.rules = rules;
+    }
+    Parser2.prototype.start = function(text) {
+      this.text = text;
+      this.done = false;
+      return this.nextSymbol();
+    };
+    Parser2.prototype.isDone = function() {
+      return this.done && this.symbol === null;
+    };
+    Parser2.prototype.nextSymbol = function() {
+      var best;
+      var bestSymbol;
+      this.symbol = null;
+      this.value = null;
+      do {
+        if (this.done)
+          return false;
+        var rule = void 0;
+        best = null;
+        for (var name_1 in this.rules) {
+          rule = this.rules[name_1];
+          var match = rule.exec(this.text);
+          if (match) {
+            if (best === null || match[0].length > best[0].length) {
+              best = match;
+              bestSymbol = name_1;
+            }
+          }
+        }
+        if (best != null) {
+          this.text = this.text.substr(best[0].length);
+          if (this.text === "")
+            this.done = true;
+        }
+        if (best == null) {
+          this.done = true;
+          this.symbol = null;
+          this.value = null;
+          return;
+        }
+      } while (bestSymbol === "SKIP");
+      this.symbol = bestSymbol;
+      this.value = best;
+      return true;
+    };
+    Parser2.prototype.accept = function(name) {
+      if (this.symbol === name) {
+        if (this.value) {
+          var v2 = this.value;
+          this.nextSymbol();
+          return v2;
+        }
+        this.nextSymbol();
+        return true;
+      }
+      return false;
+    };
+    Parser2.prototype.acceptNumber = function() {
+      return this.accept("number");
+    };
+    Parser2.prototype.expect = function(name) {
+      if (this.accept(name))
+        return true;
+      throw new Error("expected " + name + " but found " + this.symbol);
+    };
+    return Parser2;
+  })()
+);
+function parseText(text, language) {
+  if (language === void 0) {
+    language = i18n_default;
+  }
+  var options = {};
+  var ttr = new Parser(language.tokens);
+  if (!ttr.start(text))
+    return null;
+  S2();
+  return options;
+  function S2() {
+    ttr.expect("every");
+    var n = ttr.acceptNumber();
+    if (n)
+      options.interval = parseInt(n[0], 10);
+    if (ttr.isDone())
+      throw new Error("Unexpected end");
+    switch (ttr.symbol) {
+      case "day(s)":
+        options.freq = RRule.DAILY;
+        if (ttr.nextSymbol()) {
+          AT();
+          F2();
+        }
+        break;
+      // FIXME Note: every 2 weekdays != every two weeks on weekdays.
+      // DAILY on weekdays is not a valid rule
+      case "weekday(s)":
+        options.freq = RRule.WEEKLY;
+        options.byweekday = [RRule.MO, RRule.TU, RRule.WE, RRule.TH, RRule.FR];
+        ttr.nextSymbol();
+        AT();
+        F2();
+        break;
+      case "week(s)":
+        options.freq = RRule.WEEKLY;
+        if (ttr.nextSymbol()) {
+          ON();
+          AT();
+          F2();
+        }
+        break;
+      case "hour(s)":
+        options.freq = RRule.HOURLY;
+        if (ttr.nextSymbol()) {
+          ON();
+          F2();
+        }
+        break;
+      case "minute(s)":
+        options.freq = RRule.MINUTELY;
+        if (ttr.nextSymbol()) {
+          ON();
+          F2();
+        }
+        break;
+      case "month(s)":
+        options.freq = RRule.MONTHLY;
+        if (ttr.nextSymbol()) {
+          ON();
+          F2();
+        }
+        break;
+      case "year(s)":
+        options.freq = RRule.YEARLY;
+        if (ttr.nextSymbol()) {
+          ON();
+          F2();
+        }
+        break;
+      case "monday":
+      case "tuesday":
+      case "wednesday":
+      case "thursday":
+      case "friday":
+      case "saturday":
+      case "sunday":
+        options.freq = RRule.WEEKLY;
+        var key = ttr.symbol.substr(0, 2).toUpperCase();
+        options.byweekday = [RRule[key]];
+        if (!ttr.nextSymbol())
+          return;
+        while (ttr.accept("comma")) {
+          if (ttr.isDone())
+            throw new Error("Unexpected end");
+          var wkd = decodeWKD();
+          if (!wkd) {
+            throw new Error("Unexpected symbol " + ttr.symbol + ", expected weekday");
+          }
+          options.byweekday.push(RRule[wkd]);
+          ttr.nextSymbol();
+        }
+        AT();
+        MDAYs();
+        F2();
+        break;
+      case "january":
+      case "february":
+      case "march":
+      case "april":
+      case "may":
+      case "june":
+      case "july":
+      case "august":
+      case "september":
+      case "october":
+      case "november":
+      case "december":
+        options.freq = RRule.YEARLY;
+        options.bymonth = [decodeM()];
+        if (!ttr.nextSymbol())
+          return;
+        while (ttr.accept("comma")) {
+          if (ttr.isDone())
+            throw new Error("Unexpected end");
+          var m = decodeM();
+          if (!m) {
+            throw new Error("Unexpected symbol " + ttr.symbol + ", expected month");
+          }
+          options.bymonth.push(m);
+          ttr.nextSymbol();
+        }
+        ON();
+        F2();
+        break;
+      default:
+        throw new Error("Unknown symbol");
+    }
+  }
+  function ON() {
+    var on = ttr.accept("on");
+    var the = ttr.accept("the");
+    if (!(on || the))
+      return;
+    do {
+      var nth = decodeNTH();
+      var wkd = decodeWKD();
+      var m = decodeM();
+      if (nth) {
+        if (wkd) {
+          ttr.nextSymbol();
+          if (!options.byweekday)
+            options.byweekday = [];
+          options.byweekday.push(RRule[wkd].nth(nth));
+        } else {
+          if (!options.bymonthday)
+            options.bymonthday = [];
+          options.bymonthday.push(nth);
+          ttr.accept("day(s)");
+        }
+      } else if (wkd) {
+        ttr.nextSymbol();
+        if (!options.byweekday)
+          options.byweekday = [];
+        options.byweekday.push(RRule[wkd]);
+      } else if (ttr.symbol === "weekday(s)") {
+        ttr.nextSymbol();
+        if (!options.byweekday) {
+          options.byweekday = [RRule.MO, RRule.TU, RRule.WE, RRule.TH, RRule.FR];
+        }
+      } else if (ttr.symbol === "week(s)") {
+        ttr.nextSymbol();
+        var n = ttr.acceptNumber();
+        if (!n) {
+          throw new Error("Unexpected symbol " + ttr.symbol + ", expected week number");
+        }
+        options.byweekno = [parseInt(n[0], 10)];
+        while (ttr.accept("comma")) {
+          n = ttr.acceptNumber();
+          if (!n) {
+            throw new Error("Unexpected symbol " + ttr.symbol + "; expected monthday");
+          }
+          options.byweekno.push(parseInt(n[0], 10));
+        }
+      } else if (m) {
+        ttr.nextSymbol();
+        if (!options.bymonth)
+          options.bymonth = [];
+        options.bymonth.push(m);
+      } else {
+        return;
+      }
+    } while (ttr.accept("comma") || ttr.accept("the") || ttr.accept("on"));
+  }
+  function AT() {
+    var at3 = ttr.accept("at");
+    if (!at3)
+      return;
+    do {
+      var n = ttr.acceptNumber();
+      if (!n) {
+        throw new Error("Unexpected symbol " + ttr.symbol + ", expected hour");
+      }
+      options.byhour = [parseInt(n[0], 10)];
+      while (ttr.accept("comma")) {
+        n = ttr.acceptNumber();
+        if (!n) {
+          throw new Error("Unexpected symbol " + ttr.symbol + "; expected hour");
+        }
+        options.byhour.push(parseInt(n[0], 10));
+      }
+    } while (ttr.accept("comma") || ttr.accept("at"));
+  }
+  function decodeM() {
+    switch (ttr.symbol) {
+      case "january":
+        return 1;
+      case "february":
+        return 2;
+      case "march":
+        return 3;
+      case "april":
+        return 4;
+      case "may":
+        return 5;
+      case "june":
+        return 6;
+      case "july":
+        return 7;
+      case "august":
+        return 8;
+      case "september":
+        return 9;
+      case "october":
+        return 10;
+      case "november":
+        return 11;
+      case "december":
+        return 12;
+      default:
+        return false;
+    }
+  }
+  function decodeWKD() {
+    switch (ttr.symbol) {
+      case "monday":
+      case "tuesday":
+      case "wednesday":
+      case "thursday":
+      case "friday":
+      case "saturday":
+      case "sunday":
+        return ttr.symbol.substr(0, 2).toUpperCase();
+      default:
+        return false;
+    }
+  }
+  function decodeNTH() {
+    switch (ttr.symbol) {
+      case "last":
+        ttr.nextSymbol();
+        return -1;
+      case "first":
+        ttr.nextSymbol();
+        return 1;
+      case "second":
+        ttr.nextSymbol();
+        return ttr.accept("last") ? -2 : 2;
+      case "third":
+        ttr.nextSymbol();
+        return ttr.accept("last") ? -3 : 3;
+      case "nth":
+        var v2 = parseInt(ttr.value[1], 10);
+        if (v2 < -366 || v2 > 366)
+          throw new Error("Nth out of range: " + v2);
+        ttr.nextSymbol();
+        return ttr.accept("last") ? -v2 : v2;
+      default:
+        return false;
+    }
+  }
+  function MDAYs() {
+    ttr.accept("on");
+    ttr.accept("the");
+    var nth = decodeNTH();
+    if (!nth)
+      return;
+    options.bymonthday = [nth];
+    ttr.nextSymbol();
+    while (ttr.accept("comma")) {
+      nth = decodeNTH();
+      if (!nth) {
+        throw new Error("Unexpected symbol " + ttr.symbol + "; expected monthday");
+      }
+      options.bymonthday.push(nth);
+      ttr.nextSymbol();
+    }
+  }
+  function F2() {
+    if (ttr.symbol === "until") {
+      var date5 = Date.parse(ttr.text);
+      if (!date5)
+        throw new Error("Cannot parse until date:" + ttr.text);
+      options.until = new Date(date5);
+    } else if (ttr.accept("for")) {
+      options.count = parseInt(ttr.value[0], 10);
+      ttr.expect("number");
+    }
+  }
+}
+
+// ../../node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/types.js
+var Frequency;
+(function(Frequency3) {
+  Frequency3[Frequency3["YEARLY"] = 0] = "YEARLY";
+  Frequency3[Frequency3["MONTHLY"] = 1] = "MONTHLY";
+  Frequency3[Frequency3["WEEKLY"] = 2] = "WEEKLY";
+  Frequency3[Frequency3["DAILY"] = 3] = "DAILY";
+  Frequency3[Frequency3["HOURLY"] = 4] = "HOURLY";
+  Frequency3[Frequency3["MINUTELY"] = 5] = "MINUTELY";
+  Frequency3[Frequency3["SECONDLY"] = 6] = "SECONDLY";
+})(Frequency || (Frequency = {}));
+function freqIsDailyOrGreater(freq) {
+  return freq < Frequency.HOURLY;
+}
+
+// ../../node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/nlp/index.js
+var fromText = function(text, language) {
+  if (language === void 0) {
+    language = i18n_default;
+  }
+  return new RRule(parseText(text, language) || void 0);
+};
+var common = [
+  "count",
+  "until",
+  "interval",
+  "byweekday",
+  "bymonthday",
+  "bymonth"
+];
+totext_default.IMPLEMENTED = [];
+totext_default.IMPLEMENTED[Frequency.HOURLY] = common;
+totext_default.IMPLEMENTED[Frequency.MINUTELY] = common;
+totext_default.IMPLEMENTED[Frequency.DAILY] = ["byhour"].concat(common);
+totext_default.IMPLEMENTED[Frequency.WEEKLY] = common;
+totext_default.IMPLEMENTED[Frequency.MONTHLY] = common;
+totext_default.IMPLEMENTED[Frequency.YEARLY] = ["byweekno", "byyearday"].concat(common);
+var toText = function(rrule, gettext, language, dateFormatter) {
+  return new totext_default(rrule, gettext, language, dateFormatter).toString();
+};
+var isFullyConvertible = totext_default.isFullyConvertible;
+
+// ../../node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/datetime.js
+var Time = (
+  /** @class */
+  (function() {
+    function Time2(hour, minute, second, millisecond) {
+      this.hour = hour;
+      this.minute = minute;
+      this.second = second;
+      this.millisecond = millisecond || 0;
+    }
+    Time2.prototype.getHours = function() {
+      return this.hour;
+    };
+    Time2.prototype.getMinutes = function() {
+      return this.minute;
+    };
+    Time2.prototype.getSeconds = function() {
+      return this.second;
+    };
+    Time2.prototype.getMilliseconds = function() {
+      return this.millisecond;
+    };
+    Time2.prototype.getTime = function() {
+      return (this.hour * 60 * 60 + this.minute * 60 + this.second) * 1e3 + this.millisecond;
+    };
+    return Time2;
+  })()
+);
+var DateTime = (
+  /** @class */
+  (function(_super) {
+    __extends(DateTime2, _super);
+    function DateTime2(year, month, day, hour, minute, second, millisecond) {
+      var _this = _super.call(this, hour, minute, second, millisecond) || this;
+      _this.year = year;
+      _this.month = month;
+      _this.day = day;
+      return _this;
+    }
+    DateTime2.fromDate = function(date5) {
+      return new this(date5.getUTCFullYear(), date5.getUTCMonth() + 1, date5.getUTCDate(), date5.getUTCHours(), date5.getUTCMinutes(), date5.getUTCSeconds(), date5.valueOf() % 1e3);
+    };
+    DateTime2.prototype.getWeekday = function() {
+      return getWeekday(new Date(this.getTime()));
+    };
+    DateTime2.prototype.getTime = function() {
+      return new Date(Date.UTC(this.year, this.month - 1, this.day, this.hour, this.minute, this.second, this.millisecond)).getTime();
+    };
+    DateTime2.prototype.getDay = function() {
+      return this.day;
+    };
+    DateTime2.prototype.getMonth = function() {
+      return this.month;
+    };
+    DateTime2.prototype.getYear = function() {
+      return this.year;
+    };
+    DateTime2.prototype.addYears = function(years) {
+      this.year += years;
+    };
+    DateTime2.prototype.addMonths = function(months) {
+      this.month += months;
+      if (this.month > 12) {
+        var yearDiv = Math.floor(this.month / 12);
+        var monthMod = pymod(this.month, 12);
+        this.month = monthMod;
+        this.year += yearDiv;
+        if (this.month === 0) {
+          this.month = 12;
+          --this.year;
+        }
+      }
+    };
+    DateTime2.prototype.addWeekly = function(days, wkst) {
+      if (wkst > this.getWeekday()) {
+        this.day += -(this.getWeekday() + 1 + (6 - wkst)) + days * 7;
+      } else {
+        this.day += -(this.getWeekday() - wkst) + days * 7;
+      }
+      this.fixDay();
+    };
+    DateTime2.prototype.addDaily = function(days) {
+      this.day += days;
+      this.fixDay();
+    };
+    DateTime2.prototype.addHours = function(hours, filtered, byhour) {
+      if (filtered) {
+        this.hour += Math.floor((23 - this.hour) / hours) * hours;
+      }
+      for (; ; ) {
+        this.hour += hours;
+        var _a3 = divmod(this.hour, 24), dayDiv = _a3.div, hourMod = _a3.mod;
+        if (dayDiv) {
+          this.hour = hourMod;
+          this.addDaily(dayDiv);
+        }
+        if (empty(byhour) || includes(byhour, this.hour))
+          break;
+      }
+    };
+    DateTime2.prototype.addMinutes = function(minutes, filtered, byhour, byminute) {
+      if (filtered) {
+        this.minute += Math.floor((1439 - (this.hour * 60 + this.minute)) / minutes) * minutes;
+      }
+      for (; ; ) {
+        this.minute += minutes;
+        var _a3 = divmod(this.minute, 60), hourDiv = _a3.div, minuteMod = _a3.mod;
+        if (hourDiv) {
+          this.minute = minuteMod;
+          this.addHours(hourDiv, false, byhour);
+        }
+        if ((empty(byhour) || includes(byhour, this.hour)) && (empty(byminute) || includes(byminute, this.minute))) {
+          break;
+        }
+      }
+    };
+    DateTime2.prototype.addSeconds = function(seconds, filtered, byhour, byminute, bysecond) {
+      if (filtered) {
+        this.second += Math.floor((86399 - (this.hour * 3600 + this.minute * 60 + this.second)) / seconds) * seconds;
+      }
+      for (; ; ) {
+        this.second += seconds;
+        var _a3 = divmod(this.second, 60), minuteDiv = _a3.div, secondMod = _a3.mod;
+        if (minuteDiv) {
+          this.second = secondMod;
+          this.addMinutes(minuteDiv, false, byhour, byminute);
+        }
+        if ((empty(byhour) || includes(byhour, this.hour)) && (empty(byminute) || includes(byminute, this.minute)) && (empty(bysecond) || includes(bysecond, this.second))) {
+          break;
+        }
+      }
+    };
+    DateTime2.prototype.fixDay = function() {
+      if (this.day <= 28) {
+        return;
+      }
+      var daysinmonth = monthRange(this.year, this.month - 1)[1];
+      if (this.day <= daysinmonth) {
+        return;
+      }
+      while (this.day > daysinmonth) {
+        this.day -= daysinmonth;
+        ++this.month;
+        if (this.month === 13) {
+          this.month = 1;
+          ++this.year;
+          if (this.year > MAXYEAR) {
+            return;
+          }
+        }
+        daysinmonth = monthRange(this.year, this.month - 1)[1];
+      }
+    };
+    DateTime2.prototype.add = function(options, filtered) {
+      var freq = options.freq, interval = options.interval, wkst = options.wkst, byhour = options.byhour, byminute = options.byminute, bysecond = options.bysecond;
+      switch (freq) {
+        case Frequency.YEARLY:
+          return this.addYears(interval);
+        case Frequency.MONTHLY:
+          return this.addMonths(interval);
+        case Frequency.WEEKLY:
+          return this.addWeekly(interval, wkst);
+        case Frequency.DAILY:
+          return this.addDaily(interval);
+        case Frequency.HOURLY:
+          return this.addHours(interval, filtered, byhour);
+        case Frequency.MINUTELY:
+          return this.addMinutes(interval, filtered, byhour, byminute);
+        case Frequency.SECONDLY:
+          return this.addSeconds(interval, filtered, byhour, byminute, bysecond);
+      }
+    };
+    return DateTime2;
+  })(Time)
+);
+
+// ../../node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/parseoptions.js
+function initializeOptions(options) {
+  var invalid = [];
+  var keys = Object.keys(options);
+  for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
+    var key = keys_1[_i];
+    if (!includes(defaultKeys, key))
+      invalid.push(key);
+    if (isDate(options[key]) && !isValidDate(options[key])) {
+      invalid.push(key);
+    }
+  }
+  if (invalid.length) {
+    throw new Error("Invalid options: " + invalid.join(", "));
+  }
+  return __assign({}, options);
+}
+function parseOptions(options) {
+  var opts = __assign(__assign({}, DEFAULT_OPTIONS), initializeOptions(options));
+  if (isPresent(opts.byeaster))
+    opts.freq = RRule.YEARLY;
+  if (!(isPresent(opts.freq) && RRule.FREQUENCIES[opts.freq])) {
+    throw new Error("Invalid frequency: ".concat(opts.freq, " ").concat(options.freq));
+  }
+  if (!opts.dtstart)
+    opts.dtstart = new Date((/* @__PURE__ */ new Date()).setMilliseconds(0));
+  if (!isPresent(opts.wkst)) {
+    opts.wkst = RRule.MO.weekday;
+  } else if (isNumber(opts.wkst)) {
+  } else {
+    opts.wkst = opts.wkst.weekday;
+  }
+  if (isPresent(opts.bysetpos)) {
+    if (isNumber(opts.bysetpos))
+      opts.bysetpos = [opts.bysetpos];
+    for (var i = 0; i < opts.bysetpos.length; i++) {
+      var v2 = opts.bysetpos[i];
+      if (v2 === 0 || !(v2 >= -366 && v2 <= 366)) {
+        throw new Error("bysetpos must be between 1 and 366, or between -366 and -1");
+      }
+    }
+  }
+  if (!(Boolean(opts.byweekno) || notEmpty(opts.byweekno) || notEmpty(opts.byyearday) || Boolean(opts.bymonthday) || notEmpty(opts.bymonthday) || isPresent(opts.byweekday) || isPresent(opts.byeaster))) {
+    switch (opts.freq) {
+      case RRule.YEARLY:
+        if (!opts.bymonth)
+          opts.bymonth = opts.dtstart.getUTCMonth() + 1;
+        opts.bymonthday = opts.dtstart.getUTCDate();
+        break;
+      case RRule.MONTHLY:
+        opts.bymonthday = opts.dtstart.getUTCDate();
+        break;
+      case RRule.WEEKLY:
+        opts.byweekday = [getWeekday(opts.dtstart)];
+        break;
+    }
+  }
+  if (isPresent(opts.bymonth) && !isArray(opts.bymonth)) {
+    opts.bymonth = [opts.bymonth];
+  }
+  if (isPresent(opts.byyearday) && !isArray(opts.byyearday) && isNumber(opts.byyearday)) {
+    opts.byyearday = [opts.byyearday];
+  }
+  if (!isPresent(opts.bymonthday)) {
+    opts.bymonthday = [];
+    opts.bynmonthday = [];
+  } else if (isArray(opts.bymonthday)) {
+    var bymonthday = [];
+    var bynmonthday = [];
+    for (var i = 0; i < opts.bymonthday.length; i++) {
+      var v2 = opts.bymonthday[i];
+      if (v2 > 0) {
+        bymonthday.push(v2);
+      } else if (v2 < 0) {
+        bynmonthday.push(v2);
+      }
+    }
+    opts.bymonthday = bymonthday;
+    opts.bynmonthday = bynmonthday;
+  } else if (opts.bymonthday < 0) {
+    opts.bynmonthday = [opts.bymonthday];
+    opts.bymonthday = [];
+  } else {
+    opts.bynmonthday = [];
+    opts.bymonthday = [opts.bymonthday];
+  }
+  if (isPresent(opts.byweekno) && !isArray(opts.byweekno)) {
+    opts.byweekno = [opts.byweekno];
+  }
+  if (!isPresent(opts.byweekday)) {
+    opts.bynweekday = null;
+  } else if (isNumber(opts.byweekday)) {
+    opts.byweekday = [opts.byweekday];
+    opts.bynweekday = null;
+  } else if (isWeekdayStr(opts.byweekday)) {
+    opts.byweekday = [Weekday.fromStr(opts.byweekday).weekday];
+    opts.bynweekday = null;
+  } else if (opts.byweekday instanceof Weekday) {
+    if (!opts.byweekday.n || opts.freq > RRule.MONTHLY) {
+      opts.byweekday = [opts.byweekday.weekday];
+      opts.bynweekday = null;
+    } else {
+      opts.bynweekday = [[opts.byweekday.weekday, opts.byweekday.n]];
+      opts.byweekday = null;
+    }
+  } else {
+    var byweekday = [];
+    var bynweekday = [];
+    for (var i = 0; i < opts.byweekday.length; i++) {
+      var wday = opts.byweekday[i];
+      if (isNumber(wday)) {
+        byweekday.push(wday);
+        continue;
+      } else if (isWeekdayStr(wday)) {
+        byweekday.push(Weekday.fromStr(wday).weekday);
+        continue;
+      }
+      if (!wday.n || opts.freq > RRule.MONTHLY) {
+        byweekday.push(wday.weekday);
+      } else {
+        bynweekday.push([wday.weekday, wday.n]);
+      }
+    }
+    opts.byweekday = notEmpty(byweekday) ? byweekday : null;
+    opts.bynweekday = notEmpty(bynweekday) ? bynweekday : null;
+  }
+  if (!isPresent(opts.byhour)) {
+    opts.byhour = opts.freq < RRule.HOURLY ? [opts.dtstart.getUTCHours()] : null;
+  } else if (isNumber(opts.byhour)) {
+    opts.byhour = [opts.byhour];
+  }
+  if (!isPresent(opts.byminute)) {
+    opts.byminute = opts.freq < RRule.MINUTELY ? [opts.dtstart.getUTCMinutes()] : null;
+  } else if (isNumber(opts.byminute)) {
+    opts.byminute = [opts.byminute];
+  }
+  if (!isPresent(opts.bysecond)) {
+    opts.bysecond = opts.freq < RRule.SECONDLY ? [opts.dtstart.getUTCSeconds()] : null;
+  } else if (isNumber(opts.bysecond)) {
+    opts.bysecond = [opts.bysecond];
+  }
+  return { parsedOptions: opts };
+}
+function buildTimeset(opts) {
+  var millisecondModulo = opts.dtstart.getTime() % 1e3;
+  if (!freqIsDailyOrGreater(opts.freq)) {
+    return [];
+  }
+  var timeset = [];
+  opts.byhour.forEach(function(hour) {
+    opts.byminute.forEach(function(minute) {
+      opts.bysecond.forEach(function(second) {
+        timeset.push(new Time(hour, minute, second, millisecondModulo));
+      });
+    });
+  });
+  return timeset;
+}
+
+// ../../node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/parsestring.js
+function parseString(rfcString) {
+  var options = rfcString.split("\n").map(parseLine).filter(function(x) {
+    return x !== null;
+  });
+  return __assign(__assign({}, options[0]), options[1]);
+}
+function parseDtstart(line) {
+  var options = {};
+  var dtstartWithZone = /DTSTART(?:;TZID=([^:=]+?))?(?::|=)([^;\s]+)/i.exec(line);
+  if (!dtstartWithZone) {
+    return options;
+  }
+  var tzid = dtstartWithZone[1], dtstart = dtstartWithZone[2];
+  if (tzid) {
+    options.tzid = tzid;
+  }
+  options.dtstart = untilStringToDate(dtstart);
+  return options;
+}
+function parseLine(rfcString) {
+  rfcString = rfcString.replace(/^\s+|\s+$/, "");
+  if (!rfcString.length)
+    return null;
+  var header = /^([A-Z]+?)[:;]/.exec(rfcString.toUpperCase());
+  if (!header) {
+    return parseRrule(rfcString);
+  }
+  var key = header[1];
+  switch (key.toUpperCase()) {
+    case "RRULE":
+    case "EXRULE":
+      return parseRrule(rfcString);
+    case "DTSTART":
+      return parseDtstart(rfcString);
+    default:
+      throw new Error("Unsupported RFC prop ".concat(key, " in ").concat(rfcString));
+  }
+}
+function parseRrule(line) {
+  var strippedLine = line.replace(/^RRULE:/i, "");
+  var options = parseDtstart(strippedLine);
+  var attrs = line.replace(/^(?:RRULE|EXRULE):/i, "").split(";");
+  attrs.forEach(function(attr) {
+    var _a3 = attr.split("="), key = _a3[0], value = _a3[1];
+    switch (key.toUpperCase()) {
+      case "FREQ":
+        options.freq = Frequency[value.toUpperCase()];
+        break;
+      case "WKST":
+        options.wkst = Days[value.toUpperCase()];
+        break;
+      case "COUNT":
+      case "INTERVAL":
+      case "BYSETPOS":
+      case "BYMONTH":
+      case "BYMONTHDAY":
+      case "BYYEARDAY":
+      case "BYWEEKNO":
+      case "BYHOUR":
+      case "BYMINUTE":
+      case "BYSECOND":
+        var num = parseNumber(value);
+        var optionKey = key.toLowerCase();
+        options[optionKey] = num;
+        break;
+      case "BYWEEKDAY":
+      case "BYDAY":
+        options.byweekday = parseWeekday(value);
+        break;
+      case "DTSTART":
+      case "TZID":
+        var dtstart = parseDtstart(line);
+        options.tzid = dtstart.tzid;
+        options.dtstart = dtstart.dtstart;
+        break;
+      case "UNTIL":
+        options.until = untilStringToDate(value);
+        break;
+      case "BYEASTER":
+        options.byeaster = Number(value);
+        break;
+      default:
+        throw new Error("Unknown RRULE property '" + key + "'");
+    }
+  });
+  return options;
+}
+function parseNumber(value) {
+  if (value.indexOf(",") !== -1) {
+    var values = value.split(",");
+    return values.map(parseIndividualNumber);
+  }
+  return parseIndividualNumber(value);
+}
+function parseIndividualNumber(value) {
+  if (/^[+-]?\d+$/.test(value)) {
+    return Number(value);
+  }
+  return value;
+}
+function parseWeekday(value) {
+  var days = value.split(",");
+  return days.map(function(day) {
+    if (day.length === 2) {
+      return Days[day];
+    }
+    var parts = day.match(/^([+-]?\d{1,2})([A-Z]{2})$/);
+    if (!parts || parts.length < 3) {
+      throw new SyntaxError("Invalid weekday string: ".concat(day));
+    }
+    var n = Number(parts[1]);
+    var wdaypart = parts[2];
+    var wday = Days[wdaypart].weekday;
+    return new Weekday(wday, n);
+  });
+}
+
+// ../../node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/datewithzone.js
+var DateWithZone = (
+  /** @class */
+  (function() {
+    function DateWithZone2(date5, tzid) {
+      if (isNaN(date5.getTime())) {
+        throw new RangeError("Invalid date passed to DateWithZone");
+      }
+      this.date = date5;
+      this.tzid = tzid;
+    }
+    Object.defineProperty(DateWithZone2.prototype, "isUTC", {
+      get: function() {
+        return !this.tzid || this.tzid.toUpperCase() === "UTC";
+      },
+      enumerable: false,
+      configurable: true
+    });
+    DateWithZone2.prototype.toString = function() {
+      var datestr = timeToUntilString(this.date.getTime(), this.isUTC);
+      if (!this.isUTC) {
+        return ";TZID=".concat(this.tzid, ":").concat(datestr);
+      }
+      return ":".concat(datestr);
+    };
+    DateWithZone2.prototype.getTime = function() {
+      return this.date.getTime();
+    };
+    DateWithZone2.prototype.rezonedDate = function() {
+      if (this.isUTC) {
+        return this.date;
+      }
+      return dateInTimeZone(this.date, this.tzid);
+    };
+    return DateWithZone2;
+  })()
+);
+
+// ../../node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/optionstostring.js
+function optionsToString(options) {
+  var rrule = [];
+  var dtstart = "";
+  var keys = Object.keys(options);
+  var defaultKeys2 = Object.keys(DEFAULT_OPTIONS);
+  for (var i = 0; i < keys.length; i++) {
+    if (keys[i] === "tzid")
+      continue;
+    if (!includes(defaultKeys2, keys[i]))
+      continue;
+    var key = keys[i].toUpperCase();
+    var value = options[keys[i]];
+    var outValue = "";
+    if (!isPresent(value) || isArray(value) && !value.length)
+      continue;
+    switch (key) {
+      case "FREQ":
+        outValue = RRule.FREQUENCIES[options.freq];
+        break;
+      case "WKST":
+        if (isNumber(value)) {
+          outValue = new Weekday(value).toString();
+        } else {
+          outValue = value.toString();
+        }
+        break;
+      case "BYWEEKDAY":
+        key = "BYDAY";
+        outValue = toArray(value).map(function(wday) {
+          if (wday instanceof Weekday) {
+            return wday;
+          }
+          if (isArray(wday)) {
+            return new Weekday(wday[0], wday[1]);
+          }
+          return new Weekday(wday);
+        }).toString();
+        break;
+      case "DTSTART":
+        dtstart = buildDtstart(value, options.tzid);
+        break;
+      case "UNTIL":
+        outValue = timeToUntilString(value, !options.tzid);
+        break;
+      default:
+        if (isArray(value)) {
+          var strValues = [];
+          for (var j3 = 0; j3 < value.length; j3++) {
+            strValues[j3] = String(value[j3]);
+          }
+          outValue = strValues.toString();
+        } else {
+          outValue = String(value);
+        }
+    }
+    if (outValue) {
+      rrule.push([key, outValue]);
+    }
+  }
+  var rules = rrule.map(function(_a3) {
+    var key2 = _a3[0], value2 = _a3[1];
+    return "".concat(key2, "=").concat(value2.toString());
+  }).join(";");
+  var ruleString = "";
+  if (rules !== "") {
+    ruleString = "RRULE:".concat(rules);
+  }
+  return [dtstart, ruleString].filter(function(x) {
+    return !!x;
+  }).join("\n");
+}
+function buildDtstart(dtstart, tzid) {
+  if (!dtstart) {
+    return "";
+  }
+  return "DTSTART" + new DateWithZone(new Date(dtstart), tzid).toString();
+}
+
+// ../../node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/cache.js
+function argsMatch(left, right) {
+  if (Array.isArray(left)) {
+    if (!Array.isArray(right))
+      return false;
+    if (left.length !== right.length)
+      return false;
+    return left.every(function(date5, i) {
+      return date5.getTime() === right[i].getTime();
+    });
+  }
+  if (left instanceof Date) {
+    return right instanceof Date && left.getTime() === right.getTime();
+  }
+  return left === right;
+}
+var Cache = (
+  /** @class */
+  (function() {
+    function Cache2() {
+      this.all = false;
+      this.before = [];
+      this.after = [];
+      this.between = [];
+    }
+    Cache2.prototype._cacheAdd = function(what, value, args) {
+      if (value) {
+        value = value instanceof Date ? clone2(value) : cloneDates(value);
+      }
+      if (what === "all") {
+        this.all = value;
+      } else {
+        args._value = value;
+        this[what].push(args);
+      }
+    };
+    Cache2.prototype._cacheGet = function(what, args) {
+      var cached2 = false;
+      var argsKeys = args ? Object.keys(args) : [];
+      var findCacheDiff = function(item2) {
+        for (var i2 = 0; i2 < argsKeys.length; i2++) {
+          var key = argsKeys[i2];
+          if (!argsMatch(args[key], item2[key])) {
+            return true;
+          }
+        }
+        return false;
+      };
+      var cachedObject = this[what];
+      if (what === "all") {
+        cached2 = this.all;
+      } else if (isArray(cachedObject)) {
+        for (var i = 0; i < cachedObject.length; i++) {
+          var item = cachedObject[i];
+          if (argsKeys.length && findCacheDiff(item))
+            continue;
+          cached2 = item._value;
+          break;
+        }
+      }
+      if (!cached2 && this.all) {
+        var iterResult = new iterresult_default(what, args);
+        for (var i = 0; i < this.all.length; i++) {
+          if (!iterResult.accept(this.all[i]))
+            break;
+        }
+        cached2 = iterResult.getValue();
+        this._cacheAdd(what, cached2, args);
+      }
+      return isArray(cached2) ? cloneDates(cached2) : cached2 instanceof Date ? clone2(cached2) : cached2;
+    };
+    return Cache2;
+  })()
+);
+
+// ../../node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/masks.js
+var M365MASK = __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], repeat(1, 31), true), repeat(2, 28), true), repeat(3, 31), true), repeat(4, 30), true), repeat(5, 31), true), repeat(6, 30), true), repeat(7, 31), true), repeat(8, 31), true), repeat(9, 30), true), repeat(10, 31), true), repeat(11, 30), true), repeat(12, 31), true), repeat(1, 7), true);
+var M366MASK = __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], repeat(1, 31), true), repeat(2, 29), true), repeat(3, 31), true), repeat(4, 30), true), repeat(5, 31), true), repeat(6, 30), true), repeat(7, 31), true), repeat(8, 31), true), repeat(9, 30), true), repeat(10, 31), true), repeat(11, 30), true), repeat(12, 31), true), repeat(1, 7), true);
+var M28 = range(1, 29);
+var M29 = range(1, 30);
+var M30 = range(1, 31);
+var M31 = range(1, 32);
+var MDAY366MASK = __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], M31, true), M29, true), M31, true), M30, true), M31, true), M30, true), M31, true), M31, true), M30, true), M31, true), M30, true), M31, true), M31.slice(0, 7), true);
+var MDAY365MASK = __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], M31, true), M28, true), M31, true), M30, true), M31, true), M30, true), M31, true), M31, true), M30, true), M31, true), M30, true), M31, true), M31.slice(0, 7), true);
+var NM28 = range(-28, 0);
+var NM29 = range(-29, 0);
+var NM30 = range(-30, 0);
+var NM31 = range(-31, 0);
+var NMDAY366MASK = __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], NM31, true), NM29, true), NM31, true), NM30, true), NM31, true), NM30, true), NM31, true), NM31, true), NM30, true), NM31, true), NM30, true), NM31, true), NM31.slice(0, 7), true);
+var NMDAY365MASK = __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], NM31, true), NM28, true), NM31, true), NM30, true), NM31, true), NM30, true), NM31, true), NM31, true), NM30, true), NM31, true), NM30, true), NM31, true), NM31.slice(0, 7), true);
+var M366RANGE = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366];
+var M365RANGE = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365];
+var WDAYMASK = (function() {
+  var wdaymask = [];
+  for (var i = 0; i < 55; i++)
+    wdaymask = wdaymask.concat(range(7));
+  return wdaymask;
+})();
+
+// ../../node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/iterinfo/yearinfo.js
+function rebuildYear(year, options) {
+  var firstyday = datetime3(year, 1, 1);
+  var yearlen = isLeapYear(year) ? 366 : 365;
+  var nextyearlen = isLeapYear(year + 1) ? 366 : 365;
+  var yearordinal = toOrdinal(firstyday);
+  var yearweekday = getWeekday(firstyday);
+  var result = __assign(__assign({ yearlen, nextyearlen, yearordinal, yearweekday }, baseYearMasks(year)), { wnomask: null });
+  if (empty(options.byweekno)) {
+    return result;
+  }
+  result.wnomask = repeat(0, yearlen + 7);
+  var firstwkst;
+  var wyearlen;
+  var no1wkst = firstwkst = pymod(7 - yearweekday + options.wkst, 7);
+  if (no1wkst >= 4) {
+    no1wkst = 0;
+    wyearlen = result.yearlen + pymod(yearweekday - options.wkst, 7);
+  } else {
+    wyearlen = yearlen - no1wkst;
+  }
+  var div = Math.floor(wyearlen / 7);
+  var mod = pymod(wyearlen, 7);
+  var numweeks = Math.floor(div + mod / 4);
+  for (var j3 = 0; j3 < options.byweekno.length; j3++) {
+    var n = options.byweekno[j3];
+    if (n < 0) {
+      n += numweeks + 1;
+    }
+    if (!(n > 0 && n <= numweeks)) {
+      continue;
+    }
+    var i = void 0;
+    if (n > 1) {
+      i = no1wkst + (n - 1) * 7;
+      if (no1wkst !== firstwkst) {
+        i -= 7 - firstwkst;
+      }
+    } else {
+      i = no1wkst;
+    }
+    for (var k2 = 0; k2 < 7; k2++) {
+      result.wnomask[i] = 1;
+      i++;
+      if (result.wdaymask[i] === options.wkst)
+        break;
+    }
+  }
+  if (includes(options.byweekno, 1)) {
+    var i = no1wkst + numweeks * 7;
+    if (no1wkst !== firstwkst)
+      i -= 7 - firstwkst;
+    if (i < yearlen) {
+      for (var j3 = 0; j3 < 7; j3++) {
+        result.wnomask[i] = 1;
+        i += 1;
+        if (result.wdaymask[i] === options.wkst)
+          break;
+      }
+    }
+  }
+  if (no1wkst) {
+    var lnumweeks = void 0;
+    if (!includes(options.byweekno, -1)) {
+      var lyearweekday = getWeekday(datetime3(year - 1, 1, 1));
+      var lno1wkst = pymod(7 - lyearweekday.valueOf() + options.wkst, 7);
+      var lyearlen = isLeapYear(year - 1) ? 366 : 365;
+      var weekst = void 0;
+      if (lno1wkst >= 4) {
+        lno1wkst = 0;
+        weekst = lyearlen + pymod(lyearweekday - options.wkst, 7);
+      } else {
+        weekst = yearlen - no1wkst;
+      }
+      lnumweeks = Math.floor(52 + pymod(weekst, 7) / 4);
+    } else {
+      lnumweeks = -1;
+    }
+    if (includes(options.byweekno, lnumweeks)) {
+      for (var i = 0; i < no1wkst; i++)
+        result.wnomask[i] = 1;
+    }
+  }
+  return result;
+}
+function baseYearMasks(year) {
+  var yearlen = isLeapYear(year) ? 366 : 365;
+  var firstyday = datetime3(year, 1, 1);
+  var wday = getWeekday(firstyday);
+  if (yearlen === 365) {
+    return {
+      mmask: M365MASK,
+      mdaymask: MDAY365MASK,
+      nmdaymask: NMDAY365MASK,
+      wdaymask: WDAYMASK.slice(wday),
+      mrange: M365RANGE
+    };
+  }
+  return {
+    mmask: M366MASK,
+    mdaymask: MDAY366MASK,
+    nmdaymask: NMDAY366MASK,
+    wdaymask: WDAYMASK.slice(wday),
+    mrange: M366RANGE
+  };
+}
+
+// ../../node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/iterinfo/monthinfo.js
+function rebuildMonth(year, month, yearlen, mrange, wdaymask, options) {
+  var result = {
+    lastyear: year,
+    lastmonth: month,
+    nwdaymask: []
+  };
+  var ranges = [];
+  if (options.freq === RRule.YEARLY) {
+    if (empty(options.bymonth)) {
+      ranges = [[0, yearlen]];
+    } else {
+      for (var j3 = 0; j3 < options.bymonth.length; j3++) {
+        month = options.bymonth[j3];
+        ranges.push(mrange.slice(month - 1, month + 1));
+      }
+    }
+  } else if (options.freq === RRule.MONTHLY) {
+    ranges = [mrange.slice(month - 1, month + 1)];
+  }
+  if (empty(ranges)) {
+    return result;
+  }
+  result.nwdaymask = repeat(0, yearlen);
+  for (var j3 = 0; j3 < ranges.length; j3++) {
+    var rang = ranges[j3];
+    var first = rang[0];
+    var last = rang[1] - 1;
+    for (var k2 = 0; k2 < options.bynweekday.length; k2++) {
+      var i = void 0;
+      var _a3 = options.bynweekday[k2], wday = _a3[0], n = _a3[1];
+      if (n < 0) {
+        i = last + (n + 1) * 7;
+        i -= pymod(wdaymask[i] - wday, 7);
+      } else {
+        i = first + (n - 1) * 7;
+        i += pymod(7 - wdaymask[i] + wday, 7);
+      }
+      if (first <= i && i <= last)
+        result.nwdaymask[i] = 1;
+    }
+  }
+  return result;
+}
+
+// ../../node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/iterinfo/easter.js
+function easter(y, offset) {
+  if (offset === void 0) {
+    offset = 0;
+  }
+  var a = y % 19;
+  var b2 = Math.floor(y / 100);
+  var c2 = y % 100;
+  var d2 = Math.floor(b2 / 4);
+  var e2 = b2 % 4;
+  var f = Math.floor((b2 + 8) / 25);
+  var g = Math.floor((b2 - f + 1) / 3);
+  var h2 = Math.floor(19 * a + b2 - d2 - g + 15) % 30;
+  var i = Math.floor(c2 / 4);
+  var k2 = c2 % 4;
+  var l = Math.floor(32 + 2 * e2 + 2 * i - h2 - k2) % 7;
+  var m = Math.floor((a + 11 * h2 + 22 * l) / 451);
+  var month = Math.floor((h2 + l - 7 * m + 114) / 31);
+  var day = (h2 + l - 7 * m + 114) % 31 + 1;
+  var date5 = Date.UTC(y, month - 1, day + offset);
+  var yearStart = Date.UTC(y, 0, 1);
+  return [Math.ceil((date5 - yearStart) / (1e3 * 60 * 60 * 24))];
+}
+
+// ../../node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/iterinfo/index.js
+var Iterinfo = (
+  /** @class */
+  (function() {
+    function Iterinfo2(options) {
+      this.options = options;
+    }
+    Iterinfo2.prototype.rebuild = function(year, month) {
+      var options = this.options;
+      if (year !== this.lastyear) {
+        this.yearinfo = rebuildYear(year, options);
+      }
+      if (notEmpty(options.bynweekday) && (month !== this.lastmonth || year !== this.lastyear)) {
+        var _a3 = this.yearinfo, yearlen = _a3.yearlen, mrange = _a3.mrange, wdaymask = _a3.wdaymask;
+        this.monthinfo = rebuildMonth(year, month, yearlen, mrange, wdaymask, options);
+      }
+      if (isPresent(options.byeaster)) {
+        this.eastermask = easter(year, options.byeaster);
+      }
+    };
+    Object.defineProperty(Iterinfo2.prototype, "lastyear", {
+      get: function() {
+        return this.monthinfo ? this.monthinfo.lastyear : null;
+      },
+      enumerable: false,
+      configurable: true
+    });
+    Object.defineProperty(Iterinfo2.prototype, "lastmonth", {
+      get: function() {
+        return this.monthinfo ? this.monthinfo.lastmonth : null;
+      },
+      enumerable: false,
+      configurable: true
+    });
+    Object.defineProperty(Iterinfo2.prototype, "yearlen", {
+      get: function() {
+        return this.yearinfo.yearlen;
+      },
+      enumerable: false,
+      configurable: true
+    });
+    Object.defineProperty(Iterinfo2.prototype, "yearordinal", {
+      get: function() {
+        return this.yearinfo.yearordinal;
+      },
+      enumerable: false,
+      configurable: true
+    });
+    Object.defineProperty(Iterinfo2.prototype, "mrange", {
+      get: function() {
+        return this.yearinfo.mrange;
+      },
+      enumerable: false,
+      configurable: true
+    });
+    Object.defineProperty(Iterinfo2.prototype, "wdaymask", {
+      get: function() {
+        return this.yearinfo.wdaymask;
+      },
+      enumerable: false,
+      configurable: true
+    });
+    Object.defineProperty(Iterinfo2.prototype, "mmask", {
+      get: function() {
+        return this.yearinfo.mmask;
+      },
+      enumerable: false,
+      configurable: true
+    });
+    Object.defineProperty(Iterinfo2.prototype, "wnomask", {
+      get: function() {
+        return this.yearinfo.wnomask;
+      },
+      enumerable: false,
+      configurable: true
+    });
+    Object.defineProperty(Iterinfo2.prototype, "nwdaymask", {
+      get: function() {
+        return this.monthinfo ? this.monthinfo.nwdaymask : [];
+      },
+      enumerable: false,
+      configurable: true
+    });
+    Object.defineProperty(Iterinfo2.prototype, "nextyearlen", {
+      get: function() {
+        return this.yearinfo.nextyearlen;
+      },
+      enumerable: false,
+      configurable: true
+    });
+    Object.defineProperty(Iterinfo2.prototype, "mdaymask", {
+      get: function() {
+        return this.yearinfo.mdaymask;
+      },
+      enumerable: false,
+      configurable: true
+    });
+    Object.defineProperty(Iterinfo2.prototype, "nmdaymask", {
+      get: function() {
+        return this.yearinfo.nmdaymask;
+      },
+      enumerable: false,
+      configurable: true
+    });
+    Iterinfo2.prototype.ydayset = function() {
+      return [range(this.yearlen), 0, this.yearlen];
+    };
+    Iterinfo2.prototype.mdayset = function(_, month) {
+      var start = this.mrange[month - 1];
+      var end = this.mrange[month];
+      var set2 = repeat(null, this.yearlen);
+      for (var i = start; i < end; i++)
+        set2[i] = i;
+      return [set2, start, end];
+    };
+    Iterinfo2.prototype.wdayset = function(year, month, day) {
+      var set2 = repeat(null, this.yearlen + 7);
+      var i = toOrdinal(datetime3(year, month, day)) - this.yearordinal;
+      var start = i;
+      for (var j3 = 0; j3 < 7; j3++) {
+        set2[i] = i;
+        ++i;
+        if (this.wdaymask[i] === this.options.wkst)
+          break;
+      }
+      return [set2, start, i];
+    };
+    Iterinfo2.prototype.ddayset = function(year, month, day) {
+      var set2 = repeat(null, this.yearlen);
+      var i = toOrdinal(datetime3(year, month, day)) - this.yearordinal;
+      set2[i] = i;
+      return [set2, i, i + 1];
+    };
+    Iterinfo2.prototype.htimeset = function(hour, _, second, millisecond) {
+      var _this = this;
+      var set2 = [];
+      this.options.byminute.forEach(function(minute) {
+        set2 = set2.concat(_this.mtimeset(hour, minute, second, millisecond));
+      });
+      sort(set2);
+      return set2;
+    };
+    Iterinfo2.prototype.mtimeset = function(hour, minute, _, millisecond) {
+      var set2 = this.options.bysecond.map(function(second) {
+        return new Time(hour, minute, second, millisecond);
+      });
+      sort(set2);
+      return set2;
+    };
+    Iterinfo2.prototype.stimeset = function(hour, minute, second, millisecond) {
+      return [new Time(hour, minute, second, millisecond)];
+    };
+    Iterinfo2.prototype.getdayset = function(freq) {
+      switch (freq) {
+        case Frequency.YEARLY:
+          return this.ydayset.bind(this);
+        case Frequency.MONTHLY:
+          return this.mdayset.bind(this);
+        case Frequency.WEEKLY:
+          return this.wdayset.bind(this);
+        case Frequency.DAILY:
+          return this.ddayset.bind(this);
+        default:
+          return this.ddayset.bind(this);
+      }
+    };
+    Iterinfo2.prototype.gettimeset = function(freq) {
+      switch (freq) {
+        case Frequency.HOURLY:
+          return this.htimeset.bind(this);
+        case Frequency.MINUTELY:
+          return this.mtimeset.bind(this);
+        case Frequency.SECONDLY:
+          return this.stimeset.bind(this);
+      }
+    };
+    return Iterinfo2;
+  })()
+);
+var iterinfo_default = Iterinfo;
+
+// ../../node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/iter/poslist.js
+function buildPoslist(bysetpos, timeset, start, end, ii, dayset) {
+  var poslist = [];
+  for (var j3 = 0; j3 < bysetpos.length; j3++) {
+    var daypos = void 0;
+    var timepos = void 0;
+    var pos = bysetpos[j3];
+    if (pos < 0) {
+      daypos = Math.floor(pos / timeset.length);
+      timepos = pymod(pos, timeset.length);
+    } else {
+      daypos = Math.floor((pos - 1) / timeset.length);
+      timepos = pymod(pos - 1, timeset.length);
+    }
+    var tmp = [];
+    for (var k2 = start; k2 < end; k2++) {
+      var val = dayset[k2];
+      if (!isPresent(val))
+        continue;
+      tmp.push(val);
+    }
+    var i = void 0;
+    if (daypos < 0) {
+      i = tmp.slice(daypos)[0];
+    } else {
+      i = tmp[daypos];
+    }
+    var time3 = timeset[timepos];
+    var date5 = fromOrdinal(ii.yearordinal + i);
+    var res = combine(date5, time3);
+    if (!includes(poslist, res))
+      poslist.push(res);
+  }
+  sort(poslist);
+  return poslist;
+}
+
+// ../../node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/iter/index.js
+function iter(iterResult, options) {
+  var dtstart = options.dtstart, freq = options.freq, interval = options.interval, until = options.until, bysetpos = options.bysetpos;
+  var count = options.count;
+  if (count === 0 || interval === 0) {
+    return emitResult(iterResult);
+  }
+  var counterDate = DateTime.fromDate(dtstart);
+  var ii = new iterinfo_default(options);
+  ii.rebuild(counterDate.year, counterDate.month);
+  var timeset = makeTimeset(ii, counterDate, options);
+  for (; ; ) {
+    var _a3 = ii.getdayset(freq)(counterDate.year, counterDate.month, counterDate.day), dayset = _a3[0], start = _a3[1], end = _a3[2];
+    var filtered = removeFilteredDays(dayset, start, end, ii, options);
+    if (notEmpty(bysetpos)) {
+      var poslist = buildPoslist(bysetpos, timeset, start, end, ii, dayset);
+      for (var j3 = 0; j3 < poslist.length; j3++) {
+        var res = poslist[j3];
+        if (until && res > until) {
+          return emitResult(iterResult);
+        }
+        if (res >= dtstart) {
+          var rezonedDate = rezoneIfNeeded(res, options);
+          if (!iterResult.accept(rezonedDate)) {
+            return emitResult(iterResult);
+          }
+          if (count) {
+            --count;
+            if (!count) {
+              return emitResult(iterResult);
+            }
+          }
+        }
+      }
+    } else {
+      for (var j3 = start; j3 < end; j3++) {
+        var currentDay = dayset[j3];
+        if (!isPresent(currentDay)) {
+          continue;
+        }
+        var date5 = fromOrdinal(ii.yearordinal + currentDay);
+        for (var k2 = 0; k2 < timeset.length; k2++) {
+          var time3 = timeset[k2];
+          var res = combine(date5, time3);
+          if (until && res > until) {
+            return emitResult(iterResult);
+          }
+          if (res >= dtstart) {
+            var rezonedDate = rezoneIfNeeded(res, options);
+            if (!iterResult.accept(rezonedDate)) {
+              return emitResult(iterResult);
+            }
+            if (count) {
+              --count;
+              if (!count) {
+                return emitResult(iterResult);
+              }
+            }
+          }
+        }
+      }
+    }
+    if (options.interval === 0) {
+      return emitResult(iterResult);
+    }
+    counterDate.add(options, filtered);
+    if (counterDate.year > MAXYEAR) {
+      return emitResult(iterResult);
+    }
+    if (!freqIsDailyOrGreater(freq)) {
+      timeset = ii.gettimeset(freq)(counterDate.hour, counterDate.minute, counterDate.second, 0);
+    }
+    ii.rebuild(counterDate.year, counterDate.month);
+  }
+}
+function isFiltered(ii, currentDay, options) {
+  var bymonth = options.bymonth, byweekno = options.byweekno, byweekday = options.byweekday, byeaster = options.byeaster, bymonthday = options.bymonthday, bynmonthday = options.bynmonthday, byyearday = options.byyearday;
+  return notEmpty(bymonth) && !includes(bymonth, ii.mmask[currentDay]) || notEmpty(byweekno) && !ii.wnomask[currentDay] || notEmpty(byweekday) && !includes(byweekday, ii.wdaymask[currentDay]) || notEmpty(ii.nwdaymask) && !ii.nwdaymask[currentDay] || byeaster !== null && !includes(ii.eastermask, currentDay) || (notEmpty(bymonthday) || notEmpty(bynmonthday)) && !includes(bymonthday, ii.mdaymask[currentDay]) && !includes(bynmonthday, ii.nmdaymask[currentDay]) || notEmpty(byyearday) && (currentDay < ii.yearlen && !includes(byyearday, currentDay + 1) && !includes(byyearday, -ii.yearlen + currentDay) || currentDay >= ii.yearlen && !includes(byyearday, currentDay + 1 - ii.yearlen) && !includes(byyearday, -ii.nextyearlen + currentDay - ii.yearlen));
+}
+function rezoneIfNeeded(date5, options) {
+  return new DateWithZone(date5, options.tzid).rezonedDate();
+}
+function emitResult(iterResult) {
+  return iterResult.getValue();
+}
+function removeFilteredDays(dayset, start, end, ii, options) {
+  var filtered = false;
+  for (var dayCounter = start; dayCounter < end; dayCounter++) {
+    var currentDay = dayset[dayCounter];
+    filtered = isFiltered(ii, currentDay, options);
+    if (filtered)
+      dayset[currentDay] = null;
+  }
+  return filtered;
+}
+function makeTimeset(ii, counterDate, options) {
+  var freq = options.freq, byhour = options.byhour, byminute = options.byminute, bysecond = options.bysecond;
+  if (freqIsDailyOrGreater(freq)) {
+    return buildTimeset(options);
+  }
+  if (freq >= RRule.HOURLY && notEmpty(byhour) && !includes(byhour, counterDate.hour) || freq >= RRule.MINUTELY && notEmpty(byminute) && !includes(byminute, counterDate.minute) || freq >= RRule.SECONDLY && notEmpty(bysecond) && !includes(bysecond, counterDate.second)) {
+    return [];
+  }
+  return ii.gettimeset(freq)(counterDate.hour, counterDate.minute, counterDate.second, counterDate.millisecond);
+}
+
+// ../../node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/rrule.js
+var Days = {
+  MO: new Weekday(0),
+  TU: new Weekday(1),
+  WE: new Weekday(2),
+  TH: new Weekday(3),
+  FR: new Weekday(4),
+  SA: new Weekday(5),
+  SU: new Weekday(6)
+};
+var DEFAULT_OPTIONS = {
+  freq: Frequency.YEARLY,
+  dtstart: null,
+  interval: 1,
+  wkst: Days.MO,
+  count: null,
+  until: null,
+  tzid: null,
+  bysetpos: null,
+  bymonth: null,
+  bymonthday: null,
+  bynmonthday: null,
+  byyearday: null,
+  byweekno: null,
+  byweekday: null,
+  bynweekday: null,
+  byhour: null,
+  byminute: null,
+  bysecond: null,
+  byeaster: null
+};
+var defaultKeys = Object.keys(DEFAULT_OPTIONS);
+var RRule = (
+  /** @class */
+  (function() {
+    function RRule3(options, noCache) {
+      if (options === void 0) {
+        options = {};
+      }
+      if (noCache === void 0) {
+        noCache = false;
+      }
+      this._cache = noCache ? null : new Cache();
+      this.origOptions = initializeOptions(options);
+      var parsedOptions = parseOptions(options).parsedOptions;
+      this.options = parsedOptions;
+    }
+    RRule3.parseText = function(text, language) {
+      return parseText(text, language);
+    };
+    RRule3.fromText = function(text, language) {
+      return fromText(text, language);
+    };
+    RRule3.fromString = function(str) {
+      return new RRule3(RRule3.parseString(str) || void 0);
+    };
+    RRule3.prototype._iter = function(iterResult) {
+      return iter(iterResult, this.options);
+    };
+    RRule3.prototype._cacheGet = function(what, args) {
+      if (!this._cache)
+        return false;
+      return this._cache._cacheGet(what, args);
+    };
+    RRule3.prototype._cacheAdd = function(what, value, args) {
+      if (!this._cache)
+        return;
+      return this._cache._cacheAdd(what, value, args);
+    };
+    RRule3.prototype.all = function(iterator) {
+      if (iterator) {
+        return this._iter(new callbackiterresult_default("all", {}, iterator));
+      }
+      var result = this._cacheGet("all");
+      if (result === false) {
+        result = this._iter(new iterresult_default("all", {}));
+        this._cacheAdd("all", result);
+      }
+      return result;
+    };
+    RRule3.prototype.between = function(after, before, inc, iterator) {
+      if (inc === void 0) {
+        inc = false;
+      }
+      if (!isValidDate(after) || !isValidDate(before)) {
+        throw new Error("Invalid date passed in to RRule.between");
+      }
+      var args = {
+        before,
+        after,
+        inc
+      };
+      if (iterator) {
+        return this._iter(new callbackiterresult_default("between", args, iterator));
+      }
+      var result = this._cacheGet("between", args);
+      if (result === false) {
+        result = this._iter(new iterresult_default("between", args));
+        this._cacheAdd("between", result, args);
+      }
+      return result;
+    };
+    RRule3.prototype.before = function(dt2, inc) {
+      if (inc === void 0) {
+        inc = false;
+      }
+      if (!isValidDate(dt2)) {
+        throw new Error("Invalid date passed in to RRule.before");
+      }
+      var args = { dt: dt2, inc };
+      var result = this._cacheGet("before", args);
+      if (result === false) {
+        result = this._iter(new iterresult_default("before", args));
+        this._cacheAdd("before", result, args);
+      }
+      return result;
+    };
+    RRule3.prototype.after = function(dt2, inc) {
+      if (inc === void 0) {
+        inc = false;
+      }
+      if (!isValidDate(dt2)) {
+        throw new Error("Invalid date passed in to RRule.after");
+      }
+      var args = { dt: dt2, inc };
+      var result = this._cacheGet("after", args);
+      if (result === false) {
+        result = this._iter(new iterresult_default("after", args));
+        this._cacheAdd("after", result, args);
+      }
+      return result;
+    };
+    RRule3.prototype.count = function() {
+      return this.all().length;
+    };
+    RRule3.prototype.toString = function() {
+      return optionsToString(this.origOptions);
+    };
+    RRule3.prototype.toText = function(gettext, language, dateFormatter) {
+      return toText(this, gettext, language, dateFormatter);
+    };
+    RRule3.prototype.isFullyConvertibleToText = function() {
+      return isFullyConvertible(this);
+    };
+    RRule3.prototype.clone = function() {
+      return new RRule3(this.origOptions);
+    };
+    RRule3.FREQUENCIES = [
+      "YEARLY",
+      "MONTHLY",
+      "WEEKLY",
+      "DAILY",
+      "HOURLY",
+      "MINUTELY",
+      "SECONDLY"
+    ];
+    RRule3.YEARLY = Frequency.YEARLY;
+    RRule3.MONTHLY = Frequency.MONTHLY;
+    RRule3.WEEKLY = Frequency.WEEKLY;
+    RRule3.DAILY = Frequency.DAILY;
+    RRule3.HOURLY = Frequency.HOURLY;
+    RRule3.MINUTELY = Frequency.MINUTELY;
+    RRule3.SECONDLY = Frequency.SECONDLY;
+    RRule3.MO = Days.MO;
+    RRule3.TU = Days.TU;
+    RRule3.WE = Days.WE;
+    RRule3.TH = Days.TH;
+    RRule3.FR = Days.FR;
+    RRule3.SA = Days.SA;
+    RRule3.SU = Days.SU;
+    RRule3.parseString = parseString;
+    RRule3.optionsToString = optionsToString;
+    return RRule3;
+  })()
+);
+
+// ../../node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/iterset.js
+function iterSet(iterResult, _rrule, _exrule, _rdate, _exdate, tzid) {
+  var _exdateHash = {};
+  var _accept = iterResult.accept;
+  function evalExdate(after, before) {
+    _exrule.forEach(function(rrule) {
+      rrule.between(after, before, true).forEach(function(date5) {
+        _exdateHash[Number(date5)] = true;
+      });
+    });
+  }
+  _exdate.forEach(function(date5) {
+    var zonedDate2 = new DateWithZone(date5, tzid).rezonedDate();
+    _exdateHash[Number(zonedDate2)] = true;
+  });
+  iterResult.accept = function(date5) {
+    var dt2 = Number(date5);
+    if (isNaN(dt2))
+      return _accept.call(this, date5);
+    if (!_exdateHash[dt2]) {
+      evalExdate(new Date(dt2 - 1), new Date(dt2 + 1));
+      if (!_exdateHash[dt2]) {
+        _exdateHash[dt2] = true;
+        return _accept.call(this, date5);
+      }
+    }
+    return true;
+  };
+  if (iterResult.method === "between") {
+    evalExdate(iterResult.args.after, iterResult.args.before);
+    iterResult.accept = function(date5) {
+      var dt2 = Number(date5);
+      if (!_exdateHash[dt2]) {
+        _exdateHash[dt2] = true;
+        return _accept.call(this, date5);
+      }
+      return true;
+    };
+  }
+  for (var i = 0; i < _rdate.length; i++) {
+    var zonedDate = new DateWithZone(_rdate[i], tzid).rezonedDate();
+    if (!iterResult.accept(new Date(zonedDate.getTime())))
+      break;
+  }
+  _rrule.forEach(function(rrule) {
+    iter(iterResult, rrule.options);
+  });
+  var res = iterResult._result;
+  sort(res);
+  switch (iterResult.method) {
+    case "all":
+    case "between":
+      return res;
+    case "before":
+      return res.length && res[res.length - 1] || null;
+    case "after":
+    default:
+      return res.length && res[0] || null;
+  }
+}
+
+// ../../node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/rrulestr.js
+var DEFAULT_OPTIONS2 = {
+  dtstart: null,
+  cache: false,
+  unfold: false,
+  forceset: false,
+  compatible: false,
+  tzid: null
+};
+function parseInput(s, options) {
+  var rrulevals = [];
+  var rdatevals = [];
+  var exrulevals = [];
+  var exdatevals = [];
+  var parsedDtstart = parseDtstart(s);
+  var dtstart = parsedDtstart.dtstart;
+  var tzid = parsedDtstart.tzid;
+  var lines = splitIntoLines(s, options.unfold);
+  lines.forEach(function(line) {
+    var _a3;
+    if (!line)
+      return;
+    var _b = breakDownLine(line), name = _b.name, parms = _b.parms, value = _b.value;
+    switch (name.toUpperCase()) {
+      case "RRULE":
+        if (parms.length) {
+          throw new Error("unsupported RRULE parm: ".concat(parms.join(",")));
+        }
+        rrulevals.push(parseString(line));
+        break;
+      case "RDATE":
+        var _c = (_a3 = /RDATE(?:;TZID=([^:=]+))?/i.exec(line)) !== null && _a3 !== void 0 ? _a3 : [], rdateTzid = _c[1];
+        if (rdateTzid && !tzid) {
+          tzid = rdateTzid;
+        }
+        rdatevals = rdatevals.concat(parseRDate(value, parms));
+        break;
+      case "EXRULE":
+        if (parms.length) {
+          throw new Error("unsupported EXRULE parm: ".concat(parms.join(",")));
+        }
+        exrulevals.push(parseString(value));
+        break;
+      case "EXDATE":
+        exdatevals = exdatevals.concat(parseRDate(value, parms));
+        break;
+      case "DTSTART":
+        break;
+      default:
+        throw new Error("unsupported property: " + name);
+    }
+  });
+  return {
+    dtstart,
+    tzid,
+    rrulevals,
+    rdatevals,
+    exrulevals,
+    exdatevals
+  };
+}
+function buildRule(s, options) {
+  var _a3 = parseInput(s, options), rrulevals = _a3.rrulevals, rdatevals = _a3.rdatevals, exrulevals = _a3.exrulevals, exdatevals = _a3.exdatevals, dtstart = _a3.dtstart, tzid = _a3.tzid;
+  var noCache = options.cache === false;
+  if (options.compatible) {
+    options.forceset = true;
+    options.unfold = true;
+  }
+  if (options.forceset || rrulevals.length > 1 || rdatevals.length || exrulevals.length || exdatevals.length) {
+    var rset_1 = new RRuleSet(noCache);
+    rset_1.dtstart(dtstart);
+    rset_1.tzid(tzid || void 0);
+    rrulevals.forEach(function(val2) {
+      rset_1.rrule(new RRule(groomRruleOptions(val2, dtstart, tzid), noCache));
+    });
+    rdatevals.forEach(function(date5) {
+      rset_1.rdate(date5);
+    });
+    exrulevals.forEach(function(val2) {
+      rset_1.exrule(new RRule(groomRruleOptions(val2, dtstart, tzid), noCache));
+    });
+    exdatevals.forEach(function(date5) {
+      rset_1.exdate(date5);
+    });
+    if (options.compatible && options.dtstart)
+      rset_1.rdate(dtstart);
+    return rset_1;
+  }
+  var val = rrulevals[0] || {};
+  return new RRule(groomRruleOptions(val, val.dtstart || options.dtstart || dtstart, val.tzid || options.tzid || tzid), noCache);
+}
+function rrulestr(s, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return buildRule(s, initializeOptions2(options));
+}
+function groomRruleOptions(val, dtstart, tzid) {
+  return __assign(__assign({}, val), { dtstart, tzid });
+}
+function initializeOptions2(options) {
+  var invalid = [];
+  var keys = Object.keys(options);
+  var defaultKeys2 = Object.keys(DEFAULT_OPTIONS2);
+  keys.forEach(function(key) {
+    if (!includes(defaultKeys2, key))
+      invalid.push(key);
+  });
+  if (invalid.length) {
+    throw new Error("Invalid options: " + invalid.join(", "));
+  }
+  return __assign(__assign({}, DEFAULT_OPTIONS2), options);
+}
+function extractName(line) {
+  if (line.indexOf(":") === -1) {
+    return {
+      name: "RRULE",
+      value: line
+    };
+  }
+  var _a3 = split(line, ":", 1), name = _a3[0], value = _a3[1];
+  return {
+    name,
+    value
+  };
+}
+function breakDownLine(line) {
+  var _a3 = extractName(line), name = _a3.name, value = _a3.value;
+  var parms = name.split(";");
+  if (!parms)
+    throw new Error("empty property name");
+  return {
+    name: parms[0].toUpperCase(),
+    parms: parms.slice(1),
+    value
+  };
+}
+function splitIntoLines(s, unfold) {
+  if (unfold === void 0) {
+    unfold = false;
+  }
+  s = s && s.trim();
+  if (!s)
+    throw new Error("Invalid empty string");
+  if (!unfold) {
+    return s.split(/\s/);
+  }
+  var lines = s.split("\n");
+  var i = 0;
+  while (i < lines.length) {
+    var line = lines[i] = lines[i].replace(/\s+$/g, "");
+    if (!line) {
+      lines.splice(i, 1);
+    } else if (i > 0 && line[0] === " ") {
+      lines[i - 1] += line.slice(1);
+      lines.splice(i, 1);
+    } else {
+      i += 1;
+    }
+  }
+  return lines;
+}
+function validateDateParm(parms) {
+  parms.forEach(function(parm) {
+    if (!/(VALUE=DATE(-TIME)?)|(TZID=)/.test(parm)) {
+      throw new Error("unsupported RDATE/EXDATE parm: " + parm);
+    }
+  });
+}
+function parseRDate(rdateval, parms) {
+  validateDateParm(parms);
+  return rdateval.split(",").map(function(datestr) {
+    return untilStringToDate(datestr);
+  });
+}
+
+// ../../node_modules/.pnpm/rrule@2.8.1/node_modules/rrule/dist/esm/rruleset.js
+function createGetterSetter(fieldName) {
+  var _this = this;
+  return function(field) {
+    if (field !== void 0) {
+      _this["_".concat(fieldName)] = field;
+    }
+    if (_this["_".concat(fieldName)] !== void 0) {
+      return _this["_".concat(fieldName)];
+    }
+    for (var i = 0; i < _this._rrule.length; i++) {
+      var field_1 = _this._rrule[i].origOptions[fieldName];
+      if (field_1) {
+        return field_1;
+      }
+    }
+  };
+}
+var RRuleSet = (
+  /** @class */
+  (function(_super) {
+    __extends(RRuleSet2, _super);
+    function RRuleSet2(noCache) {
+      if (noCache === void 0) {
+        noCache = false;
+      }
+      var _this = _super.call(this, {}, noCache) || this;
+      _this.dtstart = createGetterSetter.apply(_this, ["dtstart"]);
+      _this.tzid = createGetterSetter.apply(_this, ["tzid"]);
+      _this._rrule = [];
+      _this._rdate = [];
+      _this._exrule = [];
+      _this._exdate = [];
+      return _this;
+    }
+    RRuleSet2.prototype._iter = function(iterResult) {
+      return iterSet(iterResult, this._rrule, this._exrule, this._rdate, this._exdate, this.tzid());
+    };
+    RRuleSet2.prototype.rrule = function(rrule) {
+      _addRule(rrule, this._rrule);
+    };
+    RRuleSet2.prototype.exrule = function(rrule) {
+      _addRule(rrule, this._exrule);
+    };
+    RRuleSet2.prototype.rdate = function(date5) {
+      _addDate(date5, this._rdate);
+    };
+    RRuleSet2.prototype.exdate = function(date5) {
+      _addDate(date5, this._exdate);
+    };
+    RRuleSet2.prototype.rrules = function() {
+      return this._rrule.map(function(e2) {
+        return rrulestr(e2.toString());
+      });
+    };
+    RRuleSet2.prototype.exrules = function() {
+      return this._exrule.map(function(e2) {
+        return rrulestr(e2.toString());
+      });
+    };
+    RRuleSet2.prototype.rdates = function() {
+      return this._rdate.map(function(e2) {
+        return new Date(e2.getTime());
+      });
+    };
+    RRuleSet2.prototype.exdates = function() {
+      return this._exdate.map(function(e2) {
+        return new Date(e2.getTime());
+      });
+    };
+    RRuleSet2.prototype.valueOf = function() {
+      var result = [];
+      if (!this._rrule.length && this._dtstart) {
+        result = result.concat(optionsToString({ dtstart: this._dtstart }));
+      }
+      this._rrule.forEach(function(rrule) {
+        result = result.concat(rrule.toString().split("\n"));
+      });
+      this._exrule.forEach(function(exrule) {
+        result = result.concat(exrule.toString().split("\n").map(function(line) {
+          return line.replace(/^RRULE:/, "EXRULE:");
+        }).filter(function(line) {
+          return !/^DTSTART/.test(line);
+        }));
+      });
+      if (this._rdate.length) {
+        result.push(rdatesToString("RDATE", this._rdate, this.tzid()));
+      }
+      if (this._exdate.length) {
+        result.push(rdatesToString("EXDATE", this._exdate, this.tzid()));
+      }
+      return result;
+    };
+    RRuleSet2.prototype.toString = function() {
+      return this.valueOf().join("\n");
+    };
+    RRuleSet2.prototype.clone = function() {
+      var rrs = new RRuleSet2(!!this._cache);
+      this._rrule.forEach(function(rule) {
+        return rrs.rrule(rule.clone());
+      });
+      this._exrule.forEach(function(rule) {
+        return rrs.exrule(rule.clone());
+      });
+      this._rdate.forEach(function(date5) {
+        return rrs.rdate(new Date(date5.getTime()));
+      });
+      this._exdate.forEach(function(date5) {
+        return rrs.exdate(new Date(date5.getTime()));
+      });
+      return rrs;
+    };
+    return RRuleSet2;
+  })(RRule)
+);
+function _addRule(rrule, collection) {
+  if (!(rrule instanceof RRule)) {
+    throw new TypeError(String(rrule) + " is not RRule instance");
+  }
+  if (!includes(collection.map(String), String(rrule))) {
+    collection.push(rrule);
+  }
+}
+function _addDate(date5, collection) {
+  if (!(date5 instanceof Date)) {
+    throw new TypeError(String(date5) + " is not Date instance");
+  }
+  if (!includes(collection.map(Number), Number(date5))) {
+    collection.push(date5);
+    sort(collection);
+  }
+}
+function rdatesToString(param, rdates, tzid) {
+  var isUTC = !tzid || tzid.toUpperCase() === "UTC";
+  var header = isUTC ? "".concat(param, ":") : "".concat(param, ";TZID=").concat(tzid, ":");
+  var dateString = rdates.map(function(rdate) {
+    return timeToUntilString(rdate.valueOf(), isUTC);
+  }).join(",");
+  return "".concat(header).concat(dateString);
+}
+
+// ../api-server-api/src/modules/schedules/rrule.ts
+var rrulePkg = Reflect.get(esm_exports, "default") ?? esm_exports;
+var { Frequency: Frequency2, RRule: RRule2 } = rrulePkg;
+var ALL_DAYS = [1, 2, 3, 4, 5, 6, 7];
+var ISO_TO_RRULE_WEEKDAY = {
+  1: RRule2.MO,
+  2: RRule2.TU,
+  3: RRule2.WE,
+  4: RRule2.TH,
+  5: RRule2.FR,
+  6: RRule2.SA,
+  7: RRule2.SU
+};
+function buildRRule(preset) {
+  if (preset.kind === "custom") {
+    return stripRRulePrefix(preset.rrule.trim());
+  }
+  const opts = toOptions(preset);
+  return stripRRulePrefix(new RRule2(opts).toString());
+}
+function toOptions(preset) {
+  const byweekday = daysFilterToByWeekday(preset.days);
+  switch (preset.kind) {
+    case "minutely":
+      return {
+        freq: Frequency2.MINUTELY,
+        interval: preset.interval,
+        ...byweekday
+      };
+    case "hourly":
+      return {
+        freq: Frequency2.HOURLY,
+        interval: preset.interval,
+        ...byweekday
+      };
+    case "daily":
+      return {
+        freq: Frequency2.DAILY,
+        byhour: [preset.hour],
+        byminute: [preset.minute],
+        bysecond: [0],
+        ...byweekday
+      };
+  }
+}
+function daysFilterToByWeekday(days) {
+  if (days.length === 0 || days.length === ALL_DAYS.length) return {};
+  const mapped = days.map((d2) => ISO_TO_RRULE_WEEKDAY[d2]).filter(Boolean);
+  return mapped.length > 0 ? { byweekday: mapped } : {};
+}
+function stripRRulePrefix(s) {
+  return s.replace(/^RRULE:/, "");
+}
+function rruleToText(rruleBody) {
+  try {
+    const rule = RRule2.fromString(rruleBody);
+    return rule.toText();
+  } catch {
+    return rruleBody;
+  }
+}
+function detectPreset(rruleBody) {
+  try {
+    const options = RRule2.parseString(rruleBody);
+    const days = byweekdayToIso(options.byweekday) ?? [...ALL_DAYS];
+    const interval = typeof options.interval === "number" ? options.interval : 1;
+    const hours = toNumArray(options.byhour);
+    const minutes = toNumArray(options.byminute);
+    if (options.freq === Frequency2.MINUTELY && hours.length === 0 && minutes.length === 0) {
+      return { kind: "minutely", interval, days };
+    }
+    if (options.freq === Frequency2.HOURLY && hours.length === 0 && minutes.length === 0) {
+      return { kind: "hourly", interval, days };
+    }
+    if ((options.freq === Frequency2.DAILY || options.freq === Frequency2.WEEKLY) && hours.length === 1 && minutes.length === 1) {
+      return { kind: "daily", hour: hours[0], minute: minutes[0], days };
+    }
+  } catch {
+  }
+  return { kind: "custom", rrule: rruleBody };
+}
+function toNumArray(v2) {
+  if (v2 == null) return [];
+  if (Array.isArray(v2))
+    return v2.filter((x) => typeof x === "number");
+  return typeof v2 === "number" ? [v2] : [];
+}
+function byweekdayToIso(byweekday) {
+  if (!Array.isArray(byweekday) || byweekday.length === 0) return null;
+  const mapped = [];
+  for (const bw of byweekday) {
+    const n = typeof bw === "number" ? bw : bw.weekday;
+    if (typeof n !== "number") continue;
+    mapped.push(n + 1);
+  }
+  mapped.sort((a, b2) => a - b2);
+  return mapped.length > 0 ? mapped : null;
+}
+function detectTimezone() {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+  } catch {
+    return "UTC";
+  }
+}
+function isInQuietHours(date5, windows) {
+  if (windows.length === 0) return false;
+  const m = date5.getUTCHours() * 60 + date5.getUTCMinutes();
+  for (const w3 of windows) {
+    if (!w3.enabled) continue;
+    const start = parseHHMM(w3.startTime);
+    const end = parseHHMM(w3.endTime);
+    if (start == null || end == null || start === end) continue;
+    const hit = start < end ? m >= start && m < end : m >= start || m < end;
+    if (hit) return true;
+  }
+  return false;
+}
+function hasVisibleOccurrence(rruleBody, windows) {
+  const enabled = windows.filter((w3) => w3.enabled);
+  if (enabled.length === 0) return true;
+  try {
+    const rule = RRule2.fromString(rruleBody);
+    let visible = false;
+    rule.all((date5, i) => {
+      if (i >= 1440) return false;
+      if (!isInQuietHours(date5, enabled)) {
+        visible = true;
+        return false;
+      }
+      return true;
+    });
+    return visible;
+  } catch {
+    return true;
+  }
+}
+function parseHHMM(s) {
+  const match = /^(\d{2}):(\d{2})$/.exec(s);
+  if (!match) return null;
+  const h2 = Number(match[1]);
+  const mi = Number(match[2]);
+  if (h2 < 0 || h2 > 23 || mi < 0 || mi > 59) return null;
+  return h2 * 60 + mi;
+}
+
 // ../api-server-api/src/modules/secrets/schemas.ts
 var presetSecretTypeSchema = external_exports.enum([
   "anthropic",
@@ -26847,6 +29893,7 @@ var EXIT_AGENT_NOT_RESOLVED = 5;
 var EXIT_RULE_NOT_FOUND = 6;
 var EXIT_AGENT_NOT_REACHABLE = 7;
 var EXIT_APPROVAL_NOT_ACTIONABLE = 8;
+var EXIT_SCHEDULE_NOT_FOUND = 9;
 var EXIT_SIGINT = 130;
 
 // src/modules/agent/commands/errors.ts
@@ -30177,7 +33224,7 @@ var ESC_MAP = {
   '"': '"',
   "\\": "\\"
 };
-function parseString(str, ptr = 0, endPtr = str.length) {
+function parseString2(str, ptr = 0, endPtr = str.length) {
   let isLiteral = str[ptr] === "'";
   let isMultiline = str[ptr++] === str[ptr] && str[ptr] === str[ptr + 1];
   if (isMultiline) {
@@ -30337,7 +33384,7 @@ function extractValue(str, ptr, end, depth, integersAsBigInt) {
   let endPtr;
   if (c2 === '"' || c2 === "'") {
     endPtr = getStringEnd(str, ptr);
-    let parsed = parseString(str, ptr, endPtr);
+    let parsed = parseString2(str, ptr, endPtr);
     if (end) {
       endPtr = skipVoid(str, endPtr);
       if (str[endPtr] && str[endPtr] !== "," && str[endPtr] !== end && str[endPtr] !== "\n" && str[endPtr] !== "\r") {
@@ -30421,7 +33468,7 @@ function parseKey(str, ptr, end = "=") {
             });
           }
         }
-        parsed.push(parseString(str, ptr, eos));
+        parsed.push(parseString2(str, ptr, eos));
       } else {
         dot = str.indexOf(".", ptr);
         let part = str.slice(ptr, dot < 0 || dot > endPtr ? endPtr : dot);
@@ -34843,7 +37890,7 @@ function createProcessEnvReader() {
 
 // src/modules/cli/infrastructure/package-version.ts
 function readPackageVersion() {
-  return true ? "0.2.3-rc2" : DEV_VERSION;
+  return true ? "0.2.4-rc1" : DEV_VERSION;
 }
 
 // src/modules/cli/infrastructure/version-probe.ts
@@ -35303,7 +38350,7 @@ async function collectInputs(template, opts, json2) {
   return { values, presetsApplied };
 }
 function buildPayload(template, name, values) {
-  const common = { templateId: template.id, name };
+  const common2 = { templateId: template.id, name };
   const v2 = (k2) => {
     const s = values[k2]?.trim();
     return s && s.length > 0 ? s : void 0;
@@ -35311,7 +38358,7 @@ function buildPayload(template, name, values) {
   switch (template.authKind) {
     case "oauth":
       return {
-        ...common,
+        ...common2,
         authKind: "oauth",
         ...v2("url") ? { url: v2("url") } : {},
         ...v2("host") ? { host: v2("host") } : {},
@@ -35329,7 +38376,7 @@ function buildPayload(template, name, values) {
         if (ov) configInputs[input.name] = ov;
       }
       return {
-        ...common,
+        ...common2,
         authKind: "header",
         ...v2("host") ? { host: v2("host") } : {},
         ...v2("headerName") ? { headerName: v2("headerName") } : {},
@@ -35341,7 +38388,7 @@ function buildPayload(template, name, values) {
     }
     case "none":
       return {
-        ...common,
+        ...common2,
         authKind: "none",
         ...v2("url") ? { url: v2("url") } : {}
       };
@@ -37090,6 +40137,765 @@ function composeImportModule(opts) {
   };
 }
 
+// src/modules/schedule/domain/recurrence-flags.ts
+var WEEKDAY_TO_ISO = {
+  MO: 1,
+  TU: 2,
+  WE: 3,
+  TH: 4,
+  FR: 5,
+  SA: 6,
+  SU: 7
+};
+var ISO_TO_WEEKDAY = {
+  1: "MO",
+  2: "TU",
+  3: "WE",
+  4: "TH",
+  5: "FR",
+  6: "SA",
+  7: "SU"
+};
+function formatWeekdays(days) {
+  return days.map((d2) => ISO_TO_WEEKDAY[d2]).filter((t) => t !== void 0).join(",");
+}
+function parseWeekdays(s) {
+  const tokens = s.split(",").map((t) => t.trim().toUpperCase()).filter((t) => t.length > 0);
+  if (tokens.length === 0) {
+    throw new Error("--weekdays needs at least one of MO,TU,WE,TH,FR,SA,SU");
+  }
+  const days = [];
+  for (const tok of tokens) {
+    const iso = WEEKDAY_TO_ISO[tok];
+    if (iso === void 0) {
+      throw new Error(`unknown weekday "${tok}" \u2014 use MO,TU,WE,TH,FR,SA,SU`);
+    }
+    if (!days.includes(iso)) days.push(iso);
+  }
+  days.sort((a, b2) => a - b2);
+  return days;
+}
+function parseEvery(s) {
+  const m = /^(\d+)(m|h)$/.exec(s.trim());
+  if (!m) {
+    throw new Error(`--every must be <N>m or <N>h (e.g. 30m, 2h), got "${s}"`);
+  }
+  const interval = Number(m[1]);
+  if (interval < 1) {
+    throw new Error(`--every interval must be a positive integer, got "${s}"`);
+  }
+  return { kind: m[2] === "m" ? "minutely" : "hourly", interval };
+}
+function parseDaily(s) {
+  const m = /^(\d{2}):(\d{2})$/.exec(s.trim());
+  if (!m) throw new Error(`--daily must be HH:MM (24h), got "${s}"`);
+  const hour = Number(m[1]);
+  const minute = Number(m[2]);
+  if (hour > 23 || minute > 59) {
+    throw new Error(`--daily must be a valid 24h time 00:00\u201323:59, got "${s}"`);
+  }
+  return { hour, minute };
+}
+function buildPresetFromFlags(opts) {
+  const chosen = [opts.daily, opts.every, opts.rrule].filter(
+    (v2) => v2 !== void 0
+  );
+  if (chosen.length === 0) {
+    throw new Error(
+      "a recurrence is required \u2014 pass exactly one of --daily, --every, or --rrule"
+    );
+  }
+  if (chosen.length > 1) {
+    throw new Error(
+      "--daily, --every, and --rrule are mutually exclusive \u2014 pass exactly one"
+    );
+  }
+  if (opts.rrule !== void 0) {
+    if (opts.weekdays !== void 0) {
+      throw new Error(
+        "--weekdays cannot combine with --rrule (the raw RRULE body carries its own BYDAY)"
+      );
+    }
+    return { kind: "custom", rrule: opts.rrule };
+  }
+  const days = opts.weekdays !== void 0 ? parseWeekdays(opts.weekdays) : [...ALL_DAYS];
+  if (opts.every !== void 0) {
+    const { kind, interval } = parseEvery(opts.every);
+    return { kind, interval, days };
+  }
+  const { hour, minute } = parseDaily(opts.daily);
+  return { kind: "daily", hour, minute, days };
+}
+function parseQuietWindow(s) {
+  const parts = s.split("-");
+  if (parts.length !== 2) {
+    throw new Error(
+      `--quiet-window must be HH:MM-HH:MM (e.g. 22:00-06:00), got "${s}"`
+    );
+  }
+  const parsed = quietWindowSchema.safeParse({
+    startTime: parts[0]?.trim(),
+    endTime: parts[1]?.trim(),
+    enabled: true
+  });
+  if (!parsed.success) {
+    const msg = parsed.error.issues[0]?.message ?? "invalid quiet window";
+    throw new Error(`--quiet-window "${s}": ${msg}`);
+  }
+  return parsed.data;
+}
+
+// src/modules/schedule/commands/create.ts
+function buildCreateCommand3(deps) {
+  return new Command("create").description("Create an RRULE schedule on an Agent").argument("<agent>", "Agent Ref \u2014 name or 'agent-\u2026' ID").requiredOption("--name <name>", "schedule name").requiredOption("--task <task>", "task prompt to run each tick").option("--daily <HH:MM>", "run daily at HH:MM (24h)").option("--every <interval>", "run every N minutes (Nm) or hours (Nh)").option(
+    "--rrule <body>",
+    "raw RFC 5545 RRULE body (mutually exclusive with --daily/--every/--weekdays)"
+  ).option(
+    "--weekdays <days>",
+    "limit --daily/--every to these days, e.g. MO,WE,FR"
+  ).option("--timezone <tz>", "IANA timezone (default: host zone)").option(
+    "--quiet-window <HH:MM-HH:MM>",
+    "suppress fires inside this daily window (repeatable)",
+    (v2, acc) => [...acc, v2],
+    []
+  ).addOption(
+    new Option(
+      "--session-mode <mode>",
+      "session strategy each tick (default: fresh)"
+    ).choices(["fresh", "continuous"])
+  ).option(
+    "--server <url>",
+    "override the configured server URL for this call"
+  ).option("--json", "emit the created schedule as JSON").addHelpText(
+    "after",
+    "\nExamples:\n  dam schedule create my-agent --name nightly --task 'Check dashboards' --daily 22:00\n  dam schedule create my-agent --name standup --task 'Summarize' --every 30m --weekdays MO,WE,FR --quiet-window 22:00-06:00\n  dam schedule create my-agent --name custom --task 'Run' --rrule 'FREQ=WEEKLY;BYDAY=MO;BYHOUR=7;BYMINUTE=0'\n"
+  ).action(async (ref, opts) => {
+    const host = await resolveActiveHost(deps, {
+      flag: opts.server ? { server: opts.server } : void 0,
+      exitCodes: {
+        runtimeFailure: EXIT_RUNTIME_FAILURE,
+        belowFloor: EXIT_BELOW_FLOOR
+      }
+    });
+    const resolver = createAgentResolver({
+      agentService: deps.createAgentService(host)
+    });
+    const resolved = await resolver.resolve(ref);
+    if (!resolved.ok) {
+      printResolveError(resolved.error, host);
+      process.exit(exitCodeForResolveError(resolved.error));
+    }
+    let rrule;
+    let quietHours;
+    try {
+      rrule = buildRRule(
+        buildPresetFromFlags({
+          daily: opts.daily,
+          every: opts.every,
+          rrule: opts.rrule,
+          weekdays: opts.weekdays
+        })
+      );
+      quietHours = opts.quietWindow.map(parseQuietWindow);
+    } catch (e2) {
+      process.stderr.write(`error: ${e2.message}
+`);
+      process.exit(EXIT_INVALID_INPUT);
+    }
+    const timezone = opts.timezone ?? detectTimezone();
+    if (!hasVisibleOccurrence(rrule, quietHours)) {
+      process.stderr.write(
+        "error: quiet hours cover every scheduled occurrence \u2014 this schedule would never fire\n"
+      );
+      process.exit(EXIT_INVALID_INPUT);
+    }
+    const result = await deps.createScheduleService(host).createRRule({
+      name: opts.name,
+      agentId: resolved.value.id,
+      rrule,
+      timezone,
+      quietHours,
+      task: opts.task,
+      ...opts.sessionMode ? { sessionMode: opts.sessionMode } : {}
+    });
+    if (!result.ok) {
+      if (result.error.kind === "invalid-input") {
+        process.stderr.write(`error: ${result.error.message}
+`);
+        process.exit(EXIT_INVALID_INPUT);
+      }
+      printServiceError(result.error, host);
+      process.exit(EXIT_RUNTIME_FAILURE);
+    }
+    if (opts.json) {
+      process.stdout.write(`${JSON.stringify(result.value)}
+`);
+    } else {
+      process.stdout.write(
+        `\u2713 Created schedule ${result.value.id} (${result.value.name}) on ${ref}.
+`
+      );
+    }
+    process.exit(EXIT_SUCCESS);
+  });
+}
+
+// src/modules/schedule/commands/delete.ts
+function buildDeleteCommand2(deps) {
+  return new Command("delete").description("Delete a schedule. Idempotent \u2014 unknown ids exit 0.").argument("<schedule-id>", "Schedule id (from `dam schedule list`)").option(
+    "--server <url>",
+    "override the configured server URL for this call"
+  ).option("-y, --yes", "skip the confirmation prompt").option("--json", "emit { deleted, id } as JSON").addHelpText(
+    "after",
+    "\nExamples:\n  dam schedule delete sched-abc123\n  dam schedule delete sched-abc123 --yes\n"
+  ).action(
+    async (id, opts) => {
+      const host = await resolveActiveHost(deps, {
+        flag: opts.server ? { server: opts.server } : void 0,
+        exitCodes: {
+          runtimeFailure: EXIT_RUNTIME_FAILURE,
+          belowFloor: EXIT_BELOW_FLOOR
+        }
+      });
+      if (!opts.yes) {
+        if (!process.stdin.isTTY) {
+          process.stderr.write(
+            "error: refusing to delete without --yes on non-interactive stdin\n"
+          );
+          process.exit(EXIT_INVALID_INPUT);
+        }
+        if (!await confirm(`Delete schedule ${id}?`)) exitCancelled(opts);
+      }
+      const result = await deps.createScheduleService(host).delete(id);
+      if (!result.ok) {
+        printServiceError(result.error, host);
+        process.exit(EXIT_RUNTIME_FAILURE);
+      }
+      if (opts.json) {
+        process.stdout.write(`${JSON.stringify({ deleted: true, id })}
+`);
+      } else {
+        process.stdout.write(`\u2713 Deleted schedule ${id}.
+`);
+      }
+      process.exit(EXIT_SUCCESS);
+    }
+  );
+}
+
+// src/modules/schedule/commands/toggle-command.ts
+function buildToggleCommand(deps, enable) {
+  const verb = enable ? "enable" : "disable";
+  return new Command(verb).description(
+    `${enable ? "Enable" : "Disable"} a schedule (idempotent \u2014 a no-op if already ${verb}d)`
+  ).argument("<schedule-id>", "Schedule id (from `dam schedule list`)").option(
+    "--server <url>",
+    "override the configured server URL for this call"
+  ).option("--json", "emit the resulting schedule as JSON").addHelpText("after", `
+Examples:
+  dam schedule ${verb} sched-abc123
+`).action(async (id, opts) => {
+    const host = await resolveActiveHost(deps, {
+      flag: opts.server ? { server: opts.server } : void 0,
+      exitCodes: {
+        runtimeFailure: EXIT_RUNTIME_FAILURE,
+        belowFloor: EXIT_BELOW_FLOOR
+      }
+    });
+    const svc = deps.createScheduleService(host);
+    const current = await svc.get(id);
+    if (!current.ok) {
+      if (current.error.kind === "schedule-not-found") {
+        process.stderr.write(`error: schedule not found: ${id}
+`);
+        process.exit(EXIT_SCHEDULE_NOT_FOUND);
+      }
+      printServiceError(current.error, host);
+      process.exit(EXIT_RUNTIME_FAILURE);
+    }
+    if (current.value.enabled === enable) {
+      if (opts.json) {
+        process.stdout.write(`${JSON.stringify(current.value)}
+`);
+      } else {
+        process.stdout.write(`Schedule ${id} is already ${verb}d.
+`);
+      }
+      process.exit(EXIT_SUCCESS);
+    }
+    const result = await svc.toggle(id);
+    if (!result.ok) {
+      if (result.error.kind === "schedule-not-found") {
+        process.stderr.write(`error: schedule not found: ${id}
+`);
+        process.exit(EXIT_SCHEDULE_NOT_FOUND);
+      }
+      printServiceError(result.error, host);
+      process.exit(EXIT_RUNTIME_FAILURE);
+    }
+    if (opts.json) {
+      process.stdout.write(`${JSON.stringify(result.value)}
+`);
+    } else {
+      process.stdout.write(`\u2713 ${enable ? "Enabled" : "Disabled"} ${id}.
+`);
+    }
+    process.exit(EXIT_SUCCESS);
+  });
+}
+
+// src/modules/schedule/commands/disable.ts
+function buildDisableCommand(deps) {
+  return buildToggleCommand(deps, false);
+}
+
+// src/modules/schedule/commands/enable.ts
+function buildEnableCommand(deps) {
+  return buildToggleCommand(deps, true);
+}
+
+// src/modules/schedule/commands/get.ts
+function renderSchedule(view) {
+  const lines = [];
+  lines.push(`ID:          ${view.id}`);
+  lines.push(
+    `Name:        ${view.createdBy === "agent" ? `${view.name} (agent)` : view.name}`
+  );
+  if (view.rrule !== null) {
+    lines.push(`Recurrence:  ${rruleToText(view.rrule)}`);
+    lines.push(`RRULE:       ${view.rrule}`);
+    lines.push(`Timezone:    ${view.timezone ?? "\u2014"}`);
+    if (view.quietHours.length > 0) {
+      const windows = view.quietHours.map(
+        (q2) => `${q2.startTime}-${q2.endTime}${q2.enabled ? "" : " (disabled)"}`
+      ).join(", ");
+      lines.push(`Quiet hours: ${windows}`);
+    }
+  } else {
+    lines.push(`Cron:        ${view.cron ?? ""}`);
+  }
+  lines.push(`Session:     ${view.sessionMode ?? "fresh"}`);
+  lines.push(`Enabled:     ${view.enabled}`);
+  lines.push(`Created by:  ${view.createdBy}`);
+  if (view.status?.lastRun) lines.push(`Last run:    ${view.status.lastRun}`);
+  if (view.status?.nextRun) lines.push(`Next run:    ${view.status.nextRun}`);
+  if (view.status?.lastResult) {
+    lines.push(`Last result: ${view.status.lastResult}`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+function buildGetCommand2(deps) {
+  return new Command("get").description("Show one schedule, expanded").argument("<schedule-id>", "Schedule id (from `dam schedule list`)").option(
+    "--server <url>",
+    "override the configured server URL for this call"
+  ).option("--json", "emit the raw schedule as JSON").addHelpText(
+    "after",
+    "\nExamples:\n  dam schedule get sched-abc123\n  dam schedule get sched-abc123 --json\n"
+  ).action(async (id, opts) => {
+    const host = await resolveActiveHost(deps, {
+      flag: opts.server ? { server: opts.server } : void 0,
+      exitCodes: {
+        runtimeFailure: EXIT_RUNTIME_FAILURE,
+        belowFloor: EXIT_BELOW_FLOOR
+      }
+    });
+    const result = await deps.createScheduleService(host).get(id);
+    if (!result.ok) {
+      if (result.error.kind === "schedule-not-found") {
+        process.stderr.write(`error: schedule not found: ${id}
+`);
+        process.exit(EXIT_SCHEDULE_NOT_FOUND);
+      }
+      printServiceError(result.error, host);
+      process.exit(EXIT_RUNTIME_FAILURE);
+    }
+    if (opts.json) {
+      process.stdout.write(`${JSON.stringify(result.value)}
+`);
+    } else {
+      process.stdout.write(renderSchedule(result.value));
+    }
+    process.exit(EXIT_SUCCESS);
+  });
+}
+
+// src/modules/schedule/commands/list.ts
+function recurrenceText(view) {
+  return view.rrule !== null ? rruleToText(view.rrule) : view.cron ?? "";
+}
+function buildListCommand5(deps) {
+  return new Command("list").description("List the schedules attached to an Agent").argument("<agent>", "Agent Ref \u2014 name or 'agent-\u2026' ID").option(
+    "--server <url>",
+    "override the configured server URL for this call"
+  ).option("--json", "emit raw JSON instead of the default table").addHelpText(
+    "after",
+    "\nExamples:\n  dam schedule list my-agent\n  dam schedule list agent-abc123 --json\n"
+  ).action(async (ref, opts) => {
+    const host = await resolveActiveHost(deps, {
+      flag: opts.server ? { server: opts.server } : void 0,
+      exitCodes: {
+        runtimeFailure: EXIT_RUNTIME_FAILURE,
+        belowFloor: EXIT_BELOW_FLOOR
+      }
+    });
+    const resolver = createAgentResolver({
+      agentService: deps.createAgentService(host)
+    });
+    const resolved = await resolver.resolve(ref);
+    if (!resolved.ok) {
+      printResolveError(resolved.error, host);
+      process.exit(exitCodeForResolveError(resolved.error));
+    }
+    const result = await deps.createScheduleService(host).list(resolved.value.id);
+    if (!result.ok) {
+      printServiceError(result.error, host);
+      process.exit(EXIT_RUNTIME_FAILURE);
+    }
+    if (opts.json) {
+      process.stdout.write(`${JSON.stringify(result.value)}
+`);
+      process.exit(EXIT_SUCCESS);
+    }
+    if (result.value.length === 0) {
+      process.stderr.write(
+        `No schedules. Add one with \`dam schedule create ${ref} --name <n> --task <t> --daily HH:MM\`.
+`
+      );
+      process.exit(EXIT_SUCCESS);
+    }
+    process.stdout.write(
+      renderTable([
+        [
+          "ID",
+          "NAME",
+          "RECURRENCE",
+          "TZ",
+          "ENABLED",
+          "NEXT-RUN",
+          "LAST-RESULT"
+        ],
+        ...result.value.map((v2) => [
+          v2.id,
+          v2.createdBy === "agent" ? `${v2.name} (agent)` : v2.name,
+          recurrenceText(v2),
+          v2.timezone ?? "\u2014",
+          String(v2.enabled),
+          v2.status?.nextRun ?? "\u2014",
+          v2.status?.lastResult ?? "\u2014"
+        ])
+      ])
+    );
+    process.exit(EXIT_SUCCESS);
+  });
+}
+
+// src/modules/schedule/commands/reset-session.ts
+function buildResetSessionCommand(deps) {
+  return new Command("reset-session").description(
+    "Clear a continuous schedule's accumulated session so the next tick starts fresh"
+  ).argument("<schedule-id>", "Schedule id (from `dam schedule list`)").option(
+    "--server <url>",
+    "override the configured server URL for this call"
+  ).option("--json", "emit { reset, id, sessionMode } as JSON").addHelpText(
+    "after",
+    "\nExamples:\n  dam schedule reset-session sched-abc123\n"
+  ).action(async (id, opts) => {
+    const host = await resolveActiveHost(deps, {
+      flag: opts.server ? { server: opts.server } : void 0,
+      exitCodes: {
+        runtimeFailure: EXIT_RUNTIME_FAILURE,
+        belowFloor: EXIT_BELOW_FLOOR
+      }
+    });
+    const svc = deps.createScheduleService(host);
+    const current = await svc.get(id);
+    if (!current.ok) {
+      if (current.error.kind === "schedule-not-found") {
+        process.stderr.write(`error: schedule not found: ${id}
+`);
+        process.exit(EXIT_SCHEDULE_NOT_FOUND);
+      }
+      printServiceError(current.error, host);
+      process.exit(EXIT_RUNTIME_FAILURE);
+    }
+    const sessionMode = current.value.sessionMode ?? "fresh";
+    if (sessionMode !== "continuous") {
+      if (opts.json) {
+        process.stdout.write(
+          `${JSON.stringify({ reset: false, id, sessionMode })}
+`
+        );
+      } else {
+        process.stdout.write(
+          `Nothing to reset \u2014 "${current.value.name}" is a fresh-session schedule.
+`
+        );
+      }
+      process.exit(EXIT_SUCCESS);
+    }
+    const result = await svc.resetSession(id);
+    if (!result.ok) {
+      printServiceError(result.error, host);
+      process.exit(EXIT_RUNTIME_FAILURE);
+    }
+    if (opts.json) {
+      process.stdout.write(
+        `${JSON.stringify({ reset: true, id, sessionMode })}
+`
+      );
+    } else {
+      process.stdout.write(
+        `\u2713 Reset session for "${current.value.name}". The next tick starts fresh.
+`
+      );
+    }
+    process.exit(EXIT_SUCCESS);
+  });
+}
+
+// src/modules/schedule/commands/update.ts
+function buildUpdateCommand2(deps) {
+  return new Command("update").description(
+    "Update an RRULE schedule (read-merge-write). Partial \u2014 pass only the fields to change. Legacy cron schedules are read-only."
+  ).argument("<schedule-id>", "Schedule id (from `dam schedule list`)").option("--name <name>", "new schedule name").option("--task <task>", "new task prompt").option("--daily <HH:MM>", "rebuild recurrence: daily at HH:MM").option("--every <interval>", "rebuild recurrence: every Nm/Nh").option("--rrule <body>", "rebuild recurrence: raw RFC 5545 RRULE body").option(
+    "--weekdays <days>",
+    "BYDAY filter for --daily/--every, e.g. MO,WE,FR"
+  ).option("--timezone <tz>", "new IANA timezone").option(
+    "--quiet-window <HH:MM-HH:MM>",
+    "replace ALL quiet windows with these (repeatable)",
+    (v2, acc) => [...acc, v2],
+    []
+  ).addOption(
+    new Option("--session-mode <mode>", "session strategy each tick").choices(
+      ["fresh", "continuous"]
+    )
+  ).option(
+    "--server <url>",
+    "override the configured server URL for this call"
+  ).option("--json", "emit the updated schedule as JSON").addHelpText(
+    "after",
+    "\nExamples:\n  dam schedule update sched-abc123 --name nightly\n  dam schedule update sched-abc123 --every 30m --weekdays MO,WE,FR\n  dam schedule update sched-abc123 --quiet-window 22:00-06:00\n"
+  ).action(async (id, opts) => {
+    const recurrenceGiven = opts.daily !== void 0 || opts.every !== void 0 || opts.rrule !== void 0;
+    const quietGiven = opts.quietWindow.length > 0;
+    const anyFlag = opts.name !== void 0 || opts.task !== void 0 || opts.timezone !== void 0 || opts.sessionMode !== void 0 || opts.weekdays !== void 0 || recurrenceGiven || quietGiven;
+    if (!anyFlag) {
+      process.stderr.write(
+        "error: nothing to update \u2014 pass at least one of --name, --task, --daily/--every/--rrule, --weekdays, --timezone, --quiet-window, --session-mode\n"
+      );
+      process.exit(EXIT_INVALID_INPUT);
+    }
+    if (opts.weekdays !== void 0 && !recurrenceGiven) {
+      process.stderr.write(
+        "error: --weekdays only applies when rebuilding the recurrence; pass it with --daily or --every\n"
+      );
+      process.exit(EXIT_INVALID_INPUT);
+    }
+    const host = await resolveActiveHost(deps, {
+      flag: opts.server ? { server: opts.server } : void 0,
+      exitCodes: {
+        runtimeFailure: EXIT_RUNTIME_FAILURE,
+        belowFloor: EXIT_BELOW_FLOOR
+      }
+    });
+    const svc = deps.createScheduleService(host);
+    const current = await svc.get(id);
+    if (!current.ok) {
+      if (current.error.kind === "schedule-not-found") {
+        process.stderr.write(`error: schedule not found: ${id}
+`);
+        process.exit(EXIT_SCHEDULE_NOT_FOUND);
+      }
+      printServiceError(current.error, host);
+      process.exit(EXIT_RUNTIME_FAILURE);
+    }
+    const view = current.value;
+    if (view.rrule === null) {
+      process.stderr.write(
+        "error: this is a legacy cron schedule; recreate it as an RRULE to edit\n"
+      );
+      process.exit(EXIT_INVALID_INPUT);
+    }
+    let rrule = view.rrule;
+    if (recurrenceGiven) {
+      try {
+        rrule = buildRRule(
+          buildPresetFromFlags({
+            daily: opts.daily,
+            every: opts.every,
+            rrule: opts.rrule,
+            weekdays: opts.weekdays
+          })
+        );
+      } catch (e2) {
+        process.stderr.write(`error: ${e2.message}
+`);
+        process.exit(EXIT_INVALID_INPUT);
+      }
+      if (opts.weekdays === void 0 && opts.rrule === void 0) {
+        const old = detectPreset(view.rrule);
+        if (old.kind !== "custom" && old.days.length < ALL_DAYS.length) {
+          process.stderr.write(
+            `note: weekday filter (${formatWeekdays(old.days)}) cleared by the new recurrence; re-pass --weekdays to keep it
+`
+          );
+        }
+      }
+    }
+    let quietHours = view.quietHours;
+    if (quietGiven) {
+      try {
+        quietHours = opts.quietWindow.map(parseQuietWindow);
+      } catch (e2) {
+        process.stderr.write(`error: ${e2.message}
+`);
+        process.exit(EXIT_INVALID_INPUT);
+      }
+    }
+    if (!hasVisibleOccurrence(rrule, quietHours)) {
+      process.stderr.write(
+        "error: quiet hours cover every scheduled occurrence \u2014 this schedule would never fire\n"
+      );
+      process.exit(EXIT_INVALID_INPUT);
+    }
+    const sessionMode = opts.sessionMode ?? view.sessionMode;
+    const result = await svc.updateRRule({
+      id,
+      name: opts.name ?? view.name,
+      rrule,
+      timezone: opts.timezone ?? view.timezone ?? detectTimezone(),
+      quietHours,
+      task: opts.task ?? view.task ?? "",
+      ...sessionMode ? { sessionMode } : {}
+    });
+    if (!result.ok) {
+      if (result.error.kind === "schedule-not-found") {
+        process.stderr.write(`error: schedule not found: ${id}
+`);
+        process.exit(EXIT_SCHEDULE_NOT_FOUND);
+      }
+      if (result.error.kind === "invalid-input") {
+        process.stderr.write(`error: ${result.error.message}
+`);
+        process.exit(EXIT_INVALID_INPUT);
+      }
+      printServiceError(result.error, host);
+      process.exit(EXIT_RUNTIME_FAILURE);
+    }
+    if (opts.json) {
+      process.stdout.write(`${JSON.stringify(result.value)}
+`);
+    } else {
+      process.stdout.write(
+        `\u2713 Updated schedule ${result.value.id} (${result.value.name}).
+`
+      );
+    }
+    process.exit(EXIT_SUCCESS);
+  });
+}
+
+// src/modules/schedule/services/schedule-service.ts
+function codeOf(e2) {
+  return e2?.data?.code;
+}
+function messageOf(e2) {
+  return e2 instanceof Error ? e2.message : "invalid schedule input";
+}
+function createScheduleService(deps) {
+  return {
+    async list(agentId) {
+      return trpcCall(
+        () => deps.trpc.schedules.list.query({ agentId })
+      );
+    },
+    async get(id) {
+      try {
+        return ok2(await deps.trpc.schedules.get.query({ id }));
+      } catch (e2) {
+        if (codeOf(e2) === "NOT_FOUND") {
+          return err2({ kind: "schedule-not-found", id });
+        }
+        return classifyTrpcError(e2);
+      }
+    },
+    async createRRule(input) {
+      try {
+        return ok2(await deps.trpc.schedules.createRRule.mutate(input));
+      } catch (e2) {
+        if (codeOf(e2) === "BAD_REQUEST") {
+          return err2({ kind: "invalid-input", message: messageOf(e2) });
+        }
+        return classifyTrpcError(e2);
+      }
+    },
+    async updateRRule(input) {
+      try {
+        return ok2(await deps.trpc.schedules.updateRRule.mutate(input));
+      } catch (e2) {
+        const code = codeOf(e2);
+        if (code === "NOT_FOUND") {
+          return err2({ kind: "schedule-not-found", id: input.id });
+        }
+        if (code === "BAD_REQUEST") {
+          return err2({ kind: "invalid-input", message: messageOf(e2) });
+        }
+        return classifyTrpcError(e2);
+      }
+    },
+    async toggle(id) {
+      try {
+        return ok2(await deps.trpc.schedules.toggle.mutate({ id }));
+      } catch (e2) {
+        if (codeOf(e2) === "NOT_FOUND") {
+          return err2({ kind: "schedule-not-found", id });
+        }
+        return classifyTrpcError(e2);
+      }
+    },
+    async delete(id) {
+      return trpcCall(async () => {
+        await deps.trpc.schedules.delete.mutate({ id });
+      });
+    },
+    async resetSession(id) {
+      return trpcCall(async () => {
+        await deps.trpc.schedules.resetSession.mutate({ id });
+      });
+    }
+  };
+}
+
+// src/modules/schedule/compose.ts
+function composeScheduleModule(opts) {
+  const buildTrpc = (host) => createTrpcClient({ host, tokenProvider: opts.tokenProvider });
+  const createService = (host) => createScheduleService({ trpc: buildTrpc(host) });
+  const agentScoped = {
+    compatService: opts.compatService,
+    configService: opts.configService,
+    createAgentService: opts.createAgentService,
+    createScheduleService: createService
+  };
+  const idScoped = {
+    compatService: opts.compatService,
+    configService: opts.configService,
+    createScheduleService: createService
+  };
+  const parent = new Command("schedule").description(
+    "Manage time-triggered tasks (schedules) attached to an Agent"
+  );
+  parent.addCommand(buildListCommand5(agentScoped));
+  parent.addCommand(buildGetCommand2(idScoped));
+  parent.addCommand(buildCreateCommand3(agentScoped));
+  parent.addCommand(buildUpdateCommand2(idScoped));
+  parent.addCommand(buildEnableCommand(idScoped));
+  parent.addCommand(buildDisableCommand(idScoped));
+  parent.addCommand(buildDeleteCommand2(idScoped));
+  parent.addCommand(buildResetSessionCommand(idScoped));
+  return { commands: [parent], exports: { createService } };
+}
+
 // src/modules/skill/domain/source-ref.ts
 function resolveSourceRef(sources, ref) {
   if (ref.includes("://")) {
@@ -37361,7 +41167,7 @@ function buildInstallCommand(deps) {
 // src/modules/skill/commands/list.ts
 var INSTALLED_HEADER = ["SOURCE", "NAME", "VERSION"];
 var STANDALONE_HEADER = ["NAME", "PUBLISHED"];
-function buildListCommand5(deps) {
+function buildListCommand6(deps) {
   return new Command("list").description("List the skills on an Agent \u2014 installed and standalone").argument("<agent>", "Agent Ref \u2014 name or 'agent-\u2026' ID").option(
     "--server <url>",
     "override the configured server URL for this call"
@@ -38119,7 +41925,7 @@ function composeSkillModule(opts) {
   sourceGroup.addCommand(buildSourceRefreshCommand(shared));
   parent.addCommand(sourceGroup);
   parent.addCommand(buildCatalogCommand(shared));
-  parent.addCommand(buildListCommand5(shared));
+  parent.addCommand(buildListCommand6(shared));
   parent.addCommand(buildInstallCommand(shared));
   parent.addCommand(buildUninstallCommand(shared));
   parent.addCommand(buildPublishCommand(shared));
@@ -38684,7 +42490,7 @@ function composeSshModule(opts) {
 
 // src/modules/template/commands/list.ts
 var DESCRIPTION_MAX = 60;
-function buildListCommand6(deps) {
+function buildListCommand7(deps) {
   return new Command("list").description("List agent templates available on the active host").option(
     "--server <url>",
     "override the configured server URL for this call"
@@ -38769,7 +42575,7 @@ function composeTemplateModule(opts) {
     "Discover agent templates on the active host"
   );
   parent.addCommand(
-    buildListCommand6({
+    buildListCommand7({
       compatService: opts.compatService,
       configService: opts.configService,
       createTemplateService: createService
@@ -38843,6 +42649,12 @@ function compose(opts = {}) {
     createAgentService: agent.exports.createService,
     browserOpener: createBrowserOpener()
   });
+  const schedule = composeScheduleModule({
+    tokenProvider: auth.exports.tokenProvider,
+    configService: cli.services.configService,
+    compatService: cli.services.compatService,
+    createAgentService: agent.exports.createService
+  });
   const skill = composeSkillModule({
     tokenProvider: auth.exports.tokenProvider,
     configService: cli.services.configService,
@@ -38868,6 +42680,7 @@ function compose(opts = {}) {
   for (const command of egress.commands) program3.addCommand(command);
   for (const command of approval.commands) program3.addCommand(command);
   for (const command of connection2.commands) program3.addCommand(command);
+  for (const command of schedule.commands) program3.addCommand(command);
   for (const command of skill.commands) program3.addCommand(command);
   for (const command of ssh.commands) program3.addCommand(command);
   return program3;