tribuchet: building on eliza
An example execution:

[State 0]
{
  schedFixed::scheduler::cl: Map("c1" -> CIdle, "c2" -> CIdle),
  schedFixed::scheduler::crashes: 0,
  schedFixed::scheduler::entry: [],
  schedFixed::scheduler::free: Map("w1" -> 1, "w2" -> 1),
  schedFixed::scheduler::mAssigned: Set(),
  schedFixed::scheduler::mBuild: Set(),
  schedFixed::scheduler::mDone: Set(),
  schedFixed::scheduler::mExpect: Set(),
  schedFixed::scheduler::mResult: Set(),
  schedFixed::scheduler::mRetry: Set(),
  schedFixed::scheduler::mSchedule: Set(),
  schedFixed::scheduler::published: 0,
  schedFixed::scheduler::publishedBy: Set(),
  schedFixed::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 1]
{
  schedFixed::scheduler::cl: Map("c1" -> CQueued, "c2" -> CIdle),
  schedFixed::scheduler::crashes: 0,
  schedFixed::scheduler::entry: [],
  schedFixed::scheduler::free: Map("w1" -> 1, "w2" -> 1),
  schedFixed::scheduler::mAssigned: Set(),
  schedFixed::scheduler::mBuild: Set(),
  schedFixed::scheduler::mDone: Set(),
  schedFixed::scheduler::mExpect: Set(),
  schedFixed::scheduler::mResult: Set(),
  schedFixed::scheduler::mRetry: Set(),
  schedFixed::scheduler::mSchedule: Set("c1"),
  schedFixed::scheduler::published: 0,
  schedFixed::scheduler::publishedBy: Set(),
  schedFixed::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 2]
{
  schedFixed::scheduler::cl: Map("c1" -> CQueued, "c2" -> CIdle),
  schedFixed::scheduler::crashes: 0,
  schedFixed::scheduler::entry:
    [{ followers: Set("c1"), leased: true, worker: "w1" }],
  schedFixed::scheduler::free: Map("w1" -> 0, "w2" -> 1),
  schedFixed::scheduler::mAssigned: Set(("c1", "w1")),
  schedFixed::scheduler::mBuild: Set(),
  schedFixed::scheduler::mDone: Set(),
  schedFixed::scheduler::mExpect: Set("w1"),
  schedFixed::scheduler::mResult: Set(),
  schedFixed::scheduler::mRetry: Set(),
  schedFixed::scheduler::mSchedule: Set(),
  schedFixed::scheduler::published: 0,
  schedFixed::scheduler::publishedBy: Set(),
  schedFixed::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 3]
{
  schedFixed::scheduler::cl: Map("c1" -> CQueued, "c2" -> CQueued),
  schedFixed::scheduler::crashes: 0,
  schedFixed::scheduler::entry:
    [{ followers: Set("c1"), leased: true, worker: "w1" }],
  schedFixed::scheduler::free: Map("w1" -> 0, "w2" -> 1),
  schedFixed::scheduler::mAssigned: Set(("c1", "w1")),
  schedFixed::scheduler::mBuild: Set(),
  schedFixed::scheduler::mDone: Set(),
  schedFixed::scheduler::mExpect: Set("w1"),
  schedFixed::scheduler::mResult: Set(),
  schedFixed::scheduler::mRetry: Set(),
  schedFixed::scheduler::mSchedule: Set("c2"),
  schedFixed::scheduler::published: 0,
  schedFixed::scheduler::publishedBy: Set(),
  schedFixed::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 4]
{
  schedFixed::scheduler::cl: Map("c1" -> CQueued, "c2" -> CQueued),
  schedFixed::scheduler::crashes: 1,
  schedFixed::scheduler::entry:
    [{ followers: Set("c1"), leased: true, worker: "w1" }],
  schedFixed::scheduler::free: Map("w1" -> 0, "w2" -> 1),
  schedFixed::scheduler::mAssigned: Set(("c1", "w1")),
  schedFixed::scheduler::mBuild: Set(),
  schedFixed::scheduler::mDone: Set(),
  schedFixed::scheduler::mExpect: Set("w1"),
  schedFixed::scheduler::mResult: Set(),
  schedFixed::scheduler::mRetry: Set(),
  schedFixed::scheduler::mSchedule: Set("c2"),
  schedFixed::scheduler::published: 0,
  schedFixed::scheduler::publishedBy: Set(),
  schedFixed::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: false,
          up: false
        }
    )
}

[State 5]
{
  schedFixed::scheduler::cl: Map("c1" -> CSent("w1"), "c2" -> CQueued),
  schedFixed::scheduler::crashes: 1,
  schedFixed::scheduler::entry:
    [{ followers: Set("c1"), leased: true, worker: "w1" }],
  schedFixed::scheduler::free: Map("w1" -> 0, "w2" -> 1),
  schedFixed::scheduler::mAssigned: Set(),
  schedFixed::scheduler::mBuild: Set(("c1", "w1")),
  schedFixed::scheduler::mDone: Set(),
  schedFixed::scheduler::mExpect: Set("w1"),
  schedFixed::scheduler::mResult: Set(),
  schedFixed::scheduler::mRetry: Set(),
  schedFixed::scheduler::mSchedule: Set("c2"),
  schedFixed::scheduler::published: 0,
  schedFixed::scheduler::publishedBy: Set(),
  schedFixed::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: false,
          up: false
        }
    )
}

[State 6]
{
  schedFixed::scheduler::cl: Map("c1" -> CSent("w1"), "c2" -> CQueued),
  schedFixed::scheduler::crashes: 1,
  schedFixed::scheduler::entry:
    [{ followers: Set("c1"), leased: true, worker: "w1" }],
  schedFixed::scheduler::free: Map("w1" -> 0, "w2" -> 1),
  schedFixed::scheduler::mAssigned: Set(),
  schedFixed::scheduler::mBuild: Set(),
  schedFixed::scheduler::mDone: Set(),
  schedFixed::scheduler::mExpect: Set("w1"),
  schedFixed::scheduler::mResult: Set(),
  schedFixed::scheduler::mRetry: Set("c1"),
  schedFixed::scheduler::mSchedule: Set("c2"),
  schedFixed::scheduler::published: 0,
  schedFixed::scheduler::publishedBy: Set(),
  schedFixed::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: false,
          up: false
        }
    )
}

[State 7]
{
  schedFixed::scheduler::cl: Map("c1" -> CSent("w1"), "c2" -> CQueued),
  schedFixed::scheduler::crashes: 1,
  schedFixed::scheduler::entry:
    [{ followers: Set("c1", "c2"), leased: true, worker: "w1" }],
  schedFixed::scheduler::free: Map("w1" -> 0, "w2" -> 1),
  schedFixed::scheduler::mAssigned: Set(("c2", "w1")),
  schedFixed::scheduler::mBuild: Set(),
  schedFixed::scheduler::mDone: Set(),
  schedFixed::scheduler::mExpect: Set("w1"),
  schedFixed::scheduler::mResult: Set(),
  schedFixed::scheduler::mRetry: Set("c1"),
  schedFixed::scheduler::mSchedule: Set(),
  schedFixed::scheduler::published: 0,
  schedFixed::scheduler::publishedBy: Set(),
  schedFixed::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: false,
          up: false
        }
    )
}

