@blamejs/blamejs-shop 0.5.12 → 0.5.13

package/lib/vendor/blamejs/test/layer-0-primitives/calendar.test.js

@@ -867,6 +867,532 @@ function testJmapCatalogueCarriesCalendarMethods() {
   check("CalendarEvent/get accepted in JMAP catalogue", reg && typeof reg.dispatch === "function");
 }
 
+// ---- Uncovered error / adversarial / defensive / option-default branches ----
+
+function _expectValidateCode(label, jsCal, codeFragment) {
+  var threw = null;
+  try { b.calendar.validate(jsCal); } catch (e) { threw = e; }
+  check(label, threw && (threw.code || "").indexOf(codeFragment) !== -1);
+}
+
+function testValidateOversizeUid() {
+  // uid length cap (RFC-shape anti-DoS). A 1025-char uid is refused
+  // with the dedicated code; a 1024-char uid is accepted.
+  var bigUid = new Array(1026).join("u");                                                              // 1025 chars
+  check("oversize-uid length precondition", bigUid.length === 1025);
+  _expectValidateCode("uid > 1024 bytes refused",
+    { "@type": "Event", uid: bigUid, updated: "2026-05-21T10:00:00Z" }, "calendar/oversize-uid");
+  var okUid = new Array(1025).join("u");                                                               // exactly 1024 chars
+  var rv = b.calendar.validate({ "@type": "Event", uid: okUid, updated: "2026-05-21T10:00:00Z" });
+  check("uid == 1024 bytes accepted", rv && rv.uid.length === 1024);
+}
+
+function testValidateEventBadStart() {
+  // Event.start present but not a LocalDateTime.
+  _expectValidateCode("Event non-string start refused",
+    { "@type": "Event", uid: "x", updated: "2026-05-21T10:00:00Z", start: 20260522 }, "calendar/bad-start");
+  _expectValidateCode("Event malformed start string refused",
+    { "@type": "Event", uid: "x", updated: "2026-05-21T10:00:00Z", start: "2026-05-22 09:00" }, "calendar/bad-start");
+  // A UTC-suffixed start is NOT a LocalDateTime (Z is disallowed on start).
+  _expectValidateCode("Event start with Z suffix refused (LocalDateTime has no Z)",
+    { "@type": "Event", uid: "x", updated: "2026-05-21T10:00:00Z", start: "2026-05-22T09:00:00Z" }, "calendar/bad-start");
+}
+
+function testValidateTaskBadStart() {
+  _expectValidateCode("Task non-string start refused",
+    { "@type": "Task", uid: "x", updated: "2026-05-21T10:00:00Z", start: 5 }, "calendar/bad-start");
+  _expectValidateCode("Task malformed start refused",
+    { "@type": "Task", uid: "x", updated: "2026-05-21T10:00:00Z", start: "yesterday" }, "calendar/bad-start");
+}
+
+function testValidateTaskBadProgressUpdated() {
+  // progressUpdated MUST be a UTCDateTime (has the Z suffix).
+  _expectValidateCode("Task non-string progressUpdated refused",
+    { "@type": "Task", uid: "x", updated: "2026-05-21T10:00:00Z", progressUpdated: 12345 },
+    "calendar/bad-progress-updated");
+  _expectValidateCode("Task LocalDateTime progressUpdated refused (needs Z)",
+    { "@type": "Task", uid: "x", updated: "2026-05-21T10:00:00Z", progressUpdated: "2026-05-21T10:00:00" },
+    "calendar/bad-progress-updated");
+  var rv = b.calendar.validate({
+    "@type": "Task", uid: "x", updated: "2026-05-21T10:00:00Z", progressUpdated: "2026-05-21T09:30:00Z",
+  });
+  check("valid Task progressUpdated accepted", rv && rv.progressUpdated === "2026-05-21T09:30:00Z");
+}
+
+function testValidateNoteBadStart() {
+  _expectValidateCode("Note non-string start refused",
+    { "@type": "Note", uid: "x", updated: "2026-05-21T10:00:00Z", start: {} }, "calendar/bad-start");
+  _expectValidateCode("Note malformed start refused",
+    { "@type": "Note", uid: "x", updated: "2026-05-21T10:00:00Z", start: "2026/05/21" }, "calendar/bad-start");
+}
+
+function testValidateGroupEntryNotObject() {
+  // Group.entries element that is null / non-object / array → bad-entries
+  // via the object-shape guard (distinct from the @type / nesting guard).
+  _expectValidateCode("Group entry null refused",
+    { "@type": "Group", uid: "x", updated: "2026-05-21T10:00:00Z", entries: [null] }, "calendar/bad-entries");
+  _expectValidateCode("Group entry primitive refused",
+    { "@type": "Group", uid: "x", updated: "2026-05-21T10:00:00Z", entries: [42] }, "calendar/bad-entries");
+  _expectValidateCode("Group entry array refused",
+    { "@type": "Group", uid: "x", updated: "2026-05-21T10:00:00Z", entries: [[]] }, "calendar/bad-entries");
+}
+
+function testValidateRecurrenceRulesNotArray() {
+  // recurrenceRules present on a non-Group but not an array.
+  _expectValidateCode("recurrenceRules as string refused",
+    { "@type": "Event", uid: "x", updated: "2026-05-21T10:00:00Z", recurrenceRules: "FREQ=DAILY" },
+    "calendar/bad-recurrence");
+  _expectValidateCode("recurrenceRules as object refused",
+    { "@type": "Event", uid: "x", updated: "2026-05-21T10:00:00Z", recurrenceRules: { frequency: "daily" } },
+    "calendar/bad-recurrence");
+}
+
+function testValidateAlertsObjectMap() {
+  // The alerts object-map validation path (distinct from the
+  // "alerts must be an object" refusal an array triggers).
+  var rv = b.calendar.validate({
+    "@type": "Event", uid: "x", updated: "2026-05-21T10:00:00Z",
+    alerts: {
+      a1: { "@type": "Alert", action: "display" },
+      a2: { "@type": "Alert", action: "email" },
+      a3: { "@type": "Alert" },                                                                        // action optional
+    },
+  });
+  check("valid alerts object map accepted", rv && rv["@type"] === "Event");
+  _expectValidateCode("alert with wrong @type refused",
+    { "@type": "Event", uid: "x", updated: "2026-05-21T10:00:00Z",
+      alerts: { a1: { "@type": "Reminder", action: "display" } } }, "calendar/bad-alerts");
+  _expectValidateCode("alert with null value refused",
+    { "@type": "Event", uid: "x", updated: "2026-05-21T10:00:00Z",
+      alerts: { a1: null } }, "calendar/bad-alerts");
+  _expectValidateCode("alert with unknown action refused",
+    { "@type": "Event", uid: "x", updated: "2026-05-21T10:00:00Z",
+      alerts: { a1: { "@type": "Alert", action: "vibrate" } } }, "calendar/bad-alerts");
+}
+
+function testFromIcalTzidParamPreservedAsString() {
+  // A DTSTART;TZID=<zone> parameter must map to JSCalendar
+  // `timeZone` as a STRING (RFC 8984 §4.7.1 TimeZoneId is a String),
+  // not the raw multi-valued parameter array safeIcal exposes.
+  var ical =
+    "BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:-//x//EN\r\n" +
+    "BEGIN:VEVENT\r\nUID:tz@x\r\nDTSTAMP:20260521T100000Z\r\n" +
+    "DTSTART;TZID=America/New_York:20260522T090000\r\nDURATION:PT1H\r\nSUMMARY:tz\r\n" +
+    "END:VEVENT\r\nEND:VCALENDAR\r\n";
+  var ev = b.calendar.fromIcal(ical);
+  check("VEVENT TZID → timeZone is a string", typeof ev.timeZone === "string");
+  check("VEVENT TZID → timeZone value", ev.timeZone === "America/New_York");
+  // Round-trips back to a TZID-parameterized DTSTART.
+  var back = b.calendar.toIcal(ev);
+  check("toIcal re-emits DTSTART;TZID from a named zone",
+        /DTSTART;TZID=America\/New_York:20260522T090000/.test(back));
+}
+
+function testToIcalNamedTimeZoneEmitsTzid() {
+  // Event with a named (non-UTC) timeZone → DTSTART;TZID=<zone>.
+  var ev = {
+    "@type":  "Event",
+    uid:      "named-tz",
+    updated:  "2026-05-21T10:00:00Z",
+    title:    "Standup",
+    start:    "2026-05-22T09:00:00",
+    duration: "PT1H",
+    timeZone: "Europe/Berlin",
+  };
+  var ical = b.calendar.toIcal(ev);
+  check("named timeZone emits DTSTART;TZID", /DTSTART;TZID=Europe\/Berlin:20260522T090000/.test(ical));
+  check("named timeZone does NOT emit a Z-suffixed DTSTART", !/DTSTART:20260522T090000Z/.test(ical));
+}
+
+function testToIcalTaskDueTimeZones() {
+  // VTODO DUE property honours the same UTC / TZID / floating handling
+  // as DTSTART.
+  var utcTask = {
+    "@type":  "Task",
+    uid:      "due-utc",
+    updated:  "2026-05-21T10:00:00Z",
+    title:    "Ship",
+    due:      "2026-05-22T17:00:00",
+    timeZone: "Etc/UTC",
+  };
+  var utcIcal = b.calendar.toIcal(utcTask);
+  check("VTODO DUE with Etc/UTC emits Z suffix", /DUE:20260522T170000Z/.test(utcIcal));
+
+  var tzTask = {
+    "@type":  "Task",
+    uid:      "due-tz",
+    updated:  "2026-05-21T10:00:00Z",
+    title:    "Ship",
+    due:      "2026-05-22T17:00:00",
+    timeZone: "America/Chicago",
+  };
+  var tzIcal = b.calendar.toIcal(tzTask);
+  check("VTODO DUE with named zone emits TZID", /DUE;TZID=America\/Chicago:20260522T170000/.test(tzIcal));
+}
+
+function testToIcalEmitsRruleWithAllParts() {
+  // toIcal serializes recurrenceRules → RRULE, exercising the full
+  // _recurrenceRuleToIcal serializer (INTERVAL / COUNT / UNTIL / BYDAY /
+  // BYMONTH / BYMONTHDAY).
+  var ev = {
+    "@type":  "Event",
+    uid:      "rrule-out",
+    updated:  "2026-05-21T10:00:00Z",
+    title:    "Cadence",
+    start:    "2026-05-22T09:00:00",
+    timeZone: "Etc/UTC",
+    recurrenceRules: [{
+      "@type":     "RecurrenceRule",
+      frequency:   "monthly",
+      interval:    2,
+      count:       6,
+      until:       "2027-01-01T00:00:00Z",
+      byDay:       [{ "@type": "NDay", day: "mo" }, { "@type": "NDay", day: "we" }],
+      byMonth:     [3, 6, 9, 12],
+      byMonthDay:  [1, 15],
+    }],
+  };
+  var ical = b.calendar.toIcal(ev);
+  var rruleLine = ical.split("\r\n").filter(function (l) { return l.indexOf("RRULE:") === 0; })[0] || "";
+  check("toIcal emits an RRULE line", rruleLine.indexOf("FREQ=MONTHLY") !== -1);
+  check("RRULE carries INTERVAL",     rruleLine.indexOf("INTERVAL=2") !== -1);
+  check("RRULE carries COUNT",        rruleLine.indexOf("COUNT=6") !== -1);
+  check("RRULE carries UNTIL",        rruleLine.indexOf("UNTIL=20270101T000000Z") !== -1);
+  check("RRULE carries BYDAY upper",  rruleLine.indexOf("BYDAY=MO,WE") !== -1);
+  check("RRULE carries BYMONTH",      rruleLine.indexOf("BYMONTH=3,6,9,12") !== -1);
+  check("RRULE carries BYMONTHDAY",   rruleLine.indexOf("BYMONTHDAY=1,15") !== -1);
+}
+
+function testExpandRecurrenceNoRules() {
+  // No recurrenceRules → a single-instance (the start) or empty set.
+  var withStart = b.calendar.expandRecurrence(
+    { "@type": "Event", uid: "single", updated: "2026-05-21T10:00:00Z", start: "2026-05-22T09:00:00" }, {});
+  check("no rules + start → single instance", withStart.length === 1 && withStart[0] === "2026-05-22T09:00:00Z");
+  var noStart = b.calendar.expandRecurrence(
+    { "@type": "Event", uid: "empty", updated: "2026-05-21T10:00:00Z" }, {});
+  check("no rules + no start → empty set", Array.isArray(noStart) && noStart.length === 0);
+  // Also exercised when recurrenceRules is an empty array.
+  var emptyRules = b.calendar.expandRecurrence(
+    { "@type": "Event", uid: "emptyrr", updated: "2026-05-21T10:00:00Z",
+      start: "2026-05-22T09:00:00", recurrenceRules: [] }, {});
+  check("empty recurrenceRules array → single instance", emptyRules.length === 1);
+}
+
+function testExpandWindowToBeforeFrom() {
+  var ev = {
+    "@type":  "Event",
+    uid:      "bad-window",
+    updated:  "2026-05-21T10:00:00Z",
+    start:    "2026-05-22T09:00:00",
+    recurrenceRules: [{ "@type": "RecurrenceRule", frequency: "daily", count: 5 }],
+  };
+  var threw = null;
+  try { b.calendar.expandRecurrence(ev, { from: "2026-06-01T00:00:00Z", to: "2026-05-01T00:00:00Z" }); }
+  catch (e) { threw = e; }
+  check("expand with to < from refused",
+        threw && (threw.code || "").indexOf("calendar/bad-expansion-window") !== -1);
+}
+
+function testExpandRecurrenceRulesButNoStart() {
+  // recurrenceRules present but no start → the start becomes unparseable
+  // and expansion fails closed with calendar/bad-start.
+  var ev = {
+    "@type":  "Event",
+    uid:      "rules-no-start",
+    updated:  "2026-05-21T10:00:00Z",
+    recurrenceRules: [{ "@type": "RecurrenceRule", frequency: "daily", count: 3 }],
+  };
+  var threw = null;
+  try { b.calendar.expandRecurrence(ev, { from: "2026-05-22T00:00:00Z", to: "2026-06-01T00:00:00Z" }); }
+  catch (e) { threw = e; }
+  check("expand with rules but no start refused",
+        threw && (threw.code || "").indexOf("calendar/bad-start") !== -1);
+}
+
+function testExpandRecurrenceByMonthDay() {
+  // FREQ=DAILY;BYMONTHDAY=1,15 — only the 1st and 15th of each month fire.
+  var ev = {
+    "@type":  "Event",
+    uid:      "bymonthday",
+    updated:  "2026-05-21T10:00:00Z",
+    start:    "2026-05-01T09:00:00",
+    timeZone: "Etc/UTC",
+    recurrenceRules: [{ "@type": "RecurrenceRule", frequency: "daily",
+                        byMonthDay: [1, 15], count: 4 }],
+  };
+  var insts = b.calendar.expandRecurrence(ev, { from: "2026-05-01T00:00:00Z", to: "2026-08-01T00:00:00Z" });
+  check("BYMONTHDAY=1,15 emits 4 instances", insts.length === 4);
+  check("first is May 1",  insts[0] === "2026-05-01T09:00:00Z");
+  check("second is May 15", insts[1] === "2026-05-15T09:00:00Z");
+  check("third is Jun 1",  insts[2] === "2026-06-01T09:00:00Z");
+  check("every instance is a 1st or 15th",
+        insts.every(function (s) { return /-(01|15)T/.test(s); }));
+}
+
+function testBysetposWeeklyPeriod() {
+  // BYSETPOS with FREQ=WEEKLY exercises the weekly period-anchoring
+  // branch of _periodForIndex (WKST=Monday alignment).
+  var ev = {
+    "@type":  "Event",
+    uid:      "weekly-setpos",
+    updated:  "2026-05-21T10:00:00Z",
+    start:    "2026-05-04T09:00:00",                                                                   // Monday
+    timeZone: "Etc/UTC",
+    recurrenceRules: [{ "@type": "RecurrenceRule", frequency: "weekly",
+                        byDay: ["MO", "TU", "WE", "TH", "FR"], bySetPos: [1], count: 3 }],
+  };
+  var insts = b.calendar.expandRecurrence(ev, { from: "2026-05-01T00:00:00Z", to: "2026-06-15T00:00:00Z" });
+  check("weekly BYSETPOS=1 emits 3 instances", insts.length === 3);
+  check("first weekday of week 1 (Mon May 4)", insts[0] === "2026-05-04T09:00:00Z");
+  check("first weekday of week 2 (Mon May 11)", insts[1] === "2026-05-11T09:00:00Z");
+}
+
+function testFromIcalVtodoTzidLocationAndRrule() {
+  // VTODO carrying a TZID param, a LOCATION, and an RRULE.
+  var ical =
+    "BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:-//x//EN\r\n" +
+    "BEGIN:VTODO\r\nUID:vt-tz@x\r\nDTSTAMP:20260521T100000Z\r\n" +
+    "DTSTART;TZID=Asia/Tokyo:20260522T090000\r\nDUE;TZID=Asia/Tokyo:20260522T170000\r\n" +
+    "LOCATION:HQ Floor 3\r\nRRULE:FREQ=WEEKLY;COUNT=4\r\nSUMMARY:Standup task\r\n" +
+    "END:VTODO\r\nEND:VCALENDAR\r\n";
+  var task = b.calendar.fromIcal(ical);
+  check("VTODO TZID → timeZone string", task.timeZone === "Asia/Tokyo");
+  check("VTODO LOCATION → locations[]", task.locations && task.locations.L1 &&
+                                        task.locations.L1.name === "HQ Floor 3");
+  check("VTODO RRULE → recurrenceRules", Array.isArray(task.recurrenceRules) &&
+                                         task.recurrenceRules[0].frequency === "weekly");
+}
+
+function testFromIcalVtodoUtcSuffix() {
+  // VTODO with a Z-suffixed DTSTART (no TZID) → timeZone "Etc/UTC".
+  var ical =
+    "BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:-//x//EN\r\n" +
+    "BEGIN:VTODO\r\nUID:vt-utc@x\r\nDTSTAMP:20260521T100000Z\r\n" +
+    "DTSTART:20260522T090000Z\r\nSUMMARY:UTC task\r\n" +
+    "END:VTODO\r\nEND:VCALENDAR\r\n";
+  var task = b.calendar.fromIcal(ical);
+  check("VTODO Z-suffix DTSTART → Etc/UTC", task.timeZone === "Etc/UTC");
+  check("VTODO start LocalDateTime stripped of Z", task.start === "2026-05-22T09:00:00");
+}
+
+function testFromIcalVjournalTzidLocationAndRrule() {
+  // VJOURNAL carrying a TZID param, a LOCATION, and an RRULE.
+  var ical =
+    "BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:-//x//EN\r\n" +
+    "BEGIN:VJOURNAL\r\nUID:vj-tz@x\r\nDTSTAMP:20260521T100000Z\r\n" +
+    "DTSTART;TZID=Europe/Paris:20260521T120000\r\nLOCATION:Paris Office\r\n" +
+    "RRULE:FREQ=MONTHLY;COUNT=3\r\nSUMMARY:Journal\r\n" +
+    "END:VJOURNAL\r\nEND:VCALENDAR\r\n";
+  var note = b.calendar.fromIcal(ical);
+  check("VJOURNAL TZID → timeZone string", note.timeZone === "Europe/Paris");
+  check("VJOURNAL LOCATION → locations[]", note.locations && note.locations.L1 &&
+                                           note.locations.L1.name === "Paris Office");
+  check("VJOURNAL RRULE → recurrenceRules", Array.isArray(note.recurrenceRules) &&
+                                            note.recurrenceRules[0].frequency === "monthly");
+}
+
+function testFromIcalVjournalNoDescription() {
+  // VJOURNAL with no DESCRIPTION property → description stays unset
+  // (exercises the empty-values branch of the description join).
+  var ical =
+    "BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:-//x//EN\r\n" +
+    "BEGIN:VJOURNAL\r\nUID:vj-nodesc@x\r\nDTSTAMP:20260521T100000Z\r\n" +
+    "SUMMARY:Titled but empty\r\nEND:VJOURNAL\r\nEND:VCALENDAR\r\n";
+  var note = b.calendar.fromIcal(ical);
+  check("VJOURNAL without DESCRIPTION has no description", note.description === undefined);
+  check("VJOURNAL title preserved", note.title === "Titled but empty");
+}
+
+function testFromIcalRruleByMonthDay() {
+  // The ical→jscal RRULE parser maps BYMONTHDAY to integers.
+  var ical =
+    "BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:-//x//EN\r\n" +
+    "BEGIN:VEVENT\r\nUID:rr-bmd@x\r\nDTSTAMP:20260521T100000Z\r\n" +
+    "DTSTART:20260501T090000\r\nRRULE:FREQ=MONTHLY;BYMONTHDAY=1,15,-1\r\nSUMMARY:Payroll\r\n" +
+    "END:VEVENT\r\nEND:VCALENDAR\r\n";
+  var ev = b.calendar.fromIcal(ical);
+  check("RRULE BYMONTHDAY parsed to integer array",
+        Array.isArray(ev.recurrenceRules[0].byMonthDay) &&
+        ev.recurrenceRules[0].byMonthDay[0] === 1 &&
+        ev.recurrenceRules[0].byMonthDay[2] === -1);
+}
+
+function testToIcalFoldsLongLine() {
+  // RFC 5545 §3.1 line folding — a >75-octet UID is folded with
+  // CRLF + a leading space.
+  var longUid = new Array(101).join("u") + "@example.com";                                            // 112 chars
+  var ev = { "@type": "Event", uid: longUid, updated: "2026-05-21T10:00:00Z", title: "x" };
+  var ical = b.calendar.toIcal(ev);
+  var uidRegion = ical.slice(ical.indexOf("UID:"));
+  check("long UID line is folded (CRLF + space continuation)", /\r\n /.test(uidRegion));
+  // Reconstruct: strip the CRLF-space fold sequences and read the UID line.
+  var joined = ical.replace(/\r\n /g, "");
+  var uidLine = joined.split("\r\n").filter(function (l) { return l.indexOf("UID:") === 0; })[0];
+  check("unfolded UID matches original", uidLine === "UID:" + longUid);
+}
+
+function testToIcalLocationsAsArray() {
+  // toIcal accepts `locations` as an ARRAY (not only the object map
+  // fromIcal produces), emitting one LOCATION per named entry.
+  var ev = {
+    "@type":   "Event",
+    uid:       "loc-array",
+    updated:   "2026-05-21T10:00:00Z",
+    title:     "Offsite",
+    start:     "2026-05-22T09:00:00",
+    locations: [
+      { "@type": "Location", name: "Room A" },
+      { "@type": "Location", name: "Room B" },
+      { "@type": "Location" },                                                                         // no name → skipped
+    ],
+  };
+  var ical = b.calendar.toIcal(ev);
+  check("locations array emits first LOCATION",  ical.indexOf("LOCATION:Room A") !== -1);
+  check("locations array emits second LOCATION", ical.indexOf("LOCATION:Room B") !== -1);
+  check("nameless location entry is skipped",    (ical.match(/LOCATION:/g) || []).length === 2);
+}
+
+function testFromIcalBareComponentDefaults() {
+  // A VEVENT lacking UID and DTSTAMP still parses; the missing
+  // required properties default to empty strings (the `|| ""` guards).
+  var ical =
+    "BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:-//x//EN\r\n" +
+    "BEGIN:VEVENT\r\nSUMMARY:Bare event\r\nEND:VEVENT\r\nEND:VCALENDAR\r\n";
+  var ev = b.calendar.fromIcal(ical);
+  check("bare VEVENT uid defaults to empty string", ev.uid === "");
+  check("bare VEVENT updated defaults to empty string", ev.updated === "");
+  check("bare VEVENT title preserved", ev.title === "Bare event");
+}
+
+function testExpandRecurrenceDefaultOpts() {
+  // expandRecurrence called with NO opts argument — opts defaults to {},
+  // no from/to window, count bounds the set.
+  var ev = {
+    "@type":  "Event",
+    uid:      "no-opts",
+    updated:  "2026-05-21T10:00:00Z",
+    start:    "2026-05-22T09:00:00",
+    recurrenceRules: [{ "@type": "RecurrenceRule", frequency: "daily", count: 3 }],
+  };
+  var insts = b.calendar.expandRecurrence(ev);
+  check("expand with no opts uses defaults + count", insts.length === 3);
+  check("expand with no opts first instance at start", insts[0] === "2026-05-22T09:00:00Z");
+}
+
+function testFromIcalMalformedRruleSegmentSkipped() {
+  // A RRULE segment without an '=' (e.g. a stray token) is skipped
+  // rather than corrupting the parsed rule.
+  var ical =
+    "BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:-//x//EN\r\n" +
+    "BEGIN:VEVENT\r\nUID:rr-junk@x\r\nDTSTAMP:20260521T100000Z\r\n" +
+    "DTSTART:20260501T090000\r\nRRULE:FREQ=WEEKLY;GARBAGE;COUNT=3\r\nSUMMARY:x\r\n" +
+    "END:VEVENT\r\nEND:VCALENDAR\r\n";
+  var ev = b.calendar.fromIcal(ical);
+  check("malformed RRULE segment skipped; freq parsed", ev.recurrenceRules[0].frequency === "weekly");
+  check("malformed RRULE segment skipped; count parsed", ev.recurrenceRules[0].count === 3);
+}
+
+function testFromIcalBareVtodoAndVjournalDefaults() {
+  // Bare VTODO / VJOURNAL (no UID / DTSTAMP) still parse, defaulting the
+  // required properties to empty strings.
+  var vtodoIcal =
+    "BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:-//x//EN\r\n" +
+    "BEGIN:VTODO\r\nSUMMARY:Bare task\r\nEND:VTODO\r\nEND:VCALENDAR\r\n";
+  var task = b.calendar.fromIcal(vtodoIcal);
+  check("bare VTODO uid defaults to empty string", task.uid === "");
+  check("bare VTODO updated defaults to empty string", task.updated === "");
+  check("bare VTODO @type Task", task["@type"] === "Task");
+
+  var vjournalIcal =
+    "BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:-//x//EN\r\n" +
+    "BEGIN:VJOURNAL\r\nSUMMARY:Bare note\r\nEND:VJOURNAL\r\nEND:VCALENDAR\r\n";
+  var note = b.calendar.fromIcal(vjournalIcal);
+  check("bare VJOURNAL uid defaults to empty string", note.uid === "");
+  check("bare VJOURNAL updated defaults to empty string", note.updated === "");
+  check("bare VJOURNAL @type Note", note["@type"] === "Note");
+}
+
+function testBysetposWeeklySundayAnchor() {
+  // A weekly BYSETPOS rule whose start falls on a Sunday exercises the
+  // WKST-Monday period anchor's Sunday (getUTCDay() === 0 → 7) branch.
+  var ev = {
+    "@type":  "Event",
+    uid:      "weekly-sunday",
+    updated:  "2026-05-21T10:00:00Z",
+    start:    "2026-05-03T09:00:00",                                                                   // 2026-05-03 is a Sunday
+    timeZone: "Etc/UTC",
+    recurrenceRules: [{ "@type": "RecurrenceRule", frequency: "weekly",
+                        byDay: ["SU"], bySetPos: [1], count: 2 }],
+  };
+  var insts = b.calendar.expandRecurrence(ev, { from: "2026-05-01T00:00:00Z", to: "2026-06-01T00:00:00Z" });
+  check("weekly Sunday-anchored BYSETPOS emits 2", insts.length === 2);
+  check("first Sunday is the start (May 3)", insts[0] === "2026-05-03T09:00:00Z");
+}
+
+function testBysetposUnboundedIntervalTerminates() {
+  // Adversarial DoS — a BYSETPOS rule whose FREQ interval is large
+  // enough that the SECOND period's Date.UTC overflows to NaN (year
+  // 2026 + 300000 is beyond the representable ECMAScript date range).
+  // A NaN period runs the day-enumeration loop zero times, so it never
+  // decrements the shared step budget, and the untilMs / toMs window
+  // breaks are NaN-comparison no-ops — the BYSETPOS expander would
+  // otherwise spin forever. Every accepted recurrenceRule MUST make
+  // expandRecurrence terminate. Driven in a child process with a hard
+  // wall-clock kill so a regression manifests as a killed child rather
+  // than hanging this suite.
+  var childProc = require("child_process");
+  var fs   = require("fs");
+  var os   = require("os");
+  var path = require("path");
+  var calPath = path.resolve(__dirname, "../../lib/calendar");
+  var ev = {
+    "@type":  "Event",
+    uid:      "bysetpos-dos",
+    updated:  "2026-05-21T10:00:00Z",
+    start:    "2026-06-15T09:00:00",
+    timeZone: "Etc/UTC",
+    recurrenceRules: [{ "@type": "RecurrenceRule", frequency: "yearly",
+                        interval: 300000, byDay: ["FR"], bySetPos: [1] }],       // allow:raw-byte-literal — interval large enough to overflow Date.UTC on period 2
+  };
+  var target = path.join(os.tmpdir(),
+    "blamejs-cal-bysetpos-dos-" + process.pid + "-" + Date.now() + ".js");
+  var src =
+    "\"use strict\";\n" +
+    "var cal = require(" + JSON.stringify(calPath) + ");\n" +
+    "cal.expandRecurrence(" + JSON.stringify(ev) + ", {});\n" +
+    "process.stdout.write(\"DONE\");\n";
+  fs.writeFileSync(target, src);
+  var r;
+  try {
+    r = childProc.spawnSync(process.execPath, [target],
+      { timeout: 5000, killSignal: "SIGKILL", encoding: "utf8" });          // allow:raw-byte-literal — child wall-clock kill budget; a fixed tree returns in <100ms
+  } finally {
+    try { fs.unlinkSync(target); } catch (_e) { /* best-effort cleanup */ }
+  }
+  check("BYSETPOS + unbounded interval terminates (no infinite loop)",
+        r.status === 0 && !r.signal && /DONE/.test(r.stdout || ""));
+
+  // Same root, non-BYSETPOS manifestation: the plain step loop does not
+  // hang (it decrements the budget every iteration) but a large interval
+  // makes _advance overflow to NaN, which _msToIsoZ then throws on
+  // (uncaught TimeError → the request crashes). This runs in-process
+  // because it terminates; it must return a bounded array, not throw.
+  var evPlain = {
+    "@type":  "Event",
+    uid:      "interval-dos",
+    updated:  "2026-05-21T10:00:00Z",
+    start:    "2026-06-15T09:00:00",
+    timeZone: "Etc/UTC",
+    recurrenceRules: [{ "@type": "RecurrenceRule", frequency: "yearly",
+                        interval: 300000 }],                                     // allow:raw-byte-literal — interval large enough to overflow Date.UTC on the first advance
+  };
+  var threwPlain = null, instsPlain = null;
+  try { instsPlain = b.calendar.expandRecurrence(evPlain, {}); }
+  catch (e) { threwPlain = e; }
+  check("unbounded interval does not crash the expander (no NaN date throw)",
+        threwPlain === null && Array.isArray(instsPlain));
+}
+
 function run() {
   testSurface();
   testValidateHappyPath();
@@ -914,6 +1440,37 @@ function run() {
   testBysetposRefusesDailyFrequency();
   testMixedVcalendarReturnsArray();
   testJmapCatalogueCarriesCalendarMethods();
+  // Uncovered error / adversarial / defensive / option-default branches.
+  testValidateOversizeUid();
+  testValidateEventBadStart();
+  testValidateTaskBadStart();
+  testValidateTaskBadProgressUpdated();
+  testValidateNoteBadStart();
+  testValidateGroupEntryNotObject();
+  testValidateRecurrenceRulesNotArray();
+  testValidateAlertsObjectMap();
+  testFromIcalTzidParamPreservedAsString();
+  testToIcalNamedTimeZoneEmitsTzid();
+  testToIcalTaskDueTimeZones();
+  testToIcalEmitsRruleWithAllParts();
+  testExpandRecurrenceNoRules();
+  testExpandWindowToBeforeFrom();
+  testExpandRecurrenceRulesButNoStart();
+  testExpandRecurrenceByMonthDay();
+  testBysetposWeeklyPeriod();
+  testFromIcalVtodoTzidLocationAndRrule();
+  testFromIcalVtodoUtcSuffix();
+  testFromIcalVjournalTzidLocationAndRrule();
+  testFromIcalVjournalNoDescription();
+  testFromIcalRruleByMonthDay();
+  testToIcalFoldsLongLine();
+  testToIcalLocationsAsArray();
+  testFromIcalBareComponentDefaults();
+  testExpandRecurrenceDefaultOpts();
+  testFromIcalMalformedRruleSegmentSkipped();
+  testFromIcalBareVtodoAndVjournalDefaults();
+  testBysetposWeeklySundayAnchor();
+  testBysetposUnboundedIntervalTerminates();
 }
 
 module.exports = { run: run };