flakiness 0.0.0 → 0.146.1

package/lib/cli/cli.js

@@ -0,0 +1,1980 @@
+#!/usr/bin/env node
+
+// src/cli/cli.ts
+import { showReport } from "@flakiness/sdk";
+import { FlakinessProjectConfig as FlakinessProjectConfig4 } from "@flakiness/sdk/flakinessProjectConfig";
+
+// ../node_modules/vlq/src/index.js
+var char_to_integer = {};
+var integer_to_char = {};
+"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".split("").forEach(function(char, i) {
+  char_to_integer[char] = i;
+  integer_to_char[i] = char;
+});
+function decode(string) {
+  let result = [];
+  let shift = 0;
+  let value = 0;
+  for (let i = 0; i < string.length; i += 1) {
+    let integer = char_to_integer[string[i]];
+    if (integer === void 0) {
+      throw new Error("Invalid character (" + string[i] + ")");
+    }
+    const has_continuation_bit = integer & 32;
+    integer &= 31;
+    value += integer << shift;
+    if (has_continuation_bit) {
+      shift += 5;
+    } else {
+      const should_negate = value & 1;
+      value >>>= 1;
+      if (should_negate) {
+        result.push(value === 0 ? -2147483648 : -value);
+      } else {
+        result.push(value);
+      }
+      value = shift = 0;
+    }
+  }
+  return result;
+}
+function encode(value) {
+  if (typeof value === "number") {
+    return encode_integer(value);
+  }
+  let result = "";
+  for (let i = 0; i < value.length; i += 1) {
+    result += encode_integer(value[i]);
+  }
+  return result;
+}
+function encode_integer(num) {
+  let result = "";
+  if (num < 0) {
+    num = -num << 1 | 1;
+  } else {
+    num <<= 1;
+  }
+  do {
+    let clamped = num & 31;
+    num >>>= 5;
+    if (num > 0) {
+      clamped |= 32;
+    }
+    result += integer_to_char[clamped];
+  } while (num > 0);
+  return result;
+}
+
+// ../server/lib/common/heap.js
+var Heap = class _Heap {
+  constructor(_cmp, elements = []) {
+    this._cmp = _cmp;
+    this._heap = elements.map(([element, score]) => ({ element, score }));
+    for (let idx = this._heap.length - 1; idx >= 0; --idx)
+      this._down(idx);
+  }
+  static createMin(elements = []) {
+    return new _Heap((a, b) => a - b, elements);
+  }
+  static createMax(elements = []) {
+    return new _Heap((a, b) => b - a, elements);
+  }
+  _heap = [];
+  _up(idx) {
+    const e = this._heap[idx];
+    while (idx > 0) {
+      const parentIdx = idx - 1 >>> 1;
+      if (this._cmp(this._heap[parentIdx].score, e.score) <= 0)
+        break;
+      this._heap[idx] = this._heap[parentIdx];
+      idx = parentIdx;
+    }
+    this._heap[idx] = e;
+  }
+  _down(idx) {
+    const N = this._heap.length;
+    const e = this._heap[idx];
+    while (true) {
+      const leftIdx = idx * 2 + 1;
+      const rightIdx = idx * 2 + 2;
+      let smallestIdx;
+      if (leftIdx < N && rightIdx < N) {
+        smallestIdx = this._cmp(this._heap[leftIdx].score, this._heap[rightIdx].score) < 0 ? leftIdx : rightIdx;
+      } else if (leftIdx < N) {
+        smallestIdx = leftIdx;
+      } else if (rightIdx < N) {
+        smallestIdx = rightIdx;
+      } else {
+        break;
+      }
+      if (this._cmp(e.score, this._heap[smallestIdx].score) < 0)
+        break;
+      this._heap[idx] = this._heap[smallestIdx];
+      idx = smallestIdx;
+    }
+    this._heap[idx] = e;
+  }
+  push(element, score) {
+    this._heap.push({ element, score });
+    this._up(this._heap.length - 1);
+  }
+  get size() {
+    return this._heap.length;
+  }
+  peekEntry() {
+    return this._heap.length ? [this._heap[0].element, this._heap[0].score] : void 0;
+  }
+  popEntry() {
+    if (!this._heap.length)
+      return void 0;
+    const entry = this._heap[0];
+    const last = this._heap.pop();
+    if (!this._heap.length)
+      return [entry.element, entry.score];
+    this._heap[0] = last;
+    this._down(0);
+    return [entry.element, entry.score];
+  }
+};
+
+// ../server/lib/common/sequence.js
+var Sequence = class _Sequence {
+  constructor(_seek, length) {
+    this._seek = _seek;
+    this.length = length;
+  }
+  static fromList(a) {
+    return new _Sequence(
+      function(pos) {
+        return {
+          next() {
+            if (pos >= a.length)
+              return { done: true, value: void 0 };
+            return { done: false, value: a[pos++] };
+          }
+        };
+      },
+      a.length
+    );
+  }
+  static chain(seqs) {
+    const leftsums = [];
+    let length = 0;
+    for (let i = 0; i < seqs.length; ++i) {
+      length += seqs[i].length;
+      leftsums.push(length);
+    }
+    return new _Sequence(
+      function(fromIdx) {
+        fromIdx = Math.max(0, Math.min(length, fromIdx));
+        let idx = _Sequence.fromList(leftsums).partitionPoint(((x) => x <= fromIdx));
+        if (idx >= seqs.length) {
+          return {
+            next: () => ({ done: true, value: void 0 })
+          };
+        }
+        let it = seqs[idx].seek(idx > 0 ? fromIdx - leftsums[idx - 1] : fromIdx);
+        return {
+          next() {
+            let result = it.next();
+            while (result.done && ++idx < seqs.length) {
+              it = seqs[idx].seek(0);
+              result = it.next();
+            }
+            return result.done ? result : { done: false, value: [result.value, idx] };
+          }
+        };
+      },
+      length
+    );
+  }
+  static merge(sequences, cmp) {
+    const length = sequences.reduce((acc, seq) => acc + seq.length, 0);
+    return new _Sequence(
+      function(fromIdx) {
+        fromIdx = Math.max(0, Math.min(length, fromIdx));
+        const offsets = quickAdvance(sequences, cmp, fromIdx);
+        const entries = [];
+        for (let i = 0; i < sequences.length; ++i) {
+          const seq = sequences[i];
+          const it = seq.seek(offsets[i]);
+          const itval = it.next();
+          if (!itval.done)
+            entries.push([it, itval.value]);
+        }
+        const heap = new Heap(cmp, entries);
+        return {
+          next() {
+            if (!heap.size)
+              return { done: true, value: void 0 };
+            ++fromIdx;
+            const [it, e] = heap.popEntry();
+            const itval = it.next();
+            if (!itval.done)
+              heap.push(it, itval.value);
+            return { done: false, value: e };
+          }
+        };
+      },
+      length
+    );
+  }
+  static EMPTY = new _Sequence(function* () {
+  }, 0);
+  seek(idx) {
+    const it = this._seek(idx);
+    it[Symbol.iterator] = () => it;
+    return it;
+  }
+  get(idx) {
+    return this.seek(idx).next().value;
+  }
+  map(mapper) {
+    const originalSeek = this._seek;
+    return new _Sequence(
+      function(idx) {
+        const it = originalSeek(idx);
+        return {
+          next() {
+            const next = it.next();
+            if (next.done)
+              return next;
+            return { done: false, value: mapper(next.value) };
+          }
+        };
+      },
+      this.length
+    );
+  }
+  /** Number of elements in sequence that are <= comparator. Only works on sorted sequences. */
+  partitionPoint(predicate) {
+    let lo = 0, hi = this.length;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      if (predicate(this.get(mid)))
+        lo = mid + 1;
+      else
+        hi = mid;
+    }
+    return lo;
+  }
+};
+function quickAdvance(sequences, cmp, k) {
+  const offsets = new Map(sequences.map((s) => [s, 0]));
+  while (offsets.size && k > 0) {
+    const t = offsets.size;
+    const x = Math.max(Math.floor(k / t / 2), 1);
+    const entries = [];
+    for (const [seq, offset] of offsets) {
+      if (offset + x <= seq.length)
+        entries.push([seq, seq.get(offset + x - 1)]);
+    }
+    const heap = new Heap(cmp, entries);
+    while (heap.size && k > 0 && (x === 1 || k >= x * t)) {
+      k -= x;
+      const [seq] = heap.popEntry();
+      const offset = offsets.get(seq) + x;
+      if (offset === seq.length)
+        offsets.delete(seq);
+      else
+        offsets.set(seq, offset);
+      if (offset + x <= seq.length)
+        heap.push(seq, seq.get(offset + x - 1));
+    }
+  }
+  return sequences.map((seq) => offsets.get(seq) ?? seq.length);
+}
+
+// ../server/lib/common/ranges.js
+var Ranges;
+((Ranges2) => {
+  Ranges2.EMPTY = [];
+  Ranges2.FULL = [-Infinity, Infinity];
+  function isFull(ranges) {
+    return ranges.length === 2 && Object.is(ranges[0], -Infinity) && Object.is(ranges[1], Infinity);
+  }
+  Ranges2.isFull = isFull;
+  function compress(ranges) {
+    if (!ranges.length)
+      return "";
+    if (isInfinite(ranges))
+      throw new Error("Compression of infinite ranges is not supported");
+    const prepared = [];
+    let last = ranges[0] - 1;
+    prepared.push(last);
+    for (let i = 0; i < ranges.length; i += 2) {
+      if (ranges[i] === ranges[i + 1]) {
+        prepared.push(-(ranges[i] - last));
+      } else {
+        prepared.push(ranges[i] - last);
+        prepared.push(ranges[i + 1] - ranges[i]);
+      }
+      last = ranges[i + 1];
+    }
+    return encode(prepared);
+  }
+  Ranges2.compress = compress;
+  function decompress(compressed) {
+    if (!compressed.length)
+      return [];
+    const prepared = decode(compressed);
+    const result = [];
+    let last = prepared[0];
+    for (let i = 1; i < prepared.length; ++i) {
+      if (prepared[i] < 0) {
+        result.push(-prepared[i] + last);
+        result.push(-prepared[i] + last);
+        last -= prepared[i];
+      } else {
+        result.push(prepared[i] + last);
+        last += prepared[i];
+      }
+    }
+    return result;
+  }
+  Ranges2.decompress = decompress;
+  function toString(ranges) {
+    const tokens = [];
+    for (let i = 0; i < ranges.length - 1; i += 2) {
+      if (ranges[i] === ranges[i + 1])
+        tokens.push(ranges[i]);
+      else
+        tokens.push(`${ranges[i]}-${ranges[i + 1]}`);
+    }
+    if (!tokens.length)
+      return `[]`;
+    return `[ ` + tokens.join(", ") + ` ]`;
+  }
+  Ranges2.toString = toString;
+  function popInplace(ranges) {
+    if (isInfinite(ranges))
+      throw new Error("cannot pop from infinite ranges!");
+    const last = ranges.at(-1);
+    const prelast = ranges.at(-2);
+    if (last === void 0 || prelast === void 0)
+      return void 0;
+    if (last === prelast) {
+      ranges.pop();
+      ranges.pop();
+    } else {
+      ranges[ranges.length - 1] = last - 1;
+    }
+    return last;
+  }
+  Ranges2.popInplace = popInplace;
+  function* iterate(ranges) {
+    if (isInfinite(ranges))
+      throw new Error("cannot iterate infinite ranges!");
+    for (let i = 0; i < ranges.length - 1; i += 2) {
+      for (let j = ranges[i]; j <= ranges[i + 1]; ++j)
+        yield j;
+    }
+  }
+  Ranges2.iterate = iterate;
+  function toSortedList(ranges) {
+    if (isInfinite(ranges))
+      throw new Error("cannot convert infinite ranges!");
+    const list = [];
+    for (let i = 0; i < ranges.length - 1; i += 2) {
+      for (let j = ranges[i]; j <= ranges[i + 1]; ++j)
+        list.push(j);
+    }
+    return list;
+  }
+  Ranges2.toSortedList = toSortedList;
+  function toInt32Array(ranges) {
+    if (isInfinite(ranges))
+      throw new Error("cannot convert infinite ranges!");
+    const result = new Int32Array(cardinality(ranges));
+    let idx = 0;
+    for (let i = 0; i < ranges.length - 1; i += 2) {
+      for (let j = ranges[i]; j <= ranges[i + 1]; ++j)
+        result[idx++] = j;
+    }
+    return result;
+  }
+  Ranges2.toInt32Array = toInt32Array;
+  function fromList(x) {
+    for (let i = 0; i < x.length - 1; ++i) {
+      if (x[i] > x[i + 1]) {
+        x = x.toSorted((a, b) => a - b);
+        break;
+      }
+    }
+    return fromSortedList(x);
+  }
+  Ranges2.fromList = fromList;
+  function from(x) {
+    return [x, x];
+  }
+  Ranges2.from = from;
+  function fromSortedList(sorted) {
+    const ranges = [];
+    let rangeStart = 0;
+    for (let i = 1; i <= sorted.length; ++i) {
+      if (i < sorted.length && sorted[i] - sorted[i - 1] <= 1)
+        continue;
+      ranges.push(sorted[rangeStart], sorted[i - 1]);
+      rangeStart = i;
+    }
+    return ranges;
+  }
+  Ranges2.fromSortedList = fromSortedList;
+  function isInfinite(ranges) {
+    return ranges.length > 0 && (Object.is(ranges[0], Infinity) || Object.is(ranges[ranges.length - 1], Infinity));
+  }
+  Ranges2.isInfinite = isInfinite;
+  function includes(ranges, e) {
+    if (!ranges.length)
+      return false;
+    if (e < ranges[0] || ranges[ranges.length - 1] < e)
+      return false;
+    if (ranges.length < 17) {
+      for (let i = 0; i < ranges.length - 1; i += 2) {
+        if (ranges[i] <= e && e <= ranges[i + 1])
+          return true;
+      }
+      return false;
+    }
+    let lo = 0, hi = ranges.length;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      if (ranges[mid] === e)
+        return true;
+      if (ranges[mid] < e)
+        lo = mid + 1;
+      else
+        hi = mid;
+    }
+    return (lo & 1) !== 0;
+  }
+  Ranges2.includes = includes;
+  function cardinality(ranges) {
+    if (isInfinite(ranges))
+      return Infinity;
+    let sum = 0;
+    for (let i = 0; i < ranges.length - 1; i += 2)
+      sum += ranges[i + 1] - ranges[i] + 1;
+    return sum;
+  }
+  Ranges2.cardinality = cardinality;
+  function offset(ranges, offset2) {
+    return ranges.map((x) => x + offset2);
+  }
+  Ranges2.offset = offset;
+  function intersect(ranges1, ranges2) {
+    const ranges = [];
+    if (!ranges1.length || !ranges2.length)
+      return ranges;
+    if (ranges1[ranges1.length - 1] < ranges2[0] || ranges2[ranges2.length - 1] < ranges1[0])
+      return ranges;
+    let p1 = 0;
+    let p2 = 0;
+    while (p1 < ranges1.length - 1 && p2 < ranges2.length - 1) {
+      if (ranges1[p1 + 1] < ranges2[p2]) {
+        p1 += 2;
+        let offset2 = 1;
+        while (p1 + offset2 * 2 + 1 < ranges1.length && ranges1[p1 + offset2 * 2 + 1] < ranges2[p2])
+          offset2 <<= 1;
+        p1 += offset2 >> 1 << 1;
+      } else if (ranges2[p2 + 1] < ranges1[p1]) {
+        p2 += 2;
+        let offset2 = 1;
+        while (p2 + offset2 * 2 + 1 < ranges2.length && ranges2[p2 + offset2 * 2 + 1] < ranges1[p1])
+          offset2 <<= 1;
+        p2 += offset2 >> 1 << 1;
+      } else {
+        const a1 = ranges1[p1], a2 = ranges1[p1 + 1];
+        const b1 = ranges2[p2], b2 = ranges2[p2 + 1];
+        ranges.push(Math.max(a1, b1), Math.min(a2, b2));
+        if (a2 < b2) {
+          p1 += 2;
+        } else if (a2 > b2) {
+          p2 += 2;
+        } else {
+          p1 += 2;
+          p2 += 2;
+        }
+      }
+    }
+    return ranges;
+  }
+  Ranges2.intersect = intersect;
+  function capAt(ranges, cap) {
+    const result = [];
+    for (let i = 0; i < ranges.length; i += 2) {
+      const start = ranges[i];
+      const end = ranges[i + 1];
+      if (start > cap)
+        break;
+      if (end <= cap) {
+        result.push(start, end);
+      } else {
+        result.push(start, cap);
+        break;
+      }
+    }
+    return result;
+  }
+  Ranges2.capAt = capAt;
+  function isIntersecting(ranges1, ranges2) {
+    if (!ranges1.length || !ranges2.length)
+      return false;
+    if (ranges1[ranges1.length - 1] < ranges2[0] || ranges2[ranges2.length - 1] < ranges1[0])
+      return false;
+    let p1 = 0;
+    let p2 = 0;
+    while (p1 < ranges1.length - 1 && p2 < ranges2.length - 1) {
+      const a1 = ranges1[p1], a2 = ranges1[p1 + 1];
+      const b1 = ranges2[p2], b2 = ranges2[p2 + 1];
+      if (a2 < b1) {
+        p1 += 2;
+        let offset2 = 1;
+        while (p1 + offset2 * 2 + 1 < ranges1.length && ranges1[p1 + offset2 * 2 + 1] < ranges2[p2])
+          offset2 <<= 1;
+        p1 += offset2 >> 1 << 1;
+      } else if (b2 < a1) {
+        p2 += 2;
+        let offset2 = 1;
+        while (p2 + offset2 * 2 + 1 < ranges2.length && ranges2[p2 + offset2 * 2 + 1] < ranges1[p1])
+          offset2 <<= 1;
+        p2 += offset2 >> 1 << 1;
+      } else {
+        return true;
+      }
+    }
+    return false;
+  }
+  Ranges2.isIntersecting = isIntersecting;
+  function complement(r) {
+    if (r.length === 0)
+      return [-Infinity, Infinity];
+    const result = [];
+    if (!Object.is(r[0], -Infinity))
+      result.push(-Infinity, r[0] - 1);
+    for (let i = 1; i < r.length - 2; i += 2)
+      result.push(r[i] + 1, r[i + 1] - 1);
+    if (!Object.is(r[r.length - 1], Infinity))
+      result.push(r[r.length - 1] + 1, Infinity);
+    return result;
+  }
+  Ranges2.complement = complement;
+  function subtract(ranges1, ranges2) {
+    return intersect(ranges1, complement(ranges2));
+  }
+  Ranges2.subtract = subtract;
+  function singleRange(from2, to) {
+    return [from2, to];
+  }
+  Ranges2.singleRange = singleRange;
+  function unionAll(ranges) {
+    let result = Ranges2.EMPTY;
+    for (const r of ranges)
+      result = union(result, r);
+    return result;
+  }
+  Ranges2.unionAll = unionAll;
+  function unionAll_2(rangesIterable) {
+    const ranges = Array.isArray(rangesIterable) ? rangesIterable : Array.from(rangesIterable);
+    if (ranges.length === 0)
+      return [];
+    if (ranges.length === 1)
+      return ranges[0];
+    if (ranges.length === 2)
+      return union(ranges[0], ranges[1]);
+    const seq = Sequence.merge(ranges.map((r) => intervalSequence(r)), (a, b) => a[0] - b[0]);
+    const result = [];
+    let last;
+    for (const interval of seq.seek(0)) {
+      if (!last || last[1] + 1 < interval[0]) {
+        result.push(interval);
+        last = interval;
+        continue;
+      }
+      if (last[1] < interval[1])
+        last[1] = interval[1];
+    }
+    return result.flat();
+  }
+  Ranges2.unionAll_2 = unionAll_2;
+  function intersectAll(ranges) {
+    if (!ranges.length)
+      return Ranges2.EMPTY;
+    let result = Ranges2.FULL;
+    for (const range of ranges)
+      result = Ranges2.intersect(result, range);
+    return result;
+  }
+  Ranges2.intersectAll = intersectAll;
+  function domain(ranges) {
+    if (!ranges.length)
+      return void 0;
+    return { min: ranges[0], max: ranges[ranges.length - 1] };
+  }
+  Ranges2.domain = domain;
+  function union(ranges1, ranges2) {
+    if (!ranges1.length)
+      return ranges2;
+    if (!ranges2.length)
+      return ranges1;
+    if (ranges2[0] < ranges1[0])
+      [ranges1, ranges2] = [ranges2, ranges1];
+    const r = [ranges1[0], ranges1[1]];
+    let p1 = 2, p2 = 0;
+    while (p1 < ranges1.length - 1 && p2 < ranges2.length - 1) {
+      if (ranges1[p1] <= ranges2[p2]) {
+        if (r[r.length - 1] + 1 < ranges1[p1]) {
+          r.push(ranges1[p1], ranges1[p1 + 1]);
+          p1 += 2;
+        } else if (r[r.length - 1] < ranges1[p1 + 1]) {
+          r[r.length - 1] = ranges1[p1 + 1];
+          p1 += 2;
+        } else {
+          p1 += 2;
+          let offset2 = 1;
+          while (p1 + offset2 * 2 + 1 < ranges1.length && r[r.length - 1] >= ranges1[p1 + offset2 * 2 + 1])
+            offset2 <<= 1;
+          p1 += offset2 >> 1 << 1;
+        }
+      } else {
+        if (r[r.length - 1] + 1 < ranges2[p2]) {
+          r.push(ranges2[p2], ranges2[p2 + 1]);
+          p2 += 2;
+        } else if (r[r.length - 1] < ranges2[p2 + 1]) {
+          r[r.length - 1] = ranges2[p2 + 1];
+          p2 += 2;
+        } else {
+          p2 += 2;
+          let offset2 = 1;
+          while (p2 + offset2 * 2 + 1 < ranges2.length && r[r.length - 1] >= ranges2[p2 + offset2 * 2 + 1])
+            offset2 <<= 1;
+          p2 += offset2 >> 1 << 1;
+        }
+      }
+    }
+    while (p1 < ranges1.length - 1) {
+      if (r[r.length - 1] + 1 < ranges1[p1]) {
+        r.push(ranges1[p1], ranges1[p1 + 1]);
+        p1 += 2;
+      } else if (r[r.length - 1] < ranges1[p1 + 1]) {
+        r[r.length - 1] = ranges1[p1 + 1];
+        p1 += 2;
+      } else {
+        p1 += 2;
+        let offset2 = 1;
+        while (p1 + offset2 * 2 + 1 < ranges1.length && r[r.length - 1] >= ranges1[p1 + offset2 * 2 + 1])
+          offset2 <<= 1;
+        p1 += offset2 >> 1 << 1;
+      }
+    }
+    while (p2 < ranges2.length - 1) {
+      if (r[r.length - 1] + 1 < ranges2[p2]) {
+        r.push(ranges2[p2], ranges2[p2 + 1]);
+        p2 += 2;
+      } else if (r[r.length - 1] < ranges2[p2 + 1]) {
+        r[r.length - 1] = ranges2[p2 + 1];
+        p2 += 2;
+      } else {
+        p2 += 2;
+        let offset2 = 1;
+        while (p2 + offset2 * 2 + 1 < ranges2.length && r[r.length - 1] >= ranges2[p2 + offset2 * 2 + 1])
+          offset2 <<= 1;
+        p2 += offset2 >> 1 << 1;
+      }
+    }
+    return r;
+  }
+  Ranges2.union = union;
+  function intervalSequence(ranges) {
+    return new Sequence(function(idx) {
+      return {
+        next() {
+          if (idx * 2 >= ranges.length)
+            return { done: true, value: void 0 };
+          const value = [ranges[idx * 2], ranges[idx * 2 + 1]];
+          ++idx;
+          return { done: false, value };
+        }
+      };
+    }, ranges.length >>> 1);
+  }
+  Ranges2.intervalSequence = intervalSequence;
+  function sequence(ranges) {
+    let length = 0;
+    const leftsums = [];
+    for (let i = 0; i < ranges.length - 1; i += 2) {
+      length += ranges[i + 1] - ranges[i] + 1;
+      leftsums.push(length);
+    }
+    return new Sequence(
+      function(fromIdx) {
+        fromIdx = Math.max(0, Math.min(length, fromIdx));
+        const idx = Sequence.fromList(leftsums).partitionPoint((x) => x <= fromIdx);
+        const intervals = Ranges2.intervalSequence(ranges);
+        const it = intervals.seek(idx);
+        const firstInterval = it.next();
+        if (firstInterval.done)
+          return { next: () => firstInterval };
+        let from2 = firstInterval.value[0] + fromIdx - (idx > 0 ? leftsums[idx - 1] : 0);
+        let to = firstInterval.value[1];
+        return {
+          next() {
+            if (from2 > to) {
+              const interval = it.next();
+              if (interval.done)
+                return { done: true, value: void 0 };
+              from2 = interval.value[0];
+              to = interval.value[1];
+            }
+            return { done: false, value: from2++ };
+          }
+        };
+      },
+      length
+    );
+  }
+  Ranges2.sequence = sequence;
+})(Ranges || (Ranges = {}));
+
+// src/cli/cli.ts
+import { TypedHTTP as TypedHTTP2 } from "@flakiness/shared/common/typedHttp.js";
+import assert3 from "assert";
+import { Command, Option } from "commander";
+import fs8 from "fs";
+import ora from "ora";
+import path8 from "path";
+
+// ../package.json
+var package_default = {
+  name: "flakiness",
+  version: "0.146.1",
+  private: true,
+  scripts: {
+    minor: "./version.mjs minor",
+    patch: "./version.mjs patch",
+    dev: "npx kubik --env-file=.env.dev -w $(find . -name build.mts) ./app.mts ./stripe.mts",
+    "dev+billing": "npx kubik --env-file=.env.dev+billing -w $(find . -name build.mts) ./app.mts ./stripe.mts",
+    prod: "npx kubik --env-file=.env.prodlocal -w ./cli/build.mts ./server.mts ./web/build.mts ./experimental/build.mts ./landing/build.mts",
+    build: "npx kubik $(find . -name build.mts)",
+    perf: "node --max-old-space-size=10240 --enable-source-maps --env-file=.env.prodlocal experimental/lib/perf_filter.js"
+  },
+  engines: {
+    node: ">=24"
+  },
+  author: "Degu Labs, Inc",
+  license: "Fair Source 100",
+  workspaces: [
+    "./report",
+    "./sdk",
+    "./cli",
+    "./docs",
+    "./landing",
+    "./legal",
+    "./devenv",
+    "./database",
+    "./server",
+    "./shared",
+    "./experimental",
+    "./web"
+  ],
+  devDependencies: {
+    "@playwright/test": "^1.57.0",
+    "@types/node": "^22.10.2",
+    esbuild: "^0.27.0",
+    glob: "^10.3.10",
+    kubik: "^0.24.0",
+    tsx: "^4.19.2",
+    typescript: "^5.6.2"
+  }
+};
+
+// src/flakinessSession.ts
+import fs2 from "fs/promises";
+import os2 from "os";
+import path2 from "path";
+
+// src/serverapi.ts
+import { TypedHTTP } from "@flakiness/shared/common/typedHttp.js";
+
+// src/utils.ts
+import { ReportUtils } from "@flakiness/report";
+import assert from "assert";
+import { spawnSync } from "child_process";
+import crypto from "crypto";
+import fs from "fs";
+import http from "http";
+import https from "https";
+import os from "os";
+import path, { posix as posixPath, win32 as win32Path } from "path";
+async function existsAsync(aPath) {
+  return fs.promises.stat(aPath).then(() => true).catch((e) => false);
+}
+function extractEnvConfiguration() {
+  const ENV_PREFIX = "FK_ENV_";
+  return Object.fromEntries(
+    Object.entries(process.env).filter(([key]) => key.toUpperCase().startsWith(ENV_PREFIX.toUpperCase())).map(([key, value]) => [key.substring(ENV_PREFIX.length).toLowerCase(), (value ?? "").trim().toLowerCase()])
+  );
+}
+function sha1File(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash("sha1");
+    const stream = fs.createReadStream(filePath);
+    stream.on("data", (chunk) => {
+      hash.update(chunk);
+    });
+    stream.on("end", () => {
+      resolve(hash.digest("hex"));
+    });
+    stream.on("error", (err2) => {
+      reject(err2);
+    });
+  });
+}
+var FLAKINESS_DBG = !!process.env.FLAKINESS_DBG;
+function errorText(error) {
+  return FLAKINESS_DBG ? error.stack : error.message;
+}
+function sha1Buffer(data) {
+  const hash = crypto.createHash("sha1");
+  hash.update(data);
+  return hash.digest("hex");
+}
+async function retryWithBackoff(job, backoff = []) {
+  for (const timeout of backoff) {
+    try {
+      return await job();
+    } catch (e) {
+      if (e instanceof AggregateError)
+        console.error(`[flakiness.io err]`, errorText(e.errors[0]));
+      else if (e instanceof Error)
+        console.error(`[flakiness.io err]`, errorText(e));
+      else
+        console.error(`[flakiness.io err]`, e);
+      await new Promise((x) => setTimeout(x, timeout));
+    }
+  }
+  return await job();
+}
+var httpUtils;
+((httpUtils2) => {
+  function createRequest({ url, method = "get", headers = {} }) {
+    let resolve;
+    let reject;
+    const responseDataPromise = new Promise((a, b) => {
+      resolve = a;
+      reject = b;
+    });
+    const protocol = url.startsWith("https") ? https : http;
+    headers = Object.fromEntries(Object.entries(headers).filter(([key, value]) => value !== void 0));
+    const request = protocol.request(url, { method, headers }, (res) => {
+      const chunks = [];
+      res.on("data", (chunk) => chunks.push(chunk));
+      res.on("end", () => {
+        if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300)
+          resolve(Buffer.concat(chunks));
+        else
+          reject(new Error(`Request to ${url} failed with ${res.statusCode}`));
+      });
+      res.on("error", (error) => reject(error));
+    });
+    request.on("error", reject);
+    return { request, responseDataPromise };
+  }
+  httpUtils2.createRequest = createRequest;
+  async function getBuffer(url, backoff) {
+    return await retryWithBackoff(async () => {
+      const { request, responseDataPromise } = createRequest({ url });
+      request.end();
+      return await responseDataPromise;
+    }, backoff);
+  }
+  httpUtils2.getBuffer = getBuffer;
+  async function getText(url, backoff) {
+    const buffer = await getBuffer(url, backoff);
+    return buffer.toString("utf-8");
+  }
+  httpUtils2.getText = getText;
+  async function getJSON(url) {
+    return JSON.parse(await getText(url));
+  }
+  httpUtils2.getJSON = getJSON;
+  async function postText(url, text, backoff) {
+    const headers = {
+      "Content-Type": "application/json",
+      "Content-Length": Buffer.byteLength(text) + ""
+    };
+    return await retryWithBackoff(async () => {
+      const { request, responseDataPromise } = createRequest({ url, headers, method: "post" });
+      request.write(text);
+      request.end();
+      return await responseDataPromise;
+    }, backoff);
+  }
+  httpUtils2.postText = postText;
+  async function postJSON(url, json, backoff) {
+    const buffer = await postText(url, JSON.stringify(json), backoff);
+    return JSON.parse(buffer.toString("utf-8"));
+  }
+  httpUtils2.postJSON = postJSON;
+})(httpUtils || (httpUtils = {}));
+var ansiRegex = new RegExp("[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))", "g");
+function stripAnsi(str) {
+  return str.replace(ansiRegex, "");
+}
+async function saveReportAndAttachments(report, attachments, outputFolder) {
+  const reportPath = path.join(outputFolder, "report.json");
+  const attachmentsFolder = path.join(outputFolder, "attachments");
+  await fs.promises.rm(outputFolder, { recursive: true, force: true });
+  await fs.promises.mkdir(outputFolder, { recursive: true });
+  await fs.promises.writeFile(reportPath, JSON.stringify(report), "utf-8");
+  if (attachments.length)
+    await fs.promises.mkdir(attachmentsFolder);
+  const movedAttachments = [];
+  for (const attachment of attachments) {
+    const attachmentPath = path.join(attachmentsFolder, attachment.id);
+    if (attachment.path)
+      await fs.promises.cp(attachment.path, attachmentPath);
+    else if (attachment.body)
+      await fs.promises.writeFile(attachmentPath, attachment.body);
+    movedAttachments.push({
+      contentType: attachment.contentType,
+      id: attachment.id,
+      path: attachmentPath
+    });
+  }
+  return movedAttachments;
+}
+function shell(command, args, options) {
+  try {
+    const result = spawnSync(command, args, { encoding: "utf-8", ...options });
+    if (result.status !== 0) {
+      return void 0;
+    }
+    return result.stdout.trim();
+  } catch (e) {
+    console.error(e);
+    return void 0;
+  }
+}
+function readLinuxOSRelease() {
+  const osReleaseText = fs.readFileSync("/etc/os-release", "utf-8");
+  return new Map(osReleaseText.toLowerCase().split("\n").filter((line) => line.includes("=")).map((line) => {
+    line = line.trim();
+    let [key, value] = line.split("=");
+    if (value.startsWith('"') && value.endsWith('"'))
+      value = value.substring(1, value.length - 1);
+    return [key, value];
+  }));
+}
+function osLinuxInfo() {
+  const arch = shell(`uname`, [`-m`]);
+  const osReleaseMap = readLinuxOSRelease();
+  const name = osReleaseMap.get("name") ?? shell(`uname`);
+  const version = osReleaseMap.get("version_id");
+  return { name, arch, version };
+}
+function osDarwinInfo() {
+  const name = "macos";
+  const arch = shell(`uname`, [`-m`]);
+  const version = shell(`sw_vers`, [`-productVersion`]);
+  return { name, arch, version };
+}
+function osWinInfo() {
+  const name = "win";
+  const arch = process.arch;
+  const version = os.release();
+  return { name, arch, version };
+}
+function getOSInfo() {
+  if (process.platform === "darwin")
+    return osDarwinInfo();
+  if (process.platform === "win32")
+    return osWinInfo();
+  return osLinuxInfo();
+}
+function inferRunUrl() {
+  if (process.env.GITHUB_REPOSITORY && process.env.GITHUB_RUN_ID)
+    return `https://github.com/${process.env.GITHUB_REPOSITORY}/actions/runs/${process.env.GITHUB_RUN_ID}`;
+  return void 0;
+}
+function parseStringDate(dateString) {
+  return +new Date(dateString);
+}
+function gitCommitInfo(gitRepo) {
+  const sha = shell(`git`, ["rev-parse", "HEAD"], {
+    cwd: gitRepo,
+    encoding: "utf-8"
+  });
+  assert(sha, `FAILED: git rev-parse HEAD @ ${gitRepo}`);
+  return sha.trim();
+}
+async function resolveAttachmentPaths(report, attachmentsDir) {
+  const attachmentFiles = await listFilesRecursively(attachmentsDir);
+  const filenameToPath = new Map(attachmentFiles.map((file) => [path.basename(file), file]));
+  const attachmentIdToPath = /* @__PURE__ */ new Map();
+  const missingAttachments = /* @__PURE__ */ new Set();
+  ReportUtils.visitTests(report, (test) => {
+    for (const attempt of test.attempts) {
+      for (const attachment of attempt.attachments ?? []) {
+        const attachmentPath = filenameToPath.get(attachment.id);
+        if (!attachmentPath) {
+          missingAttachments.add(attachment.id);
+        } else {
+          attachmentIdToPath.set(attachment.id, {
+            contentType: attachment.contentType,
+            id: attachment.id,
+            path: attachmentPath
+          });
+        }
+      }
+    }
+  });
+  return { attachmentIdToPath, missingAttachments: Array.from(missingAttachments) };
+}
+async function listFilesRecursively(dir, result = []) {
+  const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory())
+      await listFilesRecursively(fullPath, result);
+    else
+      result.push(fullPath);
+  }
+  return result;
+}
+function computeGitRoot(somePathInsideGitRepo) {
+  const root = shell(`git`, ["rev-parse", "--show-toplevel"], {
+    cwd: somePathInsideGitRepo,
+    encoding: "utf-8"
+  });
+  assert(root, `FAILED: git rev-parse --show-toplevel HEAD @ ${somePathInsideGitRepo}`);
+  return normalizePath(root);
+}
+var IS_WIN32_PATH = new RegExp("^[a-zA-Z]:\\\\", "i");
+var IS_ALMOST_POSIX_PATH = new RegExp("^[a-zA-Z]:/", "i");
+function normalizePath(aPath) {
+  if (IS_WIN32_PATH.test(aPath)) {
+    aPath = aPath.split(win32Path.sep).join(posixPath.sep);
+  }
+  if (IS_ALMOST_POSIX_PATH.test(aPath))
+    return "/" + aPath[0] + aPath.substring(2);
+  return aPath;
+}
+function gitFilePath(gitRoot, absolutePath) {
+  return posixPath.relative(gitRoot, absolutePath);
+}
+function parseDurationMS(value) {
+  if (isNaN(value))
+    throw new Error("Duration cannot be NaN");
+  if (value < 0)
+    throw new Error(`Duration cannot be less than 0, found ${value}`);
+  return value | 0;
+}
+function createEnvironments(projects) {
+  const envConfiguration = extractEnvConfiguration();
+  const osInfo = getOSInfo();
+  let uniqueNames = /* @__PURE__ */ new Set();
+  const result = /* @__PURE__ */ new Map();
+  for (const project of projects) {
+    let defaultName = project.name;
+    if (!defaultName.trim())
+      defaultName = "anonymous";
+    let name = defaultName;
+    for (let i = 2; uniqueNames.has(name); ++i)
+      name = `${defaultName}-${i}`;
+    uniqueNames.add(defaultName);
+    result.set(project, {
+      name,
+      systemData: {
+        osArch: osInfo.arch,
+        osName: osInfo.name,
+        osVersion: osInfo.version
+      },
+      userSuppliedData: {
+        ...envConfiguration,
+        ...project.metadata
+      },
+      opaqueData: {
+        project
+      }
+    });
+  }
+  return result;
+}
+
+// src/serverapi.ts
+function createServerAPI(endpoint, options) {
+  endpoint += "/api/";
+  const fetcher = options?.auth ? (url, init) => fetch(url, {
+    ...init,
+    headers: {
+      ...init.headers,
+      "Authorization": `Bearer ${options.auth}`
+    }
+  }) : fetch;
+  if (options?.retries)
+    return TypedHTTP.createClient(endpoint, (url, init) => retryWithBackoff(() => fetcher(url, init), options.retries));
+  return TypedHTTP.createClient(endpoint, fetcher);
+}
+
+// src/flakinessSession.ts
+var CONFIG_DIR = (() => {
+  const configDir = process.platform === "darwin" ? path2.join(os2.homedir(), "Library", "Application Support", "flakiness") : process.platform === "win32" ? path2.join(os2.homedir(), "AppData", "Roaming", "flakiness") : path2.join(os2.homedir(), ".config", "flakiness");
+  return configDir;
+})();
+var CONFIG_PATH = path2.join(CONFIG_DIR, "config.json");
+var FlakinessSession = class _FlakinessSession {
+  constructor(_config) {
+    this._config = _config;
+    this.api = createServerAPI(this._config.endpoint, { auth: this._config.token });
+  }
+  static async loadOrDie() {
+    const session2 = await _FlakinessSession.load();
+    if (!session2)
+      throw new Error(`Please login first with 'npx flakiness login'`);
+    return session2;
+  }
+  static async load() {
+    const data = await fs2.readFile(CONFIG_PATH, "utf-8").catch((e) => void 0);
+    if (!data)
+      return void 0;
+    const json = JSON.parse(data);
+    return new _FlakinessSession(json);
+  }
+  static async remove() {
+    await fs2.unlink(CONFIG_PATH).catch((e) => void 0);
+  }
+  api;
+  endpoint() {
+    return this._config.endpoint;
+  }
+  path() {
+    return CONFIG_PATH;
+  }
+  sessionToken() {
+    return this._config.token;
+  }
+  async save() {
+    await fs2.mkdir(CONFIG_DIR, { recursive: true });
+    await fs2.writeFile(CONFIG_PATH, JSON.stringify(this._config, null, 2));
+  }
+};
+
+// src/cli/cmd-convert.ts
+import fs4 from "fs/promises";
+import path4 from "path";
+
+// src/junit.ts
+import { ReportUtils as ReportUtils2 } from "@flakiness/report";
+import { parseXml, XmlElement, XmlText } from "@rgrove/parse-xml";
+import assert2 from "assert";
+import fs3 from "fs";
+import path3 from "path";
+function getProperties(element) {
+  const propertiesNodes = element.children.filter((node) => node instanceof XmlElement).filter((node) => node.name === "properties");
+  if (!propertiesNodes.length)
+    return [];
+  const result = [];
+  for (const propertiesNode of propertiesNodes) {
+    const properties = propertiesNode.children.filter((node) => node instanceof XmlElement).filter((node) => node.name === "property");
+    for (const property of properties) {
+      const name = property.attributes["name"];
+      const innerText = property.children.find((node) => node instanceof XmlText);
+      const value = property.attributes["value"] ?? innerText?.text ?? "";
+      result.push([name, value]);
+    }
+  }
+  return result;
+}
+function extractErrors(testcase) {
+  const xmlErrors = testcase.children.filter((e) => e instanceof XmlElement).filter((element) => element.name === "error" || element.name === "failure");
+  if (!xmlErrors.length)
+    return void 0;
+  const errors = [];
+  for (const xmlErr of xmlErrors) {
+    const message = [xmlErr.attributes["type"], xmlErr.attributes["message"]].filter((x) => !!x).join(" ");
+    const xmlStackNodes = xmlErr.children.filter((child) => child instanceof XmlText);
+    const stack = xmlStackNodes ? xmlStackNodes.map((node) => node.text).join("\n") : void 0;
+    errors.push({
+      message,
+      stack
+    });
+  }
+  return errors;
+}
+function extractStdout(testcase, stdio) {
+  const xmlStdio = testcase.children.filter((e) => e instanceof XmlElement).filter((element) => element.name === stdio);
+  if (!xmlStdio.length)
+    return void 0;
+  return xmlStdio.map((node) => node.children.filter((node2) => node2 instanceof XmlText)).flat().map((txtNode) => ({
+    text: txtNode.text
+  }));
+}
+async function parseAttachment(value) {
+  let absolutePath = path3.resolve(process.cwd(), value);
+  if (fs3.existsSync(absolutePath)) {
+    const id = await sha1File(absolutePath);
+    return {
+      contentType: "image/png",
+      path: absolutePath,
+      id
+    };
+  }
+  return {
+    contentType: "text/plain",
+    id: sha1Buffer(value),
+    body: Buffer.from(value)
+  };
+}
+async function traverseJUnitReport(context, node) {
+  const element = node;
+  if (!(element instanceof XmlElement))
+    return;
+  let { currentEnv, currentEnvIndex, currentSuite, report, currentTimeMs, attachments } = context;
+  if (element.attributes["timestamp"])
+    currentTimeMs = new Date(element.attributes["timestamp"]).getTime();
+  if (element.name === "testsuite") {
+    const file = element.attributes["file"];
+    const line = parseInt(element.attributes["line"], 10);
+    const name = element.attributes["name"];
+    const newSuite = {
+      title: name ?? file,
+      location: file && !isNaN(line) ? {
+        file,
+        line,
+        column: 1
+      } : void 0,
+      type: name ? "suite" : file ? "file" : "anonymous suite",
+      suites: [],
+      tests: []
+    };
+    if (currentSuite) {
+      currentSuite.suites ??= [];
+      currentSuite.suites.push(newSuite);
+    } else {
+      report.suites.push(newSuite);
+    }
+    currentSuite = newSuite;
+    const userSuppliedData = getProperties(element);
+    if (userSuppliedData.length) {
+      currentEnv = structuredClone(currentEnv);
+      currentEnv.userSuppliedData ??= {};
+      for (const [key, value] of userSuppliedData)
+        currentEnv.userSuppliedData[key] = value;
+      currentEnvIndex = report.environments.push(currentEnv) - 1;
+    }
+  } else if (element.name === "testcase") {
+    assert2(currentSuite);
+    const file = element.attributes["file"];
+    const name = element.attributes["name"];
+    const line = parseInt(element.attributes["line"], 10);
+    const timeMs = parseFloat(element.attributes["time"]) * 1e3;
+    const startTimestamp = currentTimeMs;
+    const duration = timeMs;
+    currentTimeMs += timeMs;
+    const annotations = [];
+    const attachments2 = [];
+    for (const [key, value] of getProperties(element)) {
+      if (key.toLowerCase().startsWith("attachment")) {
+        if (context.ignoreAttachments)
+          continue;
+        const attachment = await parseAttachment(value);
+        context.attachments.set(attachment.id, attachment);
+        attachments2.push({
+          id: attachment.id,
+          contentType: attachment.contentType,
+          //TODO: better default names for attachments?
+          name: attachment.path ? path3.basename(attachment.path) : `attachment`
+        });
+      } else {
+        annotations.push({
+          type: key,
+          description: value.length ? value : void 0
+        });
+      }
+    }
+    const childElements = element.children.filter((child) => child instanceof XmlElement);
+    const xmlSkippedAnnotation = childElements.find((child) => child.name === "skipped");
+    if (xmlSkippedAnnotation)
+      annotations.push({ type: "skipped", description: xmlSkippedAnnotation.attributes["message"] });
+    const expectedStatus = xmlSkippedAnnotation ? "skipped" : "passed";
+    const errors = extractErrors(element);
+    const test = {
+      title: name,
+      location: file && !isNaN(line) ? {
+        file,
+        line,
+        column: 1
+      } : void 0,
+      attempts: [{
+        environmentIdx: currentEnvIndex,
+        expectedStatus,
+        annotations,
+        attachments: attachments2,
+        startTimestamp,
+        duration,
+        status: xmlSkippedAnnotation ? "skipped" : errors ? "failed" : "passed",
+        errors,
+        stdout: extractStdout(element, "system-out"),
+        stderr: extractStdout(element, "system-err")
+      }]
+    };
+    currentSuite.tests ??= [];
+    currentSuite.tests.push(test);
+  }
+  context = { ...context, currentEnv, currentEnvIndex, currentSuite, currentTimeMs };
+  for (const child of element.children)
+    await traverseJUnitReport(context, child);
+}
+async function parseJUnit(xmls, options) {
+  const report = {
+    category: "junit",
+    commitId: options.commitId,
+    duration: options.runDuration,
+    startTimestamp: options.runStartTimestamp,
+    url: options.runUrl,
+    environments: [options.defaultEnv],
+    suites: [],
+    unattributedErrors: []
+  };
+  const context = {
+    currentEnv: options.defaultEnv,
+    currentEnvIndex: 0,
+    currentTimeMs: 0,
+    report,
+    currentSuite: void 0,
+    attachments: /* @__PURE__ */ new Map(),
+    ignoreAttachments: !!options.ignoreAttachments
+  };
+  for (const xml of xmls) {
+    const doc = parseXml(xml);
+    for (const element of doc.children)
+      await traverseJUnitReport(context, element);
+  }
+  return {
+    report: ReportUtils2.dedupeSuitesTestsEnvironments(report),
+    attachments: Array.from(context.attachments.values())
+  };
+}
+
+// src/cli/cmd-convert.ts
+async function cmdConvert(junitPath, options) {
+  const fullPath = path4.resolve(junitPath);
+  if (!await fs4.access(fullPath, fs4.constants.F_OK).then(() => true).catch(() => false)) {
+    console.error(`Error: path ${fullPath} is not accessible`);
+    process.exit(1);
+  }
+  const stat = await fs4.stat(fullPath);
+  let xmlContents = [];
+  if (stat.isFile()) {
+    const xmlContent = await fs4.readFile(fullPath, "utf-8");
+    xmlContents.push(xmlContent);
+  } else if (stat.isDirectory()) {
+    const xmlFiles = await findXmlFiles(fullPath);
+    if (xmlFiles.length === 0) {
+      console.error(`Error: No XML files found in directory ${fullPath}`);
+      process.exit(1);
+    }
+    console.log(`Found ${xmlFiles.length} XML files`);
+    for (const xmlFile of xmlFiles) {
+      const xmlContent = await fs4.readFile(xmlFile, "utf-8");
+      xmlContents.push(xmlContent);
+    }
+  } else {
+    console.error(`Error: ${fullPath} is neither a file nor a directory`);
+    process.exit(1);
+  }
+  let commitId;
+  if (options.commitId) {
+    commitId = options.commitId;
+  } else {
+    try {
+      commitId = gitCommitInfo(process.cwd());
+    } catch (e) {
+      console.error("Failed to get git commit info. Please provide --commit-id option.");
+      process.exit(1);
+    }
+  }
+  const { report, attachments } = await parseJUnit(xmlContents, {
+    commitId,
+    defaultEnv: { name: options.envName },
+    runStartTimestamp: Date.now(),
+    runDuration: 0
+  });
+  await saveReportAndAttachments(report, attachments, options.outputDir);
+  console.log(`\u2713 Saved to ${options.outputDir}`);
+}
+async function findXmlFiles(dir, result = []) {
+  const entries = await fs4.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path4.join(dir, entry.name);
+    if (entry.isFile() && entry.name.toLowerCase().endsWith(".xml"))
+      result.push(fullPath);
+    else if (entry.isDirectory())
+      await findXmlFiles(fullPath, result);
+  }
+  return result;
+}
+
+// src/cli/cmd-download.ts
+import fs5 from "fs";
+import path5 from "path";
+async function cmdDownload(session2, project, runId, rootDir) {
+  if (fs5.existsSync(rootDir)) {
+    console.log(`Directory ${rootDir} already exists!`);
+    return;
+  }
+  const urls = await session2.api.run.downloadURLs.GET({
+    orgSlug: project.org.orgSlug,
+    projectSlug: project.projectSlug,
+    runId
+  });
+  const attachmentsDir = path5.join(rootDir, "attachments");
+  await fs5.promises.mkdir(rootDir, { recursive: true });
+  if (urls.attachmentURLs.length)
+    await fs5.promises.mkdir(attachmentsDir, { recursive: true });
+  const response = await fetch(urls.reportURL);
+  if (!response.ok)
+    throw new Error(`HTTP error ${response.status} for report URL: ${urls.reportURL}`);
+  const reportContent = await response.text();
+  await fs5.promises.writeFile(path5.join(rootDir, "report.json"), reportContent);
+  const attachmentDownloader = async () => {
+    while (urls.attachmentURLs.length) {
+      const url = urls.attachmentURLs.pop();
+      const response2 = await fetch(url);
+      if (!response2.ok)
+        throw new Error(`HTTP error ${response2.status} for attachment URL: ${url}`);
+      const fileBuffer = Buffer.from(await response2.arrayBuffer());
+      const filename = path5.basename(new URL(url).pathname);
+      await fs5.promises.writeFile(path5.join(attachmentsDir, filename), fileBuffer);
+    }
+  };
+  const workerPromises = [];
+  for (let i = 0; i < 4; ++i)
+    workerPromises.push(attachmentDownloader());
+  await Promise.all(workerPromises);
+}
+
+// src/cli/cmd-link.ts
+import { FlakinessProjectConfig } from "@flakiness/sdk/flakinessProjectConfig";
+async function cmdLink(session2, slug) {
+  const [orgSlug, projectSlug] = slug.split("/");
+  const project = await session2.api.project.findProject.GET({
+    orgSlug,
+    projectSlug
+  });
+  if (!project) {
+    console.log(`Failed to find project ${slug}`);
+    process.exit(1);
+  }
+  const config = FlakinessProjectConfig.createEmpty();
+  config.setProjectPublicId(project.projectPublicId);
+  await config.save();
+  console.log(`\u2713 Linked to ${session2.endpoint()}/${project.org.orgSlug}/${project.projectSlug}`);
+}
+
+// ../server/lib/common/knownClientIds.js
+var KNOWN_CLIENT_IDS = {
+  OFFICIAL_WEB: "flakiness-io-official-cli",
+  OFFICIAL_CLI: "flakiness-io-official-website"
+};
+
+// src/cli/cmd-login.ts
+import open from "open";
+import os3 from "os";
+
+// src/cli/cmd-logout.ts
+async function cmdLogout() {
+  const session2 = await FlakinessSession.load();
+  if (!session2)
+    return;
+  const currentSession = await session2.api.user.currentSession.GET().catch((e) => void 0);
+  if (currentSession)
+    await session2.api.user.logoutSession.POST({ sessionId: currentSession.sessionPublicId }).catch((e) => void 0);
+  await FlakinessSession.remove();
+}
+
+// src/cli/cmd-login.ts
+var DEFAULT_FLAKINESS_ENDPOINT = "https://flakiness.io";
+async function cmdLogin(endpoint = DEFAULT_FLAKINESS_ENDPOINT) {
+  await cmdLogout();
+  const api = createServerAPI(endpoint);
+  const data = await api.deviceauth.createRequest.POST({
+    clientId: KNOWN_CLIENT_IDS.OFFICIAL_CLI,
+    name: os3.hostname()
+  });
+  await open(new URL(data.verificationUrl, endpoint).href);
+  console.log(`Please navigate to ${new URL(data.verificationUrl, endpoint)}`);
+  let token;
+  while (Date.now() < data.deadline) {
+    await new Promise((x) => setTimeout(x, 2e3));
+    const result = await api.deviceauth.getToken.GET({ deviceCode: data.deviceCode }).catch((e) => void 0);
+    if (!result) {
+      console.error(`Authorization request was rejected.`);
+      process.exit(1);
+    }
+    token = result.token;
+    if (token)
+      break;
+  }
+  if (!token) {
+    console.log(`Failed to login.`);
+    process.exit(1);
+  }
+  const session2 = new FlakinessSession({
+    endpoint,
+    token
+  });
+  try {
+    const user = await session2.api.user.whoami.GET();
+    await session2.save();
+    console.log(`\u2713 Logged in as ${user.userName} (${user.userLogin})`);
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    console.error(`x Failed to login:`, message);
+  }
+  return session2;
+}
+
+// src/cli/cmd-status.ts
+import { FlakinessProjectConfig as FlakinessProjectConfig2 } from "@flakiness/sdk/flakinessProjectConfig";
+async function cmdStatus() {
+  const session2 = await FlakinessSession.load();
+  if (!session2) {
+    console.log(`user: not logged in`);
+    return;
+  }
+  const user = await session2.api.user.whoami.GET();
+  console.log(`user: ${user.userName} (${user.userLogin})`);
+  const config = await FlakinessProjectConfig2.load();
+  const projectPublicId = config.projectPublicId();
+  if (!projectPublicId) {
+    console.log(`project: <not linked>`);
+    return;
+  }
+  const project = await session2.api.project.getProject.GET({ projectPublicId });
+  console.log(`project: ${session2.endpoint()}/${project.org.orgSlug}/${project.projectSlug}`);
+}
+
+// src/cli/cmd-unlink.ts
+import { FlakinessProjectConfig as FlakinessProjectConfig3 } from "@flakiness/sdk/flakinessProjectConfig";
+async function cmdUnlink() {
+  const config = await FlakinessProjectConfig3.load();
+  if (!config.projectPublicId())
+    return;
+  config.setProjectPublicId(void 0);
+  await config.save();
+}
+
+// src/cli/cmd-upload-playwright-json.ts
+import { ReportUploader } from "@flakiness/sdk/uploader";
+import fs6 from "fs/promises";
+import path6 from "path";
+
+// src/playwrightJSONReport.ts
+import { FlakinessReport as FK2, ReportUtils as ReportUtils3 } from "@flakiness/report";
+import debug from "debug";
+import { posix as posixPath2 } from "path";
+var dlog = debug("flakiness:json-report");
+var PlaywrightJSONReport;
+((PlaywrightJSONReport2) => {
+  function collectMetadata(somePathInsideProject = process.cwd()) {
+    const commitId = gitCommitInfo(somePathInsideProject);
+    const osInfo = getOSInfo();
+    const metadata = {
+      gitRoot: computeGitRoot(somePathInsideProject),
+      commitId,
+      osName: osInfo.name,
+      arch: osInfo.arch,
+      osVersion: osInfo.version,
+      runURL: inferRunUrl()
+    };
+    dlog(`metadata directory: ${somePathInsideProject}`);
+    dlog(`metadata: ${JSON.stringify(metadata)}`);
+    dlog(`commit info: ${JSON.stringify(commitId)}`);
+    dlog(`os info: ${JSON.stringify(osInfo)}`);
+    return metadata;
+  }
+  PlaywrightJSONReport2.collectMetadata = collectMetadata;
+  async function parse(metadata, jsonReport, options) {
+    const context = {
+      projectId2environmentIdx: /* @__PURE__ */ new Map(),
+      testBaseDir: normalizePath(jsonReport.config.rootDir),
+      gitRoot: metadata.gitRoot,
+      attachments: /* @__PURE__ */ new Map(),
+      unaccessibleAttachmentPaths: [],
+      extractAttachments: options.extractAttachments
+    };
+    const configPath = jsonReport.config.configFile ? gitFilePath(context.gitRoot, normalizePath(jsonReport.config.configFile)) : void 0;
+    const report = {
+      category: FK2.CATEGORY_PLAYWRIGHT,
+      commitId: metadata.commitId,
+      configPath,
+      url: metadata.runURL,
+      environments: [],
+      suites: [],
+      opaqueData: jsonReport.config,
+      unattributedErrors: jsonReport.errors.map((error) => parseJSONError(context, error)),
+      // The report.stats is a releatively new addition to Playwright's JSONReport,
+      // so we have to polyfill with some reasonable values when it's missing.
+      duration: jsonReport.stats?.duration && jsonReport.stats?.duration > 0 ? parseDurationMS(jsonReport.stats.duration) : 0,
+      startTimestamp: jsonReport.stats && jsonReport.stats.startTime ? parseStringDate(jsonReport.stats.startTime) : Date.now()
+    };
+    report.environments = [...createEnvironments(jsonReport.config.projects).values()];
+    for (let envIdx = 0; envIdx < report.environments.length; ++envIdx)
+      context.projectId2environmentIdx.set(jsonReport.config.projects[envIdx].id, envIdx);
+    report.suites = await Promise.all(jsonReport.suites.map((suite) => parseJSONSuite(context, suite)));
+    return {
+      report: ReportUtils3.dedupeSuitesTestsEnvironments(report),
+      attachments: [...context.attachments.values()],
+      unaccessibleAttachmentPaths: context.unaccessibleAttachmentPaths
+    };
+  }
+  PlaywrightJSONReport2.parse = parse;
+})(PlaywrightJSONReport || (PlaywrightJSONReport = {}));
+async function parseJSONSuite(context, jsonSuite) {
+  let type = "suite";
+  if (jsonSuite.column === 0 && jsonSuite.line === 0)
+    type = "file";
+  else if (!jsonSuite.title)
+    type = "anonymous suite";
+  const suite = {
+    type,
+    title: jsonSuite.title,
+    location: {
+      file: gitFilePath(context.gitRoot, normalizePath(jsonSuite.file)),
+      line: jsonSuite.line,
+      column: jsonSuite.column
+    }
+  };
+  if (jsonSuite.suites && jsonSuite.suites.length)
+    suite.suites = await Promise.all(jsonSuite.suites.map((suite2) => parseJSONSuite(context, suite2)));
+  if (jsonSuite.specs && jsonSuite.specs.length)
+    suite.tests = await Promise.all(jsonSuite.specs.map((spec) => parseJSONSpec(context, spec)));
+  return suite;
+}
+async function parseJSONSpec(context, jsonSpec) {
+  const test = {
+    title: jsonSpec.title,
+    tags: jsonSpec.tags,
+    location: {
+      file: gitFilePath(context.gitRoot, normalizePath(posixPath2.join(context.testBaseDir, normalizePath(jsonSpec.file)))),
+      line: jsonSpec.line,
+      column: jsonSpec.column
+    },
+    attempts: []
+  };
+  for (const jsonTest of jsonSpec.tests) {
+    const environmentIdx = context.projectId2environmentIdx.get(jsonTest.projectId);
+    if (environmentIdx === void 0)
+      throw new Error("Inconsistent report - no project for a test found!");
+    const testResults = jsonTest.results.filter((result) => result.status !== void 0);
+    if (!testResults.length)
+      continue;
+    test.attempts.push(...await Promise.all(testResults.map((jsonTestResult) => parseJSONTestResult(context, jsonTest, environmentIdx, jsonTestResult))));
+  }
+  return test;
+}
+function createLocation(context, location) {
+  return {
+    file: gitFilePath(context.gitRoot, normalizePath(location.file)),
+    line: location.line,
+    column: location.column
+  };
+}
+async function parseJSONTestResult(context, jsonTest, environmentIdx, jsonTestResult) {
+  const attachments = [];
+  const attempt = {
+    timeout: parseDurationMS(jsonTest.timeout),
+    annotations: jsonTest.annotations.map((annotation) => ({
+      type: annotation.type,
+      description: annotation.description,
+      location: annotation.location ? createLocation(context, annotation.location) : void 0
+    })),
+    environmentIdx,
+    expectedStatus: jsonTest.expectedStatus,
+    parallelIndex: jsonTestResult.parallelIndex,
+    status: jsonTestResult.status,
+    errors: jsonTestResult.errors && jsonTestResult.errors.length ? jsonTestResult.errors.map((error) => parseJSONError(context, error)) : void 0,
+    stdout: jsonTestResult.stdout && jsonTestResult.stdout.length ? jsonTestResult.stdout : void 0,
+    stderr: jsonTestResult.stderr && jsonTestResult.stderr.length ? jsonTestResult.stderr : void 0,
+    steps: jsonTestResult.steps ? jsonTestResult.steps.map((jsonTestStep) => parseJSONTestStep(context, jsonTestStep)) : void 0,
+    startTimestamp: parseStringDate(jsonTestResult.startTime),
+    duration: jsonTestResult.duration && jsonTestResult.duration > 0 ? parseDurationMS(jsonTestResult.duration) : 0,
+    attachments
+  };
+  if (context.extractAttachments) {
+    await Promise.all((jsonTestResult.attachments ?? []).map(async (jsonAttachment) => {
+      if (jsonAttachment.path && !await existsAsync(jsonAttachment.path)) {
+        context.unaccessibleAttachmentPaths.push(jsonAttachment.path);
+        return;
+      }
+      const id = jsonAttachment.path ? await sha1File(jsonAttachment.path) : sha1Buffer(jsonAttachment.body ?? "");
+      context.attachments.set(id, {
+        contentType: jsonAttachment.contentType,
+        id,
+        body: jsonAttachment.body ? Buffer.from(jsonAttachment.body) : void 0,
+        path: jsonAttachment.path
+      });
+      attachments.push({
+        id,
+        name: jsonAttachment.name,
+        contentType: jsonAttachment.contentType
+      });
+    }));
+  }
+  return attempt;
+}
+function parseJSONTestStep(context, jsonStep) {
+  const step = {
+    // NOTE: jsonStep.duration was -1 in some playwright versions
+    duration: parseDurationMS(Math.max(jsonStep.duration, 0)),
+    title: jsonStep.title
+  };
+  if (jsonStep.error)
+    step.error = parseJSONError(context, jsonStep.error);
+  if (jsonStep.steps)
+    step.steps = jsonStep.steps.map((childJSONStep) => parseJSONTestStep(context, childJSONStep));
+  return step;
+}
+function parseJSONError(context, error) {
+  return {
+    location: error.location ? createLocation(context, error.location) : void 0,
+    message: error.message ? stripAnsi(error.message).split("\n")[0] : void 0,
+    stack: error.stack,
+    value: error.value
+  };
+}
+
+// src/cli/cmd-upload-playwright-json.ts
+async function cmdUploadPlaywrightJson(relativePath, options) {
+  const fullPath = path6.resolve(relativePath);
+  if (!await fs6.access(fullPath, fs6.constants.F_OK).then(() => true).catch(() => false)) {
+    console.error(`Error: path ${fullPath} is not accessible`);
+    process.exit(1);
+  }
+  const text = await fs6.readFile(fullPath, "utf-8");
+  const playwrightJson = JSON.parse(text);
+  const { attachments, report, unaccessibleAttachmentPaths } = await PlaywrightJSONReport.parse(PlaywrightJSONReport.collectMetadata(), playwrightJson, {
+    extractAttachments: true
+  });
+  for (const unaccessibleAttachment of unaccessibleAttachmentPaths)
+    console.warn(`WARN: cannot access attachment ${unaccessibleAttachment}`);
+  const uploader = new ReportUploader({
+    flakinessAccessToken: options.accessToken,
+    flakinessEndpoint: options.endpoint
+  });
+  const upload = uploader.createUpload(report, attachments);
+  const uploadResult = await upload.upload();
+  if (!uploadResult.success) {
+    console.log(`[flakiness.io] X Failed to upload to ${options.endpoint}: ${uploadResult.message}`);
+  } else {
+    console.log(`[flakiness.io] \u2713 Report uploaded ${uploadResult.reportUrl ?? uploadResult.message ?? ""}`);
+  }
+}
+
+// src/cli/cmd-upload.ts
+import { ReportUploader as ReportUploader2 } from "@flakiness/sdk/uploader";
+import chalk from "chalk";
+import fs7 from "fs/promises";
+import path7 from "path";
+var warn = (txt) => console.warn(chalk.yellow(`[flakiness.io] WARN: ${txt}`));
+var err = (txt) => console.error(chalk.red(`[flakiness.io] Error: ${txt}`));
+var log = (txt) => console.log(`[flakiness.io] ${txt}`);
+async function cmdUpload(relativePaths, options) {
+  const uploader = new ReportUploader2({
+    flakinessAccessToken: options.accessToken,
+    flakinessEndpoint: options.endpoint
+  });
+  for (const relativePath of relativePaths) {
+    const fullPath = path7.resolve(relativePath);
+    if (!await fs7.access(fullPath, fs7.constants.F_OK).then(() => true).catch(() => false)) {
+      err(`Path ${fullPath} is not accessible!`);
+      process.exit(1);
+    }
+    const text = await fs7.readFile(fullPath, "utf-8");
+    const report = JSON.parse(text);
+    const attachmentsDir = options.attachmentsDir ?? path7.dirname(fullPath);
+    const { attachmentIdToPath, missingAttachments } = await resolveAttachmentPaths(report, attachmentsDir);
+    if (missingAttachments.length) {
+      warn(`Missing ${missingAttachments.length} attachments`);
+    }
+    const upload = uploader.createUpload(report, Array.from(attachmentIdToPath.values()));
+    const uploadResult = await upload.upload();
+    if (!uploadResult.success) {
+      err(`Failed to upload to ${options.endpoint}: ${uploadResult.message}`);
+    } else {
+      log(`\u2713 Uploaded ${uploadResult.reportUrl ?? uploadResult.message ?? ""}`);
+    }
+  }
+}
+
+// src/cli/cmd-whoami.ts
+async function cmdWhoami() {
+  const session2 = await FlakinessSession.load();
+  if (!session2) {
+    console.log('Not logged in. Run "flakiness login" first.');
+    process.exit(1);
+  }
+  console.log(`Logged into ${session2.endpoint()}`);
+  const user = await session2.api.user.whoami.GET();
+  console.log(user);
+}
+
+// src/cli/cli.ts
+var session = await FlakinessSession.load();
+var optAccessToken = new Option("-t, --access-token <token>", "A read-write flakiness.io access token").env("FLAKINESS_ACCESS_TOKEN");
+var optEndpoint = new Option("-e, --endpoint <url>", "An endpoint where the service is deployed").default(session?.endpoint() ?? DEFAULT_FLAKINESS_ENDPOINT).env("FLAKINESS_ENDPOINT");
+var optAttachmentsDir = new Option("--attachments-dir <dir>", "Directory containing attachments to upload. Defaults to the report directory");
+async function runCommand(callback) {
+  try {
+    await callback();
+  } catch (e) {
+    if (!(e instanceof Error))
+      throw e;
+    console.error(errorText(e));
+    process.exit(1);
+  }
+}
+var program = new Command().name("flakiness").description("Flakiness CLI tool").version(package_default.version);
+async function ensureAccessToken(options) {
+  let accessToken = options.accessToken;
+  if (!accessToken) {
+    const config = await FlakinessProjectConfig4.load();
+    const projectPublicId = config.projectPublicId();
+    if (session && projectPublicId) {
+      try {
+        accessToken = (await session.api.project.getProject.GET({ projectPublicId })).readWriteAccessToken;
+      } catch (e) {
+        if (e instanceof TypedHTTP2.HttpError && e.status === 404) {
+        } else {
+          throw e;
+        }
+      }
+    }
+  }
+  assert3(accessToken, `Please either pass FLAKINESS_ACCESS_TOKEN or run login + link`);
+  return {
+    ...options,
+    accessToken
+  };
+}
+program.command("upload-playwright-json", { hidden: true }).description("Upload Playwright Test JSON report to the flakiness.io service").argument("<relative-path-to-json>", "Path to the Playwright JSON report file").addOption(optAccessToken).addOption(optEndpoint).action(async (relativePath, options) => runCommand(async () => {
+  await cmdUploadPlaywrightJson(relativePath, await ensureAccessToken(options));
+}));
+program.command("login").description("Login to the Flakiness.io service").addOption(optEndpoint).action(async (options) => runCommand(async () => {
+  await cmdLogin(options.endpoint);
+}));
+program.command("logout").description("Logout from current session").action(async () => runCommand(async () => {
+  await cmdLogout();
+}));
+program.command("whoami").description("Show current logged in user information").action(async () => runCommand(async () => {
+  await cmdWhoami();
+}));
+program.command("link").description("Link repository to the flakiness project").addOption(optEndpoint).argument("flakiness.io/org/project", "A URL of the Flakiness.io project").action(async (slugOrUrl, options) => runCommand(async () => {
+  let slug = slugOrUrl;
+  let endpoint = options.endpoint;
+  if (slugOrUrl.startsWith("http://") || slugOrUrl.startsWith("https://")) {
+    const url = URL.parse(slugOrUrl);
+    if (!url) {
+      console.error(`Invalid URL: ${slugOrUrl}`);
+      process.exit(1);
+    }
+    slug = url.pathname.substring(1);
+    endpoint = url.origin;
+  } else if (slugOrUrl.startsWith("flakiness.io/")) {
+    endpoint = "https://flakiness.io";
+    slug = slugOrUrl.substring("flakiness.io/".length);
+  }
+  let session2 = await FlakinessSession.load();
+  if (!session2 || session2.endpoint() !== endpoint || await session2.api.user.whoami.GET().catch((e) => void 0) === void 0)
+    session2 = await cmdLogin(endpoint);
+  await cmdLink(session2, slug);
+}));
+program.command("unlink").description("Unlink repository from the flakiness project").action(async () => runCommand(async () => {
+  await cmdUnlink();
+}));
+program.command("status").description("Status repository from the flakiness project").action(async () => runCommand(async () => {
+  await cmdStatus();
+}));
+var optRunId = new Option("--run-id <runId>", "RunId flakiness.io access token").argParser((value) => {
+  const parsed = parseInt(value, 10);
+  if (isNaN(parsed) || parsed < 1) {
+    throw new Error("runId must be a number >= 1");
+  }
+  return parsed;
+});
+var optSince = new Option("--since <date>", "Start date for filtering").argParser((value) => {
+  const parsed = new Date(value);
+  if (isNaN(parsed.getTime())) {
+    throw new Error("Invalid date format");
+  }
+  return parsed;
+});
+var optParallel = new Option("-j, --parallel <date>", "Parallel jobs to run").argParser((value) => {
+  const parsed = parseInt(value, 10);
+  if (isNaN(parsed) || parsed < 1) {
+    throw new Error("parallel must be a number >= 1");
+  }
+  return parsed;
+});
+program.command("download").description("Download run").addOption(optSince).addOption(optRunId).addOption(optParallel).action(async (options) => runCommand(async () => {
+  const config = await FlakinessProjectConfig4.load();
+  const session2 = await FlakinessSession.loadOrDie();
+  const projectPublicId = config.projectPublicId();
+  if (!projectPublicId)
+    throw new Error(`Please link to flakiness project with 'npx flakiness link'`);
+  const project = await session2.api.project.getProject.GET({ projectPublicId }).catch((e) => void 0);
+  if (!project)
+    throw new Error(`Failed to fetch linked project; please re-link with 'npx flakiness link'`);
+  let runIds = [];
+  if (options.runId) {
+    runIds = [options.runId, options.runId];
+  } else if (options.since) {
+    runIds = await session2.api.project.listRuns.GET({
+      orgSlug: project.org.orgSlug,
+      projectSlug: project.projectSlug,
+      sinceTimestampMs: +options.since
+    });
+    console.log(`Found ${Ranges.cardinality(runIds)} reports uploaded since ${options.since}`);
+  }
+  const alreadyExisting = fs8.readdirSync(process.cwd());
+  const downloadedRuns = alreadyExisting.filter((entry) => entry.startsWith("fkrun-")).map((run) => parseInt(run.substring(`fkrun-`.length), 10)).filter((runId) => !isNaN(runId));
+  console.log(`Found ${downloadedRuns.length} locally downloaded reports`);
+  const toBeDownloaded = Ranges.subtract(runIds, Ranges.fromList(downloadedRuns));
+  console.log(`Downloading ${Ranges.cardinality(toBeDownloaded)} reports`);
+  const it = Ranges.iterate(toBeDownloaded);
+  const downloaders = [];
+  const spinner = ora("Downloading reports:").start();
+  const total = Ranges.cardinality(toBeDownloaded);
+  let downloaded = 0;
+  for (let i = 0; i < (options.parallel ?? 1); ++i) {
+    downloaders.push((async () => {
+      for (let result = it.next(); !result.done; result = it.next()) {
+        const runId = result.value;
+        await cmdDownload(session2, project, result.value, `fkrun-${runId}`);
+        ++downloaded;
+        spinner.text = `Downloaded ${Math.floor(downloaded / total * 100)}% [${downloaded}/${total}] reports`;
+      }
+    })());
+  }
+  await Promise.all(downloaders);
+  spinner.stop();
+}));
+program.command("upload").description("Upload Flakiness report to the flakiness.io service").argument("<relative-paths...>", "Paths to the Flakiness report files").addOption(optAccessToken).addOption(optEndpoint).addOption(optAttachmentsDir).action(async (relativePaths, options) => {
+  await runCommand(async () => {
+    await cmdUpload(relativePaths, await ensureAccessToken(options));
+  });
+});
+program.command("show").description("Show flakiness report").argument("[relative-path]", "Path to the Flakiness report file or folder that contains `report.json`. (default: flakiness-report)").action(async (arg) => runCommand(async () => {
+  const dir = path8.resolve(arg ?? "flakiness-report");
+  await showReport(dir);
+}));
+program.command("convert-junit").description("Convert JUnit XML report(s) to Flakiness report format").argument("<junit-root-dir-path>", "Path to JUnit XML file or directory containing XML files").option("--env-name <name>", "Environment name for the report", "junit").option("--commit-id <id>", "Git commit ID (auto-detected if not provided)").option("--output-dir <dir>", "Output directory for the report", "flakiness-report").action(async (junitPath, options) => {
+  await runCommand(async () => {
+    await cmdConvert(junitPath, options);
+  });
+});
+await program.parseAsync();
+//# sourceMappingURL=cli.js.map