[State 8]
{
  schedFixed::scheduler::cl: Map("c1" -> CSent("w1"), "c2" -> CQueued),
  schedFixed::scheduler::crashes: 1,
  schedFixed::scheduler::entry:
    [{ followers: Set("c1", "c2"), leased: true, worker: "w1" }],
  schedFixed::scheduler::free: Map("w1" -> 0, "w2" -> 1),
  schedFixed::scheduler::mAssigned: Set(("c2", "w1")),
  schedFixed::scheduler::mBuild: Set(),
  schedFixed::scheduler::mDone: Set(),
  schedFixed::scheduler::mExpect: Set("w1"),
  schedFixed::scheduler::mResult: Set(),
  schedFixed::scheduler::mRetry: Set("c1"),
  schedFixed::scheduler::mSchedule: Set(),
  schedFixed::scheduler::published: 0,
  schedFixed::scheduler::publishedBy: Set(),
  schedFixed::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 9]
{
  schedFixed::scheduler::cl: Map("c1" -> CSent("w1"), "c2" -> CQueued),
  schedFixed::scheduler::crashes: 2,
  schedFixed::scheduler::entry: [],
  schedFixed::scheduler::free: Map("w1" -> 1, "w2" -> 1),
  schedFixed::scheduler::mAssigned: Set(),
  schedFixed::scheduler::mBuild: Set(),
  schedFixed::scheduler::mDone: Set(),
  schedFixed::scheduler::mExpect: Set(),
  schedFixed::scheduler::mResult: Set(),
  schedFixed::scheduler::mRetry: Set("c1", "c2"),
  schedFixed::scheduler::mSchedule: Set(),
  schedFixed::scheduler::published: 0,
  schedFixed::scheduler::publishedBy: Set(),
  schedFixed::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 10]
{
  schedFixed::scheduler::cl: Map("c1" -> CQueued, "c2" -> CQueued),
  schedFixed::scheduler::crashes: 2,
  schedFixed::scheduler::entry: [],
  schedFixed::scheduler::free: Map("w1" -> 1, "w2" -> 1),
  schedFixed::scheduler::mAssigned: Set(),
  schedFixed::scheduler::mBuild: Set(),
  schedFixed::scheduler::mDone: Set(),
  schedFixed::scheduler::mExpect: Set(),
  schedFixed::scheduler::mResult: Set(),
  schedFixed::scheduler::mRetry: Set("c2"),
  schedFixed::scheduler::mSchedule: Set("c1"),
  schedFixed::scheduler::published: 0,
  schedFixed::scheduler::publishedBy: Set(),
  schedFixed::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 11]
{
  schedFixed::scheduler::cl: Map("c1" -> CQueued, "c2" -> CQueued),
  schedFixed::scheduler::crashes: 2,
  schedFixed::scheduler::entry: [],
  schedFixed::scheduler::free: Map("w1" -> 1, "w2" -> 1),
  schedFixed::scheduler::mAssigned: Set(),
  schedFixed::scheduler::mBuild: Set(),
  schedFixed::scheduler::mDone: Set(),
  schedFixed::scheduler::mExpect: Set(),
  schedFixed::scheduler::mResult: Set(),
  schedFixed::scheduler::mRetry: Set(),
  schedFixed::scheduler::mSchedule: Set("c1", "c2"),
  schedFixed::scheduler::published: 0,
  schedFixed::scheduler::publishedBy: Set(),
  schedFixed::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 12]
{
  schedFixed::scheduler::cl: Map("c1" -> CQueued, "c2" -> CQueued),
  schedFixed::scheduler::crashes: 2,
  schedFixed::scheduler::entry:
    [{ followers: Set("c2"), leased: true, worker: "w1" }],
  schedFixed::scheduler::free: Map("w1" -> 0, "w2" -> 1),
  schedFixed::scheduler::mAssigned: Set(("c2", "w1")),
  schedFixed::scheduler::mBuild: Set(),
  schedFixed::scheduler::mDone: Set(),
  schedFixed::scheduler::mExpect: Set("w1"),
  schedFixed::scheduler::mResult: Set(),
  schedFixed::scheduler::mRetry: Set(),
  schedFixed::scheduler::mSchedule: Set("c1"),
  schedFixed::scheduler::published: 0,
  schedFixed::scheduler::publishedBy: Set(),
  schedFixed::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 13]
{
  schedFixed::scheduler::cl: Map("c1" -> CQueued, "c2" -> CQueued),
  schedFixed::scheduler::crashes: 2,
  schedFixed::scheduler::entry:
    [{ followers: Set("c1", "c2"), leased: true, worker: "w1" }],
  schedFixed::scheduler::free: Map("w1" -> 0, "w2" -> 1),
  schedFixed::scheduler::mAssigned: Set(("c1", "w1"), ("c2", "w1")),
  schedFixed::scheduler::mBuild: Set(),
  schedFixed::scheduler::mDone: Set(),
  schedFixed::scheduler::mExpect: Set("w1"),
  schedFixed::scheduler::mResult: Set(),
  schedFixed::scheduler::mRetry: Set(),
  schedFixed::scheduler::mSchedule: Set(),
  schedFixed::scheduler::published: 0,
  schedFixed::scheduler::publishedBy: Set(),
  schedFixed::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 14]
{
  schedFixed::scheduler::cl: Map("c1" -> CSent("w1"), "c2" -> CQueued),
  schedFixed::scheduler::crashes: 2,
  schedFixed::scheduler::entry:
    [{ followers: Set("c1", "c2"), leased: true, worker: "w1" }],
  schedFixed::scheduler::free: Map("w1" -> 0, "w2" -> 1),
  schedFixed::scheduler::mAssigned: Set(("c2", "w1")),
  schedFixed::scheduler::mBuild: Set(("c1", "w1")),
  schedFixed::scheduler::mDone: Set(),
  schedFixed::scheduler::mExpect: Set("w1"),
  schedFixed::scheduler::mResult: Set(),
  schedFixed::scheduler::mRetry: Set(),
  schedFixed::scheduler::mSchedule: Set(),
  schedFixed::scheduler::published: 0,
  schedFixed::scheduler::publishedBy: Set(),
  schedFixed::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 15]
{
  schedFixed::scheduler::cl: Map("c1" -> CSent("w1"), "c2" -> CQueued),
  schedFixed::scheduler::crashes: 2,
  schedFixed::scheduler::entry:
    [{ followers: Set("c1", "c2"), leased: true, worker: "w1" }],
  schedFixed::scheduler::free: Map("w1" -> 0, "w2" -> 1),
  schedFixed::scheduler::mAssigned: Set(("c2", "w1")),
  schedFixed::scheduler::mBuild: Set(),
  schedFixed::scheduler::mDone: Set(),
  schedFixed::scheduler::mExpect: Set("w1"),
  schedFixed::scheduler::mResult: Set(),
  schedFixed::scheduler::mRetry: Set("c1"),
  schedFixed::scheduler::mSchedule: Set(),
  schedFixed::scheduler::published: 0,
  schedFixed::scheduler::publishedBy: Set(),
  schedFixed::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 16]
{
  schedFixed::scheduler::cl: Map("c1" -> CSent("w1"), "c2" -> CSent("w1")),
  schedFixed::scheduler::crashes: 2,
  schedFixed::scheduler::entry:
    [{ followers: Set("c1", "c2"), leased: true, worker: "w1" }],
  schedFixed::scheduler::free: Map("w1" -> 0, "w2" -> 1),
  schedFixed::scheduler::mAssigned: Set(),
  schedFixed::scheduler::mBuild: Set(("c2", "w1")),
  schedFixed::scheduler::mDone: Set(),
  schedFixed::scheduler::mExpect: Set("w1"),
  schedFixed::scheduler::mResult: Set(),
  schedFixed::scheduler::mRetry: Set("c1"),
  schedFixed::scheduler::mSchedule: Set(),
  schedFixed::scheduler::published: 0,
  schedFixed::scheduler::publishedBy: Set(),
  schedFixed::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 17]
{
  schedFixed::scheduler::cl: Map("c1" -> CSent("w1"), "c2" -> CSent("w1")),
  schedFixed::scheduler::crashes: 2,
  schedFixed::scheduler::entry:
    [{ followers: Set("c1", "c2"), leased: true, worker: "w1" }],
  schedFixed::scheduler::free: Map("w1" -> 0, "w2" -> 1),
  schedFixed::scheduler::mAssigned: Set(),
  schedFixed::scheduler::mBuild: Set(),
  schedFixed::scheduler::mDone: Set(),
  schedFixed::scheduler::mExpect: Set("w1"),
  schedFixed::scheduler::mResult: Set(),
  schedFixed::scheduler::mRetry: Set("c1", "c2"),
  schedFixed::scheduler::mSchedule: Set(),
  schedFixed::scheduler::published: 0,
  schedFixed::scheduler::publishedBy: Set(),
  schedFixed::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 18]
{
  schedFixed::scheduler::cl: Map("c1" -> CSent("w1"), "c2" -> CQueued),
  schedFixed::scheduler::crashes: 2,
  schedFixed::scheduler::entry:
    [{ followers: Set("c1", "c2"), leased: true, worker: "w1" }],
  schedFixed::scheduler::free: Map("w1" -> 0, "w2" -> 1),
  schedFixed::scheduler::mAssigned: Set(),
  schedFixed::scheduler::mBuild: Set(),
  schedFixed::scheduler::mDone: Set(),
  schedFixed::scheduler::mExpect: Set("w1"),
  schedFixed::scheduler::mResult: Set(),
  schedFixed::scheduler::mRetry: Set("c1"),
  schedFixed::scheduler::mSchedule: Set("c2"),
  schedFixed::scheduler::published: 0,
  schedFixed::scheduler::publishedBy: Set(),
  schedFixed::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 19]
{
  schedFixed::scheduler::cl: Map("c1" -> CSent("w1"), "c2" -> CQueued),
  schedFixed::scheduler::crashes: 2,
  schedFixed::scheduler::entry:
    [{ followers: Set("c1", "c2"), leased: true, worker: "w1" }],
  schedFixed::scheduler::free: Map("w1" -> 0, "w2" -> 1),
  schedFixed::scheduler::mAssigned: Set(("c2", "w1")),
  schedFixed::scheduler::mBuild: Set(),
  schedFixed::scheduler::mDone: Set(),
  schedFixed::scheduler::mExpect: Set("w1"),
  schedFixed::scheduler::mResult: Set(),
  schedFixed::scheduler::mRetry: Set("c1"),
  schedFixed::scheduler::mSchedule: Set(),
  schedFixed::scheduler::published: 0,
  schedFixed::scheduler::publishedBy: Set(),
  schedFixed::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 20]
{
  schedFixed::scheduler::cl: Map("c1" -> CSent("w1"), "c2" -> CQueued),
  schedFixed::scheduler::crashes: 2,
  schedFixed::scheduler::entry:
    [{ followers: Set("c1", "c2"), leased: true, worker: "w1" }],
  schedFixed::scheduler::free: Map("w1" -> 0, "w2" -> 1),
  schedFixed::scheduler::mAssigned: Set(("c2", "w1")),
  schedFixed::scheduler::mBuild: Set(),
  schedFixed::scheduler::mDone: Set(),
  schedFixed::scheduler::mExpect: Set(),
  schedFixed::scheduler::mResult: Set(),
  schedFixed::scheduler::mRetry: Set("c1"),
  schedFixed::scheduler::mSchedule: Set(),
  schedFixed::scheduler::published: 0,
  schedFixed::scheduler::publishedBy: Set(),
  schedFixed::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: true,
          running: true,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 21]
{
  schedFixed::scheduler::cl: Map("c1" -> CSent("w1"), "c2" -> CSent("w1")),
  schedFixed::scheduler::crashes: 2,
  schedFixed::scheduler::entry:
    [{ followers: Set("c1", "c2"), leased: true, worker: "w1" }],
  schedFixed::scheduler::free: Map("w1" -> 0, "w2" -> 1),
  schedFixed::scheduler::mAssigned: Set(),
  schedFixed::scheduler::mBuild: Set(("c2", "w1")),
  schedFixed::scheduler::mDone: Set(),
  schedFixed::scheduler::mExpect: Set(),
  schedFixed::scheduler::mResult: Set(),
  schedFixed::scheduler::mRetry: Set("c1"),
  schedFixed::scheduler::mSchedule: Set(),
  schedFixed::scheduler::published: 0,
  schedFixed::scheduler::publishedBy: Set(),
  schedFixed::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: true,
          running: true,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 22]
{
  schedFixed::scheduler::cl: Map("c1" -> CQueued, "c2" -> CSent("w1")),
  schedFixed::scheduler::crashes: 2,
  schedFixed::scheduler::entry:
    [{ followers: Set("c1", "c2"), leased: true, worker: "w1" }],
  schedFixed::scheduler::free: Map("w1" -> 0, "w2" -> 1),
  schedFixed::scheduler::mAssigned: Set(),
  schedFixed::scheduler::mBuild: Set(("c2", "w1")),
  schedFixed::scheduler::mDone: Set(),
  schedFixed::scheduler::mExpect: Set(),
  schedFixed::scheduler::mResult: Set(),
  schedFixed::scheduler::mRetry: Set(),
  schedFixed::scheduler::mSchedule: Set("c1"),
  schedFixed::scheduler::published: 0,
  schedFixed::scheduler::publishedBy: Set(),
  schedFixed::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: true,
          running: true,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 23]
{
  schedFixed::scheduler::cl: Map("c1" -> CQueued, "c2" -> CSent("w1")),
  schedFixed::scheduler::crashes: 2,
  schedFixed::scheduler::entry:
    [{ followers: Set("c1", "c2"), leased: true, worker: "w1" }],
  schedFixed::scheduler::free: Map("w1" -> 0, "w2" -> 1),
  schedFixed::scheduler::mAssigned: Set(("c1", "w1")),
  schedFixed::scheduler::mBuild: Set(("c2", "w1")),
  schedFixed::scheduler::mDone: Set(),
  schedFixed::scheduler::mExpect: Set(),
  schedFixed::scheduler::mResult: Set(),
  schedFixed::scheduler::mRetry: Set(),
  schedFixed::scheduler::mSchedule: Set(),
  schedFixed::scheduler::published: 0,
  schedFixed::scheduler::publishedBy: Set(),
  schedFixed::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: true,
          running: true,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 24]
{
  schedFixed::scheduler::cl: Map("c1" -> CQueued, "c2" -> CSent("w1")),
  schedFixed::scheduler::crashes: 2,
  schedFixed::scheduler::entry:
    [{ followers: Set("c1", "c2"), leased: true, worker: "w1" }],
  schedFixed::scheduler::free: Map("w1" -> 0, "w2" -> 1),
  schedFixed::scheduler::mAssigned: Set(("c1", "w1")),
  schedFixed::scheduler::mBuild: Set(("c2", "w1")),
  schedFixed::scheduler::mDone: Set("w1"),
  schedFixed::scheduler::mExpect: Set(),
  schedFixed::scheduler::mResult: Set(),
  schedFixed::scheduler::mRetry: Set(),
  schedFixed::scheduler::mSchedule: Set(),
  schedFixed::scheduler::published: 1,
  schedFixed::scheduler::publishedBy: Set("w1"),
  schedFixed::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: true,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 25]
{
  schedFixed::scheduler::cl: Map("c1" -> CQueued, "c2" -> CSent("w1")),
  schedFixed::scheduler::crashes: 2,
  schedFixed::scheduler::entry:
    [{ followers: Set("c1", "c2"), leased: true, worker: "w1" }],
  schedFixed::scheduler::free: Map("w1" -> 0, "w2" -> 1),
  schedFixed::scheduler::mAssigned: Set(("c1", "w1")),
  schedFixed::scheduler::mBuild: Set(),
  schedFixed::scheduler::mDone: Set("w1"),
  schedFixed::scheduler::mExpect: Set(),
  schedFixed::scheduler::mResult: Set("c2"),
  schedFixed::scheduler::mRetry: Set(),
  schedFixed::scheduler::mSchedule: Set(),
  schedFixed::scheduler::published: 1,
  schedFixed::scheduler::publishedBy: Set("w1"),
  schedFixed::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: true,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 26]
{
  schedFixed::scheduler::cl: Map("c1" -> CQueued, "c2" -> CSent("w1")),
  schedFixed::scheduler::crashes: 2,
  schedFixed::scheduler::entry: [],
  schedFixed::scheduler::free: Map("w1" -> 1, "w2" -> 1),
  schedFixed::scheduler::mAssigned: Set(("c1", "w1")),
  schedFixed::scheduler::mBuild: Set(),
  schedFixed::scheduler::mDone: Set(),
  schedFixed::scheduler::mExpect: Set(),
  schedFixed::scheduler::mResult: Set("c2"),
  schedFixed::scheduler::mRetry: Set(),
  schedFixed::scheduler::mSchedule: Set(),
  schedFixed::scheduler::published: 1,
  schedFixed::scheduler::publishedBy: Set("w1"),
  schedFixed::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: true,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 27]
{
  schedFixed::scheduler::cl: Map("c1" -> CQueued, "c2" -> CDone),
  schedFixed::scheduler::crashes: 2,
  schedFixed::scheduler::entry: [],
  schedFixed::scheduler::free: Map("w1" -> 1, "w2" -> 1),
  schedFixed::scheduler::mAssigned: Set(("c1", "w1")),
  schedFixed::scheduler::mBuild: Set(),
  schedFixed::scheduler::mDone: Set(),
  schedFixed::scheduler::mExpect: Set(),
  schedFixed::scheduler::mResult: Set(),
  schedFixed::scheduler::mRetry: Set(),
  schedFixed::scheduler::mSchedule: Set(),
  schedFixed::scheduler::published: 1,
  schedFixed::scheduler::publishedBy: Set("w1"),
  schedFixed::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: true,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 28]
{
  schedFixed::scheduler::cl: Map("c1" -> CSent("w1"), "c2" -> CDone),
  schedFixed::scheduler::crashes: 2,
  schedFixed::scheduler::entry: [],
  schedFixed::scheduler::free: Map("w1" -> 1, "w2" -> 1),
  schedFixed::scheduler::mAssigned: Set(),
  schedFixed::scheduler::mBuild: Set(("c1", "w1")),
  schedFixed::scheduler::mDone: Set(),
  schedFixed::scheduler::mExpect: Set(),
  schedFixed::scheduler::mResult: Set(),
  schedFixed::scheduler::mRetry: Set(),
  schedFixed::scheduler::mSchedule: Set(),
  schedFixed::scheduler::published: 1,
  schedFixed::scheduler::publishedBy: Set("w1"),
  schedFixed::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: true,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 29]
{
  schedFixed::scheduler::cl: Map("c1" -> CSent("w1"), "c2" -> CDone),
  schedFixed::scheduler::crashes: 2,
  schedFixed::scheduler::entry: [],
  schedFixed::scheduler::free: Map("w1" -> 1, "w2" -> 1),
  schedFixed::scheduler::mAssigned: Set(),
  schedFixed::scheduler::mBuild: Set(),
  schedFixed::scheduler::mDone: Set(),
  schedFixed::scheduler::mExpect: Set(),
  schedFixed::scheduler::mResult: Set("c1"),
  schedFixed::scheduler::mRetry: Set(),
  schedFixed::scheduler::mSchedule: Set(),
  schedFixed::scheduler::published: 1,
  schedFixed::scheduler::publishedBy: Set("w1"),
  schedFixed::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: true,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 30]
{
  schedFixed::scheduler::cl: Map("c1" -> CDone, "c2" -> CDone),
  schedFixed::scheduler::crashes: 2,
  schedFixed::scheduler::entry: [],
  schedFixed::scheduler::free: Map("w1" -> 1, "w2" -> 1),
  schedFixed::scheduler::mAssigned: Set(),
  schedFixed::scheduler::mBuild: Set(),
  schedFixed::scheduler::mDone: Set(),
  schedFixed::scheduler::mExpect: Set(),
  schedFixed::scheduler::mResult: Set(),
  schedFixed::scheduler::mRetry: Set(),
  schedFixed::scheduler::mSchedule: Set(),
  schedFixed::scheduler::published: 1,
  schedFixed::scheduler::publishedBy: Set("w1"),
  schedFixed::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: true,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[ok] No violation found (7094ms at 4229 traces/second).
Trace length statistics: max=27, min=14, average=17.88
You may increase --max-samples and --max-steps.
Use --verbosity to produce more (or less) output.
Use --seed=0x1477875f26bc8154 --backend=rust to reproduce.
An example execution:

[State 0]
{
  schedNoFence::scheduler::cl: Map("c1" -> CIdle, "c2" -> CIdle),
  schedNoFence::scheduler::crashes: 0,
  schedNoFence::scheduler::entry: [],
  schedNoFence::scheduler::free: Map("w1" -> 1, "w2" -> 1),
  schedNoFence::scheduler::mAssigned: Set(),
  schedNoFence::scheduler::mBuild: Set(),
  schedNoFence::scheduler::mDone: Set(),
  schedNoFence::scheduler::mExpect: Set(),
  schedNoFence::scheduler::mResult: Set(),
  schedNoFence::scheduler::mRetry: Set(),
  schedNoFence::scheduler::mSchedule: Set(),
  schedNoFence::scheduler::published: 0,
  schedNoFence::scheduler::publishedBy: Set(),
  schedNoFence::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 1]
{
  schedNoFence::scheduler::cl: Map("c1" -> CIdle, "c2" -> CQueued),
  schedNoFence::scheduler::crashes: 0,
  schedNoFence::scheduler::entry: [],
  schedNoFence::scheduler::free: Map("w1" -> 1, "w2" -> 1),
  schedNoFence::scheduler::mAssigned: Set(),
  schedNoFence::scheduler::mBuild: Set(),
  schedNoFence::scheduler::mDone: Set(),
  schedNoFence::scheduler::mExpect: Set(),
  schedNoFence::scheduler::mResult: Set(),
  schedNoFence::scheduler::mRetry: Set(),
  schedNoFence::scheduler::mSchedule: Set("c2"),
  schedNoFence::scheduler::published: 0,
  schedNoFence::scheduler::publishedBy: Set(),
  schedNoFence::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 2]
{
  schedNoFence::scheduler::cl: Map("c1" -> CQueued, "c2" -> CQueued),
  schedNoFence::scheduler::crashes: 0,
  schedNoFence::scheduler::entry: [],
  schedNoFence::scheduler::free: Map("w1" -> 1, "w2" -> 1),
  schedNoFence::scheduler::mAssigned: Set(),
  schedNoFence::scheduler::mBuild: Set(),
  schedNoFence::scheduler::mDone: Set(),
  schedNoFence::scheduler::mExpect: Set(),
  schedNoFence::scheduler::mResult: Set(),
  schedNoFence::scheduler::mRetry: Set(),
  schedNoFence::scheduler::mSchedule: Set("c1", "c2"),
  schedNoFence::scheduler::published: 0,
  schedNoFence::scheduler::publishedBy: Set(),
  schedNoFence::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 3]
{
  schedNoFence::scheduler::cl: Map("c1" -> CQueued, "c2" -> CQueued),
  schedNoFence::scheduler::crashes: 1,
  schedNoFence::scheduler::entry: [],
  schedNoFence::scheduler::free: Map("w1" -> 1, "w2" -> 1),
  schedNoFence::scheduler::mAssigned: Set(),
  schedNoFence::scheduler::mBuild: Set(),
  schedNoFence::scheduler::mDone: Set(),
  schedNoFence::scheduler::mExpect: Set(),
  schedNoFence::scheduler::mResult: Set(),
  schedNoFence::scheduler::mRetry: Set(),
  schedNoFence::scheduler::mSchedule: Set("c1", "c2"),
  schedNoFence::scheduler::published: 0,
  schedNoFence::scheduler::publishedBy: Set(),
  schedNoFence::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: false,
          up: false
        }
    )
}

[State 4]
{
  schedNoFence::scheduler::cl: Map("c1" -> CQueued, "c2" -> CQueued),
  schedNoFence::scheduler::crashes: 1,
  schedNoFence::scheduler::entry:
    [{ followers: Set("c1"), leased: true, worker: "w1" }],
  schedNoFence::scheduler::free: Map("w1" -> 0, "w2" -> 1),
  schedNoFence::scheduler::mAssigned: Set(("c1", "w1")),
  schedNoFence::scheduler::mBuild: Set(),
  schedNoFence::scheduler::mDone: Set(),
  schedNoFence::scheduler::mExpect: Set("w1"),
  schedNoFence::scheduler::mResult: Set(),
  schedNoFence::scheduler::mRetry: Set(),
  schedNoFence::scheduler::mSchedule: Set("c2"),
  schedNoFence::scheduler::published: 0,
  schedNoFence::scheduler::publishedBy: Set(),
  schedNoFence::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: false,
          up: false
        }
    )
}

[State 5]
{
  schedNoFence::scheduler::cl: Map("c1" -> CQueued, "c2" -> CQueued),
  schedNoFence::scheduler::crashes: 1,
  schedNoFence::scheduler::entry:
    [{ followers: Set("c1", "c2"), leased: true, worker: "w1" }],
  schedNoFence::scheduler::free: Map("w1" -> 0, "w2" -> 1),
  schedNoFence::scheduler::mAssigned: Set(("c1", "w1"), ("c2", "w1")),
  schedNoFence::scheduler::mBuild: Set(),
  schedNoFence::scheduler::mDone: Set(),
  schedNoFence::scheduler::mExpect: Set("w1"),
  schedNoFence::scheduler::mResult: Set(),
  schedNoFence::scheduler::mRetry: Set(),
  schedNoFence::scheduler::mSchedule: Set(),
  schedNoFence::scheduler::published: 0,
  schedNoFence::scheduler::publishedBy: Set(),
  schedNoFence::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: false,
          up: false
        }
    )
}

