@quolu/lattice 0.1.0

package/src/schedulability-compiler-v2.mjs

@@ -0,0 +1,303 @@
+const GRAPH_SCHEMA = 'lattice.normalized_boundary_graph.v2';
+const PLAN_SCHEMA = 'lattice.plan_graph.v2';
+const MAX_TODOS = 8;
+const MAX_INPUT_TODOS = 256;
+const DEFAULT_MAX_SEARCH_STATES = 2_000_000;
+const IDENTIFIER = /^[0-9A-Za-z](?:[0-9A-Za-z._-]{0,127})$/;
+
+function fail(reason) {
+  throw new TypeError(`schedulability compiler v2契約違反: ${reason}`);
+}
+
+function plainRecord(value) {
+  return value !== null
+    && typeof value === 'object'
+    && !Array.isArray(value)
+    && Object.getPrototypeOf(value) === Object.prototype;
+}
+
+function exactRecord(value, keys) {
+  if (!plainRecord(value)) return false;
+  const actual = Object.keys(value).sort();
+  const expected = [...keys].sort();
+  return actual.length === expected.length
+    && actual.every((key, index) => key === expected[index]);
+}
+
+function identifier(value) {
+  return typeof value === 'string' && IDENTIFIER.test(value);
+}
+
+function boundedText(value) {
+  return typeof value === 'string'
+    && value.length > 0
+    && value === value.trim()
+    && Buffer.byteLength(value, 'utf8') <= 4_096;
+}
+
+function compareText(left, right) {
+  if (left < right) return -1;
+  if (left > right) return 1;
+  return 0;
+}
+
+function assertArray(value, label) {
+  if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype) {
+    fail(`${label}がarrayではない`);
+  }
+}
+
+function normalizeOptions(options) {
+  if (!exactRecord(options, []) && !exactRecord(options, ['maxSearchStates'])) {
+    fail('options shapeが不正');
+  }
+  const maxSearchStates = options.maxSearchStates ?? DEFAULT_MAX_SEARCH_STATES;
+  if (!Number.isSafeInteger(maxSearchStates) || maxSearchStates < 0) {
+    fail('maxSearchStatesがnon-negative safe integerではない');
+  }
+  return { maxSearchStates };
+}
+
+function assertAcyclic(todos, precedences) {
+  const indegree = new Map(todos.map((todoId) => [todoId, 0]));
+  const outgoing = new Map(todos.map((todoId) => [todoId, new Set()]));
+  for (const { from_todo_id: from, to_todo_id: to } of precedences) {
+    if (!outgoing.get(from).has(to)) {
+      outgoing.get(from).add(to);
+      indegree.set(to, indegree.get(to) + 1);
+    }
+  }
+
+  const ready = todos.filter((todoId) => indegree.get(todoId) === 0);
+  let visited = 0;
+  while (ready.length > 0) {
+    const todoId = ready.shift();
+    visited += 1;
+    for (const next of outgoing.get(todoId)) {
+      const remaining = indegree.get(next) - 1;
+      indegree.set(next, remaining);
+      if (remaining === 0) ready.push(next);
+    }
+  }
+  if (visited !== todos.length) fail('precedencesにcycleがある');
+}
+
+function normalizeGraph(value) {
+  if (!exactRecord(value, [
+    'schema_version',
+    'todos',
+    'conflicts',
+    'precedences',
+    'unknowns',
+    'capacity',
+  ]) || value.schema_version !== GRAPH_SCHEMA) {
+    fail('normalized graph shapeまたはschema_versionが不正');
+  }
+
+  assertArray(value.todos, 'todos');
+  if (value.todos.length < 1 || value.todos.length > MAX_INPUT_TODOS
+    || !value.todos.every(identifier)
+    || new Set(value.todos).size !== value.todos.length) {
+    fail('todosがbounded unique identifier arrayではない');
+  }
+  const todos = [...value.todos].sort(compareText);
+  const todoSet = new Set(todos);
+
+  if (!Number.isSafeInteger(value.capacity)
+    || value.capacity < 1
+    || value.capacity > MAX_INPUT_TODOS) {
+    fail('capacityがbounded positive integerではない');
+  }
+
+  assertArray(value.conflicts, 'conflicts');
+  const conflictKeys = new Set();
+  const conflicts = value.conflicts.map((entry) => {
+    if (!exactRecord(entry, ['todo_ids', 'resource_id'])) {
+      fail('conflict shapeが不正');
+    }
+    assertArray(entry.todo_ids, 'conflict.todo_ids');
+    if (entry.todo_ids.length !== 2
+      || !entry.todo_ids.every((todoId) => todoSet.has(todoId))
+      || entry.todo_ids[0] === entry.todo_ids[1]
+      || !identifier(entry.resource_id)) {
+      fail('conflict relationが不正');
+    }
+    const todoIds = [...entry.todo_ids].sort(compareText);
+    const key = `${todoIds[0]}\u0000${todoIds[1]}\u0000${entry.resource_id}`;
+    if (conflictKeys.has(key)) fail('duplicate conflictがある');
+    conflictKeys.add(key);
+    return { todo_ids: todoIds, resource_id: entry.resource_id };
+  }).sort((left, right) => (
+    compareText(left.todo_ids[0], right.todo_ids[0])
+    || compareText(left.todo_ids[1], right.todo_ids[1])
+    || compareText(left.resource_id, right.resource_id)
+  ));
+
+  assertArray(value.precedences, 'precedences');
+  const precedenceKeys = new Set();
+  const precedences = value.precedences.map((entry) => {
+    if (!exactRecord(entry, ['from_todo_id', 'to_todo_id', 'reason'])
+      || !todoSet.has(entry.from_todo_id)
+      || !todoSet.has(entry.to_todo_id)
+      || entry.from_todo_id === entry.to_todo_id
+      || !boundedText(entry.reason)) {
+      fail('precedence relationが不正');
+    }
+    const key = `${entry.from_todo_id}\u0000${entry.to_todo_id}\u0000${entry.reason}`;
+    if (precedenceKeys.has(key)) fail('duplicate precedenceがある');
+    precedenceKeys.add(key);
+    return {
+      from_todo_id: entry.from_todo_id,
+      to_todo_id: entry.to_todo_id,
+      reason: entry.reason,
+    };
+  }).sort((left, right) => (
+    compareText(left.from_todo_id, right.from_todo_id)
+    || compareText(left.to_todo_id, right.to_todo_id)
+    || compareText(left.reason, right.reason)
+  ));
+  assertAcyclic(todos, precedences);
+
+  assertArray(value.unknowns, 'unknowns');
+  const unknownKeys = new Set();
+  const unknowns = value.unknowns.map((entry) => {
+    if (!exactRecord(entry, ['todo_id', 'kind', 'reason'])
+      || !todoSet.has(entry.todo_id)
+      || !identifier(entry.kind)
+      || !boundedText(entry.reason)) {
+      fail('unknown relationが不正');
+    }
+    const key = `${entry.todo_id}\u0000${entry.kind}\u0000${entry.reason}`;
+    if (unknownKeys.has(key)) fail('duplicate unknownがある');
+    unknownKeys.add(key);
+    return { todo_id: entry.todo_id, kind: entry.kind, reason: entry.reason };
+  }).sort((left, right) => (
+    compareText(left.todo_id, right.todo_id)
+    || compareText(left.kind, right.kind)
+    || compareText(left.reason, right.reason)
+  ));
+
+  return { todos, conflicts, precedences, unknowns, capacity: value.capacity };
+}
+
+function feasibleAssignment(graph, waveByIndex, indexByTodo) {
+  const counts = new Array(graph.todos.length).fill(0);
+  for (const waveIndex of waveByIndex) {
+    counts[waveIndex] += 1;
+    if (counts[waveIndex] > graph.capacity) return false;
+  }
+  for (const conflict of graph.conflicts) {
+    if (waveByIndex[indexByTodo.get(conflict.todo_ids[0])]
+      === waveByIndex[indexByTodo.get(conflict.todo_ids[1])]) {
+      return false;
+    }
+  }
+  for (const precedence of graph.precedences) {
+    if (waveByIndex[indexByTodo.get(precedence.from_todo_id)]
+      >= waveByIndex[indexByTodo.get(precedence.to_todo_id)]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function searchMinimum(graph, maxSearchStates) {
+  const assignment = new Array(graph.todos.length).fill(0);
+  const indexByTodo = new Map(graph.todos.map((todoId, index) => [todoId, index]));
+  let examined = 0;
+
+  for (let waveCount = 1; waveCount <= graph.todos.length; waveCount += 1) {
+    const used = new Array(waveCount).fill(0);
+    let solution = null;
+    let exhausted = false;
+
+    function visit(todoIndex, usedCount) {
+      if (solution !== null || exhausted) return;
+      if (todoIndex === graph.todos.length) {
+        if (usedCount !== waveCount) return;
+        if (examined >= maxSearchStates) {
+          exhausted = true;
+          return;
+        }
+        examined += 1;
+        if (feasibleAssignment(graph, assignment, indexByTodo)) {
+          solution = [...assignment];
+        }
+        return;
+      }
+
+      const remainingAfter = graph.todos.length - todoIndex - 1;
+      for (let waveIndex = 0; waveIndex < waveCount; waveIndex += 1) {
+        const isNew = used[waveIndex] === 0;
+        const nextUsedCount = usedCount + (isNew ? 1 : 0);
+        if (waveCount - nextUsedCount > remainingAfter) continue;
+        assignment[todoIndex] = waveIndex;
+        used[waveIndex] += 1;
+        visit(todoIndex + 1, nextUsedCount);
+        used[waveIndex] -= 1;
+        if (solution !== null || exhausted) return;
+      }
+    }
+
+    visit(0, 0);
+    if (exhausted) return { outcome: 'exhausted' };
+    if (solution !== null) return { outcome: 'found', assignment: solution, waveCount };
+  }
+  fail('acyclic bounded graphにfeasible scheduleがない');
+}
+
+function pairwiseVerdicts(graph) {
+  return [
+    ...graph.conflicts.map((conflict) => ({
+      type: 'conflict',
+      todo_ids: [...conflict.todo_ids],
+      resource_id: conflict.resource_id,
+    })),
+    ...graph.precedences.map((precedence) => ({
+      type: 'precedence',
+      from_todo_id: precedence.from_todo_id,
+      to_todo_id: precedence.to_todo_id,
+      reason: precedence.reason,
+    })),
+  ];
+}
+
+/**
+ * Candidate非依存のbounded graphをcanonical minimum-wave planへcompileする。
+ * @param {unknown} normalizedGraph
+ * @param {unknown} options
+ * @returns {object}
+ */
+export function compileSchedulabilityGraphV2(normalizedGraph, options = {}) {
+  const graph = normalizeGraph(normalizedGraph);
+  const { maxSearchStates } = normalizeOptions(options);
+
+  if (graph.todos.length > MAX_TODOS) {
+    return { outcome: 'unsupported', code: 'NODE_LIMIT_EXCEEDED' };
+  }
+  if (graph.unknowns.length > 0) {
+    return { outcome: 'unknown', code: 'BOUNDARY_UNKNOWN', unknowns: graph.unknowns };
+  }
+  if (maxSearchStates === 0) {
+    return { outcome: 'unsupported', code: 'SEARCH_BUDGET_EXHAUSTED' };
+  }
+
+  const searched = searchMinimum(graph, maxSearchStates);
+  if (searched.outcome === 'exhausted') {
+    return { outcome: 'unsupported', code: 'SEARCH_BUDGET_EXHAUSTED' };
+  }
+
+  const waves = Array.from({ length: searched.waveCount }, () => ({ todo_ids: [] }));
+  searched.assignment.forEach((waveIndex, todoIndex) => {
+    waves[waveIndex].todo_ids.push(graph.todos[todoIndex]);
+  });
+  return {
+    outcome: 'compiled',
+    pairwise_verdicts: pairwiseVerdicts(graph),
+    plan: {
+      schema_version: PLAN_SCHEMA,
+      waves,
+      minimum_feasible_waves: searched.waveCount,
+    },
+  };
+}

package/src/schedulability-verifier-v2.mjs

@@ -0,0 +1,317 @@
+const GRAPH_SCHEMA = 'lattice.normalized_boundary_graph.v2';
+const PLAN_SCHEMA = 'lattice.plan_graph.v2';
+const MAX_TODOS = 8;
+const MAX_INPUT_TODOS = 256;
+const DEFAULT_MAX_SEARCH_STATES = 2_000_000;
+const IDENTIFIER = /^[0-9A-Za-z](?:[0-9A-Za-z._-]{0,127})$/;
+
+function contractError(reason) {
+  throw new TypeError(`schedulability verifier v2契約違反: ${reason}`);
+}
+
+function isPlainObject(value) {
+  return value !== null
+    && typeof value === 'object'
+    && !Array.isArray(value)
+    && Object.getPrototypeOf(value) === Object.prototype;
+}
+
+function hasOnlyKeys(value, keys) {
+  if (!isPlainObject(value)) return false;
+  const found = Object.keys(value).sort();
+  const wanted = [...keys].sort();
+  return found.length === wanted.length
+    && found.every((key, index) => key === wanted[index]);
+}
+
+function validIdentifier(value) {
+  return typeof value === 'string' && IDENTIFIER.test(value);
+}
+
+function validReason(value) {
+  return typeof value === 'string'
+    && value.length > 0
+    && value === value.trim()
+    && Buffer.byteLength(value, 'utf8') <= 4_096;
+}
+
+function textOrder(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+
+function requireArray(value, label) {
+  if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype) {
+    contractError(`${label}がarrayではない`);
+  }
+}
+
+function verifierOptions(options) {
+  if (!hasOnlyKeys(options, []) && !hasOnlyKeys(options, ['maxSearchStates'])) {
+    contractError('options shapeが不正');
+  }
+  const limit = options.maxSearchStates ?? DEFAULT_MAX_SEARCH_STATES;
+  if (!Number.isSafeInteger(limit) || limit < 0) {
+    contractError('maxSearchStatesがnon-negative safe integerではない');
+  }
+  return { limit };
+}
+
+function requireDag(todoIds, precedences) {
+  const incoming = new Map(todoIds.map((todoId) => [todoId, 0]));
+  const nextByTodo = new Map(todoIds.map((todoId) => [todoId, new Set()]));
+  for (const edge of precedences) {
+    const next = nextByTodo.get(edge.from);
+    if (!next.has(edge.to)) {
+      next.add(edge.to);
+      incoming.set(edge.to, incoming.get(edge.to) + 1);
+    }
+  }
+  const queue = todoIds.filter((todoId) => incoming.get(todoId) === 0);
+  let removed = 0;
+  for (let cursor = 0; cursor < queue.length; cursor += 1) {
+    const todoId = queue[cursor];
+    removed += 1;
+    for (const next of nextByTodo.get(todoId)) {
+      incoming.set(next, incoming.get(next) - 1);
+      if (incoming.get(next) === 0) queue.push(next);
+    }
+  }
+  if (removed !== todoIds.length) contractError('precedencesにcycleがある');
+}
+
+function verifierGraph(value) {
+  if (!hasOnlyKeys(value, [
+    'schema_version',
+    'todos',
+    'conflicts',
+    'precedences',
+    'unknowns',
+    'capacity',
+  ]) || value.schema_version !== GRAPH_SCHEMA) {
+    contractError('normalized graph shapeまたはschema_versionが不正');
+  }
+
+  requireArray(value.todos, 'todos');
+  if (value.todos.length < 1 || value.todos.length > MAX_INPUT_TODOS
+    || !value.todos.every(validIdentifier)
+    || new Set(value.todos).size !== value.todos.length) {
+    contractError('todosがbounded unique identifier arrayではない');
+  }
+  const todoIds = [...value.todos].sort(textOrder);
+  const knownTodos = new Set(todoIds);
+  if (!Number.isSafeInteger(value.capacity)
+    || value.capacity < 1
+    || value.capacity > MAX_INPUT_TODOS) {
+    contractError('capacityがbounded positive integerではない');
+  }
+
+  requireArray(value.conflicts, 'conflicts');
+  const seenConflicts = new Set();
+  const conflicts = value.conflicts.map((item) => {
+    if (!hasOnlyKeys(item, ['todo_ids', 'resource_id'])) {
+      contractError('conflict shapeが不正');
+    }
+    requireArray(item.todo_ids, 'conflict.todo_ids');
+    if (item.todo_ids.length !== 2
+      || !item.todo_ids.every((todoId) => knownTodos.has(todoId))
+      || item.todo_ids[0] === item.todo_ids[1]
+      || !validIdentifier(item.resource_id)) {
+      contractError('conflict relationが不正');
+    }
+    const pair = [...item.todo_ids].sort(textOrder);
+    const key = `${pair[0]}\u0000${pair[1]}\u0000${item.resource_id}`;
+    if (seenConflicts.has(key)) contractError('duplicate conflictがある');
+    seenConflicts.add(key);
+    return { left: pair[0], right: pair[1] };
+  });
+
+  requireArray(value.precedences, 'precedences');
+  const seenPrecedences = new Set();
+  const precedences = value.precedences.map((item) => {
+    if (!hasOnlyKeys(item, ['from_todo_id', 'to_todo_id', 'reason'])
+      || !knownTodos.has(item.from_todo_id)
+      || !knownTodos.has(item.to_todo_id)
+      || item.from_todo_id === item.to_todo_id
+      || !validReason(item.reason)) {
+      contractError('precedence relationが不正');
+    }
+    const key = `${item.from_todo_id}\u0000${item.to_todo_id}\u0000${item.reason}`;
+    if (seenPrecedences.has(key)) contractError('duplicate precedenceがある');
+    seenPrecedences.add(key);
+    return { from: item.from_todo_id, to: item.to_todo_id };
+  });
+  requireDag(todoIds, precedences);
+
+  requireArray(value.unknowns, 'unknowns');
+  const seenUnknowns = new Set();
+  const unknowns = value.unknowns.map((item) => {
+    if (!hasOnlyKeys(item, ['todo_id', 'kind', 'reason'])
+      || !knownTodos.has(item.todo_id)
+      || !validIdentifier(item.kind)
+      || !validReason(item.reason)) {
+      contractError('unknown relationが不正');
+    }
+    const key = `${item.todo_id}\u0000${item.kind}\u0000${item.reason}`;
+    if (seenUnknowns.has(key)) contractError('duplicate unknownがある');
+    seenUnknowns.add(key);
+    return { todoId: item.todo_id };
+  });
+
+  return { todoIds, knownTodos, conflicts, precedences, unknowns, capacity: value.capacity };
+}
+
+function rejected(code, extra = {}) {
+  return { outcome: 'rejected', code, ...extra };
+}
+
+function inspectPlan(value, graph) {
+  if (!hasOnlyKeys(value, ['schema_version', 'waves', 'minimum_feasible_waves'])
+    || value.schema_version !== PLAN_SCHEMA
+    || !Number.isSafeInteger(value.minimum_feasible_waves)
+    || value.minimum_feasible_waves < 1) {
+    return { result: rejected('PLAN_SCHEMA_INVALID') };
+  }
+  if (!Array.isArray(value.waves)
+    || Object.getPrototypeOf(value.waves) !== Array.prototype
+    || value.waves.length < 1
+    || value.waves.length > graph.todoIds.length) {
+    return { result: rejected('PLAN_SCHEMA_INVALID') };
+  }
+  if (value.minimum_feasible_waves !== value.waves.length) {
+    return { result: rejected('MINIMUM_CLAIM_MISMATCH') };
+  }
+
+  const waveByTodo = new Map();
+  for (let waveIndex = 0; waveIndex < value.waves.length; waveIndex += 1) {
+    const wave = value.waves[waveIndex];
+    if (!hasOnlyKeys(wave, ['todo_ids'])
+      || !Array.isArray(wave.todo_ids)
+      || Object.getPrototypeOf(wave.todo_ids) !== Array.prototype
+      || wave.todo_ids.length < 1
+      || !wave.todo_ids.every(validIdentifier)) {
+      return { result: rejected('PLAN_SCHEMA_INVALID') };
+    }
+    if (wave.todo_ids.length > graph.capacity) {
+      return { result: rejected('CAPACITY_EXCEEDED') };
+    }
+    for (const todoId of wave.todo_ids) {
+      if (!graph.knownTodos.has(todoId)) return { result: rejected('TODO_UNKNOWN') };
+      if (waveByTodo.has(todoId)) return { result: rejected('TODO_DUPLICATED') };
+      waveByTodo.set(todoId, waveIndex);
+    }
+  }
+  if (waveByTodo.size !== graph.todoIds.length) {
+    return { result: rejected('TODO_MISSING') };
+  }
+  for (const conflict of graph.conflicts) {
+    if (waveByTodo.get(conflict.left) === waveByTodo.get(conflict.right)) {
+      return { result: rejected('CONFLICT_COLOCATED') };
+    }
+  }
+  for (const precedence of graph.precedences) {
+    if (waveByTodo.get(precedence.from) >= waveByTodo.get(precedence.to)) {
+      return { result: rejected('PRECEDENCE_VIOLATION') };
+    }
+  }
+  return { waveCount: value.waves.length };
+}
+
+function assignmentSatisfies(graph, assignment, positionByTodo) {
+  const occupancy = new Map();
+  for (const waveIndex of assignment) {
+    const count = (occupancy.get(waveIndex) ?? 0) + 1;
+    if (count > graph.capacity) return false;
+    occupancy.set(waveIndex, count);
+  }
+  for (const edge of graph.conflicts) {
+    if (assignment[positionByTodo.get(edge.left)]
+      === assignment[positionByTodo.get(edge.right)]) {
+      return false;
+    }
+  }
+  for (const edge of graph.precedences) {
+    if (assignment[positionByTodo.get(edge.from)]
+      >= assignment[positionByTodo.get(edge.to)]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function shorterSchedule(graph, upperExclusive, budget) {
+  const assignment = new Array(graph.todoIds.length).fill(0);
+  const positionByTodo = new Map(graph.todoIds.map((todoId, index) => [todoId, index]));
+
+  for (let waveCount = 1; waveCount < upperExclusive; waveCount += 1) {
+    const occupancy = new Array(waveCount).fill(0);
+    let answer = false;
+    let ranOut = false;
+
+    const enumerate = (todoIndex, occupiedWaves) => {
+      if (answer || ranOut) return;
+      if (todoIndex === graph.todoIds.length) {
+        if (occupiedWaves !== waveCount) return;
+        if (budget.examined >= budget.limit) {
+          ranOut = true;
+          return;
+        }
+        budget.examined += 1;
+        answer = assignmentSatisfies(graph, assignment, positionByTodo);
+        return;
+      }
+
+      const unassignedAfter = graph.todoIds.length - todoIndex - 1;
+      for (let candidateWave = 0; candidateWave < waveCount; candidateWave += 1) {
+        const opensWave = occupancy[candidateWave] === 0;
+        const nextOccupied = occupiedWaves + (opensWave ? 1 : 0);
+        if (waveCount - nextOccupied > unassignedAfter) continue;
+        assignment[todoIndex] = candidateWave;
+        occupancy[candidateWave] += 1;
+        enumerate(todoIndex + 1, nextOccupied);
+        occupancy[candidateWave] -= 1;
+        if (answer || ranOut) return;
+      }
+    };
+
+    enumerate(0, 0);
+    if (ranOut) return { state: 'exhausted' };
+    if (answer) return { state: 'found', waveCount };
+  }
+  return { state: 'none' };
+}
+
+/**
+ * Producerを呼ばず、保存graphからplanのfeasibilityとminimumを再計算する。
+ * @param {unknown} normalizedGraph
+ * @param {unknown} plan
+ * @param {unknown} options
+ * @returns {object}
+ */
+export function verifySchedulabilityPlanV2(normalizedGraph, plan, options = {}) {
+  const graph = verifierGraph(normalizedGraph);
+  const { limit } = verifierOptions(options);
+
+  if (graph.todoIds.length > MAX_TODOS) {
+    return { outcome: 'unsupported', code: 'NODE_LIMIT_EXCEEDED' };
+  }
+  if (graph.unknowns.length > 0) {
+    return { outcome: 'unknown', code: 'BOUNDARY_UNKNOWN' };
+  }
+
+  const inspected = inspectPlan(plan, graph);
+  if (inspected.result !== undefined) return inspected.result;
+
+  const shorter = shorterSchedule(graph, inspected.waveCount, { limit, examined: 0 });
+  if (shorter.state === 'exhausted') {
+    return { outcome: 'unsupported', code: 'SEARCH_BUDGET_EXHAUSTED' };
+  }
+  if (shorter.state === 'found') {
+    return rejected('NON_MINIMUM_SCHEDULE', {
+      minimum_feasible_waves: shorter.waveCount,
+    });
+  }
+  return {
+    outcome: 'verified',
+    minimum_feasible_waves: inspected.waveCount,
+  };
+}