Method endToEndDryRun

app/src/API/Handlers/ProjectHandler.cpp:6442–6534

* @brief End-to-end dry-run: parser + all dataset transforms applied to a sample frame. */

 * @brief End-to-end dry-run: parser + all dataset transforms applied to a sample frame.
 */
API::CommandResponse API::Handlers::ProjectHandler::endToEndDryRun(const QString& id,
                                                                   const QJsonObject& params)
{
  auto& pm           = DataModel::ProjectModel::instance();
  const auto sources = pm.sources();
  const int sourceId = params.value(Keys::SourceId).toInt(0);
  if (sources.empty())
    return CommandResponse::makeError(
      id, ErrorCode::InvalidParam, QStringLiteral("Project has no sources to dry-run against"));

  if (sourceId < 0 || sourceId >= static_cast<int>(sources.size()))
    return CommandResponse::makeError(
      id, ErrorCode::InvalidParam, QStringLiteral("Source id out of range: %1").arg(sourceId));

  const auto& source = sources[sourceId];

  const bool hasFrame  = params.contains(QStringLiteral("sampleFrame"));
  const bool hasFrames = params.contains(QStringLiteral("sampleFrames"));
  if (!hasFrame && !hasFrames)
    return CommandResponse::makeError(
      id,
      ErrorCode::MissingParam,
      QStringLiteral("Missing required parameter: sampleFrame (string) or sampleFrames (array)"));

  QStringList frames;
  if (hasFrames)
    for (const auto& v : params.value(QStringLiteral("sampleFrames")).toArray())
      frames.append(v.toString());
  else
    frames.append(params.value(QStringLiteral("sampleFrame")).toString());

  const bool verbose = params.value(QStringLiteral("verbose")).toBool(false);
  const QString code = params.contains(QStringLiteral("code"))
                       ? params.value(QStringLiteral("code")).toString()
                       : source.frameParserCode;
  const int language = params.contains(QStringLiteral("language"))
                       ? params.value(QStringLiteral("language")).toInt()
                       : source.frameParserLanguage;

  auto parser = makeScriptEngine(language);
  if (!parser->loadScript(code, sourceId, false))
    return CommandResponse::makeError(
      id,
      ErrorCode::ExecutionError,
      QStringLiteral("Frame parser failed to compile or define parse(frame).")
        + frameParserCompileHint(code, language));

  std::map<int, std::unique_ptr<DataModel::IScriptEngine>> transformEngines;
  std::map<int, bool> transformEngineOk;
  const auto& groups = pm.groups();

  QJsonArray frameResults;
  for (const auto& sample : frames) {
    const auto parsed = parser->parseString(sample);

    QJsonArray rowResults;
    for (const auto& row : parsed)
      rowResults.append(buildDryRunRow(