[State 6]
{
  schedNoFence::scheduler::cl: Map("c1" -> CQueued, "c2" -> CQueued),
  schedNoFence::scheduler::crashes: 2,
  schedNoFence::scheduler::entry:
    [{ followers: Set("c1", "c2"), leased: true, worker: "w1" }],
  schedNoFence::scheduler::free: Map("w1" -> 0, "w2" -> 1),
  schedNoFence::scheduler::mAssigned: Set(("c1", "w1"), ("c2", "w1")),
  schedNoFence::scheduler::mBuild: Set(),
  schedNoFence::scheduler::mDone: Set(),
  schedNoFence::scheduler::mExpect: Set(),
  schedNoFence::scheduler::mResult: Set(),
  schedNoFence::scheduler::mRetry: Set(),
  schedNoFence::scheduler::mSchedule: Set(),
  schedNoFence::scheduler::published: 0,
  schedNoFence::scheduler::publishedBy: Set(),
  schedNoFence::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: false,
          up: false
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: false,
          up: false
        }
    )
}

[State 7]
{
  schedNoFence::scheduler::cl: Map("c1" -> CQueued, "c2" -> CQueued),
  schedNoFence::scheduler::crashes: 2,
  schedNoFence::scheduler::entry:
    [{ followers: Set("c1", "c2"), leased: true, worker: "w1" }],
  schedNoFence::scheduler::free: Map("w1" -> 0, "w2" -> 1),
  schedNoFence::scheduler::mAssigned: Set(("c1", "w1"), ("c2", "w1")),
  schedNoFence::scheduler::mBuild: Set(),
  schedNoFence::scheduler::mDone: Set(),
  schedNoFence::scheduler::mExpect: Set(),
  schedNoFence::scheduler::mResult: Set(),
  schedNoFence::scheduler::mRetry: Set(),
  schedNoFence::scheduler::mSchedule: Set(),
  schedNoFence::scheduler::published: 0,
  schedNoFence::scheduler::publishedBy: Set(),
  schedNoFence::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: false,
          up: false
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 8]
{
  schedNoFence::scheduler::cl: Map("c1" -> CSent("w1"), "c2" -> CQueued),
  schedNoFence::scheduler::crashes: 2,
  schedNoFence::scheduler::entry:
    [{ followers: Set("c1", "c2"), leased: true, worker: "w1" }],
  schedNoFence::scheduler::free: Map("w1" -> 0, "w2" -> 1),
  schedNoFence::scheduler::mAssigned: Set(("c2", "w1")),
  schedNoFence::scheduler::mBuild: Set(("c1", "w1")),
  schedNoFence::scheduler::mDone: Set(),
  schedNoFence::scheduler::mExpect: Set(),
  schedNoFence::scheduler::mResult: Set(),
  schedNoFence::scheduler::mRetry: Set(),
  schedNoFence::scheduler::mSchedule: Set(),
  schedNoFence::scheduler::published: 0,
  schedNoFence::scheduler::publishedBy: Set(),
  schedNoFence::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: false,
          up: false
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 9]
{
  schedNoFence::scheduler::cl: Map("c1" -> CSent("w1"), "c2" -> CQueued),
  schedNoFence::scheduler::crashes: 2,
  schedNoFence::scheduler::entry: [],
  schedNoFence::scheduler::free: Map("w1" -> 1, "w2" -> 1),
  schedNoFence::scheduler::mAssigned: Set(("c2", "w1")),
  schedNoFence::scheduler::mBuild: Set(("c1", "w1")),
  schedNoFence::scheduler::mDone: Set(),
  schedNoFence::scheduler::mExpect: Set(),
  schedNoFence::scheduler::mResult: Set(),
  schedNoFence::scheduler::mRetry: Set("c1", "c2"),
  schedNoFence::scheduler::mSchedule: Set(),
  schedNoFence::scheduler::published: 0,
  schedNoFence::scheduler::publishedBy: Set(),
  schedNoFence::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: false,
          up: false
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 10]
{
  schedNoFence::scheduler::cl: Map("c1" -> CSent("w1"), "c2" -> CSent("w1")),
  schedNoFence::scheduler::crashes: 2,
  schedNoFence::scheduler::entry: [],
  schedNoFence::scheduler::free: Map("w1" -> 1, "w2" -> 1),
  schedNoFence::scheduler::mAssigned: Set(),
  schedNoFence::scheduler::mBuild: Set(("c1", "w1"), ("c2", "w1")),
  schedNoFence::scheduler::mDone: Set(),
  schedNoFence::scheduler::mExpect: Set(),
  schedNoFence::scheduler::mResult: Set(),
  schedNoFence::scheduler::mRetry: Set("c1", "c2"),
  schedNoFence::scheduler::mSchedule: Set(),
  schedNoFence::scheduler::published: 0,
  schedNoFence::scheduler::publishedBy: Set(),
  schedNoFence::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: false,
          up: false
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 11]
{
  schedNoFence::scheduler::cl: Map("c1" -> CQueued, "c2" -> CSent("w1")),
  schedNoFence::scheduler::crashes: 2,
  schedNoFence::scheduler::entry: [],
  schedNoFence::scheduler::free: Map("w1" -> 1, "w2" -> 1),
  schedNoFence::scheduler::mAssigned: Set(),
  schedNoFence::scheduler::mBuild: Set(("c1", "w1"), ("c2", "w1")),
  schedNoFence::scheduler::mDone: Set(),
  schedNoFence::scheduler::mExpect: Set(),
  schedNoFence::scheduler::mResult: Set(),
  schedNoFence::scheduler::mRetry: Set("c2"),
  schedNoFence::scheduler::mSchedule: Set("c1"),
  schedNoFence::scheduler::published: 0,
  schedNoFence::scheduler::publishedBy: Set(),
  schedNoFence::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: false,
          up: false
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 12]
{
  schedNoFence::scheduler::cl: Map("c1" -> CQueued, "c2" -> CQueued),
  schedNoFence::scheduler::crashes: 2,
  schedNoFence::scheduler::entry: [],
  schedNoFence::scheduler::free: Map("w1" -> 1, "w2" -> 1),
  schedNoFence::scheduler::mAssigned: Set(),
  schedNoFence::scheduler::mBuild: Set(("c1", "w1"), ("c2", "w1")),
  schedNoFence::scheduler::mDone: Set(),
  schedNoFence::scheduler::mExpect: Set(),
  schedNoFence::scheduler::mResult: Set(),
  schedNoFence::scheduler::mRetry: Set(),
  schedNoFence::scheduler::mSchedule: Set("c1", "c2"),
  schedNoFence::scheduler::published: 0,
  schedNoFence::scheduler::publishedBy: Set(),
  schedNoFence::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: false,
          up: false
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 13]
{
  schedNoFence::scheduler::cl: Map("c1" -> CQueued, "c2" -> CQueued),
  schedNoFence::scheduler::crashes: 2,
  schedNoFence::scheduler::entry:
    [{ followers: Set("c1"), leased: true, worker: "w2" }],
  schedNoFence::scheduler::free: Map("w1" -> 1, "w2" -> 0),
  schedNoFence::scheduler::mAssigned: Set(("c1", "w2")),
  schedNoFence::scheduler::mBuild: Set(("c1", "w1"), ("c2", "w1")),
  schedNoFence::scheduler::mDone: Set(),
  schedNoFence::scheduler::mExpect: Set("w2"),
  schedNoFence::scheduler::mResult: Set(),
  schedNoFence::scheduler::mRetry: Set(),
  schedNoFence::scheduler::mSchedule: Set("c2"),
  schedNoFence::scheduler::published: 0,
  schedNoFence::scheduler::publishedBy: Set(),
  schedNoFence::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: false,
          up: false
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 14]
{
  schedNoFence::scheduler::cl: Map("c1" -> CQueued, "c2" -> CQueued),
  schedNoFence::scheduler::crashes: 2,
  schedNoFence::scheduler::entry:
    [{ followers: Set("c1"), leased: true, worker: "w2" }],
  schedNoFence::scheduler::free: Map("w1" -> 1, "w2" -> 0),
  schedNoFence::scheduler::mAssigned: Set(("c1", "w2")),
  schedNoFence::scheduler::mBuild: Set(("c1", "w1"), ("c2", "w1")),
  schedNoFence::scheduler::mDone: Set(),
  schedNoFence::scheduler::mExpect: Set("w2"),
  schedNoFence::scheduler::mResult: Set(),
  schedNoFence::scheduler::mRetry: Set(),
  schedNoFence::scheduler::mSchedule: Set("c2"),
  schedNoFence::scheduler::published: 0,
  schedNoFence::scheduler::publishedBy: Set(),
  schedNoFence::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 15]
{
  schedNoFence::scheduler::cl: Map("c1" -> CQueued, "c2" -> CQueued),
  schedNoFence::scheduler::crashes: 2,
  schedNoFence::scheduler::entry:
    [{ followers: Set("c1", "c2"), leased: true, worker: "w2" }],
  schedNoFence::scheduler::free: Map("w1" -> 1, "w2" -> 0),
  schedNoFence::scheduler::mAssigned: Set(("c1", "w2"), ("c2", "w2")),
  schedNoFence::scheduler::mBuild: Set(("c1", "w1"), ("c2", "w1")),
  schedNoFence::scheduler::mDone: Set(),
  schedNoFence::scheduler::mExpect: Set("w2"),
  schedNoFence::scheduler::mResult: Set(),
  schedNoFence::scheduler::mRetry: Set(),
  schedNoFence::scheduler::mSchedule: Set(),
  schedNoFence::scheduler::published: 0,
  schedNoFence::scheduler::publishedBy: Set(),
  schedNoFence::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 16]
{
  schedNoFence::scheduler::cl: Map("c1" -> CQueued, "c2" -> CQueued),
  schedNoFence::scheduler::crashes: 2,
  schedNoFence::scheduler::entry:
    [{ followers: Set("c1", "c2"), leased: true, worker: "w2" }],
  schedNoFence::scheduler::free: Map("w1" -> 1, "w2" -> 0),
  schedNoFence::scheduler::mAssigned: Set(("c1", "w2"), ("c2", "w2")),
  schedNoFence::scheduler::mBuild: Set(("c1", "w1")),
  schedNoFence::scheduler::mDone: Set(),
  schedNoFence::scheduler::mExpect: Set("w2"),
  schedNoFence::scheduler::mResult: Set(),
  schedNoFence::scheduler::mRetry: Set("c2"),
  schedNoFence::scheduler::mSchedule: Set(),
  schedNoFence::scheduler::published: 0,
  schedNoFence::scheduler::publishedBy: Set(),
  schedNoFence::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 17]
{
  schedNoFence::scheduler::cl: Map("c1" -> CQueued, "c2" -> CQueued),
  schedNoFence::scheduler::crashes: 2,
  schedNoFence::scheduler::entry:
    [{ followers: Set("c1", "c2"), leased: true, worker: "w2" }],
  schedNoFence::scheduler::free: Map("w1" -> 1, "w2" -> 0),
  schedNoFence::scheduler::mAssigned: Set(("c1", "w2")),
  schedNoFence::scheduler::mBuild: Set(("c1", "w1")),
  schedNoFence::scheduler::mDone: Set(),
  schedNoFence::scheduler::mExpect: Set("w2"),
  schedNoFence::scheduler::mResult: Set(),
  schedNoFence::scheduler::mRetry: Set(),
  schedNoFence::scheduler::mSchedule: Set("c2"),
  schedNoFence::scheduler::published: 0,
  schedNoFence::scheduler::publishedBy: Set(),
  schedNoFence::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 18]
{
  schedNoFence::scheduler::cl: Map("c1" -> CQueued, "c2" -> CQueued),
  schedNoFence::scheduler::crashes: 2,
  schedNoFence::scheduler::entry:
    [{ followers: Set("c1", "c2"), leased: true, worker: "w2" }],
  schedNoFence::scheduler::free: Map("w1" -> 1, "w2" -> 0),
  schedNoFence::scheduler::mAssigned: Set(("c1", "w2")),
  schedNoFence::scheduler::mBuild: Set(),
  schedNoFence::scheduler::mDone: Set(),
  schedNoFence::scheduler::mExpect: Set("w2"),
  schedNoFence::scheduler::mResult: Set(),
  schedNoFence::scheduler::mRetry: Set("c1"),
  schedNoFence::scheduler::mSchedule: Set("c2"),
  schedNoFence::scheduler::published: 0,
  schedNoFence::scheduler::publishedBy: Set(),
  schedNoFence::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 19]
{
  schedNoFence::scheduler::cl: Map("c1" -> CQueued, "c2" -> CQueued),
  schedNoFence::scheduler::crashes: 2,
  schedNoFence::scheduler::entry:
    [{ followers: Set("c1", "c2"), leased: true, worker: "w2" }],
  schedNoFence::scheduler::free: Map("w1" -> 1, "w2" -> 0),
  schedNoFence::scheduler::mAssigned: Set(("c1", "w2"), ("c2", "w2")),
  schedNoFence::scheduler::mBuild: Set(),
  schedNoFence::scheduler::mDone: Set(),
  schedNoFence::scheduler::mExpect: Set("w2"),
  schedNoFence::scheduler::mResult: Set(),
  schedNoFence::scheduler::mRetry: Set("c1"),
  schedNoFence::scheduler::mSchedule: Set(),
  schedNoFence::scheduler::published: 0,
  schedNoFence::scheduler::publishedBy: Set(),
  schedNoFence::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 20]
{
  schedNoFence::scheduler::cl: Map("c1" -> CQueued, "c2" -> CQueued),
  schedNoFence::scheduler::crashes: 2,
  schedNoFence::scheduler::entry:
    [{ followers: Set("c1", "c2"), leased: true, worker: "w2" }],
  schedNoFence::scheduler::free: Map("w1" -> 1, "w2" -> 0),
  schedNoFence::scheduler::mAssigned: Set(("c1", "w2"), ("c2", "w2")),
  schedNoFence::scheduler::mBuild: Set(),
  schedNoFence::scheduler::mDone: Set(),
  schedNoFence::scheduler::mExpect: Set(),
  schedNoFence::scheduler::mResult: Set(),
  schedNoFence::scheduler::mRetry: Set("c1"),
  schedNoFence::scheduler::mSchedule: Set(),
  schedNoFence::scheduler::published: 0,
  schedNoFence::scheduler::publishedBy: Set(),
  schedNoFence::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: true,
          running: true,
          session: true,
          up: true
        }
    )
}

