Docs: Update benchmark results

tests/7_scheduler/outputs/anthropic_claude-opus-4.5 TEMP_0.7.js

@@ -7,71 +7,70 @@ async function findAvailableSlots(calendar1, calendar2, constraints) {
   const [whStartH, whStartM] = workHours.start.split(':').map(Number);
   const [whEndH, whEndM] = workHours.end.split(':').map(Number);
   
-  const busyIntervals = [...calendar1, ...calendar2]
-    .map(b => Interval.fromDateTimes(
-      DateTime.fromISO(b.start, { zone: 'utc' }),
-      DateTime.fromISO(b.end, { zone: 'utc' })
-    ))
-    .filter(i => i.isValid)
+  const allBusy = [...calendar1, ...calendar2]
+    .map(b => ({
+      start: DateTime.fromISO(b.start, { zone: 'utc' }),
+      end: DateTime.fromISO(b.end, { zone: 'utc' })
+    }))
+    .filter(b => b.end > rangeStart && b.start < rangeEnd)
     .sort((a, b) => a.start - b.start);
   
   const merged = [];
-  for (const interval of busyIntervals) {
-    if (!merged.length || merged[merged.length - 1].end < interval.start) {
-      merged.push(interval);
+  for (const b of allBusy) {
+    if (!merged.length || b.start > merged[merged.length - 1].end) {
+      merged.push({ start: b.start, end: b.end });
     } else {
-      const last = merged.pop();
-      merged.push(Interval.fromDateTimes(
-        last.start,
-        last.end > interval.end ? last.end : interval.end
-      ));
+      merged[merged.length - 1].end = DateTime.max(merged[merged.length - 1].end, b.end);
     }
   }
   
-  const freeIntervals = [];
+  const free = [];
   let cursor = rangeStart;
-  for (const busy of merged) {
-    if (busy.start > cursor && busy.start <= rangeEnd) {
-      freeIntervals.push(Interval.fromDateTimes(cursor, busy.start < rangeEnd ? busy.start : rangeEnd));
+  for (const b of merged) {
+    if (b.start > cursor) {
+      free.push({ start: cursor, end: b.start });
     }
-    cursor = busy.end > cursor ? busy.end : cursor;
+    cursor = DateTime.max(cursor, b.end);
   }
   if (cursor < rangeEnd) {
-    freeIntervals.push(Interval.fromDateTimes(cursor, rangeEnd));
+    free.push({ start: cursor, end: rangeEnd });
   }
   
-  const getWorkInterval = day => {
-    const start = day.set({ hour: whStartH, minute: whStartM, second: 0, millisecond: 0 });
-    const end = day.set({ hour: whEndH, minute: whEndM, second: 0, millisecond: 0 });
-    return start < end ? Interval.fromDateTimes(start, end) : null;
+  const getWorkWindow = (day) => {
+    const ws = day.set({ hour: whStartH, minute: whStartM, second: 0, millisecond: 0 });
+    const we = day.set({ hour: whEndH, minute: whEndM, second: 0, millisecond: 0 });
+    return { start: ws, end: we };
   };
   
   const slots = [];
   
-  for (const free of freeIntervals) {
-    let day = free.start.startOf('day');
-    const endDay = free.end.startOf('day');
+  for (const f of free) {
+    let day = f.start.startOf('day');
+    const lastDay = f.end.startOf('day');
     
-    while (day <= endDay) {
-      const workInt = getWorkInterval(day);
-      if (workInt) {
-        const intersection = free.intersection(workInt);
-        if (intersection && intersection.length('minutes') >= durationMinutes) {
-          let slotStart = intersection.start;
-          while (slotStart.plus({ minutes: durationMinutes }) <= intersection.end) {
-            const slotEnd = slotStart.plus({ minutes: durationMinutes });
-            slots.push({
-              start: slotStart.toISO({ suppressMilliseconds: true }),
-              end: slotEnd.toISO({ suppressMilliseconds: true })
-            });
-            slotStart = slotEnd;
-          }
+    while (day <= lastDay) {
+      const ww = getWorkWindow(day);
+      const effStart = DateTime.max(f.start, ww.start, rangeStart);
+      const effEnd = DateTime.min(f.end, ww.end, rangeEnd);
+      
+      if (effStart < effEnd) {
+        let slotStart = effStart;
+        while (true) {
+          const slotEnd = slotStart.plus({ minutes: durationMinutes });
+          if (slotEnd > effEnd) break;
+          slots.push({
+            start: slotStart.toISO(),
+            end: slotEnd.toISO()
+          });
+          slotStart = slotEnd;
         }
       }
       day = day.plus({ days: 1 });
     }
   }
   
-  return slots.sort((a, b) => a.start.localeCompare(b.start));
+  return slots;
 }
-export default findAvailableSlots;
+export default findAvailableSlots;
+// Generation time: 12.726s
+// Result: PASS