[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8,"_9":10,"_11":12},"actionData","errors","root",{"_180":-5,"_183":184,"_185":186},"routes/shell",{"_43":44,"_179":-5,"_180":-5,"_181":182},"routes/repo",{"_34":-7,"_35":36,"_37":38,"_39":40,"_41":42,"_43":44,"_45":32,"_46":32,"_47":32,"_48":32,"_49":32,"_50":32,"_51":52,"_53":52,"_54":32,"_55":-7,"_56":-7,"_57":58,"_59":60,"_61":62,"_63":-5,"_64":65,"_66":67,"_68":69,"_70":71},"routes/repo.blob",{"_13":14,"_15":16,"_17":18,"_19":20,"_21":22,"_23":24,"_25":-5,"_26":27,"_28":29,"_29":30,"_31":32,"_33":14},"ref","main","path","crates/logic/cron.rs","oid","b06f0cf2ee4daa4ae4eb295cdb73d99da45b807f","size",25755,"commit","90b43017241f81189453d326d05948f388b34652","mounts",[],"source","plain",{"_13":14,"_15":16},"kind","text","// Copyright 2026 Deno Land Inc. Apache-2.0 license.\n\n//! Cron trigger schedules, reified sans-IO.\n//!\n//! A `triggers.crons` entry in the Wrangler config becomes one reserved cell\n//! whose alarm is armed at the next occurrence. Everything about *when* that\n//! is — parsing the expression, walking to the next minute, choosing between\n//! a retry and the next occurrence — is a pure function of the expression and\n//! a timestamp. The cell and its alarm row are the executor.\n//!\n//! Resolution is one minute and the zone is UTC, matching both Cloudflare's\n//! cron triggers and the minute buckets the wake index already uses\n//! (`wake::entry_key`). The schedule is therefore never more precise than the\n//! alarm that carries it.\n//!\n//! The dialect is Cloudflare's, read out of `saffron` (the parser behind Cron\n//! Triggers) rather than out of a POSIX cron manual, because the two disagree\n//! on the day-of-week numbers and silence is the worst way to find that out.\n//! Cloudflare numbers the weekdays 1 to 7 from Sunday and rejects 0, so `1-5`\n//! is Sunday to Thursday there and Monday to Friday in Vixie cron. Two places\n//! where `saffron` contradicts its own comments are called out at the code that\n//! declines to copy them.\n\nuse crate::wake::civil_from_days;\nuse crate::Ms;\n\n/// The class name of the reserved cell that carries a script's schedule.\n///\n/// A leading `.` is inside `cell::valid_cell_scope`'s charset but is not a\n/// legal start for a JavaScript identifier, so no exported class can collide\n/// with the reserved namespace. That is the whole reason the name is punctuated\n/// rather than pretty.\npub const RESERVED_CLASS: &str = \".cron\";\n\n/// The one cell that owns a script's cron schedule.\n///\n/// Keyed on the script and nothing else — not the expressions, not a hash of\n/// them. Ownership CAS on this one name is what makes a cron fire once per\n/// fleet rather than once per node, and a stable name is what lets a deploy\n/// change the schedule without stranding the alarm the old schedule armed.\npub fn reserved_cell(script_name: &str) -> String {\n format!(\"{RESERVED_CLASS}:{script_name}\")\n}\n\n/// How far ahead `next_after` walks before it calls an expression\n/// unsatisfiable.\n///\n/// One Gregorian cycle. The calendar repeats exactly every 400 years, so a walk\n/// of 146097 consecutive days sees every (month, day-of-month, day-of-week)\n/// combination that can ever occur: an expression with no match in that window\n/// has none at all, and the bound is a proof rather than an estimate. Estimates\n/// were tried and were wrong twice over — `0 0 29 2 *` waits eight years, not\n/// four, when a century skips its leap year (2096-02-29 to 2104-02-29 is 2921\n/// days), and `0 0 * 2 SUN#5` needs a 29-day February that starts on a Sunday,\n/// which is 28 years apart. Undershooting is not a late fire but a silent\n/// retirement: `next_across` returns `None`, so the cell deletes its alarm. The\n/// full walk costs about a hundred thousand cheap iterations and only an\n/// unsatisfiable expression ever pays it, once, at arm time.\nconst MAX_LOOKAHEAD_DAYS: usize = 146_097;\n\nconst MINUTE: Field = Field {\n name: \"minute\",\n min: 0,\n max: 59,\n names: &[],\n};\nconst HOUR: Field = Field {\n name: \"hour\",\n min: 0,\n max: 23,\n names: &[],\n};\nconst DAY_OF_MONTH: Field = Field {\n name: \"day of month\",\n min: 1,\n max: 31,\n names: &[],\n};\nconst MONTH: Field = Field {\n name: \"month\",\n min: 1,\n max: 12,\n names: &[\n \"jan\", \"feb\", \"mar\", \"apr\", \"may\", \"jun\", \"jul\", \"aug\", \"sep\", \"oct\", \"nov\", \"dec\",\n ],\n};\n/// Cloudflare numbers the weekdays 1 to 7 from Sunday, so 1 is Sunday and 7 is\n/// Saturday, and 0 is out of range. Vixie cron numbers them 0 to 6 from Sunday\n/// and accepts 7 as Sunday again, which makes the same expression name a\n/// different day on the two platforms. Cloudflare documents its choice, and a\n/// value here is therefore the Cloudflare number minus one: the bit sets below\n/// are indexed by weekday with Sunday at 0.\nconst DAY_OF_WEEK: Field = Field {\n name: \"day of week\",\n min: 1,\n max: 7,\n names: &[\"sun\", \"mon\", \"tue\", \"wed\", \"thu\", \"fri\", \"sat\"],\n};\n\n/// One field's shape: its bounds and the three-letter aliases it accepts.\nstruct Field {\n name: &'static str,\n min: u32,\n max: u32,\n /// Aliases in ascending order starting at `min`.\n names: &'static [&'static str],\n}\n\n/// A parsed five-field cron expression, as bit sets.\n///\n/// The original text is kept because the `scheduled` handler's controller\n/// reports which expression fired, and it must be the string the developer\n/// wrote rather than a re-rendering of these bits.\n#[derive(Clone, Debug, PartialEq, Eq)]\npub struct Cron {\n text: String,\n minute: u64,\n hour: u32,\n month: u16,\n day_of_month: DayOfMonth,\n day_of_week: DayOfWeek,\n}\n\n/// The day-of-month field. `All` is its own variant because the day rule turns\n/// on whether the field was written `*`, which a bit set cannot say: a field\n/// listing every day is indistinguishable from `*` once expanded. The `L` and\n/// `W` variants cannot be expressed as a bit set at all, because which day they\n/// name depends on the month.\n#[derive(Clone, Debug, PartialEq, Eq)]\nenum DayOfMonth {\n /// `*`\n All,\n /// A list, range, or step: bit `d` set for day `d`.\n Days(u32),\n /// `L` — the last day of the month.\n Last,\n /// `L-` — `n` days before the last day.\n LastOffset(u32),\n /// `LW` — the last weekday of the month.\n LastWeekday,\n /// `L-W` — the weekday closest to `n` days before the last day.\n LastOffsetWeekday(u32),\n /// `W` — the weekday closest to day `d`, inside the same month.\n ClosestWeekday(u32),\n}\n\n/// The day-of-week field, with Sunday at bit 0 whatever number named it.\n#[derive(Clone, Debug, PartialEq, Eq)]\nenum DayOfWeek {\n /// `*`\n All,\n /// A list, range, or step: bit `w` set for weekday `w`, Sunday at 0.\n Days(u8),\n /// `L` — the last such weekday of the month.\n Last(u32),\n /// `#` — the nth such weekday of the month.\n Nth(u32, u32),\n}\n\nimpl Cron {\n /// The expression as the developer wrote it.\n pub fn text(&self) -> &str {\n &self.text\n }\n}\n\n/// Why an expression was refused, naming the field at fault so a deploy can\n/// report which of several crons is wrong.\n#[derive(Clone, Debug, PartialEq, Eq)]\npub struct CronError {\n pub expression: String,\n pub message: String,\n}\n\nimpl std::fmt::Display for CronError {\n fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n write!(f, \"cron expression {:?}: {}\", self.expression, self.message)\n }\n}\n\nimpl std::error::Error for CronError {}\n\n/// Parse a five-field cron expression: minute, hour, day of month, month, day\n/// of week. Each field takes `*`, a value, an `a-b` range, an `a,b` list, and a\n/// `/n` step on any of those. Month and day-of-week also take the usual\n/// three-letter names, case-insensitively. The day fields take Cloudflare's\n/// `L`, `W`, and `#` on top of that.\n///\n/// `?` is refused, as Cloudflare refuses it: its parser has no case for the\n/// character, so an expression that uses it fails there too.\npub fn parse(expression: &str) -> Result {\n let fail = |message: String| CronError {\n expression: expression.to_string(),\n message,\n };\n let fields: Vec<&str> = expression.split_whitespace().collect();\n if fields.len() != 5 {\n return Err(fail(format!(\n \"expected 5 fields (minute hour day-of-month month day-of-week), found {}\",\n fields.len()\n )));\n }\n let minute = parse_field(fields[0], &MINUTE).map_err(&fail)?;\n let hour = parse_field(fields[1], &HOUR).map_err(&fail)?;\n let day_of_month = parse_day_of_month(fields[2]).map_err(&fail)?;\n let month = parse_field(fields[3], &MONTH).map_err(&fail)?;\n let day_of_week = parse_day_of_week(fields[4]).map_err(&fail)?;\n Ok(Cron {\n text: expression.trim().to_string(),\n minute,\n hour: hour as u32,\n month: month as u16,\n day_of_month,\n day_of_week,\n })\n}\n\n/// The day-of-month field, including the `L` and `W` forms.\n///\n/// An `L` or `W` form stands alone. Cloudflare's parser stops after reading one\n/// and never looks for a comma, so `1W,15` fails there; refusing it here keeps\n/// the two answers the same instead of inventing a union it cannot express.\nfn parse_day_of_month(text: &str) -> Result {\n if text == \"*\" {\n return Ok(DayOfMonth::All);\n }\n if let Some(rest) = text.strip_prefix('L') {\n return match rest {\n \"\" => Ok(DayOfMonth::Last),\n \"W\" => Ok(DayOfMonth::LastWeekday),\n _ => {\n let (digits, weekday) = match rest.strip_suffix('W') {\n Some(digits) => (digits, true),\n None => (rest, false),\n };\n let offset = digits.strip_prefix('-').ok_or_else(|| {\n format!(\"day of month field has an unreadable `L` form in {text:?}\")\n })?;\n // Cloudflare allows 1 to 30: 30 is one short of the longest\n // month, so `L-30` is the 1st of a 31-day month, and 0 is out\n // of range rather than a spelling of `L`. Accepting 0 would\n // also make `L-0W` a different rule from `LW`, because the\n // offset arms cannot move to the Friday before a month that\n // ends on a weekend.\n let offset = parse_digits(offset).ok_or_else(|| {\n format!(\"day of month field has a non-numeric `L` offset in {text:?}\")\n })?;\n if !(1..=30).contains(&offset) {\n return Err(format!(\n \"day of month field has an `L` offset {offset} outside 1-30\"\n ));\n }\n if weekday {\n Ok(DayOfMonth::LastOffsetWeekday(offset))\n } else {\n Ok(DayOfMonth::LastOffset(offset))\n }\n }\n };\n }\n if let Some(day) = text.strip_suffix('W') {\n return Ok(DayOfMonth::ClosestWeekday(parse_value(day, &DAY_OF_MONTH)?));\n }\n Ok(DayOfMonth::Days(parse_field(text, &DAY_OF_MONTH)? as u32))\n}\n\n/// The day-of-week field, including the `L` and `#` forms.\n///\n/// `L` on its own is Saturday, which reads like a typo and is not: Cloudflare's\n/// parser maps a bare `L` in this field to day 7, and 7 is Saturday under its\n/// numbering.\nfn parse_day_of_week(text: &str) -> Result {\n if text == \"*\" {\n return Ok(DayOfWeek::All);\n }\n if text == \"L\" {\n return Ok(DayOfWeek::Days(1 << 6));\n }\n if let Some(day) = text.strip_suffix('L') {\n return Ok(DayOfWeek::Last(parse_value(day, &DAY_OF_WEEK)? - 1));\n }\n if let Some((day, nth)) = text.split_once('#') {\n let day = parse_value(day, &DAY_OF_WEEK)? - 1;\n let nth = parse_digits(nth)\n .ok_or_else(|| format!(\"day of week field has a non-numeric `#` count in {text:?}\"))?;\n if !(1..=5).contains(&nth) {\n return Err(format!(\n \"day of week field has a `#` count {nth} outside 1-5\"\n ));\n }\n return Ok(DayOfWeek::Nth(day, nth));\n }\n // Parsed in Cloudflare's 1-7 numbering and shifted down, so a range keeps\n // its meaning: `2-6` is bits 2 to 6 before the shift and Monday to Friday\n // after it.\n Ok(DayOfWeek::Days(\n (parse_field(text, &DAY_OF_WEEK)? >> 1) as u8,\n ))\n}\n\n/// One field to a bit set, bit `v` set when value `v` matches.\nfn parse_field(text: &str, field: &Field) -> Result {\n if text.is_empty() {\n return Err(format!(\"{} field is empty\", field.name));\n }\n let mut bits = 0_u64;\n let items: Vec<&str> = text.split(',').collect();\n for item in &items {\n // A bare `*` inside a list is refused, wherever in the list it sits.\n // Cloudflare rejects `*,5` outright — its parser returns on the first\n // `*` and then fails on the unread remainder — and accepts `1,*` while\n // reading that `*` as the field's minimum, so `1,*` is minute 0 and\n // minute 1 there. Both follow from one parsing routine being reused and\n // not from any intent, and reading either as \"every value\" would fire a\n // handler sixty times where Cloudflare fires it twice. Neither answer\n // can be defended, so the deploy stops where the developer can read it.\n if items.len() > 1 && item.trim() == \"*\" {\n return Err(format!(\n \"{} field has a `*` inside a list in {text:?}; write `*` alone, or list the values\",\n field.name\n ));\n }\n bits |= parse_item(item, field)?;\n }\n Ok(bits)\n}\n\nfn parse_item(item: &str, field: &Field) -> Result {\n let (spec, step) = match item.split_once('/') {\n None => (item, 1_u32),\n Some((spec, step)) => {\n let step = parse_digits(step).ok_or_else(|| {\n format!(\"{} field has a non-numeric step in {item:?}\", field.name)\n })?;\n // Cloudflare bounds a step by the width of its field, so `*/60` is\n // refused for minutes rather than read as \"every hour\". A step at\n // or past the width can only ever set the value it starts from,\n // which is what the developer did not write.\n if step == 0 || step > field.max - field.min {\n return Err(format!(\n \"{} field has a step {step} outside 1-{} in {item:?}\",\n field.name,\n field.max - field.min\n ));\n }\n (spec, step)\n }\n };\n // A step with no explicit end runs to the field's maximum, so `*/15` and\n // `30/15` differ only in where they start.\n let (first, last) = match spec {\n \"*\" => (field.min, field.max),\n _ => match spec.split_once('-') {\n Some((from, to)) => (parse_value(from, field)?, parse_value(to, field)?),\n None => {\n let value = parse_value(spec, field)?;\n if step == 1 {\n (value, value)\n } else {\n (value, field.max)\n }\n }\n },\n };\n // A descending range is refused, and this is the one place celld declines\n // to follow Cloudflare. Cloudflare accepts it and wraps around the end of\n // the field for Quartz's sake, but takes one value too many at the low end:\n // `SAT-SUN` matches Friday there and `NOV-FEB` matches October, which\n // contradicts the worked example in saffron's own comment. Copying that\n // ships a schedule known to fire on a day nobody asked for, and correcting\n // it silently means the same expression means two things. Refusing stops\n // the deploy where the developer is watching instead.\n if first > last {\n return Err(format!(\n \"{} field has a descending range in {item:?}; celld does not wrap a range around the end of a field\",\n field.name\n ));\n }\n let mut bits = 0_u64;\n let mut value = first;\n while value <= last {\n bits |= 1 << value;\n value += step;\n }\n Ok(bits)\n}\n\n/// A run of ASCII digits and nothing else.\n///\n/// `str::parse` accepts a leading `+`, and Cloudflare's parser reads digits\n/// only, so `0 0 * * +2` deploys here and fails there. Every number in an\n/// expression goes through this.\nfn parse_digits(text: &str) -> Option {\n if text.is_empty() || !text.bytes().all(|byte| byte.is_ascii_digit()) {\n return None;\n }\n text.parse().ok()\n}\n\nfn parse_value(text: &str, field: &Field) -> Result {\n let text = text.trim();\n let lower = text.to_ascii_lowercase();\n if let Some(index) = field.names.iter().position(|name| *name == lower) {\n return Ok(field.min + index as u32);\n }\n let value = parse_digits(text).ok_or_else(|| {\n if field.names.is_empty() {\n format!(\"{} field has a non-numeric value {text:?}\", field.name)\n } else {\n format!(\n \"{} field has a value {text:?} that is neither a number nor a name\",\n field.name\n )\n }\n })?;\n if value < field.min || value > field.max {\n return Err(format!(\n \"{} field has {value} outside {}-{}\",\n field.name, field.min, field.max\n ));\n }\n Ok(value)\n}\n\n/// Does this expression match the minute containing `at_ms`?\npub fn matches(cron: &Cron, at_ms: Ms) -> bool {\n let minutes = at_ms.div_euclid(60_000);\n let day = minutes.div_euclid(1440);\n let time = minutes.rem_euclid(1440);\n day_matches(cron, day)\n && cron.hour & (1 << (time / 60)) != 0\n && cron.minute & (1 << (time % 60)) != 0\n}\n\n/// The day rule: with both day fields restricted a day matches when *either*\n/// does, so `0 0 1 * MON` is the first of the month and every Monday. With one\n/// field restricted, only that one decides. A field counts as restricted unless\n/// it is literally `*`, so `*/2` is restricted and joins the union — the rule\n/// Cloudflare applies, and not Vixie's, which reads the field's first character\n/// and would call `*/2` unrestricted.\nfn day_matches(cron: &Cron, day: i64) -> bool {\n let (year, month, day_of_month) = civil_from_days(day);\n if cron.month & (1 << month) == 0 {\n return false;\n }\n // 1970-01-01 was a Thursday, and Sunday is 0.\n let day_of_week = (day + 4).rem_euclid(7) as u32;\n let last = days_in_month(year, month);\n let by_dom = day_of_month_matches(&cron.day_of_month, day_of_month, day_of_week, last);\n let by_dow = day_of_week_matches(&cron.day_of_week, day_of_month, day_of_week, last);\n match (\n cron.day_of_month == DayOfMonth::All,\n cron.day_of_week == DayOfWeek::All,\n ) {\n (true, true) => true,\n (false, true) => by_dom,\n (true, false) => by_dow,\n (false, false) => by_dom || by_dow,\n }\n}\n\n/// Saturday and Sunday. `W` moves off these two and onto the nearest of the\n/// other five, which is the whole content of the character.\nfn is_weekend(day_of_week: u32) -> bool {\n day_of_week == 0 || day_of_week == 6\n}\n\nfn days_in_month(year: i64, month: u32) -> u32 {\n match month {\n 1 | 3 | 5 | 7 | 8 | 10 | 12 => 31,\n 4 | 6 | 9 | 11 => 30,\n _ => {\n let leap = year % 4 == 0 && (year % 100 != 0 || year % 400 == 0);\n if leap {\n 29\n } else {\n 28\n }\n }\n }\n}\n\n/// Each `W` arm below is Cloudflare's, condition for condition. `W` never\n/// leaves the month: the day it names moves back to Friday or forward to\n/// Monday, and the arms that look redundant are the ones that catch a month\n/// which begins or ends on a weekend.\nfn day_of_month_matches(field: &DayOfMonth, day: u32, weekday: u32, last: u32) -> bool {\n match *field {\n DayOfMonth::All => true,\n DayOfMonth::Days(days) => days & (1 << day) != 0,\n DayOfMonth::Last => day == last,\n DayOfMonth::LastOffset(offset) => day + offset == last,\n DayOfMonth::LastWeekday => {\n (!is_weekend(weekday) && day == last) || (weekday == 5 && last - day < 3)\n }\n DayOfMonth::LastOffsetWeekday(offset) => {\n let target = day + offset;\n (!is_weekend(weekday) && target == last)\n || (weekday == 1 && target > last && target - last < 3)\n || (weekday == 5 && target + 1 == last)\n }\n DayOfMonth::ClosestWeekday(target) => {\n (!is_weekend(weekday) && day == target)\n || (weekday == 1 && day > 1 && day - 1 == target)\n // The 1st falls on a Saturday and the 2nd on a Sunday, so the\n // nearest weekday inside the month is Monday the 3rd.\n || (weekday == 1 && day == 3 && target == 1)\n || (weekday == 5 && day + 1 == target)\n // The target is the last day of the month and falls on a\n // Sunday, so the move back is two days rather than one.\n || (weekday == 5 && day + 2 == target && target == last)\n }\n }\n}\n\nfn day_of_week_matches(field: &DayOfWeek, day: u32, weekday: u32, last: u32) -> bool {\n match *field {\n DayOfWeek::All => true,\n DayOfWeek::Days(days) => days & (1 << weekday) != 0,\n DayOfWeek::Last(wanted) => weekday == wanted && day + 7 > last,\n DayOfWeek::Nth(wanted, nth) => weekday == wanted && (day - 1) / 7 + 1 == nth,\n }\n}\n\n/// The first occurrence strictly after `after_ms`, or `None` when the\n/// expression cannot match within [`MAX_LOOKAHEAD_DAYS`].\n///\n/// Strictly after is what makes a re-arm from inside the handler terminate: an\n/// occurrence that returned itself would arm an alarm already due and spin.\npub fn next_after(cron: &Cron, after_ms: Ms) -> Option {\n let start = after_ms.div_euclid(60_000) + 1;\n let mut time = start.rem_euclid(1440);\n for day in (start.div_euclid(1440)..).take(MAX_LOOKAHEAD_DAYS) {\n if day_matches(cron, day) {\n if let Some(found) = next_time_of_day(cron, time) {\n return Some((day * 1440 + found) * 60_000);\n }\n }\n time = 0;\n }\n None\n}\n\n/// The first minute-of-day at or after `from` whose hour and minute both\n/// match, walking hours so an unmatched hour costs one step rather than sixty.\nfn next_time_of_day(cron: &Cron, from: i64) -> Option {\n let (mut hour, mut minute) = (from / 60, from % 60);\n while hour < 24 {\n if cron.hour & (1 << hour) != 0 {\n while minute < 60 {\n if cron.minute & (1 << minute) != 0 {\n return Some(hour * 60 + minute);\n }\n minute += 1;\n }\n }\n hour += 1;\n minute = 0;\n }\n None\n}\n\n/// The earliest next occurrence across every expression on a script. This is\n/// what the reserved cron cell arms, because one alarm row holds one deadline\n/// however many expressions the script declares.\npub fn next_across(crons: &[Cron], after_ms: Ms) -> Option {\n crons\n .iter()\n .filter_map(|cron| next_after(cron, after_ms))\n .min()\n}\n\n/// Which expressions match a fired occurrence, by index. A single deadline can\n/// belong to several expressions, and Cloudflare invokes `scheduled` once per\n/// matching cron, so the fan-out happens here rather than at arm time.\npub fn matching(crons: &[Cron], at_ms: Ms) -> Vec {\n crons\n .iter()\n .enumerate()\n .filter(|(_, cron)| matches(cron, at_ms))\n .map(|(index, _)| index)\n .collect()\n}\n\n/// When to re-arm after a `scheduled` handler failed.\n///\n/// A cell has one alarm row, so a retry and the next occurrence compete for\n/// the same deadline. The next occurrence wins whenever it is sooner: a\n/// failing cron then retries with the usual backoff — `alarm::alarm_retry`\n/// computes `retry_ms`, this does not fork it — but can never delay or skip a\n/// scheduled run. A cron faster than the backoff simply never retries, which\n/// is the right trade when the next attempt is seconds away anyway.\n///\n/// `retry_ms` is `None` when the retry ceiling is reached and `next_ms` is\n/// `None` when no expression matches again; with both absent there is nothing\n/// left to arm and the cell retires.\npub fn cron_rearm(next_ms: Option, retry_ms: Option) -> Option {\n match (next_ms, retry_ms) {\n (Some(next), Some(retry)) => Some(next.min(retry)),\n (next, None) => next,\n (None, retry) => retry,\n }\n}\n\n/// The reserved cron cell's whole schedule decision, in one place so no\n/// engine arm keeps a copy that can drift from it.\npub struct Plan {\n /// Which expressions the fired occurrence belongs to, by index.\n pub matching: Vec,\n /// When to arm next, or `None` when the schedule is exhausted and the\n /// cell retires.\n pub arm_at: Option,\n /// Whether that deadline is the failure backoff rather than the next\n /// occurrence. `cron_rearm` takes the earlier and gives a tie to the\n /// occurrence, so `arm_at` alone cannot say, and the caller has to\n /// know: a retry owes the expressions that failed, an occurrence owes\n /// the ones that match it.\n pub arm_is_retry: bool,\n}\n\n/// `fired_ms` is the occurrence being handled, or `None` when the cell is\n/// only arming. `retry` counts the failures within that occurrence and\n/// `failed` says whether any expression of it is still owed.\npub fn plan(crons: &[Cron], fired_ms: Option, now_ms: Ms, retry: i64, failed: bool) -> Plan {\n let matching = fired_ms.map(|at| matching(crons, at)).unwrap_or_default();\n let next = next_across(crons, now_ms);\n // The retry backoff is `alarm::alarm_retry`'s, not a second schedule:\n // a cron that fails behaves like any other failing alarm, except that\n // `cron_rearm` never lets the backoff outlast the next occurrence.\n let retry_at = failed\n .then(|| crate::alarm::alarm_retry(now_ms, retry, retry, true))\n .flatten();\n let arm_at = cron_rearm(next, retry_at);\n let arm_is_retry = match (arm_at, next) {\n (Some(at), Some(occurrence)) => at < occurrence,\n (Some(_), None) => true,\n (None, _) => false,\n };\n Plan {\n matching,\n arm_at,\n arm_is_retry,\n }\n}\n","editable",false,"branch","documentNavigation","repo","denoland/celld","repoId","a23b8a10-92cf-4dc4-a7ab-a04e58298dde","ownerId","org:42048915","organization",true,"site","nexthub","private","admin","settings","maintainer","triage","starred","stars",1,"watchers","watching","pinned","notify","views",[135,136,137,138,139,140,141,142,143,144,145,146,147],"navigation",{"_57":58,"_93":94,"_95":96,"_97":98,"_99":100,"_101":102,"_103":104},"sources",[],"viewer","meta",{"_85":86,"_87":88,"_89":90,"_45":32,"_91":14,"_92":32,"_51":52,"_53":52},"branches",[14],"tags",[72,73,74,75,76,77,78,79,80,81,82,83,84],"cloneUrl","https://git.nexthub.sh/denoland/celld.git","v0.0.1","v0.0.2","v0.1.0","v0.2.0","v0.2.1","v0.3.0","v0.4.0","v0.4.1","v0.5.0","v0.5.1","v0.6.0","v0.6.1","v0.6.2","description","self-hosted, distributed Durable Objects","owner","denoland","section","","head","empty","pins",[118,119,120],"documents",{"_113":114,"_115":116},"code",{"_110":111,"_112":106},"automations",{"_108":52,"_109":-5},"delivery",{"_105":106,"_107":-5},"tag","7gTA52Z9a1vO6FP6eCQPix9zO4O","releases",0,"applications","workflows","deployments","commits",13,"changes","counts",{"_117":116},"total",38,"issue",{"_121":112,"_123":133,"_15":112,"_125":134,"_55":42,"_127":32,"_128":42,"_129":106},{"_121":130,"_123":131,"_15":130,"_125":132,"_55":42,"_127":32,"_128":42,"_129":106},{"_121":122,"_123":124,"_15":122,"_125":126,"_55":42,"_127":32,"_128":42,"_129":116},"id","issues","name","Issues","filters",{},"saved","pinnable","count","tasks","Tasks",{},"Changes",{},{"_121":112,"_123":133,"_15":112,"_125":178,"_55":42,"_127":32,"_128":42},{"_121":130,"_123":131,"_15":130,"_125":177,"_55":42,"_127":32,"_128":42},{"_121":122,"_123":124,"_15":122,"_125":176,"_55":42,"_127":32,"_128":42},{"_121":173,"_123":174,"_15":173,"_125":175,"_55":32,"_127":32,"_128":42},{"_121":170,"_123":171,"_15":170,"_125":172,"_55":32,"_127":32,"_128":42},{"_121":108,"_123":168,"_15":99,"_125":169,"_55":32,"_127":32,"_128":42},{"_121":109,"_123":165,"_15":166,"_125":167,"_55":32,"_127":32,"_128":42},{"_121":105,"_123":163,"_15":105,"_125":164,"_55":32,"_127":32,"_128":42},{"_121":159,"_123":160,"_15":161,"_125":162,"_55":32,"_127":32,"_128":42},{"_121":95,"_123":157,"_15":95,"_125":158,"_55":32,"_127":32,"_128":32},{"_121":154,"_123":155,"_15":154,"_125":156,"_55":32,"_127":32,"_128":32},{"_121":151,"_123":152,"_15":151,"_125":153,"_55":32,"_127":32,"_128":32},{"_121":148,"_123":149,"_15":148,"_125":150,"_55":32,"_127":32,"_128":32},"decisions","Decisions",{},"changelog","Changelog",{},"roadmap","Roadmap",{},"Documents",{},"activity","Activity","insights",{},"Releases",{},"Deployments","automations/deployments",{},"Workflows",{},"discussions","Discussions",{},"goals","Goals",{},{},{},{},"groups","user","agents",[],"now",1794689990124,"sidebar","expanded"]