[State 21]
{
  schedNoFence::scheduler::cl: Map("c1" -> CQueued, "c2" -> CQueued),
  schedNoFence::scheduler::crashes: 2,
  schedNoFence::scheduler::entry:
    [{ followers: Set("c1", "c2"), leased: true, worker: "w2" }],
  schedNoFence::scheduler::free: Map("w1" -> 1, "w2" -> 0),
  schedNoFence::scheduler::mAssigned: Set(("c1", "w2"), ("c2", "w2")),
  schedNoFence::scheduler::mBuild: Set(),
  schedNoFence::scheduler::mDone: Set("w2"),
  schedNoFence::scheduler::mExpect: Set(),
  schedNoFence::scheduler::mResult: Set(),
  schedNoFence::scheduler::mRetry: Set("c1"),
  schedNoFence::scheduler::mSchedule: Set(),
  schedNoFence::scheduler::published: 1,
  schedNoFence::scheduler::publishedBy: Set("w2"),
  schedNoFence::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: true,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 22]
{
  schedNoFence::scheduler::cl: Map("c1" -> CQueued, "c2" -> CQueued),
  schedNoFence::scheduler::crashes: 2,
  schedNoFence::scheduler::entry: [],
  schedNoFence::scheduler::free: Map("w1" -> 1, "w2" -> 1),
  schedNoFence::scheduler::mAssigned: Set(("c1", "w2"), ("c2", "w2")),
  schedNoFence::scheduler::mBuild: Set(),
  schedNoFence::scheduler::mDone: Set(),
  schedNoFence::scheduler::mExpect: Set(),
  schedNoFence::scheduler::mResult: Set(),
  schedNoFence::scheduler::mRetry: Set("c1"),
  schedNoFence::scheduler::mSchedule: Set(),
  schedNoFence::scheduler::published: 1,
  schedNoFence::scheduler::publishedBy: Set("w2"),
  schedNoFence::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: true,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 23]
{
  schedNoFence::scheduler::cl: Map("c1" -> CQueued, "c2" -> CSent("w2")),
  schedNoFence::scheduler::crashes: 2,
  schedNoFence::scheduler::entry: [],
  schedNoFence::scheduler::free: Map("w1" -> 1, "w2" -> 1),
  schedNoFence::scheduler::mAssigned: Set(("c1", "w2")),
  schedNoFence::scheduler::mBuild: Set(("c2", "w2")),
  schedNoFence::scheduler::mDone: Set(),
  schedNoFence::scheduler::mExpect: Set(),
  schedNoFence::scheduler::mResult: Set(),
  schedNoFence::scheduler::mRetry: Set("c1"),
  schedNoFence::scheduler::mSchedule: Set(),
  schedNoFence::scheduler::published: 1,
  schedNoFence::scheduler::publishedBy: Set("w2"),
  schedNoFence::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: true,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 24]
{
  schedNoFence::scheduler::cl: Map("c1" -> CQueued, "c2" -> CSent("w2")),
  schedNoFence::scheduler::crashes: 2,
  schedNoFence::scheduler::entry: [],
  schedNoFence::scheduler::free: Map("w1" -> 1, "w2" -> 1),
  schedNoFence::scheduler::mAssigned: Set(("c1", "w2")),
  schedNoFence::scheduler::mBuild: Set(),
  schedNoFence::scheduler::mDone: Set(),
  schedNoFence::scheduler::mExpect: Set(),
  schedNoFence::scheduler::mResult: Set("c2"),
  schedNoFence::scheduler::mRetry: Set("c1"),
  schedNoFence::scheduler::mSchedule: Set(),
  schedNoFence::scheduler::published: 1,
  schedNoFence::scheduler::publishedBy: Set("w2"),
  schedNoFence::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: true,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 25]
{
  schedNoFence::scheduler::cl: Map("c1" -> CSent("w2"), "c2" -> CSent("w2")),
  schedNoFence::scheduler::crashes: 2,
  schedNoFence::scheduler::entry: [],
  schedNoFence::scheduler::free: Map("w1" -> 1, "w2" -> 1),
  schedNoFence::scheduler::mAssigned: Set(),
  schedNoFence::scheduler::mBuild: Set(("c1", "w2")),
  schedNoFence::scheduler::mDone: Set(),
  schedNoFence::scheduler::mExpect: Set(),
  schedNoFence::scheduler::mResult: Set("c2"),
  schedNoFence::scheduler::mRetry: Set("c1"),
  schedNoFence::scheduler::mSchedule: Set(),
  schedNoFence::scheduler::published: 1,
  schedNoFence::scheduler::publishedBy: Set("w2"),
  schedNoFence::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: true,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 26]
{
  schedNoFence::scheduler::cl: Map("c1" -> CSent("w2"), "c2" -> CDone),
  schedNoFence::scheduler::crashes: 2,
  schedNoFence::scheduler::entry: [],
  schedNoFence::scheduler::free: Map("w1" -> 1, "w2" -> 1),
  schedNoFence::scheduler::mAssigned: Set(),
  schedNoFence::scheduler::mBuild: Set(("c1", "w2")),
  schedNoFence::scheduler::mDone: Set(),
  schedNoFence::scheduler::mExpect: Set(),
  schedNoFence::scheduler::mResult: Set(),
  schedNoFence::scheduler::mRetry: Set("c1"),
  schedNoFence::scheduler::mSchedule: Set(),
  schedNoFence::scheduler::published: 1,
  schedNoFence::scheduler::publishedBy: Set("w2"),
  schedNoFence::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: true,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 27]
{
  schedNoFence::scheduler::cl: Map("c1" -> CQueued, "c2" -> CDone),
  schedNoFence::scheduler::crashes: 2,
  schedNoFence::scheduler::entry: [],
  schedNoFence::scheduler::free: Map("w1" -> 1, "w2" -> 1),
  schedNoFence::scheduler::mAssigned: Set(),
  schedNoFence::scheduler::mBuild: Set(("c1", "w2")),
  schedNoFence::scheduler::mDone: Set(),
  schedNoFence::scheduler::mExpect: Set(),
  schedNoFence::scheduler::mResult: Set(),
  schedNoFence::scheduler::mRetry: Set(),
  schedNoFence::scheduler::mSchedule: Set("c1"),
  schedNoFence::scheduler::published: 1,
  schedNoFence::scheduler::publishedBy: Set("w2"),
  schedNoFence::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: true,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 28]
{
  schedNoFence::scheduler::cl: Map("c1" -> CQueued, "c2" -> CDone),
  schedNoFence::scheduler::crashes: 2,
  schedNoFence::scheduler::entry: [],
  schedNoFence::scheduler::free: Map("w1" -> 1, "w2" -> 1),
  schedNoFence::scheduler::mAssigned: Set(),
  schedNoFence::scheduler::mBuild: Set(("c1", "w2")),
  schedNoFence::scheduler::mDone: Set(),
  schedNoFence::scheduler::mExpect: Set(),
  schedNoFence::scheduler::mResult: Set("c1"),
  schedNoFence::scheduler::mRetry: Set(),
  schedNoFence::scheduler::mSchedule: Set(),
  schedNoFence::scheduler::published: 1,
  schedNoFence::scheduler::publishedBy: Set("w2"),
  schedNoFence::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: true,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 29]
{
  schedNoFence::scheduler::cl: Map("c1" -> CDone, "c2" -> CDone),
  schedNoFence::scheduler::crashes: 2,
  schedNoFence::scheduler::entry: [],
  schedNoFence::scheduler::free: Map("w1" -> 1, "w2" -> 1),
  schedNoFence::scheduler::mAssigned: Set(),
  schedNoFence::scheduler::mBuild: Set(("c1", "w2")),
  schedNoFence::scheduler::mDone: Set(),
  schedNoFence::scheduler::mExpect: Set(),
  schedNoFence::scheduler::mResult: Set(),
  schedNoFence::scheduler::mRetry: Set(),
  schedNoFence::scheduler::mSchedule: Set(),
  schedNoFence::scheduler::published: 1,
  schedNoFence::scheduler::publishedBy: Set("w2"),
  schedNoFence::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: true,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 30]
{
  schedNoFence::scheduler::cl: Map("c1" -> CDone, "c2" -> CDone),
  schedNoFence::scheduler::crashes: 2,
  schedNoFence::scheduler::entry: [],
  schedNoFence::scheduler::free: Map("w1" -> 1, "w2" -> 1),
  schedNoFence::scheduler::mAssigned: Set(),
  schedNoFence::scheduler::mBuild: Set(),
  schedNoFence::scheduler::mDone: Set(),
  schedNoFence::scheduler::mExpect: Set(),
  schedNoFence::scheduler::mResult: Set("c1"),
  schedNoFence::scheduler::mRetry: Set(),
  schedNoFence::scheduler::mSchedule: Set(),
  schedNoFence::scheduler::published: 1,
  schedNoFence::scheduler::publishedBy: Set("w2"),
  schedNoFence::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: true,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[ok] No violation found (7747ms at 3872 traces/second).
Trace length statistics: max=30, min=14, average=17.65
You may increase --max-samples and --max-steps.
Use --verbosity to produce more (or less) output.
Use --seed=0x272c6253e4bdf0b8 --backend=rust to reproduce.
An example execution:

[State 0]
{
  schedNoPush::scheduler::cl: Map("c1" -> CIdle, "c2" -> CIdle),
  schedNoPush::scheduler::crashes: 0,
  schedNoPush::scheduler::entry: [],
  schedNoPush::scheduler::free: Map("w1" -> 1, "w2" -> 1),
  schedNoPush::scheduler::mAssigned: Set(),
  schedNoPush::scheduler::mBuild: Set(),
  schedNoPush::scheduler::mDone: Set(),
  schedNoPush::scheduler::mExpect: Set(),
  schedNoPush::scheduler::mResult: Set(),
  schedNoPush::scheduler::mRetry: Set(),
  schedNoPush::scheduler::mSchedule: Set(),
  schedNoPush::scheduler::published: 0,
  schedNoPush::scheduler::publishedBy: Set(),
  schedNoPush::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 1]
{
  schedNoPush::scheduler::cl: Map("c1" -> CIdle, "c2" -> CQueued),
  schedNoPush::scheduler::crashes: 0,
  schedNoPush::scheduler::entry: [],
  schedNoPush::scheduler::free: Map("w1" -> 1, "w2" -> 1),
  schedNoPush::scheduler::mAssigned: Set(),
  schedNoPush::scheduler::mBuild: Set(),
  schedNoPush::scheduler::mDone: Set(),
  schedNoPush::scheduler::mExpect: Set(),
  schedNoPush::scheduler::mResult: Set(),
  schedNoPush::scheduler::mRetry: Set(),
  schedNoPush::scheduler::mSchedule: Set("c2"),
  schedNoPush::scheduler::published: 0,
  schedNoPush::scheduler::publishedBy: Set(),
  schedNoPush::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 2]
{
  schedNoPush::scheduler::cl: Map("c1" -> CIdle, "c2" -> CQueued),
  schedNoPush::scheduler::crashes: 0,
  schedNoPush::scheduler::entry:
    [{ followers: Set("c2"), leased: true, worker: "w1" }],
  schedNoPush::scheduler::free: Map("w1" -> 0, "w2" -> 1),
  schedNoPush::scheduler::mAssigned: Set(("c2", "w1")),
  schedNoPush::scheduler::mBuild: Set(),
  schedNoPush::scheduler::mDone: Set(),
  schedNoPush::scheduler::mExpect: Set(),
  schedNoPush::scheduler::mResult: Set(),
  schedNoPush::scheduler::mRetry: Set(),
  schedNoPush::scheduler::mSchedule: Set(),
  schedNoPush::scheduler::published: 0,
  schedNoPush::scheduler::publishedBy: Set(),
  schedNoPush::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 3]
{
  schedNoPush::scheduler::cl: Map("c1" -> CIdle, "c2" -> CSent("w1")),
  schedNoPush::scheduler::crashes: 0,
  schedNoPush::scheduler::entry:
    [{ followers: Set("c2"), leased: true, worker: "w1" }],
  schedNoPush::scheduler::free: Map("w1" -> 0, "w2" -> 1),
  schedNoPush::scheduler::mAssigned: Set(),
  schedNoPush::scheduler::mBuild: Set(("c2", "w1")),
  schedNoPush::scheduler::mDone: Set(),
  schedNoPush::scheduler::mExpect: Set(),
  schedNoPush::scheduler::mResult: Set(),
  schedNoPush::scheduler::mRetry: Set(),
  schedNoPush::scheduler::mSchedule: Set(),
  schedNoPush::scheduler::published: 0,
  schedNoPush::scheduler::publishedBy: Set(),
  schedNoPush::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 4]
{
  schedNoPush::scheduler::cl: Map("c1" -> CIdle, "c2" -> CSent("w1")),
  schedNoPush::scheduler::crashes: 1,
  schedNoPush::scheduler::entry: [],
  schedNoPush::scheduler::free: Map("w1" -> 1, "w2" -> 1),
  schedNoPush::scheduler::mAssigned: Set(),
  schedNoPush::scheduler::mBuild: Set(("c2", "w1")),
  schedNoPush::scheduler::mDone: Set(),
  schedNoPush::scheduler::mExpect: Set(),
  schedNoPush::scheduler::mResult: Set(),
  schedNoPush::scheduler::mRetry: Set(),
  schedNoPush::scheduler::mSchedule: Set(),
  schedNoPush::scheduler::published: 0,
  schedNoPush::scheduler::publishedBy: Set(),
  schedNoPush::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 5]
{
  schedNoPush::scheduler::cl: Map("c1" -> CIdle, "c2" -> CSent("w1")),
  schedNoPush::scheduler::crashes: 1,
  schedNoPush::scheduler::entry: [],
  schedNoPush::scheduler::free: Map("w1" -> 1, "w2" -> 1),
  schedNoPush::scheduler::mAssigned: Set(),
  schedNoPush::scheduler::mBuild: Set(),
  schedNoPush::scheduler::mDone: Set(),
  schedNoPush::scheduler::mExpect: Set(),
  schedNoPush::scheduler::mResult: Set(),
  schedNoPush::scheduler::mRetry: Set(),
  schedNoPush::scheduler::mSchedule: Set(),
  schedNoPush::scheduler::published: 0,
  schedNoPush::scheduler::publishedBy: Set(),
  schedNoPush::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set("c2"),
          built: false,
          expecting: true,
          running: true,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[violation] Found an issue (2365ms at 3930 traces/second).
Use --verbosity=3 to show executions.
Use --seed=0xf54e637418875411 --backend=rust to reproduce.
error: Invariant violated
An example execution:

[State 0]
{
  schedNoReport::scheduler::cl: Map("c1" -> CIdle, "c2" -> CIdle),
  schedNoReport::scheduler::crashes: 0,
  schedNoReport::scheduler::entry: [],
  schedNoReport::scheduler::free: Map("w1" -> 1, "w2" -> 1),
  schedNoReport::scheduler::mAssigned: Set(),
  schedNoReport::scheduler::mBuild: Set(),
  schedNoReport::scheduler::mDone: Set(),
  schedNoReport::scheduler::mExpect: Set(),
  schedNoReport::scheduler::mResult: Set(),
  schedNoReport::scheduler::mRetry: Set(),
  schedNoReport::scheduler::mSchedule: Set(),
  schedNoReport::scheduler::published: 0,
  schedNoReport::scheduler::publishedBy: Set(),
  schedNoReport::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 1]
{
  schedNoReport::scheduler::cl: Map("c1" -> CIdle, "c2" -> CQueued),
  schedNoReport::scheduler::crashes: 0,
  schedNoReport::scheduler::entry: [],
  schedNoReport::scheduler::free: Map("w1" -> 1, "w2" -> 1),
  schedNoReport::scheduler::mAssigned: Set(),
  schedNoReport::scheduler::mBuild: Set(),
  schedNoReport::scheduler::mDone: Set(),
  schedNoReport::scheduler::mExpect: Set(),
  schedNoReport::scheduler::mResult: Set(),
  schedNoReport::scheduler::mRetry: Set(),
  schedNoReport::scheduler::mSchedule: Set("c2"),
  schedNoReport::scheduler::published: 0,
  schedNoReport::scheduler::publishedBy: Set(),
  schedNoReport::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 2]
{
  schedNoReport::scheduler::cl: Map("c1" -> CIdle, "c2" -> CQueued),
  schedNoReport::scheduler::crashes: 1,
  schedNoReport::scheduler::entry: [],
  schedNoReport::scheduler::free: Map("w1" -> 1, "w2" -> 1),
  schedNoReport::scheduler::mAssigned: Set(),
  schedNoReport::scheduler::mBuild: Set(),
  schedNoReport::scheduler::mDone: Set(),
  schedNoReport::scheduler::mExpect: Set(),
  schedNoReport::scheduler::mResult: Set(),
  schedNoReport::scheduler::mRetry: Set("c2"),
  schedNoReport::scheduler::mSchedule: Set(),
  schedNoReport::scheduler::published: 0,
  schedNoReport::scheduler::publishedBy: Set(),
  schedNoReport::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 3]
{
  schedNoReport::scheduler::cl: Map("c1" -> CQueued, "c2" -> CQueued),
  schedNoReport::scheduler::crashes: 1,
  schedNoReport::scheduler::entry: [],
  schedNoReport::scheduler::free: Map("w1" -> 1, "w2" -> 1),
  schedNoReport::scheduler::mAssigned: Set(),
  schedNoReport::scheduler::mBuild: Set(),
  schedNoReport::scheduler::mDone: Set(),
  schedNoReport::scheduler::mExpect: Set(),
  schedNoReport::scheduler::mResult: Set(),
  schedNoReport::scheduler::mRetry: Set("c2"),
  schedNoReport::scheduler::mSchedule: Set("c1"),
  schedNoReport::scheduler::published: 0,
  schedNoReport::scheduler::publishedBy: Set(),
  schedNoReport::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 4]
{
  schedNoReport::scheduler::cl: Map("c1" -> CQueued, "c2" -> CQueued),
  schedNoReport::scheduler::crashes: 1,
  schedNoReport::scheduler::entry:
    [{ followers: Set("c1"), leased: true, worker: "w2" }],
  schedNoReport::scheduler::free: Map("w1" -> 1, "w2" -> 0),
  schedNoReport::scheduler::mAssigned: Set(("c1", "w2")),
  schedNoReport::scheduler::mBuild: Set(),
  schedNoReport::scheduler::mDone: Set(),
  schedNoReport::scheduler::mExpect: Set("w2"),
  schedNoReport::scheduler::mResult: Set(),
  schedNoReport::scheduler::mRetry: Set("c2"),
  schedNoReport::scheduler::mSchedule: Set(),
  schedNoReport::scheduler::published: 0,
  schedNoReport::scheduler::publishedBy: Set(),
  schedNoReport::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        }
    )
}

[State 5]
{
  schedNoReport::scheduler::cl: Map("c1" -> CQueued, "c2" -> CQueued),
  schedNoReport::scheduler::crashes: 1,
  schedNoReport::scheduler::entry:
    [{ followers: Set("c1"), leased: true, worker: "w2" }],
  schedNoReport::scheduler::free: Map("w1" -> 1, "w2" -> 0),
  schedNoReport::scheduler::mAssigned: Set(("c1", "w2")),
  schedNoReport::scheduler::mBuild: Set(),
  schedNoReport::scheduler::mDone: Set(),
  schedNoReport::scheduler::mExpect: Set(),
  schedNoReport::scheduler::mResult: Set(),
  schedNoReport::scheduler::mRetry: Set("c2"),
  schedNoReport::scheduler::mSchedule: Set(),
  schedNoReport::scheduler::published: 0,
  schedNoReport::scheduler::publishedBy: Set(),
  schedNoReport::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: true,
          running: true,
          session: true,
          up: true
        }
    )
}

[State 6]
{
  schedNoReport::scheduler::cl: Map("c1" -> CQueued, "c2" -> CQueued),
  schedNoReport::scheduler::crashes: 2,
  schedNoReport::scheduler::entry: [],
  schedNoReport::scheduler::free: Map("w1" -> 1, "w2" -> 1),
  schedNoReport::scheduler::mAssigned: Set(),
  schedNoReport::scheduler::mBuild: Set(),
  schedNoReport::scheduler::mDone: Set(),
  schedNoReport::scheduler::mExpect: Set(),
  schedNoReport::scheduler::mResult: Set(),
  schedNoReport::scheduler::mRetry: Set("c1", "c2"),
  schedNoReport::scheduler::mSchedule: Set(),
  schedNoReport::scheduler::published: 0,
  schedNoReport::scheduler::publishedBy: Set(),
  schedNoReport::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: true,
          running: true,
          session: true,
          up: true
        }
    )
}

[State 7]
{
  schedNoReport::scheduler::cl: Map("c1" -> CQueued, "c2" -> CQueued),
  schedNoReport::scheduler::crashes: 2,
  schedNoReport::scheduler::entry: [],
  schedNoReport::scheduler::free: Map("w1" -> 1, "w2" -> 1),
  schedNoReport::scheduler::mAssigned: Set(),
  schedNoReport::scheduler::mBuild: Set(),
  schedNoReport::scheduler::mDone: Set(),
  schedNoReport::scheduler::mExpect: Set(),
  schedNoReport::scheduler::mResult: Set(),
  schedNoReport::scheduler::mRetry: Set("c1"),
  schedNoReport::scheduler::mSchedule: Set("c2"),
  schedNoReport::scheduler::published: 0,
  schedNoReport::scheduler::publishedBy: Set(),
  schedNoReport::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: true,
          running: true,
          session: true,
          up: true
        }
    )
}

[State 8]
{
  schedNoReport::scheduler::cl: Map("c1" -> CQueued, "c2" -> CQueued),
  schedNoReport::scheduler::crashes: 2,
  schedNoReport::scheduler::entry:
    [{ followers: Set("c2"), leased: true, worker: "w1" }],
  schedNoReport::scheduler::free: Map("w1" -> 0, "w2" -> 1),
  schedNoReport::scheduler::mAssigned: Set(("c2", "w1")),
  schedNoReport::scheduler::mBuild: Set(),
  schedNoReport::scheduler::mDone: Set(),
  schedNoReport::scheduler::mExpect: Set("w1"),
  schedNoReport::scheduler::mResult: Set(),
  schedNoReport::scheduler::mRetry: Set("c1"),
  schedNoReport::scheduler::mSchedule: Set(),
  schedNoReport::scheduler::published: 0,
  schedNoReport::scheduler::publishedBy: Set(),
  schedNoReport::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: false,
          running: false,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: true,
          running: true,
          session: true,
          up: true
        }
    )
}

[State 9]
{
  schedNoReport::scheduler::cl: Map("c1" -> CQueued, "c2" -> CQueued),
  schedNoReport::scheduler::crashes: 2,
  schedNoReport::scheduler::entry:
    [{ followers: Set("c2"), leased: true, worker: "w1" }],
  schedNoReport::scheduler::free: Map("w1" -> 0, "w2" -> 1),
  schedNoReport::scheduler::mAssigned: Set(("c2", "w1")),
  schedNoReport::scheduler::mBuild: Set(),
  schedNoReport::scheduler::mDone: Set(),
  schedNoReport::scheduler::mExpect: Set(),
  schedNoReport::scheduler::mResult: Set(),
  schedNoReport::scheduler::mRetry: Set("c1"),
  schedNoReport::scheduler::mSchedule: Set(),
  schedNoReport::scheduler::published: 0,
  schedNoReport::scheduler::publishedBy: Set(),
  schedNoReport::scheduler::ws:
    Map(
      "w1" ->
        {
          attached: Set(),
          built: false,
          expecting: true,
          running: true,
          session: true,
          up: true
        },
      "w2" ->
        {
          attached: Set(),
          built: false,
          expecting: true,
          running: true,
          session: true,
          up: true
        }
    )
}

[violation] Found an issue (4691ms at 5250 traces/second).
Use --verbosity=3 to show executions.
Use --seed=0x3f5e6643701b172e --backend=rust to reproduce.
error: Invariant violated
An example execution:

[State 0]
{
  foFixed::failover::cOn: Map("c1" -> "", "c2" -> ""),
  foFixed::failover::cTo: Map("c1" -> "", "c2" -> ""),
  foFixed::failover::cl: Map("c1" -> "idle", "c2" -> "idle"),
  foFixed::failover::flaps: 0,
  foFixed::failover::mAssigned: Set(),
  foFixed::failover::mBuild: Set(),
  foFixed::failover::mDone: Set(),
  foFixed::failover::mExpect: Set(),
  foFixed::failover::mRestart: Set(),
  foFixed::failover::mResult: Set(),
  foFixed::failover::mRetry: Set(),
  foFixed::failover::mWant: Set(),
  foFixed::failover::published: 0,
  foFixed::failover::s1up: true,
  foFixed::failover::ss:
    Map(
      "s1" -> { busy: Set(), followers: Set(), has: false, worker: "" },
      "s2" -> { busy: Set(), followers: Set(), has: false, worker: "" }
    ),
  foFixed::failover::wOn: Map("w1" -> "s1", "w2" -> "s1"),
  foFixed::failover::ws:
    Map(
      "w1" ->
        { attached: Set(), built: false, expecting: false, running: false },
      "w2" ->
        { attached: Set(), built: false, expecting: false, running: false }
    )
}

[State 1]
{
  foFixed::failover::cOn: Map("c1" -> "", "c2" -> ""),
  foFixed::failover::cTo: Map("c1" -> "", "c2" -> ""),
  foFixed::failover::cl: Map("c1" -> "idle", "c2" -> "idle"),
  foFixed::failover::flaps: 1,
  foFixed::failover::mAssigned: Set(),
  foFixed::failover::mBuild: Set(),
  foFixed::failover::mDone: Set(),
  foFixed::failover::mExpect: Set(),
  foFixed::failover::mRestart: Set("w1", "w2"),
  foFixed::failover::mResult: Set(),
  foFixed::failover::mRetry: Set(),
  foFixed::failover::mWant: Set(),
  foFixed::failover::published: 0,
  foFixed::failover::s1up: false,
  foFixed::failover::ss:
    Map(
      "s1" -> { busy: Set(), followers: Set(), has: false, worker: "" },
      "s2" -> { busy: Set(), followers: Set(), has: false, worker: "" }
    ),
  foFixed::failover::wOn: Map("w1" -> "", "w2" -> ""),
  foFixed::failover::ws:
    Map(
      "w1" ->
        { attached: Set(), built: false, expecting: false, running: false },
      "w2" ->
        { attached: Set(), built: false, expecting: false, running: false }
    )
}

[State 2]
{
  foFixed::failover::cOn: Map("c1" -> "s2", "c2" -> ""),
  foFixed::failover::cTo: Map("c1" -> "", "c2" -> ""),
  foFixed::failover::cl: Map("c1" -> "queued", "c2" -> "idle"),
  foFixed::failover::flaps: 1,
  foFixed::failover::mAssigned: Set(),
  foFixed::failover::mBuild: Set(),
  foFixed::failover::mDone: Set(),
  foFixed::failover::mExpect: Set(),
  foFixed::failover::mRestart: Set("w1", "w2"),
  foFixed::failover::mResult: Set(),
  foFixed::failover::mRetry: Set(),
  foFixed::failover::mWant: Set(("c1", "s2")),
  foFixed::failover::published: 0,
  foFixed::failover::s1up: false,
  foFixed::failover::ss:
    Map(
      "s1" -> { busy: Set(), followers: Set(), has: false, worker: "" },
      "s2" -> { busy: Set(), followers: Set(), has: false, worker: "" }
    ),
  foFixed::failover::wOn: Map("w1" -> "", "w2" -> ""),
  foFixed::failover::ws:
    Map(
      "w1" ->
        { attached: Set(), built: false, expecting: false, running: false },
      "w2" ->
        { attached: Set(), built: false, expecting: false, running: false }
    )
}

[State 3]
{
  foFixed::failover::cOn: Map("c1" -> "s2", "c2" -> "s2"),
  foFixed::failover::cTo: Map("c1" -> "", "c2" -> ""),
  foFixed::failover::cl: Map("c1" -> "queued", "c2" -> "queued"),
  foFixed::failover::flaps: 1,
  foFixed::failover::mAssigned: Set(),
  foFixed::failover::mBuild: Set(),
  foFixed::failover::mDone: Set(),
  foFixed::failover::mExpect: Set(),
  foFixed::failover::mRestart: Set("w1", "w2"),
  foFixed::failover::mResult: Set(),
  foFixed::failover::mRetry: Set(),
  foFixed::failover::mWant: Set(("c1", "s2"), ("c2", "s2")),
  foFixed::failover::published: 0,
  foFixed::failover::s1up: false,
  foFixed::failover::ss:
    Map(
      "s1" -> { busy: Set(), followers: Set(), has: false, worker: "" },
      "s2" -> { busy: Set(), followers: Set(), has: false, worker: "" }
    ),
  foFixed::failover::wOn: Map("w1" -> "", "w2" -> ""),
  foFixed::failover::ws:
    Map(
      "w1" ->
        { attached: Set(), built: false, expecting: false, running: false },
      "w2" ->
        { attached: Set(), built: false, expecting: false, running: false }
    )
}

[State 4]
{
  foFixed::failover::cOn: Map("c1" -> "", "c2" -> ""),
  foFixed::failover::cTo: Map("c1" -> "", "c2" -> ""),
  foFixed::failover::cl: Map("c1" -> "queued", "c2" -> "queued"),
  foFixed::failover::flaps: 1,
  foFixed::failover::mAssigned: Set(),
  foFixed::failover::mBuild: Set(),
  foFixed::failover::mDone: Set(),
  foFixed::failover::mExpect: Set(),
  foFixed::failover::mRestart: Set("c1", "c2", "w1", "w2"),
  foFixed::failover::mResult: Set(),
  foFixed::failover::mRetry: Set(),
  foFixed::failover::mWant: Set(),
  foFixed::failover::published: 0,
  foFixed::failover::s1up: true,
  foFixed::failover::ss:
    Map(
      "s1" -> { busy: Set(), followers: Set(), has: false, worker: "" },
      "s2" -> { busy: Set(), followers: Set(), has: false, worker: "" }
    ),
  foFixed::failover::wOn: Map("w1" -> "", "w2" -> ""),
  foFixed::failover::ws:
    Map(
      "w1" ->
        { attached: Set(), built: false, expecting: false, running: false },
      "w2" ->
        { attached: Set(), built: false, expecting: false, running: false }
    )
}

[State 5]
{
  foFixed::failover::cOn: Map("c1" -> "", "c2" -> "s1"),
  foFixed::failover::cTo: Map("c1" -> "", "c2" -> ""),
  foFixed::failover::cl: Map("c1" -> "queued", "c2" -> "queued"),
  foFixed::failover::flaps: 1,
  foFixed::failover::mAssigned: Set(),
  foFixed::failover::mBuild: Set(),
  foFixed::failover::mDone: Set(),
  foFixed::failover::mExpect: Set(),
  foFixed::failover::mRestart: Set("c1", "w1", "w2"),
  foFixed::failover::mResult: Set(),
  foFixed::failover::mRetry: Set(),
  foFixed::failover::mWant: Set(("c2", "s1")),
  foFixed::failover::published: 0,
  foFixed::failover::s1up: true,
  foFixed::failover::ss:
    Map(
      "s1" -> { busy: Set(), followers: Set(), has: false, worker: "" },
      "s2" -> { busy: Set(), followers: Set(), has: false, worker: "" }
    ),
  foFixed::failover::wOn: Map("w1" -> "", "w2" -> ""),
  foFixed::failover::ws:
    Map(
      "w1" ->
        { attached: Set(), built: false, expecting: false, running: false },
      "w2" ->
        { attached: Set(), built: false, expecting: false, running: false }
    )
}

[State 6]
{
  foFixed::failover::cOn: Map("c1" -> "", "c2" -> "s1"),
  foFixed::failover::cTo: Map("c1" -> "", "c2" -> ""),
  foFixed::failover::cl: Map("c1" -> "queued", "c2" -> "queued"),
  foFixed::failover::flaps: 1,
  foFixed::failover::mAssigned: Set(),
  foFixed::failover::mBuild: Set(),
  foFixed::failover::mDone: Set(),
  foFixed::failover::mExpect: Set(),
  foFixed::failover::mRestart: Set("c1", "w2"),
  foFixed::failover::mResult: Set(),
  foFixed::failover::mRetry: Set(),
  foFixed::failover::mWant: Set(("c2", "s1")),
  foFixed::failover::published: 0,
  foFixed::failover::s1up: true,
  foFixed::failover::ss:
    Map(
      "s1" -> { busy: Set(), followers: Set(), has: false, worker: "" },
      "s2" -> { busy: Set(), followers: Set(), has: false, worker: "" }
    ),
  foFixed::failover::wOn: Map("w1" -> "s1", "w2" -> ""),
  foFixed::failover::ws:
    Map(
      "w1" ->
        { attached: Set(), built: false, expecting: false, running: false },
      "w2" ->
        { attached: Set(), built: false, expecting: false, running: false }
    )
}

[State 7]
{
  foFixed::failover::cOn: Map("c1" -> "", "c2" -> ""),
  foFixed::failover::cTo: Map("c1" -> "", "c2" -> ""),
  foFixed::failover::cl: Map("c1" -> "queued", "c2" -> "queued"),
  foFixed::failover::flaps: 2,
  foFixed::failover::mAssigned: Set(),
  foFixed::failover::mBuild: Set(),
  foFixed::failover::mDone: Set(),
  foFixed::failover::mExpect: Set(),
  foFixed::failover::mRestart: Set("c1", "c2", "w1", "w2"),
  foFixed::failover::mResult: Set(),
  foFixed::failover::mRetry: Set(),
  foFixed::failover::mWant: Set(),
  foFixed::failover::published: 0,
  foFixed::failover::s1up: false,
  foFixed::failover::ss:
    Map(
      "s1" -> { busy: Set(), followers: Set(), has: false, worker: "" },
      "s2" -> { busy: Set(), followers: Set(), has: false, worker: "" }
    ),
  foFixed::failover::wOn: Map("w1" -> "", "w2" -> ""),
  foFixed::failover::ws:
    Map(
      "w1" ->
        { attached: Set(), built: false, expecting: false, running: false },
      "w2" ->
        { attached: Set(), built: false, expecting: false, running: false }
    )
}

[State 8]
{
  foFixed::failover::cOn: Map("c1" -> "", "c2" -> ""),
  foFixed::failover::cTo: Map("c1" -> "", "c2" -> ""),
  foFixed::failover::cl: Map("c1" -> "queued", "c2" -> "queued"),
  foFixed::failover::flaps: 2,
  foFixed::failover::mAssigned: Set(),
  foFixed::failover::mBuild: Set(),
  foFixed::failover::mDone: Set(),
  foFixed::failover::mExpect: Set(),
  foFixed::failover::mRestart: Set("c1", "c2", "w2"),
  foFixed::failover::mResult: Set(),
  foFixed::failover::mRetry: Set(),
  foFixed::failover::mWant: Set(),
  foFixed::failover::published: 0,
  foFixed::failover::s1up: false,
  foFixed::failover::ss:
    Map(
      "s1" -> { busy: Set(), followers: Set(), has: false, worker: "" },
      "s2" -> { busy: Set(), followers: Set(), has: false, worker: "" }
    ),
  foFixed::failover::wOn: Map("w1" -> "s2", "w2" -> ""),
  foFixed::failover::ws:
    Map(
      "w1" ->
        { attached: Set(), built: false, expecting: false, running: false },
      "w2" ->
        { attached: Set(), built: false, expecting: false, running: false }
    )
}

[State 9]
{
  foFixed::failover::cOn: Map("c1" -> "s2", "c2" -> ""),
  foFixed::failover::cTo: Map("c1" -> "", "c2" -> ""),
  foFixed::failover::cl: Map("c1" -> "queued", "c2" -> "queued"),
  foFixed::failover::flaps: 2,
  foFixed::failover::mAssigned: Set(),
  foFixed::failover::mBuild: Set(),
  foFixed::failover::mDone: Set(),
  foFixed::failover::mExpect: Set(),
  foFixed::failover::mRestart: Set("c2", "w2"),
  foFixed::failover::mResult: Set(),
  foFixed::failover::mRetry: Set(),
  foFixed::failover::mWant: Set(("c1", "s2")),
  foFixed::failover::published: 0,
  foFixed::failover::s1up: false,
  foFixed::failover::ss:
    Map(
      "s1" -> { busy: Set(), followers: Set(), has: false, worker: "" },
      "s2" -> { busy: Set(), followers: Set(), has: false, worker: "" }
    ),
  foFixed::failover::wOn: Map("w1" -> "s2", "w2" -> ""),
  foFixed::failover::ws:
    Map(
      "w1" ->
        { attached: Set(), built: false, expecting: false, running: false },
      "w2" ->
        { attached: Set(), built: false, expecting: false, running: false }
    )
}

[State 10]
{
  foFixed::failover::cOn: Map("c1" -> "s2", "c2" -> ""),
  foFixed::failover::cTo: Map("c1" -> "", "c2" -> ""),
  foFixed::failover::cl: Map("c1" -> "queued", "c2" -> "queued"),
  foFixed::failover::flaps: 2,
  foFixed::failover::mAssigned: Set(("s2", "c1", "w1")),
  foFixed::failover::mBuild: Set(),
  foFixed::failover::mDone: Set(),
  foFixed::failover::mExpect: Set(("s2", "w1")),
  foFixed::failover::mRestart: Set("c2", "w2"),
  foFixed::failover::mResult: Set(),
  foFixed::failover::mRetry: Set(),
  foFixed::failover::mWant: Set(),
  foFixed::failover::published: 0,
  foFixed::failover::s1up: false,
  foFixed::failover::ss:
    Map(
      "s1" -> { busy: Set(), followers: Set(), has: false, worker: "" },
      "s2" -> { busy: Set("w1"), followers: Set("c1"), has: true, worker: "w1" }
    ),
  foFixed::failover::wOn: Map("w1" -> "s2", "w2" -> ""),
  foFixed::failover::ws:
    Map(
      "w1" ->
        { attached: Set(), built: false, expecting: false, running: false },
      "w2" ->
        { attached: Set(), built: false, expecting: false, running: false }
    )
}

[State 11]
{
  foFixed::failover::cOn: Map("c1" -> "s2", "c2" -> ""),
  foFixed::failover::cTo: Map("c1" -> "", "c2" -> ""),
  foFixed::failover::cl: Map("c1" -> "queued", "c2" -> "queued"),
  foFixed::failover::flaps: 2,
  foFixed::failover::mAssigned: Set(("s2", "c1", "w1")),
  foFixed::failover::mBuild: Set(),
  foFixed::failover::mDone: Set(),
  foFixed::failover::mExpect: Set(("s2", "w1")),
  foFixed::failover::mRestart: Set("c2"),
  foFixed::failover::mResult: Set(),
  foFixed::failover::mRetry: Set(),
  foFixed::failover::mWant: Set(),
  foFixed::failover::published: 0,
  foFixed::failover::s1up: false,
  foFixed::failover::ss:
    Map(
      "s1" -> { busy: Set(), followers: Set(), has: false, worker: "" },
      "s2" -> { busy: Set("w1"), followers: Set("c1"), has: true, worker: "w1" }
    ),
  foFixed::failover::wOn: Map("w1" -> "s2", "w2" -> "s2"),
  foFixed::failover::ws:
    Map(
      "w1" ->
        { attached: Set(), built: false, expecting: false, running: false },
      "w2" ->
        { attached: Set(), built: false, expecting: false, running: false }
    )
}

[State 12]
{
  foFixed::failover::cOn: Map("c1" -> "", "c2" -> ""),
  foFixed::failover::cTo: Map("c1" -> "", "c2" -> ""),
  foFixed::failover::cl: Map("c1" -> "queued", "c2" -> "queued"),
  foFixed::failover::flaps: 2,
  foFixed::failover::mAssigned: Set(),
  foFixed::failover::mBuild: Set(),
  foFixed::failover::mDone: Set(),
  foFixed::failover::mExpect: Set(),
  foFixed::failover::mRestart: Set("c1", "c2", "w1", "w2"),
  foFixed::failover::mResult: Set(),
  foFixed::failover::mRetry: Set(),
  foFixed::failover::mWant: Set(),
  foFixed::failover::published: 0,
  foFixed::failover::s1up: true,
  foFixed::failover::ss:
    Map(
      "s1" -> { busy: Set(), followers: Set(), has: false, worker: "" },
      "s2" -> { busy: Set(), followers: Set(), has: false, worker: "" }
    ),
  foFixed::failover::wOn: Map("w1" -> "", "w2" -> ""),
  foFixed::failover::ws:
    Map(
      "w1" ->
        { attached: Set(), built: false, expecting: false, running: false },
      "w2" ->
        { attached: Set(), built: false, expecting: false, running: false }
    )
}

[State 13]
{
  foFixed::failover::cOn: Map("c1" -> "", "c2" -> ""),
  foFixed::failover::cTo: Map("c1" -> "", "c2" -> ""),
  foFixed::failover::cl: Map("c1" -> "queued", "c2" -> "queued"),
  foFixed::failover::flaps: 2,
  foFixed::failover::mAssigned: Set(),
  foFixed::failover::mBuild: Set(),
  foFixed::failover::mDone: Set(),
  foFixed::failover::mExpect: Set(),
  foFixed::failover::mRestart: Set("c1", "c2", "w1"),
  foFixed::failover::mResult: Set(),
  foFixed::failover::mRetry: Set(),
  foFixed::failover::mWant: Set(),
  foFixed::failover::published: 0,
  foFixed::failover::s1up: true,
  foFixed::failover::ss:
    Map(
      "s1" -> { busy: Set(), followers: Set(), has: false, worker: "" },
      "s2" -> { busy: Set(), followers: Set(), has: false, worker: "" }
    ),
  foFixed::failover::wOn: Map("w1" -> "", "w2" -> "s1"),
  foFixed::failover::ws:
    Map(
      "w1" ->
        { attached: Set(), built: false, expecting: false, running: false },
      "w2" ->
        { attached: Set(), built: false, expecting: false, running: false }
    )
}

[State 14]
{
  foFixed::failover::cOn: Map("c1" -> "", "c2" -> ""),
  foFixed::failover::cTo: Map("c1" -> "", "c2" -> ""),
  foFixed::failover::cl: Map("c1" -> "queued", "c2" -> "queued"),
  foFixed::failover::flaps: 2,
  foFixed::failover::mAssigned: Set(),
  foFixed::failover::mBuild: Set(),
  foFixed::failover::mDone: Set(),
  foFixed::failover::mExpect: Set(),
  foFixed::failover::mRestart: Set("c1", "c2"),
  foFixed::failover::mResult: Set(),
  foFixed::failover::mRetry: Set(),
  foFixed::failover::mWant: Set(),
  foFixed::failover::published: 0,
  foFixed::failover::s1up: true,
  foFixed::failover::ss:
    Map(
      "s1" -> { busy: Set(), followers: Set(), has: false, worker: "" },
      "s2" -> { busy: Set(), followers: Set(), has: false, worker: "" }
    ),
  foFixed::failover::wOn: Map("w1" -> "s1", "w2" -> "s1"),
  foFixed::failover::ws:
    Map(
      "w1" ->
        { attached: Set(), built: false, expecting: false, running: false },
      "w2" ->
        { attached: Set(), built: false, expecting: false, running: false }
    )
}

[State 15]
{
  foFixed::failover::cOn: Map("c1" -> "", "c2" -> "s1"),
  foFixed::failover::cTo: Map("c1" -> "", "c2" -> ""),
  foFixed::failover::cl: Map("c1" -> "queued", "c2" -> "queued"),
  foFixed::failover::flaps: 2,
  foFixed::failover::mAssigned: Set(),
  foFixed::failover::mBuild: Set(),
  foFixed::failover::mDone: Set(),
  foFixed::failover::mExpect: Set(),
  foFixed::failover::mRestart: Set("c1"),
  foFixed::failover::mResult: Set(),
  foFixed::failover::mRetry: Set(),
  foFixed::failover::mWant: Set(("c2", "s1")),
  foFixed::failover::published: 0,
  foFixed::failover::s1up: true,
  foFixed::failover::ss:
    Map(
      "s1" -> { busy: Set(), followers: Set(), has: false, worker: "" },
      "s2" -> { busy: Set(), followers: Set(), has: false, worker: "" }
    ),
  foFixed::failover::wOn: Map("w1" -> "s1", "w2" -> "s1"),
  foFixed::failover::ws:
    Map(
      "w1" ->
        { attached: Set(), built: false, expecting: false, running: false },
      "w2" ->
        { attached: Set(), built: false, expecting: false, running: false }
    )
}

[State 16]
{
  foFixed::failover::cOn: Map("c1" -> "", "c2" -> ""),
  foFixed::failover::cTo: Map("c1" -> "", "c2" -> ""),
  foFixed::failover::cl: Map("c1" -> "queued", "c2" -> "queued"),
  foFixed::failover::flaps: 3,
  foFixed::failover::mAssigned: Set(),
  foFixed::failover::mBuild: Set(),
  foFixed::failover::mDone: Set(),
  foFixed::failover::mExpect: Set(),
  foFixed::failover::mRestart: Set("c1", "c2", "w1", "w2"),
  foFixed::failover::mResult: Set(),
  foFixed::failover::mRetry: Set(),
  foFixed::failover::mWant: Set(),
  foFixed::failover::published: 0,
  foFixed::failover::s1up: false,
  foFixed::failover::ss:
    Map(
      "s1" -> { busy: Set(), followers: Set(), has: false, worker: "" },
      "s2" -> { busy: Set(), followers: Set(), has: false, worker: "" }
    ),
  foFixed::failover::wOn: Map("w1" -> "", "w2" -> ""),
  foFixed::failover::ws:
    Map(
      "w1" ->
        { attached: Set(), built: false, expecting: false, running: false },
      "w2" ->
        { attached: Set(), built: false, expecting: false, running: false }
    )
}

[State 17]
{
  foFixed::failover::cOn: Map("c1" -> "", "c2" -> ""),
  foFixed::failover::cTo: Map("c1" -> "", "c2" -> ""),
  foFixed::failover::cl: Map("c1" -> "queued", "c2" -> "queued"),
  foFixed::failover::flaps: 3,
  foFixed::failover::mAssigned: Set(),
  foFixed::failover::mBuild: Set(),
  foFixed::failover::mDone: Set(),
  foFixed::failover::mExpect: Set(),
  foFixed::failover::mRestart: Set("c1", "c2", "w1"),
  foFixed::failover::mResult: Set(),
  foFixed::failover::mRetry: Set(),
  foFixed::failover::mWant: Set(),
  foFixed::failover::published: 0,
  foFixed::failover::s1up: false,
  foFixed::failover::ss:
    Map(
      "s1" -> { busy: Set(), followers: Set(), has: false, worker: "" },
      "s2" -> { busy: Set(), followers: Set(), has: false, worker: "" }
    ),
  foFixed::failover::wOn: Map("w1" -> "", "w2" -> "s2"),
  foFixed::failover::ws:
    Map(
      "w1" ->
        { attached: Set(), built: false, expecting: false, running: false },
      "w2" ->
        { attached: Set(), built: false, expecting: false, running: false }
    )
}

[State 18]
{
  foFixed::failover::cOn: Map("c1" -> "s2", "c2" -> ""),
  foFixed::failover::cTo: Map("c1" -> "", "c2" -> ""),
  foFixed::failover::cl: Map("c1" -> "queued", "c2" -> "queued"),
  foFixed::failover::flaps: 3,
  foFixed::failover::mAssigned: Set(),
  foFixed::failover::mBuild: Set(),
  foFixed::failover::mDone: Set(),
  foFixed::failover::mExpect: Set(),
  foFixed::failover::mRestart: Set("c2", "w1"),
  foFixed::failover::mResult: Set(),
  foFixed::failover::mRetry: Set(),
  foFixed::failover::mWant: Set(("c1", "s2")),
  foFixed::failover::published: 0,
  foFixed::failover::s1up: false,
  foFixed::failover::ss:
    Map(
      "s1" -> { busy: Set(), followers: Set(), has: false, worker: "" },
      "s2" -> { busy: Set(), followers: Set(), has: false, worker: "" }
    ),
  foFixed::failover::wOn: Map("w1" -> "", "w2" -> "s2"),
  foFixed::failover::ws:
    Map(
      "w1" ->
        { attached: Set(), built: false, expecting: false, running: false },
      "w2" ->
        { attached: Set(), built: false, expecting: false, running: false }
    )
}

[State 19]
{
  foFixed::failover::cOn: Map("c1" -> "", "c2" -> ""),
  foFixed::failover::cTo: Map("c1" -> "", "c2" -> ""),
  foFixed::failover::cl: Map("c1" -> "queued", "c2" -> "queued"),
  foFixed::failover::flaps: 3,
  foFixed::failover::mAssigned: Set(),
  foFixed::failover::mBuild: Set(),
  foFixed::failover::mDone: Set(),
  foFixed::failover::mExpect: Set(),
  foFixed::failover::mRestart: Set("c1", "c2", "w1", "w2"),
  foFixed::failover::mResult: Set(),
  foFixed::failover::mRetry: Set(),
  foFixed::failover::mWant: Set(),
  foFixed::failover::published: 0,
  foFixed::failover::s1up: true,
  foFixed::failover::ss:
    Map(
      "s1" -> { busy: Set(), followers: Set(), has: false, worker: "" },
      "s2" -> { busy: Set(), followers: Set(), has: false, worker: "" }
    ),
  foFixed::failover::wOn: Map("w1" -> "", "w2" -> ""),
  foFixed::failover::ws:
    Map(
      "w1" ->
        { attached: Set(), built: false, expecting: false, running: false },
      "w2" ->
        { attached: Set(), built: false, expecting: false, running: false }
    )
}

[State 20]
{
  foFixed::failover::cOn: Map("c1" -> "", "c2" -> ""),
  foFixed::failover::cTo: Map("c1" -> "", "c2" -> ""),
  foFixed::failover::cl: Map("c1" -> "queued", "c2" -> "queued"),
  foFixed::failover::flaps: 3,
  foFixed::failover::mAssigned: Set(),
  foFixed::failover::mBuild: Set(),
  foFixed::failover::mDone: Set(),
  foFixed::failover::mExpect: Set(),
  foFixed::failover::mRestart: Set("c1", "c2", "w1"),
  foFixed::failover::mResult: Set(),
  foFixed::failover::mRetry: Set(),
  foFixed::failover::mWant: Set(),
  foFixed::failover::published: 0,
  foFixed::failover::s1up: true,
  foFixed::failover::ss:
    Map(
      "s1" -> { busy: Set(), followers: Set(), has: false, worker: "" },
      "s2" -> { busy: Set(), followers: Set(), has: false, worker: "" }
    ),
  foFixed::failover::wOn: Map("w1" -> "", "w2" -> "s1"),
  foFixed::failover::ws:
    Map(
      "w1" ->
        { attached: Set(), built: false, expecting: false, running: false },
      "w2" ->
        { attached: Set(), built: false, expecting: false, running: false }
    )
}

[State 21]
{
  foFixed::failover::cOn: Map("c1" -> "s1", "c2" -> ""),
  foFixed::failover::cTo: Map("c1" -> "", "c2" -> ""),
  foFixed::failover::cl: Map("c1" -> "queued", "c2" -> "queued"),
  foFixed::failover::flaps: 3,
  foFixed::failover::mAssigned: Set(),
  foFixed::failover::mBuild: Set(),
  foFixed::failover::mDone: Set(),
  foFixed::failover::mExpect: Set(),
  foFixed::failover::mRestart: Set("c2", "w1"),
  foFixed::failover::mResult: Set(),
  foFixed::failover::mRetry: Set(),
  foFixed::failover::mWant: Set(("c1", "s1")),
  foFixed::failover::published: 0,
  foFixed::failover::s1up: true,
  foFixed::failover::ss:
    Map(
      "s1" -> { busy: Set(), followers: Set(), has: false, worker: "" },
      "s2" -> { busy: Set(), followers: Set(), has: false, worker: "" }
    ),
  foFixed::failover::wOn: Map("w1" -> "", "w2" -> "s1"),
  foFixed::failover::ws:
    Map(
      "w1" ->
        { attached: Set(), built: false, expecting: false, running: false },
      "w2" ->
        { attached: Set(), built: false, expecting: false, running: false }
    )
}

[State 22]
{
  foFixed::failover::cOn: Map("c1" -> "s1", "c2" -> ""),
  foFixed::failover::cTo: Map("c1" -> "", "c2" -> ""),
  foFixed::failover::cl: Map("c1" -> "queued", "c2" -> "queued"),
  foFixed::failover::flaps: 3,
  foFixed::failover::mAssigned: Set(),
  foFixed::failover::mBuild: Set(),
  foFixed::failover::mDone: Set(),
  foFixed::failover::mExpect: Set(),
  foFixed::failover::mRestart: Set("c2"),
  foFixed::failover::mResult: Set(),
  foFixed::failover::mRetry: Set(),
  foFixed::failover::mWant: Set(("c1", "s1")),
  foFixed::failover::published: 0,
  foFixed::failover::s1up: true,
  foFixed::failover::ss:
    Map(
      "s1" -> { busy: Set(), followers: Set(), has: false, worker: "" },
      "s2" -> { busy: Set(), followers: Set(), has: false, worker: "" }
    ),
  foFixed::failover::wOn: Map("w1" -> "s1", "w2" -> "s1"),
  foFixed::failover::ws:
    Map(
      "w1" ->
        { attached: Set(), built: false, expecting: false, running: false },
      "w2" ->
        { attached: Set(), built: false, expecting: false, running: false }
    )
}

[State 23]
{
  foFixed::failover::cOn: Map("c1" -> "s1", "c2" -> ""),
  foFixed::failover::cTo: Map("c1" -> "", "c2" -> ""),
  foFixed::failover::cl: Map("c1" -> "queued", "c2" -> "queued"),
  foFixed::failover::flaps: 3,
  foFixed::failover::mAssigned: Set(("s1", "c1", "w1")),
  foFixed::failover::mBuild: Set(),
  foFixed::failover::mDone: Set(),
  foFixed::failover::mExpect: Set(("s1", "w1")),
  foFixed::failover::mRestart: Set("c2"),
  foFixed::failover::mResult: Set(),
  foFixed::failover::mRetry: Set(),
  foFixed::failover::mWant: Set(),
  foFixed::failover::published: 0,
  foFixed::failover::s1up: true,
  foFixed::failover::ss:
    Map(
      "s1" ->
        { busy: Set("w1"), followers: Set("c1"), has: true, worker: "w1" },
      "s2" -> { busy: Set(), followers: Set(), has: false, worker: "" }
    ),
  foFixed::failover::wOn: Map("w1" -> "s1", "w2" -> "s1"),
  foFixed::failover::ws:
    Map(
      "w1" ->
        { attached: Set(), built: false, expecting: false, running: false },
      "w2" ->
        { attached: Set(), built: false, expecting: false, running: false }
    )
}

[State 24]
{
  foFixed::failover::cOn: Map("c1" -> "s1", "c2" -> ""),
  foFixed::failover::cTo: Map("c1" -> "", "c2" -> ""),
  foFixed::failover::cl: Map("c1" -> "queued", "c2" -> "queued"),
  foFixed::failover::flaps: 3,
  foFixed::failover::mAssigned: Set(("s1", "c1", "w1")),
  foFixed::failover::mBuild: Set(),
  foFixed::failover::mDone: Set(),
  foFixed::failover::mExpect: Set(),
  foFixed::failover::mRestart: Set("c2"),
  foFixed::failover::mResult: Set(),
  foFixed::failover::mRetry: Set(),
  foFixed::failover::mWant: Set(),
  foFixed::failover::published: 0,
  foFixed::failover::s1up: true,
  foFixed::failover::ss:
    Map(
      "s1" ->
        { busy: Set("w1"), followers: Set("c1"), has: true, worker: "w1" },
      "s2" -> { busy: Set(), followers: Set(), has: false, worker: "" }
    ),
  foFixed::failover::wOn: Map("w1" -> "s1", "w2" -> "s1"),
  foFixed::failover::ws:
    Map(
      "w1" ->
        { attached: Set(), built: false, expecting: true, running: false },
      "w2" ->
        { attached: Set(), built: false, expecting: false, running: false }
    )
}

[State 25]
{
  foFixed::failover::cOn: Map("c1" -> "s1", "c2" -> "s1"),
  foFixed::failover::cTo: Map("c1" -> "", "c2" -> ""),
  foFixed::failover::cl: Map("c1" -> "queued", "c2" -> "queued"),
  foFixed::failover::flaps: 3,
  foFixed::failover::mAssigned: Set(("s1", "c1", "w1")),
  foFixed::failover::mBuild: Set(),
  foFixed::failover::mDone: Set(),
  foFixed::failover::mExpect: Set(),
  foFixed::failover::mRestart: Set(),
  foFixed::failover::mResult: Set(),
  foFixed::failover::mRetry: Set(),
  foFixed::failover::mWant: Set(("c2", "s1")),
  foFixed::failover::published: 0,
  foFixed::failover::s1up: true,
  foFixed::failover::ss:
    Map(
      "s1" ->
        { busy: Set("w1"), followers: Set("c1"), has: true, worker: "w1" },
      "s2" -> { busy: Set(), followers: Set(), has: false, worker: "" }
    ),
  foFixed::failover::wOn: Map("w1" -> "s1", "w2" -> "s1"),
  foFixed::failover::ws:
    Map(
      "w1" ->
        { attached: Set(), built: false, expecting: true, running: false },
      "w2" ->
        { attached: Set(), built: false, expecting: false, running: false }
    )
}

[State 26]
{
  foFixed::failover::cOn: Map("c1" -> "s1", "c2" -> "s1"),
  foFixed::failover::cTo: Map("c1" -> "w1", "c2" -> ""),
  foFixed::failover::cl: Map("c1" -> "sent", "c2" -> "queued"),
  foFixed::failover::flaps: 3,
  foFixed::failover::mAssigned: Set(),
  foFixed::failover::mBuild: Set(("c1", "w1")),
  foFixed::failover::mDone: Set(),
  foFixed::failover::mExpect: Set(),
  foFixed::failover::mRestart: Set(),
  foFixed::failover::mResult: Set(),
  foFixed::failover::mRetry: Set(),
  foFixed::failover::mWant: Set(("c2", "s1")),
  foFixed::failover::published: 0,
  foFixed::failover::s1up: true,
  foFixed::failover::ss:
    Map(
      "s1" ->
        { busy: Set("w1"), followers: Set("c1"), has: true, worker: "w1" },
      "s2" -> { busy: Set(), followers: Set(), has: false, worker: "" }
    ),
  foFixed::failover::wOn: Map("w1" -> "s1", "w2" -> "s1"),
  foFixed::failover::ws:
    Map(
      "w1" ->
        { attached: Set(), built: false, expecting: true, running: false },
      "w2" ->
        { attached: Set(), built: false, expecting: false, running: false }
    )
}

[State 27]
{
  foFixed::failover::cOn: Map("c1" -> "s1", "c2" -> "s1"),
  foFixed::failover::cTo: Map("c1" -> "w1", "c2" -> ""),
  foFixed::failover::cl: Map("c1" -> "sent", "c2" -> "queued"),
  foFixed::failover::flaps: 3,
  foFixed::failover::mAssigned: Set(("s1", "c2", "w1")),
  foFixed::failover::mBuild: Set(("c1", "w1")),
  foFixed::failover::mDone: Set(),
  foFixed::failover::mExpect: Set(),
  foFixed::failover::mRestart: Set(),
  foFixed::failover::mResult: Set(),
  foFixed::failover::mRetry: Set(),
  foFixed::failover::mWant: Set(),
  foFixed::failover::published: 0,
  foFixed::failover::s1up: true,
  foFixed::failover::ss:
    Map(
      "s1" ->
        {
          busy: Set("w1"),
          followers: Set("c1", "c2"),
          has: true,
          worker: "w1"
        },
      "s2" -> { busy: Set(), followers: Set(), has: false, worker: "" }
    ),
  foFixed::failover::wOn: Map("w1" -> "s1", "w2" -> "s1"),
  foFixed::failover::ws:
    Map(
      "w1" ->
        { attached: Set(), built: false, expecting: true, running: false },
      "w2" ->
        { attached: Set(), built: false, expecting: false, running: false }
    )
}

[State 28]
{
  foFixed::failover::cOn: Map("c1" -> "s1", "c2" -> "s1"),
  foFixed::failover::cTo: Map("c1" -> "w1", "c2" -> ""),
  foFixed::failover::cl: Map("c1" -> "sent", "c2" -> "queued"),
  foFixed::failover::flaps: 3,
  foFixed::failover::mAssigned: Set(("s1", "c2", "w1")),
  foFixed::failover::mBuild: Set(("c1", "w1")),
  foFixed::failover::mDone: Set(("w1", "s1")),
  foFixed::failover::mExpect: Set(),
  foFixed::failover::mRestart: Set(),
  foFixed::failover::mResult: Set(),
  foFixed::failover::mRetry: Set(),
  foFixed::failover::mWant: Set(),
  foFixed::failover::published: 0,
  foFixed::failover::s1up: true,
  foFixed::failover::ss:
    Map(
      "s1" ->
        {
          busy: Set("w1"),
          followers: Set("c1", "c2"),
          has: true,
          worker: "w1"
        },
      "s2" -> { busy: Set(), followers: Set(), has: false, worker: "" }
    ),
  foFixed::failover::wOn: Map("w1" -> "s1", "w2" -> "s1"),
  foFixed::failover::ws:
    Map(
      "w1" ->
        { attached: Set(), built: false, expecting: false, running: false },
      "w2" ->
        { attached: Set(), built: false, expecting: false, running: false }
    )
}

[State 29]
{
  foFixed::failover::cOn: Map("c1" -> "s1", "c2" -> "s1"),
  foFixed::failover::cTo: Map("c1" -> "w1", "c2" -> "w1"),
  foFixed::failover::cl: Map("c1" -> "sent", "c2" -> "sent"),
  foFixed::failover::flaps: 3,
  foFixed::failover::mAssigned: Set(),
  foFixed::failover::mBuild: Set(("c1", "w1"), ("c2", "w1")),
  foFixed::failover::mDone: Set(("w1", "s1")),
  foFixed::failover::mExpect: Set(),
  foFixed::failover::mRestart: Set(),
  foFixed::failover::mResult: Set(),
  foFixed::failover::mRetry: Set(),
  foFixed::failover::mWant: Set(),
  foFixed::failover::published: 0,
  foFixed::failover::s1up: true,
  foFixed::failover::ss:
    Map(
      "s1" ->
        {
          busy: Set("w1"),
          followers: Set("c1", "c2"),
          has: true,
          worker: "w1"
        },
      "s2" -> { busy: Set(), followers: Set(), has: false, worker: "" }
    ),
  foFixed::failover::wOn: Map("w1" -> "s1", "w2" -> "s1"),
  foFixed::failover::ws:
    Map(
      "w1" ->
        { attached: Set(), built: false, expecting: false, running: false },
      "w2" ->
        { attached: Set(), built: false, expecting: false, running: false }
    )
}

[State 30]
{
  foFixed::failover::cOn: Map("c1" -> "s1", "c2" -> "s1"),
  foFixed::failover::cTo: Map("c1" -> "w1", "c2" -> "w1"),
  foFixed::failover::cl: Map("c1" -> "sent", "c2" -> "sent"),
  foFixed::failover::flaps: 3,
  foFixed::failover::mAssigned: Set(),
  foFixed::failover::mBuild: Set(("c2", "w1")),
  foFixed::failover::mDone: Set(("w1", "s1")),
  foFixed::failover::mExpect: Set(),
  foFixed::failover::mRestart: Set(),
  foFixed::failover::mResult: Set(),
  foFixed::failover::mRetry: Set("c1"),
  foFixed::failover::mWant: Set(),
  foFixed::failover::published: 0,
  foFixed::failover::s1up: true,
  foFixed::failover::ss:
    Map(
      "s1" ->
        {
          busy: Set("w1"),
          followers: Set("c1", "c2"),
          has: true,
          worker: "w1"
        },
      "s2" -> { busy: Set(), followers: Set(), has: false, worker: "" }
    ),
  foFixed::failover::wOn: Map("w1" -> "s1", "w2" -> "s1"),
  foFixed::failover::ws:
    Map(
      "w1" ->
        { attached: Set(), built: false, expecting: false, running: false },
      "w2" ->
        { attached: Set(), built: false, expecting: false, running: false }
    )
}

[ok] No violation found (1946ms at 15416 traces/second).
Trace length statistics: max=31, min=25, average=30.59
You may increase --max-samples and --max-steps.
Use --verbosity to produce more (or less) output.
Use --seed=0x2e2672ec9e23d1a3 --backend=rust to reproduce.
An example execution:

[State 0]
{
  foNoStepDown::failover::cOn: Map("c1" -> "", "c2" -> ""),
  foNoStepDown::failover::cTo: Map("c1" -> "", "c2" -> ""),
  foNoStepDown::failover::cl: Map("c1" -> "idle", "c2" -> "idle"),
  foNoStepDown::failover::flaps: 0,
  foNoStepDown::failover::mAssigned: Set(),
  foNoStepDown::failover::mBuild: Set(),
  foNoStepDown::failover::mDone: Set(),
  foNoStepDown::failover::mExpect: Set(),
  foNoStepDown::failover::mRestart: Set(),
  foNoStepDown::failover::mResult: Set(),
  foNoStepDown::failover::mRetry: Set(),
  foNoStepDown::failover::mWant: Set(),
  foNoStepDown::failover::published: 0,
  foNoStepDown::failover::s1up: true,
  foNoStepDown::failover::ss:
    Map(
      "s1" -> { busy: Set(), followers: Set(), has: false, worker: "" },
      "s2" -> { busy: Set(), followers: Set(), has: false, worker: "" }
    ),
  foNoStepDown::failover::wOn: Map("w1" -> "s1", "w2" -> "s1"),
  foNoStepDown::failover::ws:
    Map(
      "w1" ->
        { attached: Set(), built: false, expecting: false, running: false },
      "w2" ->
        { attached: Set(), built: false, expecting: false, running: false }
    )
}

[State 1]
{
  foNoStepDown::failover::cOn: Map("c1" -> "", "c2" -> ""),
  foNoStepDown::failover::cTo: Map("c1" -> "", "c2" -> ""),
  foNoStepDown::failover::cl: Map("c1" -> "idle", "c2" -> "idle"),
  foNoStepDown::failover::flaps: 1,
  foNoStepDown::failover::mAssigned: Set(),
  foNoStepDown::failover::mBuild: Set(),
  foNoStepDown::failover::mDone: Set(),
  foNoStepDown::failover::mExpect: Set(),
  foNoStepDown::failover::mRestart: Set("w1", "w2"),
  foNoStepDown::failover::mResult: Set(),
  foNoStepDown::failover::mRetry: Set(),
  foNoStepDown::failover::mWant: Set(),
  foNoStepDown::failover::published: 0,
  foNoStepDown::failover::s1up: false,
  foNoStepDown::failover::ss:
    Map(
      "s1" -> { busy: Set(), followers: Set(), has: false, worker: "" },
      "s2" -> { busy: Set(), followers: Set(), has: false, worker: "" }
    ),
  foNoStepDown::failover::wOn: Map("w1" -> "", "w2" -> ""),
  foNoStepDown::failover::ws:
    Map(
      "w1" ->
        { attached: Set(), built: false, expecting: false, running: false },
      "w2" ->
        { attached: Set(), built: false, expecting: false, running: false }
    )
}

[State 2]
{
  foNoStepDown::failover::cOn: Map("c1" -> "s2", "c2" -> ""),
  foNoStepDown::failover::cTo: Map("c1" -> "", "c2" -> ""),
  foNoStepDown::failover::cl: Map("c1" -> "queued", "c2" -> "idle"),
  foNoStepDown::failover::flaps: 1,
  foNoStepDown::failover::mAssigned: Set(),
  foNoStepDown::failover::mBuild: Set(),
  foNoStepDown::failover::mDone: Set(),
  foNoStepDown::failover::mExpect: Set(),
  foNoStepDown::failover::mRestart: Set("w1", "w2"),
  foNoStepDown::failover::mResult: Set(),
  foNoStepDown::failover::mRetry: Set(),
  foNoStepDown::failover::mWant: Set(("c1", "s2")),
  foNoStepDown::failover::published: 0,
  foNoStepDown::failover::s1up: false,
  foNoStepDown::failover::ss:
    Map(
      "s1" -> { busy: Set(), followers: Set(), has: false, worker: "" },
      "s2" -> { busy: Set(), followers: Set(), has: false, worker: "" }
    ),
  foNoStepDown::failover::wOn: Map("w1" -> "", "w2" -> ""),
  foNoStepDown::failover::ws:
    Map(
      "w1" ->
        { attached: Set(), built: false, expecting: false, running: false },
      "w2" ->
        { attached: Set(), built: false, expecting: false, running: false }
    )
}

[State 3]
{
  foNoStepDown::failover::cOn: Map("c1" -> "s2", "c2" -> ""),
  foNoStepDown::failover::cTo: Map("c1" -> "", "c2" -> ""),
  foNoStepDown::failover::cl: Map("c1" -> "queued", "c2" -> "idle"),
  foNoStepDown::failover::flaps: 1,
  foNoStepDown::failover::mAssigned: Set(),
  foNoStepDown::failover::mBuild: Set(),
  foNoStepDown::failover::mDone: Set(),
  foNoStepDown::failover::mExpect: Set(),
  foNoStepDown::failover::mRestart: Set("w1", "w2"),
  foNoStepDown::failover::mResult: Set(),
  foNoStepDown::failover::mRetry: Set(),
  foNoStepDown::failover::mWant: Set(),
  foNoStepDown::failover::published: 0,
  foNoStepDown::failover::s1up: false,
  foNoStepDown::failover::ss:
    Map(
      "s1" -> { busy: Set(), followers: Set(), has: false, worker: "" },
      "s2" -> { busy: Set(), followers: Set("c1"), has: true, worker: "" }
    ),
  foNoStepDown::failover::wOn: Map("w1" -> "", "w2" -> ""),
  foNoStepDown::failover::ws:
    Map(
      "w1" ->
        { attached: Set(), built: false, expecting: false, running: false },
      "w2" ->
        { attached: Set(), built: false, expecting: false, running: false }
    )
}

[State 4]
{
  foNoStepDown::failover::cOn: Map("c1" -> "s2", "c2" -> ""),
  foNoStepDown::failover::cTo: Map("c1" -> "", "c2" -> ""),
  foNoStepDown::failover::cl: Map("c1" -> "queued", "c2" -> "idle"),
  foNoStepDown::failover::flaps: 1,
  foNoStepDown::failover::mAssigned: Set(),
  foNoStepDown::failover::mBuild: Set(),
  foNoStepDown::failover::mDone: Set(),
  foNoStepDown::failover::mExpect: Set(),
  foNoStepDown::failover::mRestart: Set("w1", "w2"),
  foNoStepDown::failover::mResult: Set(),
  foNoStepDown::failover::mRetry: Set(),
  foNoStepDown::failover::mWant: Set(),
  foNoStepDown::failover::published: 0,
  foNoStepDown::failover::s1up: true,
  foNoStepDown::failover::ss:
    Map(
      "s1" -> { busy: Set(), followers: Set(), has: false, worker: "" },
      "s2" -> { busy: Set(), followers: Set("c1"), has: true, worker: "" }
    ),
  foNoStepDown::failover::wOn: Map("w1" -> "", "w2" -> ""),
  foNoStepDown::failover::ws:
    Map(
      "w1" ->
        { attached: Set(), built: false, expecting: false, running: false },
      "w2" ->
        { attached: Set(), built: false, expecting: false, running: false }
    )
}

[violation] Found an issue (8711ms at 66 traces/second).
Use --verbosity=3 to show executions.
Use --seed=0xc35ed63b64e501a0 --backend=rust to reproduce.
error: Invariant violated
An example execution:

[State 0]
{
  hookFixed::hook::cache: Set(),
  hookFixed::hook::drvUploaded: false,
  hookFixed::hook::local: Map("w1" -> Set("in"), "w2" -> Set("in")),
  hookFixed::hook::phase: Query,
  hookFixed::hook::restarts: 0,
  hookFixed::hook::retries: 0,
  hookFixed::hook::toUpload: Set()
}

[State 1]
{
  hookFixed::hook::cache: Set(),
  hookFixed::hook::drvUploaded: false,
  hookFixed::hook::local: Map("w1" -> Set("in"), "w2" -> Set("in")),
  hookFixed::hook::phase: Query,
  hookFixed::hook::restarts: 1,
  hookFixed::hook::retries: 1,
  hookFixed::hook::toUpload: Set()
}

[State 2]
{
  hookFixed::hook::cache: Set("in"),
  hookFixed::hook::drvUploaded: false,
  hookFixed::hook::local: Map("w1" -> Set("in"), "w2" -> Set("in")),
  hookFixed::hook::phase: Upload,
  hookFixed::hook::restarts: 1,
  hookFixed::hook::retries: 1,
  hookFixed::hook::toUpload: Set("drv")
}

[State 3]
{
  hookFixed::hook::cache: Set("in"),
  hookFixed::hook::drvUploaded: false,
  hookFixed::hook::local: Map("w1" -> Set("in"), "w2" -> Set("in")),
  hookFixed::hook::phase: Upload,
  hookFixed::hook::restarts: 2,
  hookFixed::hook::retries: 2,
  hookFixed::hook::toUpload: Set("drv")
}

[State 4]
{
  hookFixed::hook::cache: Set("drv", "in"),
  hookFixed::hook::drvUploaded: false,
  hookFixed::hook::local: Map("w1" -> Set("in"), "w2" -> Set("drv", "in")),
  hookFixed::hook::phase: Build,
  hookFixed::hook::restarts: 2,
  hookFixed::hook::retries: 2,
  hookFixed::hook::toUpload: Set("drv")
}

[State 5]
{
  hookFixed::hook::cache: Set("drv", "in", "out"),
  hookFixed::hook::drvUploaded: false,
  hookFixed::hook::local:
    Map("w1" -> Set("in"), "w2" -> Set("drv", "in", "out")),
  hookFixed::hook::phase: Fetch,
  hookFixed::hook::restarts: 2,
  hookFixed::hook::retries: 2,
  hookFixed::hook::toUpload: Set("drv")
}

[State 6]
{
  hookFixed::hook::cache: Set("drv", "in", "out"),
  hookFixed::hook::drvUploaded: false,
  hookFixed::hook::local:
    Map("w1" -> Set("in"), "w2" -> Set("drv", "in", "out")),
  hookFixed::hook::phase: Done,
  hookFixed::hook::restarts: 2,
  hookFixed::hook::retries: 2,
  hookFixed::hook::toUpload: Set("drv")
}

[ok] No violation found (1604ms at 12469 traces/second).
Trace length statistics: max=7, min=5, average=6.73
You may increase --max-samples and --max-steps.
Use --verbosity to produce more (or less) output.
Use --seed=0xcd36f2022ced4f56 --backend=rust to reproduce.
An example execution:

[State 0]
{
  hookNoSubstituteRefs::hook::cache: Set(),
  hookNoSubstituteRefs::hook::drvUploaded: false,
  hookNoSubstituteRefs::hook::local: Map("w1" -> Set(), "w2" -> Set("in")),
  hookNoSubstituteRefs::hook::phase: Query,
  hookNoSubstituteRefs::hook::restarts: 0,
  hookNoSubstituteRefs::hook::retries: 0,
  hookNoSubstituteRefs::hook::toUpload: Set()
}

[State 1]
{
  hookNoSubstituteRefs::hook::cache: Set("in"),
  hookNoSubstituteRefs::hook::drvUploaded: false,
  hookNoSubstituteRefs::hook::local: Map("w1" -> Set(), "w2" -> Set("in")),
  hookNoSubstituteRefs::hook::phase: Upload,
  hookNoSubstituteRefs::hook::restarts: 0,
  hookNoSubstituteRefs::hook::retries: 0,
  hookNoSubstituteRefs::hook::toUpload: Set("drv")
}

[State 2]
{
  hookNoSubstituteRefs::hook::cache: Set("in"),
  hookNoSubstituteRefs::hook::drvUploaded: false,
  hookNoSubstituteRefs::hook::local: Map("w1" -> Set(), "w2" -> Set("in")),
  hookNoSubstituteRefs::hook::phase: Failed,
  hookNoSubstituteRefs::hook::restarts: 0,
  hookNoSubstituteRefs::hook::retries: 0,
  hookNoSubstituteRefs::hook::toUpload: Set("drv")
}

[violation] Found an issue (68ms at 21088 traces/second).
Use --verbosity=3 to show executions.
Use --seed=0x8f8a48848f4a90bd --backend=rust to reproduce.
error: Invariant violated
An example execution:

[State 0]
{
  hookNoSubstituteDrv::hook::cache: Set(),
  hookNoSubstituteDrv::hook::drvUploaded: false,
  hookNoSubstituteDrv::hook::local: Map("w1" -> Set("in"), "w2" -> Set("in")),
  hookNoSubstituteDrv::hook::phase: Query,
  hookNoSubstituteDrv::hook::restarts: 0,
  hookNoSubstituteDrv::hook::retries: 0,
  hookNoSubstituteDrv::hook::toUpload: Set()
}

[State 1]
{
  hookNoSubstituteDrv::hook::cache: Set("in"),
  hookNoSubstituteDrv::hook::drvUploaded: false,
  hookNoSubstituteDrv::hook::local: Map("w1" -> Set("in"), "w2" -> Set("in")),
  hookNoSubstituteDrv::hook::phase: Upload,
  hookNoSubstituteDrv::hook::restarts: 0,
  hookNoSubstituteDrv::hook::retries: 0,
  hookNoSubstituteDrv::hook::toUpload: Set("drv")
}

[State 2]
{
  hookNoSubstituteDrv::hook::cache: Set("drv", "in"),
  hookNoSubstituteDrv::hook::drvUploaded: false,
  hookNoSubstituteDrv::hook::local:
    Map("w1" -> Set("in"), "w2" -> Set("drv", "in")),
  hookNoSubstituteDrv::hook::phase: Build,
  hookNoSubstituteDrv::hook::restarts: 0,
  hookNoSubstituteDrv::hook::retries: 0,
  hookNoSubstituteDrv::hook::toUpload: Set("drv")
}

[State 3]
{
  hookNoSubstituteDrv::hook::cache: Set("drv", "in"),
  hookNoSubstituteDrv::hook::drvUploaded: false,
  hookNoSubstituteDrv::hook::local:
    Map("w1" -> Set("in"), "w2" -> Set("drv", "in")),
  hookNoSubstituteDrv::hook::phase: UploadDrv,
  hookNoSubstituteDrv::hook::restarts: 0,
  hookNoSubstituteDrv::hook::retries: 0,
  hookNoSubstituteDrv::hook::toUpload: Set("drv")
}

[State 4]
{
  hookNoSubstituteDrv::hook::cache: Set("drv", "in"),
  hookNoSubstituteDrv::hook::drvUploaded: true,
  hookNoSubstituteDrv::hook::local:
    Map("w1" -> Set("in"), "w2" -> Set("drv", "in")),
  hookNoSubstituteDrv::hook::phase: Build,
  hookNoSubstituteDrv::hook::restarts: 0,
  hookNoSubstituteDrv::hook::retries: 0,
  hookNoSubstituteDrv::hook::toUpload: Set("drv")
}

[State 5]
{
  hookNoSubstituteDrv::hook::cache: Set("drv", "in"),
  hookNoSubstituteDrv::hook::drvUploaded: true,
  hookNoSubstituteDrv::hook::local:
    Map("w1" -> Set("in"), "w2" -> Set("drv", "in")),
  hookNoSubstituteDrv::hook::phase: Failed,
  hookNoSubstituteDrv::hook::restarts: 0,
  hookNoSubstituteDrv::hook::retries: 0,
  hookNoSubstituteDrv::hook::toUpload: Set("drv")
}

[violation] Found an issue (292ms at 6021 traces/second).
Use --verbosity=3 to show executions.
Use --seed=0xb52a99193584d819 --backend=rust to reproduce.
error: Invariant violated
An example execution:

[State 0]
{
  pushFixed::push::byPath: Map(),
  pushFixed::push::inflight: Set(),
  pushFixed::push::left: Map(),
  pushFixed::push::sent: Map()
}

[State 1]
{
  pushFixed::push::byPath: Map("a" -> 3, "b" -> 3),
  pushFixed::push::inflight: Set((3, "a"), (3, "b")),
  pushFixed::push::left: Map(3 -> 2),
  pushFixed::push::sent: Map(3 -> Set("a", "b"))
}

[State 2]
{
  pushFixed::push::byPath: Map("a" -> 3, "b" -> 3),
  pushFixed::push::inflight: Set((3, "b")),
  pushFixed::push::left: Map(3 -> 1),
  pushFixed::push::sent: Map(3 -> Set("a", "b"))
}

[State 3]
{
  pushFixed::push::byPath: Map("a" -> 2, "b" -> 2),
  pushFixed::push::inflight: Set((2, "a"), (2, "b"), (3, "b")),
  pushFixed::push::left: Map(2 -> 2, 3 -> 1),
  pushFixed::push::sent: Map(2 -> Set("a", "b"), 3 -> Set("a", "b"))
}

[State 4]
{
  pushFixed::push::byPath: Map("a" -> 2, "b" -> 2),
  pushFixed::push::inflight: Set((2, "a"), (3, "b")),
  pushFixed::push::left: Map(2 -> 1, 3 -> 1),
  pushFixed::push::sent: Map(2 -> Set("a", "b"), 3 -> Set("a", "b"))
}

[State 5]
{
  pushFixed::push::byPath: Map("a" -> 1, "b" -> 1),
  pushFixed::push::inflight: Set((1, "a"), (1, "b"), (2, "a"), (3, "b")),
  pushFixed::push::left: Map(1 -> 2, 2 -> 1, 3 -> 1),
  pushFixed::push::sent:
    Map(1 -> Set("a", "b"), 2 -> Set("a", "b"), 3 -> Set("a", "b"))
}

[State 6]
{
  pushFixed::push::byPath: Map("a" -> 1, "b" -> 1),
  pushFixed::push::inflight: Set((1, "a"), (1, "b"), (3, "b")),
  pushFixed::push::left: Map(1 -> 2, 2 -> 0, 3 -> 1),
  pushFixed::push::sent:
    Map(1 -> Set("a", "b"), 2 -> Set("a", "b"), 3 -> Set("a", "b"))
}

[State 7]
{
  pushFixed::push::byPath: Map("a" -> 1, "b" -> 1),
  pushFixed::push::inflight: Set((1, "b"), (3, "b")),
  pushFixed::push::left: Map(1 -> 1, 2 -> 0, 3 -> 1),
  pushFixed::push::sent:
    Map(1 -> Set("a", "b"), 2 -> Set("a", "b"), 3 -> Set("a", "b"))
}

[State 8]
{
  pushFixed::push::byPath: Map("a" -> 1, "b" -> 1),
  pushFixed::push::inflight: Set((1, "b")),
  pushFixed::push::left: Map(1 -> 1, 2 -> 0, 3 -> 0),
  pushFixed::push::sent:
    Map(1 -> Set("a", "b"), 2 -> Set("a", "b"), 3 -> Set("a", "b"))
}

[State 9]
{
  pushFixed::push::byPath: Map("a" -> 1, "b" -> 1),
  pushFixed::push::inflight: Set(),
  pushFixed::push::left: Map(1 -> 0, 2 -> 0, 3 -> 0),
  pushFixed::push::sent:
    Map(1 -> Set("a", "b"), 2 -> Set("a", "b"), 3 -> Set("a", "b"))
}

[ok] No violation found (93ms at 215054 traces/second).
Trace length statistics: max=10, min=7, average=7.94
You may increase --max-samples and --max-steps.
Use --verbosity to produce more (or less) output.
Use --seed=0xdba9f3d8cd94dd90 --backend=rust to reproduce.