native_migrate_verify.c

Go to the documentation of this file.

/**
 * @file
 * @brief Verifies sqlite migration state natively and emits structured migration verification reports.
 */
 
#include "native_migrate_verify.h"
 
#ifndef _WIN32
 
#include "native_artifact_emit.h"
#include "native_json_config.h"
#include "native_process_capture.h"
#include "native_support.h"
#include "native_yyjson_helpers.h"
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
#include <unistd.h>
 
#define native_migrate_verify_strdup strdup
 
/**
 * @brief Duplicates a static JSON literal string.
 * @param value JSON literal text to duplicate.
 * @return Newly allocated copy, or NULL on allocation failure.
 */
static char *native_json_literal_dup(const char *value) {
  return native_migrate_verify_strdup(value != NULL ? value : "null");
}
 
/**
 * @brief Duplicates a string value as JSON string text, or null when absent.
 * @param value Source string.
 * @return Newly allocated JSON string payload or null literal.
 */
static char *native_json_nullable_string_dup(const char *value) {
  if (value == NULL || value[0] == '\0') {
    return native_json_literal_dup("null");
  }
  return json_string_dup_native(value);
}
 
/**
 * @brief Duplicates a borrowed JSON value as compact JSON, or a fallback literal.
 * @param value Borrowed JSON value.
 * @param fallback Fallback JSON literal.
 * @return Newly allocated JSON text.
 */
static char *native_json_value_or_literal_dup(yyjson_val *value,
                                              const char *fallback) {
  char *json = native_json_serialize_compact_dup(value);
  if (json != NULL) {
    return json;
  }
  return native_json_literal_dup(fallback);
}
 
/**
 * @brief Duplicates an object string field as JSON string text with a default.
 * @param obj Object to inspect.
 * @param key Field name.
 * @param fallback Default plain string value.
 * @return Newly allocated JSON string text.
 */
static char *native_json_object_string_json_dup(yyjson_val *obj,
                                                const char *key,
                                                const char *fallback) {
  char *text = native_json_obj_get_string_dup(obj, key);
  char *json = NULL;
  if (text == NULL) {
    return json_string_dup_native(fallback != NULL ? fallback : "");
  }
  json = json_string_dup_native(text);
  free(text);
  return json;
}
 
/**
 * @brief Converts a long value to owned JSON number text.
 * @param value Numeric value to serialize.
 * @return Newly allocated JSON number text, or NULL on allocation failure.
 */
static char *native_long_json_dup(long value) {
  char buffer[64];
  snprintf(buffer, sizeof(buffer), "%ld", value);
  return native_migrate_verify_strdup(buffer);
}
 
/**
 * @brief Tests whether a string is a safe sqlite identifier.
 * @param value Candidate identifier.
 * @return 1 when the identifier is safe, otherwise 0.
 */
static int native_identifier_safe(const char *value) {
  const char *cursor = value;
  if (value == NULL || value[0] == '\0') {
    return 0;
  }
  while (*cursor != '\0') {
    if (!((*cursor >= 'A' && *cursor <= 'Z') ||
          (*cursor >= 'a' && *cursor <= 'z') ||
          (*cursor >= '0' && *cursor <= '9') || *cursor == '_')) {
      return 0;
    }
    cursor++;
  }
  return 1;
}
 
/**
 * @brief Resolves an executable from PATH.
 * @param command Command name or path.
 * @return Newly allocated executable path, or NULL when unavailable.
 */
static char *native_resolve_command_path(const char *command) {
  char *path_copy;
  char *segment;
  char *state = NULL;
  const char *path_env;
  if (command == NULL || command[0] == '\0') {
    return NULL;
  }
  if (strchr(command, '/') != NULL) {
    return access(command, X_OK) == 0
               ? native_migrate_verify_strdup(command)
               : NULL;
  }
  path_env = getenv("PATH");
  if (path_env == NULL || path_env[0] == '\0') {
    return NULL;
  }
  path_copy = native_migrate_verify_strdup(path_env);
  if (path_copy == NULL) {
    return NULL;
  }
  for (segment = strtok_r(path_copy, ":", &state); segment != NULL;
       segment = strtok_r(NULL, ":", &state)) {
    char candidate[4096];
    if (segment[0] == '\0') {
      continue;
    }
    snprintf(candidate, sizeof(candidate), "%s/%s", segment, command);
    if (access(candidate, X_OK) == 0) {
      char *resolved = native_migrate_verify_strdup(candidate);
      free(path_copy);
      return resolved;
    }
  }
  free(path_copy);
  return NULL;
}
 
/**
 * @brief Tests whether a required native tool is available.
 * @param command Command to resolve.
 * @return 1 when present, otherwise 0.
 */
static int native_command_exists(const char *command) {
  char *resolved = native_resolve_command_path(command);
  int present = resolved != NULL && resolved[0] != '\0';
  free(resolved);
  return present;
}
 
/**
 * @brief Runs a subprocess and trims surrounding whitespace from stdout.
 * @param argv Command argv vector.
 * @param code_out Optional process exit code output.
 * @return Newly allocated trimmed stdout text, or NULL on process failure.
 */
static char *native_capture_trimmed(char *const argv[], int *code_out) {
  char *output = NULL;
  int code = run_process_capture_native(argv, &output);
  if (output != NULL) {
    trim_in_place(output);
  }
  if (code_out != NULL) {
    *code_out = code;
  }
  return output;
}
 
/**
 * @brief Appends one SQL character with sqlite literal escaping.
 * @param buffer Destination buffer.
 * @param value Character to append.
 * @return 0 on success, otherwise -1.
 */
static int native_append_escaped_sql_char(Buffer *buffer, char value) {
  if (buffer == NULL) {
    return -1;
  }
  switch (value) {
  case '\'':
    return buffer_append(buffer, "''", 2);
  default:
    return buffer_append(buffer, &value, 1);
  }
}
 
/**
 * @brief Escapes a string for safe inclusion in a sqlite string literal.
 * @param value Input string.
 * @return Newly allocated escaped text, or NULL on allocation failure.
 */
static char *native_sql_literal_escape(const char *value) {
  Buffer buffer;
  const char *cursor = value != NULL ? value : "";
  buffer_init(&buffer);
  while (*cursor != '\0') {
    if (native_append_escaped_sql_char(&buffer, *cursor) != 0) {
      buffer_free(&buffer);
      return NULL;
    }
    cursor++;
  }
  return buffer.data;
}
 
/**
 * @brief Writes temporary text content to a file.
 * @param text Text payload.
 * @param path_out Receives the created path.
 * @return 0 on success, otherwise -1.
 */
static int native_write_temp_text_file(const char *text, char **path_out) {
  char path_template[] = "/tmp/pharos-migrate-XXXXXX";
  FILE *file = NULL;
  int fd;
  size_t text_len = text != NULL ? strlen(text) : 0;
  if (path_out == NULL) {
    return -1;
  }
  *path_out = NULL;
  fd = mkstemp(path_template);
  if (fd < 0) {
    return -1;
  }
  file = fdopen(fd, "wb");
  if (file == NULL) {
    close(fd);
    remove(path_template);
    return -1;
  }
  if (text_len > 0 && fwrite(text, 1, text_len, file) != text_len) {
    fclose(file);
    remove(path_template);
    return -1;
  }
  if (fclose(file) != 0) {
    remove(path_template);
    return -1;
  }
  *path_out = native_migrate_verify_strdup(path_template);
  if (*path_out == NULL) {
    remove(path_template);
    return -1;
  }
  return 0;
}
 
/**
 * @brief Captures checksum tool output for a temporary file.
 * @param command Checksum command.
 * @param arg1 Optional first flag.
 * @param arg2 Optional second flag.
 * @param file_path File to checksum.
 * @param code_out Optional exit code output.
 * @return Newly allocated trimmed stdout, or NULL.
 */
static char *native_capture_checksum_output(const char *command,
                                            const char *arg1,
                                            const char *arg2,
                                            const char *file_path,
                                            int *code_out) {
  char *resolved_path = NULL;
  char *argv_list[5];
  int argc = 0;
  char *output;
  if (command == NULL || file_path == NULL) {
    return NULL;
  }
  resolved_path = native_resolve_command_path(command);
  if (resolved_path == NULL) {
    return NULL;
  }
  argv_list[argc++] = resolved_path;
  if (arg1 != NULL) {
    argv_list[argc++] = (char *)arg1;
  }
  if (arg2 != NULL) {
    argv_list[argc++] = (char *)arg2;
  }
  argv_list[argc++] = (char *)file_path;
  argv_list[argc] = NULL;
  output = native_capture_trimmed(argv_list, code_out);
  free(resolved_path);
  return output;
}
 
/**
 * @brief Evaluates whether a seed expectation passes.
 * @param row_count Observed row count.
 * @param minimum_present Whether minimum_rows was provided.
 * @param minimum_rows Minimum row threshold.
 * @param exact_present Whether exact_rows was provided.
 * @param exact_rows Exact row requirement.
 * @param reason_out Receives the failure reason.
 * @return 1 when satisfied, otherwise 0.
 */
static int native_seed_expectation_satisfied(long row_count,
                                             int minimum_present,
                                             long minimum_rows,
                                             int exact_present,
                                             long exact_rows,
                                             const char **reason_out) {
  if (reason_out == NULL) {
    return 0;
  }
  if (exact_present && row_count != exact_rows) {
    *reason_out = "exact_rows_mismatch";
    return 0;
  }
  if (minimum_present && row_count < minimum_rows) {
    *reason_out = "minimum_rows_not_met";
    return 0;
  }
  *reason_out = "ok";
  return 1;
}
 
/**
 * @brief Tests whether a JSON string array contains one exact string.
 * @param array_value Array to inspect.
 * @param expected_value Expected string.
 * @return 1 when found, otherwise 0.
 */
static int native_json_string_array_contains(yyjson_val *array_value,
                                             const char *expected_value) {
  yyjson_arr_iter iter;
  yyjson_val *item = NULL;
  if (array_value == NULL || expected_value == NULL ||
      !yyjson_is_arr(array_value)) {
    return 0;
  }
  if (!yyjson_arr_iter_init(array_value, &iter)) {
    return 0;
  }
  while ((item = yyjson_arr_iter_next(&iter)) != NULL) {
    if (yyjson_is_str(item) && yyjson_equals_str(item, expected_value)) {
      return 1;
    }
  }
  return 0;
}
 
/**
 * @brief Tests whether an applied checksum satisfies expected checksum contracts.
 * @param applied Whether the migration is applied.
 * @param applied_checksum Applied checksum text.
 * @param expected_checksum Primary expected checksum.
 * @param legacy_expected_checksum Legacy expected checksum.
 * @param accepted_legacy_checksums Array of accepted legacy checksums.
 * @return 1 when the checksum matches, otherwise 0.
 */
static int native_migration_checksum_matches(
    int applied,
    const char *applied_checksum,
    const char *expected_checksum,
    const char *legacy_expected_checksum,
    yyjson_val *accepted_legacy_checksums) {
  if (!applied || applied_checksum == NULL || applied_checksum[0] == '\0') {
    return 0;
  }
  if (expected_checksum != NULL && streq(applied_checksum, expected_checksum)) {
    return 1;
  }
  if (legacy_expected_checksum != NULL &&
      streq(applied_checksum, legacy_expected_checksum)) {
    return 1;
  }
  return native_json_string_array_contains(accepted_legacy_checksums,
                                           applied_checksum);
}
 
/**
 * @brief Executes a sqlite query and captures one trimmed stdout value.
 * @param db_path Database path.
 * @param sql SQL statement.
 * @return Newly allocated stdout text, or NULL on failure.
 */
static char *native_sqlite_query_value(const char *db_path, const char *sql) {
  char *argv_list[4];
  char *sqlite_path = NULL;
  char *output = NULL;
  int code = 0;
  if (db_path == NULL || sql == NULL) {
    return NULL;
  }
  sqlite_path = native_resolve_command_path("sqlite3");
  if (sqlite_path == NULL) {
    return NULL;
  }
  argv_list[0] = sqlite_path;
  argv_list[1] = (char *)db_path;
  argv_list[2] = (char *)sql;
  argv_list[3] = NULL;
  output = native_capture_trimmed(argv_list, &code);
  free(sqlite_path);
  if (code != 0) {
    free(output);
    return NULL;
  }
  return output;
}
 
/**
 * @brief Tests whether a sqlite table exists.
 * @param db_path Database path.
 * @param table_name Table name.
 * @return 1 when present, otherwise 0.
 */
static int native_sqlite_table_exists(const char *db_path,
                                      const char *table_name) {
  char query[1024];
  char *escaped = NULL;
  char *result = NULL;
  int exists = 0;
  if (db_path == NULL || !native_identifier_safe(table_name)) {
    return 0;
  }
  escaped = native_sql_literal_escape(table_name);
  if (escaped == NULL) {
    return 0;
  }
  snprintf(query, sizeof(query),
           "SELECT name FROM sqlite_master WHERE type = 'table' AND name = "
           "'%s' LIMIT 1;",
           escaped);
  result = native_sqlite_query_value(db_path, query);
  if (result != NULL && streq(result, table_name)) {
    exists = 1;
  }
  free(escaped);
  free(result);
  return exists;
}
 
/**
 * @brief Counts rows in a sqlite table.
 * @param db_path Database path.
 * @param table_name Table name.
 * @return Observed row count or 0 on failure.
 */
static long native_sqlite_table_row_count(const char *db_path,
                                          const char *table_name) {
  char query[1024];
  char *result = NULL;
  long value = 0;
  if (db_path == NULL || !native_identifier_safe(table_name)) {
    return 0;
  }
  snprintf(query, sizeof(query), "SELECT COUNT(*) FROM \"%s\";", table_name);
  result = native_sqlite_query_value(db_path, query);
  if (result != NULL && result[0] != '\0') {
    value = strtol(result, NULL, 10);
  }
  free(result);
  return value;
}
 
/**
 * @brief Counts applied migration ledger rows.
 * @param db_path Database path.
 * @param migration_id Migration id.
 * @param backend Backend name.
 * @return Count of matching applied rows.
 */
static long native_sqlite_migration_applied_count(const char *db_path,
                                                  const char *migration_id,
                                                  const char *backend) {
  char query[2048];
  char *escaped_id = NULL;
  char *escaped_backend = NULL;
  char *result = NULL;
  long value = 0;
  if (db_path == NULL || migration_id == NULL || backend == NULL) {
    return 0;
  }
  escaped_id = native_sql_literal_escape(migration_id);
  escaped_backend = native_sql_literal_escape(backend);
  if (escaped_id == NULL || escaped_backend == NULL) {
    free(escaped_id);
    free(escaped_backend);
    return 0;
  }
  snprintf(query, sizeof(query),
           "SELECT COUNT(*) FROM pharos_schema_migration WHERE migration_id = "
           "'%s' AND backend = '%s';",
           escaped_id, escaped_backend);
  result = native_sqlite_query_value(db_path, query);
  if (result != NULL && result[0] != '\0') {
    value = strtol(result, NULL, 10);
  }
  free(escaped_id);
  free(escaped_backend);
  free(result);
  return value;
}
 
/**
 * @brief Reads the applied schema version for a migration.
 * @param db_path Database path.
 * @param migration_id Migration id.
 * @param backend Backend name.
 * @return Newly allocated schema version text, or NULL on failure.
 */
static char *native_sqlite_migration_applied_schema_version(
    const char *db_path,
    const char *migration_id,
    const char *backend) {
  char query[2048];
  char *escaped_id = NULL;
  char *escaped_backend = NULL;
  char *result = NULL;
  if (db_path == NULL || migration_id == NULL || backend == NULL) {
    return NULL;
  }
  escaped_id = native_sql_literal_escape(migration_id);
  escaped_backend = native_sql_literal_escape(backend);
  if (escaped_id == NULL || escaped_backend == NULL) {
    free(escaped_id);
    free(escaped_backend);
    return NULL;
  }
  snprintf(query, sizeof(query),
           "SELECT schema_version FROM pharos_schema_migration WHERE "
           "migration_id = '%s' AND backend = '%s' ORDER BY applied_at DESC "
           "LIMIT 1;",
           escaped_id, escaped_backend);
  result = native_sqlite_query_value(db_path, query);
  free(escaped_id);
  free(escaped_backend);
  return result;
}
 
/**
 * @brief Reads the applied checksum for a migration.
 * @param db_path Database path.
 * @param migration_id Migration id.
 * @param backend Backend name.
 * @return Newly allocated checksum text, or NULL on failure.
 */
static char *native_sqlite_migration_applied_checksum(const char *db_path,
                                                      const char *migration_id,
                                                      const char *backend) {
  char query[2048];
  char *escaped_id = NULL;
  char *escaped_backend = NULL;
  char *result = NULL;
  if (db_path == NULL || migration_id == NULL || backend == NULL) {
    return NULL;
  }
  escaped_id = native_sql_literal_escape(migration_id);
  escaped_backend = native_sql_literal_escape(backend);
  if (escaped_id == NULL || escaped_backend == NULL) {
    free(escaped_id);
    free(escaped_backend);
    return NULL;
  }
  snprintf(query, sizeof(query),
           "SELECT checksum_sha256 FROM pharos_schema_migration WHERE "
           "migration_id = '%s' AND backend = '%s' ORDER BY applied_at DESC "
           "LIMIT 1;",
           escaped_id, escaped_backend);
  result = native_sqlite_query_value(db_path, query);
  free(escaped_id);
  free(escaped_backend);
  return result;
}
 
/**
 * @brief Appends a whole file to a growable buffer followed by a newline.
 * @param buffer Destination buffer.
 * @param file_path File path to append.
 * @return 0 on success, otherwise -1.
 */
static int native_append_file_to_buffer(Buffer *buffer, const char *file_path) {
  char *text = read_file_text(file_path);
  if (text == NULL) {
    return -1;
  }
  if (buffer_append(buffer, text, strlen(text)) != 0 ||
      buffer_append(buffer, "\n", 1) != 0) {
    free(text);
    return -1;
  }
  free(text);
  return 0;
}
 
/**
 * @brief Appends a path marker line to a checksum input buffer.
 * @param buffer Destination buffer.
 * @param file_path Source file path.
 * @return 0 on success, otherwise -1.
 */
static int native_append_path_marker(Buffer *buffer, const char *file_path) {
  char marker[8192];
  if (buffer == NULL || file_path == NULL) {
    return -1;
  }
  snprintf(marker, sizeof(marker), "\n-- pharos-path: %s\n", file_path);
  return buffer_append(buffer, marker, strlen(marker));
}
 
/**
 * @brief Computes a sha256 checksum string for arbitrary text.
 * @param value Input text.
 * @return Newly allocated checksum hex text, or NULL on failure.
 */
static char *native_checksum_string(const char *value) {
  static const struct {
    const char *command;
    const char *arg1;
    const char *arg2;
  } checksum_tools[] = {{"sha256sum", NULL, NULL}, {"shasum", "-a", "256"}};
  char *tmp_path = NULL;
  char *output = NULL;
  size_t index;
  int code = 0;
  if (native_write_temp_text_file(value, &tmp_path) != 0) {
    return NULL;
  }
  for (index = 0; index < sizeof(checksum_tools) / sizeof(checksum_tools[0]);
       index++) {
    if (!native_command_exists(checksum_tools[index].command)) {
      continue;
    }
    output = native_capture_checksum_output(checksum_tools[index].command,
                                            checksum_tools[index].arg1,
                                            checksum_tools[index].arg2,
                                            tmp_path, &code);
    break;
  }
  remove(tmp_path);
  free(tmp_path);
  if (code != 0 || output == NULL) {
    free(output);
    return NULL;
  }
  {
    char *space = strchr(output, ' ');
    if (space != NULL) {
      *space = '\0';
    }
  }
  return output;
}
 
/**
 * @brief Resolves a path string relative to the app root when needed.
 * @param app_root App root directory.
 * @param value Raw path value.
 * @return Newly allocated resolved path, or NULL on failure.
 */
static char *native_resolve_app_path(const char *app_root, const char *value) {
  return resolve_relative_to(app_root, value);
}
 
/**
 * @brief Appends resolved seed source files into a checksum buffer.
 * @param buffer Destination buffer.
 * @param app_root App root used for relative seed paths.
 * @param seed_sources Array of seed source paths.
 * @return 0 on success, otherwise -1.
 */
static int native_append_seed_sources_to_buffer(Buffer *buffer,
                                                const char *app_root,
                                                yyjson_val *seed_sources) {
  yyjson_arr_iter iter;
  yyjson_val *item = NULL;
  if (buffer == NULL || app_root == NULL) {
    return -1;
  }
  if (seed_sources == NULL) {
    return 0;
  }
  if (!yyjson_is_arr(seed_sources) || !yyjson_arr_iter_init(seed_sources, &iter)) {
    return -1;
  }
  while ((item = yyjson_arr_iter_next(&iter)) != NULL) {
    char *resolved_path = NULL;
    const char *raw_path = NULL;
    if (!yyjson_is_str(item)) {
      return -1;
    }
    raw_path = yyjson_get_str(item);
    resolved_path = native_resolve_app_path(app_root, raw_path);
    if (resolved_path == NULL) {
      return -1;
    }
    if (path_exists(resolved_path)) {
      if (native_append_file_to_buffer(buffer, resolved_path) != 0 ||
          native_append_path_marker(buffer, resolved_path) != 0) {
        free(resolved_path);
        return -1;
      }
    }
    free(resolved_path);
  }
  return 0;
}
 
/**
 * @brief Appends a JSON array item into a buffer-backed array literal.
 * @param buffer Destination buffer.
 * @param json_item Already serialized JSON item.
 * @param first Tracks whether the array already has an item.
 * @return Buffer data on success, or NULL on failure.
 */
static char *native_append_json_item(Buffer *buffer, const char *json_item,
                                     int *first) {
  if (buffer == NULL || first == NULL || json_item == NULL) {
    return NULL;
  }
  if (*first) {
    if (buffer_append(buffer, "[", 1) != 0) {
      return NULL;
    }
    *first = 0;
  }
  if (buffer->len > 1 && buffer_append(buffer, ",", 1) != 0) {
    return NULL;
  }
  if (buffer_append(buffer, json_item, strlen(json_item)) != 0) {
    return NULL;
  }
  return buffer->data;
}
 
/**
 * @brief Appends a JSON string item into a buffer-backed array literal.
 * @param buffer Destination buffer.
 * @param value Plain string value.
 * @param first Tracks whether the array already has an item.
 * @return 0 on success, otherwise -1.
 */
static int native_append_json_string_item(Buffer *buffer, const char *value,
                                          int *first) {
  char *json = json_string_dup_native(value != NULL ? value : "");
  int result = -1;
  if (json == NULL) {
    return -1;
  }
  result = native_append_json_item(buffer, json, first) != NULL ? 0 : -1;
  free(json);
  return result;
}
 
/**
 * @brief Finalizes a buffer-backed JSON array literal.
 * @param buffer Array buffer.
 * @param first Whether no items were appended.
 * @return Newly allocated empty array or buffer-owned array text.
 */
static char *native_finish_json_array(Buffer *buffer, int first) {
  if (buffer == NULL) {
    return NULL;
  }
  if (first) {
    return native_migrate_verify_strdup("[]");
  }
  if (buffer_append(buffer, "]", 1) != 0) {
    buffer_free(buffer);
    return NULL;
  }
  return buffer->data;
}
 
/**
 * @brief Appends forward SQL file contents for one migration/backend pair.
 * @param combined Destination checksum input buffer.
 * @param app_root App root directory.
 * @param migration_record Migration object.
 * @param backend Backend name.
 * @return 0 on success, otherwise -1.
 */
static int native_append_forward_sql_bundle(Buffer *combined,
                                            const char *app_root,
                                            yyjson_val *migration_record,
                                            const char *backend) {
  yyjson_val *backend_files = NULL;
  yyjson_val *backend_entry = NULL;
  yyjson_val *forward_sql_files = NULL;
  yyjson_arr_iter iter;
  yyjson_val *item = NULL;
  if (combined == NULL || app_root == NULL || migration_record == NULL ||
      backend == NULL) {
    return -1;
  }
  backend_files = native_json_obj_get(migration_record, "backend_files");
  backend_entry = native_json_obj_get(backend_files, backend);
  forward_sql_files = native_json_obj_get_array(backend_entry, "forward_sql_files");
  if (forward_sql_files == NULL) {
    return 0;
  }
  if (!yyjson_arr_iter_init(forward_sql_files, &iter)) {
    return -1;
  }
  while ((item = yyjson_arr_iter_next(&iter)) != NULL) {
    char *resolved_path = NULL;
    const char *relative_path = NULL;
    if (!yyjson_is_str(item)) {
      return -1;
    }
    relative_path = yyjson_get_str(item);
    resolved_path = native_resolve_app_path(app_root, relative_path);
    if (resolved_path == NULL) {
      return -1;
    }
    if (native_append_file_to_buffer(combined, resolved_path) != 0 ||
        native_append_path_marker(combined, resolved_path) != 0) {
      free(resolved_path);
      return -1;
    }
    free(resolved_path);
  }
  return 0;
}
 
/**
 * @brief Computes the current expected checksum for a migration.
 * @param app_root App root directory.
 * @param migration_record Migration object.
 * @param entity_fixture Optional entity fixture path.
 * @param query_fixture Optional query fixture path.
 * @param backend Backend name.
 * @return Newly allocated checksum text, or NULL on failure.
 */
static char *native_expected_migration_checksum(const char *app_root,
                                                yyjson_val *migration_record,
                                                const char *entity_fixture,
                                                const char *query_fixture,
                                                const char *backend) {
  Buffer combined;
  char *checksum = NULL;
  buffer_init(&combined);
  if (native_append_forward_sql_bundle(&combined, app_root, migration_record,
                                       backend) != 0) {
    buffer_free(&combined);
    return NULL;
  }
  if (entity_fixture != NULL && path_exists(entity_fixture)) {
    if (native_append_file_to_buffer(&combined, entity_fixture) != 0) {
      buffer_free(&combined);
      return NULL;
    }
  }
  if (query_fixture != NULL && path_exists(query_fixture)) {
    if (native_append_file_to_buffer(&combined, query_fixture) != 0) {
      buffer_free(&combined);
      return NULL;
    }
  }
  checksum = native_checksum_string(combined.data != NULL ? combined.data : "");
  buffer_free(&combined);
  return checksum;
}
 
/**
 * @brief Computes the legacy expected checksum for a migration.
 * @param app_root App root directory.
 * @param migration_record Migration object.
 * @param entity_fixture Optional entity fixture path.
 * @param query_fixture Optional query fixture path.
 * @param backend Backend name.
 * @param seed_sources Resolved seed source array.
 * @return Newly allocated checksum text, or NULL on failure.
 */
static char *native_legacy_expected_migration_checksum(
    const char *app_root,
    yyjson_val *migration_record,
    const char *entity_fixture,
    const char *query_fixture,
    const char *backend,
    yyjson_val *seed_sources) {
  char *forward_checksum = NULL;
  char *entity_checksum = NULL;
  char *query_checksum = NULL;
  char *seed_checksum = NULL;
  char *result = NULL;
  Buffer payload;
  yyjson_val *drift_inputs = NULL;
  int need_entity = 0;
  int need_query = 0;
  int need_seed = 0;
  char *migration_id = NULL;
 
  if (migration_record == NULL || app_root == NULL || backend == NULL) {
    return NULL;
  }
 
  buffer_init(&payload);
  drift_inputs = native_json_obj_get_array(migration_record, "drift_inputs");
  need_entity = native_json_string_array_contains(drift_inputs,
                                                  "entity_contract_hash");
  need_query = native_json_string_array_contains(drift_inputs,
                                                 "query_contract_hash");
  need_seed = native_json_string_array_contains(drift_inputs,
                                                "seed_source_hash");
 
  forward_checksum = native_expected_migration_checksum(app_root, migration_record,
                                                        NULL, NULL, backend);
  if (need_entity && entity_fixture != NULL && path_exists(entity_fixture)) {
    char *text = read_file_text(entity_fixture);
    if (text != NULL) {
      entity_checksum = native_checksum_string(text);
      free(text);
    }
  }
  if (need_query && query_fixture != NULL && path_exists(query_fixture)) {
    char *text = read_file_text(query_fixture);
    if (text != NULL) {
      query_checksum = native_checksum_string(text);
      free(text);
    }
  }
  if (need_seed) {
    Buffer combined;
    buffer_init(&combined);
    if (native_append_seed_sources_to_buffer(&combined, app_root, seed_sources) ==
        0) {
      seed_checksum = native_checksum_string(combined.data != NULL ? combined.data :
                                             "");
    }
    buffer_free(&combined);
  }
 
  migration_id = native_json_obj_get_string_dup(migration_record, "migration_id");
  if (buffer_append(&payload, "migration_id=", 13) != 0 ||
      buffer_append(&payload, migration_id != NULL ? migration_id : "",
                    strlen(migration_id != NULL ? migration_id : "")) != 0 ||
      buffer_append(&payload, "\nbackend=", 9) != 0 ||
      buffer_append(&payload, backend, strlen(backend)) != 0 ||
      buffer_append(&payload, "\nforward_checksum=", 18) != 0 ||
      buffer_append(&payload,
                    forward_checksum != NULL ? forward_checksum : "",
                    strlen(forward_checksum != NULL ? forward_checksum : "")) != 0 ||
      buffer_append(&payload, "\nentity_contract_hash=", 22) != 0 ||
      buffer_append(&payload,
                    entity_checksum != NULL ? entity_checksum : "",
                    strlen(entity_checksum != NULL ? entity_checksum : "")) != 0 ||
      buffer_append(&payload, "\nquery_contract_hash=", 21) != 0 ||
      buffer_append(&payload,
                    query_checksum != NULL ? query_checksum : "",
                    strlen(query_checksum != NULL ? query_checksum : "")) != 0 ||
      buffer_append(&payload, "\nseed_source_hash=", 18) != 0 ||
      buffer_append(&payload,
                    seed_checksum != NULL ? seed_checksum : "",
                    strlen(seed_checksum != NULL ? seed_checksum : "")) != 0) {
    buffer_free(&payload);
    payload.data = NULL;
  }
  if (payload.data != NULL) {
    result = native_checksum_string(payload.data);
  }
 
  buffer_free(&payload);
  free(migration_id);
  free(forward_checksum);
  free(entity_checksum);
  free(query_checksum);
  free(seed_checksum);
  return result;
}
 
/**
 * @brief Returns the default sqlite path for an app.
 * @param app App runtime.
 * @return Newly allocated sqlite path.
 */
static char *native_default_sqlite_path(const AppRuntime *app) {
  char *db_path =
      app != NULL ? conf_lookup_value(app->runtime_conf_path, "db_path") : NULL;
  char buffer[4096];
  if (db_path != NULL && db_path[0] != '\0') {
    return db_path;
  }
  free(db_path);
  snprintf(buffer, sizeof(buffer), "/var/lib/pharos/%s.sqlite3",
           app != NULL && app->app_id != NULL ? app->app_id : "app");
  return native_migrate_verify_strdup(buffer);
}
 
char *native_capture_migrate_verify_sqlite_report_json(const ServeConfig *config,
                                                       const AppRuntime *app,
                                                       char **status_out,
                                                       char **error_out) {
  char *manifest_path = NULL;
  char *migration_fixture_rel = NULL;
  char *entity_fixture_rel = NULL;
  char *query_fixture_rel = NULL;
  char *migration_fixture = NULL;
  char *entity_fixture = NULL;
  char *query_fixture = NULL;
  char *preferred_backend_json = NULL;
  char *development_backend_json = NULL;
  char *testing_backend_json = NULL;
  char *schema_version_json = NULL;
  char *required_tables_json = NULL;
  char *required_migration_ids_json = NULL;
  char *seed_expectations_json = NULL;
  char *verification_contract_json = NULL;
  char *sqlite_db_path = NULL;
  char *sqlite_db_path_json = NULL;
  char *target_id_json = NULL;
  char *migration_fixture_json = NULL;
  char *entity_fixture_json = NULL;
  char *query_fixture_json = NULL;
  char *db_config_json = NULL;
  char *result = NULL;
  char *status_json = NULL;
  char *table_checks_json = NULL;
  char *seed_checks_json = NULL;
  char *migration_checks_json = NULL;
  char *missing_tables_json = NULL;
  char *missing_migrations_json = NULL;
  char *drifted_migrations_json = NULL;
  char *failed_seed_expectations_json = NULL;
  Buffer table_checks;
  Buffer seed_checks;
  Buffer migration_checks;
  Buffer missing_tables;
  Buffer missing_migrations;
  Buffer drifted_migrations;
  Buffer failed_seed_expectations;
  int first_table = 1;
  int first_seed = 1;
  int first_migration = 1;
  int first_missing_table = 1;
  int first_missing_migration = 1;
  int first_drifted_migration = 1;
  int first_failed_seed = 1;
  int database_present = 0;
  int ledger_table_present = 0;
  int verified = 0;
  const char *verification_status = "verification_failed";
  size_t needed;
  yyjson_doc *manifest_doc = NULL;
  yyjson_doc *migration_doc = NULL;
  yyjson_val *manifest_root = NULL;
  yyjson_val *migration_root = NULL;
  yyjson_val *database_obj = NULL;
  yyjson_val *seed_sources = NULL;
  yyjson_val *sqlite_backend = NULL;
  yyjson_val *verification_contract = NULL;
  yyjson_val *required_tables = NULL;
  yyjson_val *required_migration_ids = NULL;
  yyjson_val *seed_expectations = NULL;
  long schema_version = 0;
 
  if (status_out != NULL) {
    *status_out = NULL;
  }
  if (error_out != NULL) {
    *error_out = NULL;
  }
  if (config == NULL || app == NULL || app->app_root == NULL ||
      app->app_id == NULL) {
    return NULL;
  }
  if (!native_command_exists("sqlite3")) {
    return NULL;
  }
 
  buffer_init(&table_checks);
  buffer_init(&seed_checks);
  buffer_init(&migration_checks);
  buffer_init(&missing_tables);
  buffer_init(&missing_migrations);
  buffer_init(&drifted_migrations);
  buffer_init(&failed_seed_expectations);
 
  manifest_path = path_join(app->app_root, "pharos.app.json");
  if (manifest_path == NULL || !path_exists(manifest_path)) {
    goto cleanup;
  }
  manifest_doc = native_json_doc_load_file(manifest_path);
  if (manifest_doc == NULL) {
    goto cleanup;
  }
  manifest_root = yyjson_doc_get_root(manifest_doc);
  database_obj = native_json_obj_get(manifest_root, "database");
  if (database_obj == NULL) {
    goto cleanup;
  }
 
  migration_fixture_rel =
      native_json_obj_get_string_dup(database_obj, "migration_fixture");
  entity_fixture_rel = native_json_obj_get_string_dup(database_obj, "entity_fixture");
  query_fixture_rel = native_json_obj_get_string_dup(database_obj, "query_fixture");
  seed_sources = native_json_obj_get_array(database_obj, "seed_sources");
  if (migration_fixture_rel == NULL) {
    goto cleanup;
  }
 
  migration_fixture = native_resolve_app_path(app->app_root, migration_fixture_rel);
  entity_fixture = entity_fixture_rel != NULL
                      ? native_resolve_app_path(app->app_root, entity_fixture_rel)
                      : NULL;
  query_fixture = query_fixture_rel != NULL
                     ? native_resolve_app_path(app->app_root, query_fixture_rel)
                     : NULL;
  if (migration_fixture == NULL || !path_exists(migration_fixture)) {
    goto cleanup;
  }
 
  migration_doc = native_json_doc_load_file(migration_fixture);
  if (migration_doc == NULL) {
    goto cleanup;
  }
  migration_root = yyjson_doc_get_root(migration_doc);
  sqlite_backend = native_json_find_backend_by_name(migration_root, "sqlite");
  verification_contract = native_json_obj_get(sqlite_backend, "verification_contract");
  required_tables = native_json_obj_get_array(verification_contract, "required_tables");
  required_migration_ids =
      native_json_obj_get_array(verification_contract, "required_migration_ids");
  seed_expectations =
      native_json_obj_get_array(verification_contract, "seed_expectations");
 
  preferred_backend_json =
      native_json_object_string_json_dup(migration_root, "preferred_backend",
                                         "sqlite");
  development_backend_json =
      native_json_object_string_json_dup(migration_root, "development_backend",
                                         "sqlite");
  testing_backend_json =
      native_json_object_string_json_dup(migration_root, "testing_backend",
                                         "sqlite");
  schema_version =
      native_json_obj_get_long_default(migration_root, "schema_version", 0, NULL);
  schema_version_json = native_long_json_dup(schema_version);
  required_tables_json = native_json_value_or_literal_dup(required_tables, "[]");
  required_migration_ids_json =
      native_json_value_or_literal_dup(required_migration_ids, "[]");
  seed_expectations_json =
      native_json_value_or_literal_dup(seed_expectations, "[]");
  verification_contract_json =
      native_json_value_or_literal_dup(verification_contract, "{}");
  db_config_json = native_json_literal_dup("{\"backend\":\"sqlite\"}");
 
  sqlite_db_path = native_default_sqlite_path(app);
  database_present = sqlite_db_path != NULL && path_exists(sqlite_db_path);
  ledger_table_present =
      database_present &&
      native_sqlite_table_exists(sqlite_db_path, "pharos_schema_migration");
 
  if (required_tables != NULL) {
    yyjson_arr_iter iter;
    yyjson_val *item = NULL;
    if (!yyjson_arr_iter_init(required_tables, &iter)) {
      goto cleanup;
    }
    while ((item = yyjson_arr_iter_next(&iter)) != NULL) {
      const char *table_name = NULL;
      int exists = 0;
      char *table_json = NULL;
      char *item_json = NULL;
      size_t item_needed;
      if (!yyjson_is_str(item)) {
        goto cleanup;
      }
      table_name = yyjson_get_str(item);
      exists = database_present ? native_sqlite_table_exists(sqlite_db_path, table_name)
                                : 0;
      table_json = json_string_dup_native(table_name);
      item_needed = (table_json != NULL ? strlen(table_json) : 0) + 96;
      item_json = (char *)malloc(item_needed);
      if (table_json == NULL || item_json == NULL) {
        free(table_json);
        free(item_json);
        goto cleanup;
      }
      snprintf(item_json, item_needed,
               "{\"table\":%s,\"exists\":%s,\"status\":\"%s\"}",
               table_json, exists ? "true" : "false",
               exists ? "ok" : "missing_table");
      if (native_append_json_item(&table_checks, item_json, &first_table) == NULL) {
        free(table_json);
        free(item_json);
        goto cleanup;
      }
      if (!exists &&
          native_append_json_string_item(&missing_tables, table_name,
                                         &first_missing_table) != 0) {
        free(table_json);
        free(item_json);
        goto cleanup;
      }
      free(table_json);
      free(item_json);
    }
  }
 
  if (seed_expectations != NULL) {
    yyjson_arr_iter iter;
    yyjson_val *item = NULL;
    if (!yyjson_arr_iter_init(seed_expectations, &iter)) {
      goto cleanup;
    }
    while ((item = yyjson_arr_iter_next(&iter)) != NULL) {
      char *table_name = NULL;
      char *table_json = NULL;
      char *item_json = NULL;
      long minimum_rows = 0;
      long exact_rows = 0;
      int minimum_present = 0;
      int exact_present = 0;
      int table_exists = 0;
      long row_count = 0;
      int satisfied = 0;
      const char *reason = "missing_table";
      char minimum_buf[64];
      char exact_buf[64];
      size_t item_needed;
      if (!yyjson_is_obj(item)) {
        goto cleanup;
      }
      table_name = native_json_obj_get_string_dup(item, "table");
      minimum_rows =
          native_json_obj_get_long_default(item, "minimum_rows", 0,
                                           &minimum_present);
      exact_rows =
          native_json_obj_get_long_default(item, "exact_rows", 0, &exact_present);
      if (table_name != NULL && database_present) {
        table_exists = native_sqlite_table_exists(sqlite_db_path, table_name);
        if (table_exists) {
          row_count = native_sqlite_table_row_count(sqlite_db_path, table_name);
          satisfied = native_seed_expectation_satisfied(
              row_count, minimum_present, minimum_rows, exact_present, exact_rows,
              &reason);
        }
      }
      table_json = json_string_dup_native(table_name != NULL ? table_name : "");
      snprintf(minimum_buf, sizeof(minimum_buf), "%ld", minimum_rows);
      snprintf(exact_buf, sizeof(exact_buf), "%ld", exact_rows);
      item_needed = (table_json != NULL ? strlen(table_json) : 0) +
                    strlen(reason) + 192;
      item_json = (char *)malloc(item_needed);
      if (table_json == NULL || item_json == NULL) {
        free(table_name);
        free(table_json);
        free(item_json);
        goto cleanup;
      }
      snprintf(item_json, item_needed,
               "{\"table\":%s,\"table_exists\":%s,\"row_count\":%ld,"
               "\"minimum_rows\":%s,\"exact_rows\":%s,\"satisfied\":%s,"
               "\"reason\":\"%s\"}",
               table_json, table_exists ? "true" : "false", row_count,
               minimum_present ? minimum_buf : "null",
               exact_present ? exact_buf : "null",
               satisfied ? "true" : "false", reason);
      if (native_append_json_item(&seed_checks, item_json, &first_seed) == NULL) {
        free(table_name);
        free(table_json);
        free(item_json);
        goto cleanup;
      }
      if (!satisfied && native_append_json_item(&failed_seed_expectations, item_json,
                                                &first_failed_seed) == NULL) {
        free(table_name);
        free(table_json);
        free(item_json);
        goto cleanup;
      }
      free(table_name);
      free(table_json);
      free(item_json);
    }
  }
 
  if (required_migration_ids != NULL) {
    yyjson_arr_iter iter;
    yyjson_val *item = NULL;
    if (!yyjson_arr_iter_init(required_migration_ids, &iter)) {
      goto cleanup;
    }
    while ((item = yyjson_arr_iter_next(&iter)) != NULL) {
      const char *migration_id = NULL;
      yyjson_val *migration_record = NULL;
      yyjson_val *accepted_legacy_checksums = NULL;
      char *migration_json = NULL;
      char *schema_json = NULL;
      char *applied_schema_json = NULL;
      char *expected_checksum = NULL;
      char *legacy_expected_checksum = NULL;
      char *applied_checksum = NULL;
      char *accepted_legacy_checksums_json = NULL;
      char *item_json = NULL;
      long applied_count = 0;
      int applied = 0;
      int checksum_match = 0;
      long migration_schema_version = 0;
      size_t item_needed;
 
      if (!yyjson_is_str(item)) {
        goto cleanup;
      }
      migration_id = yyjson_get_str(item);
      migration_record = native_json_find_migration_by_id(migration_root, migration_id);
      accepted_legacy_checksums = native_json_obj_get_array(
          native_json_obj_get(migration_record, "accepted_legacy_checksums"),
          "sqlite");
      migration_schema_version = native_json_obj_get_long_default(
          migration_record, "schema_version", 0, NULL);
      migration_json = json_string_dup_native(migration_id);
      schema_json = native_long_json_dup(migration_schema_version);
      accepted_legacy_checksums_json =
          native_json_value_or_literal_dup(accepted_legacy_checksums, "[]");
      expected_checksum = native_expected_migration_checksum(
          app->app_root, migration_record, NULL, NULL, "sqlite");
      legacy_expected_checksum = native_legacy_expected_migration_checksum(
          app->app_root, migration_record, entity_fixture, query_fixture, "sqlite",
          seed_sources);
 
      if (ledger_table_present) {
        applied_count = native_sqlite_migration_applied_count(sqlite_db_path,
                                                              migration_id,
                                                              "sqlite");
        applied = applied_count > 0;
        applied_schema_json = native_sqlite_migration_applied_schema_version(
            sqlite_db_path, migration_id, "sqlite");
        applied_checksum = native_sqlite_migration_applied_checksum(
            sqlite_db_path, migration_id, "sqlite");
        checksum_match = native_migration_checksum_matches(
            applied, applied_checksum, expected_checksum, legacy_expected_checksum,
            accepted_legacy_checksums);
      }
 
      item_needed = (migration_json != NULL ? strlen(migration_json) : 0) +
                    (schema_json != NULL ? strlen(schema_json) : 1) +
                    (applied_schema_json != NULL ? strlen(applied_schema_json) : 4) +
                    (expected_checksum != NULL ? strlen(expected_checksum) : 0) +
                    (legacy_expected_checksum != NULL
                         ? strlen(legacy_expected_checksum)
                         : 0) +
                    (applied_checksum != NULL ? strlen(applied_checksum) : 0) +
                    (accepted_legacy_checksums_json != NULL
                         ? strlen(accepted_legacy_checksums_json)
                         : 2) +
                    256;
      item_json = (char *)malloc(item_needed);
      if (migration_json == NULL || schema_json == NULL ||
          accepted_legacy_checksums_json == NULL || item_json == NULL) {
        free(migration_json);
        free(schema_json);
        free(applied_schema_json);
        free(expected_checksum);
        free(legacy_expected_checksum);
        free(applied_checksum);
        free(accepted_legacy_checksums_json);
        free(item_json);
        goto cleanup;
      }
      {
        char *expected_json =
            json_string_dup_native(expected_checksum != NULL ? expected_checksum : "");
        char *legacy_json = json_string_dup_native(
            legacy_expected_checksum != NULL ? legacy_expected_checksum : "");
        char *applied_checksum_json =
            applied_checksum != NULL && applied_checksum[0] != '\0'
                ? json_string_dup_native(applied_checksum)
                : native_json_literal_dup("null");
        if (expected_json == NULL || legacy_json == NULL ||
            applied_checksum_json == NULL) {
          free(expected_json);
          free(legacy_json);
          free(applied_checksum_json);
          free(migration_json);
          free(schema_json);
          free(applied_schema_json);
          free(expected_checksum);
          free(legacy_expected_checksum);
          free(applied_checksum);
          free(accepted_legacy_checksums_json);
          free(item_json);
          goto cleanup;
        }
        snprintf(item_json, item_needed,
                 "{\"migration_id\":%s,\"backend\":\"sqlite\","
                 "\"schema_version\":%s,\"applied\":%s,"
                 "\"applied_count\":%ld,\"applied_schema_version\":%s,"
                 "\"expected_checksum\":%s,"
                 "\"legacy_expected_checksum\":%s,"
                 "\"accepted_legacy_checksums\":%s,"
                 "\"applied_checksum\":%s,\"checksum_match\":%s}",
                 migration_json, schema_json, applied ? "true" : "false",
                 applied_count,
                 applied_schema_json != NULL && applied_schema_json[0] != '\0'
                     ? applied_schema_json
                     : "null",
                 expected_json, legacy_json, accepted_legacy_checksums_json,
                 applied_checksum_json, checksum_match ? "true" : "false");
        free(expected_json);
        free(legacy_json);
        free(applied_checksum_json);
      }
      if (native_append_json_item(&migration_checks, item_json, &first_migration) ==
          NULL) {
        free(migration_json);
        free(schema_json);
        free(applied_schema_json);
        free(expected_checksum);
        free(legacy_expected_checksum);
        free(applied_checksum);
        free(accepted_legacy_checksums_json);
        free(item_json);
        goto cleanup;
      }
      if (!applied &&
          native_append_json_string_item(&missing_migrations, migration_id,
                                         &first_missing_migration) != 0) {
        free(migration_json);
        free(schema_json);
        free(applied_schema_json);
        free(expected_checksum);
        free(legacy_expected_checksum);
        free(applied_checksum);
        free(accepted_legacy_checksums_json);
        free(item_json);
        goto cleanup;
      }
      if (applied && !checksum_match &&
          native_append_json_string_item(&drifted_migrations, migration_id,
                                         &first_drifted_migration) != 0) {
        free(migration_json);
        free(schema_json);
        free(applied_schema_json);
        free(expected_checksum);
        free(legacy_expected_checksum);
        free(applied_checksum);
        free(accepted_legacy_checksums_json);
        free(item_json);
        goto cleanup;
      }
      free(migration_json);
      free(schema_json);
      free(applied_schema_json);
      free(expected_checksum);
      free(legacy_expected_checksum);
      free(applied_checksum);
      free(accepted_legacy_checksums_json);
      free(item_json);
    }
  }
 
  table_checks_json = native_finish_json_array(&table_checks, first_table);
  seed_checks_json = native_finish_json_array(&seed_checks, first_seed);
  migration_checks_json = native_finish_json_array(&migration_checks, first_migration);
  missing_tables_json = native_finish_json_array(&missing_tables, first_missing_table);
  missing_migrations_json =
      native_finish_json_array(&missing_migrations, first_missing_migration);
  drifted_migrations_json =
      native_finish_json_array(&drifted_migrations, first_drifted_migration);
  failed_seed_expectations_json =
      native_finish_json_array(&failed_seed_expectations, first_failed_seed);
  if (table_checks_json == NULL || seed_checks_json == NULL ||
      migration_checks_json == NULL || missing_tables_json == NULL ||
      missing_migrations_json == NULL || drifted_migrations_json == NULL ||
      failed_seed_expectations_json == NULL) {
    goto cleanup;
  }
 
  verified = database_present && ledger_table_present &&
             streq(missing_tables_json, "[]") &&
             streq(missing_migrations_json, "[]") &&
             streq(drifted_migrations_json, "[]") &&
             streq(failed_seed_expectations_json, "[]");
  verification_status = verified ? "verified" : "verification_failed";
  if (status_out != NULL) {
    *status_out = native_migrate_verify_strdup(verification_status);
  }
 
  target_id_json = json_string_dup_native(config->target_id != NULL
                                              ? config->target_id
                                              : app->app_id);
  sqlite_db_path_json = json_string_dup_native(sqlite_db_path != NULL ? sqlite_db_path : "");
  migration_fixture_json = json_string_dup_native(migration_fixture != NULL ? migration_fixture : "");
  entity_fixture_json = native_json_nullable_string_dup(entity_fixture);
  query_fixture_json = native_json_nullable_string_dup(query_fixture);
  status_json = json_string_dup_native(verification_status);
 
  needed = (target_id_json != NULL ? strlen(target_id_json) : 0) +
           (status_json != NULL ? strlen(status_json) : 0) +
           (preferred_backend_json != NULL ? strlen(preferred_backend_json) : 8) +
           (development_backend_json != NULL ? strlen(development_backend_json) : 8) +
           (testing_backend_json != NULL ? strlen(testing_backend_json) : 8) +
           (schema_version_json != NULL ? strlen(schema_version_json) : 1) +
           (required_tables_json != NULL ? strlen(required_tables_json) : 2) +
           (required_migration_ids_json != NULL
                ? strlen(required_migration_ids_json)
                : 2) +
           (seed_expectations_json != NULL ? strlen(seed_expectations_json) : 2) +
           (verification_contract_json != NULL
                ? strlen(verification_contract_json)
                : 2) +
           (sqlite_db_path_json != NULL ? strlen(sqlite_db_path_json) : 0) +
           (migration_fixture_json != NULL ? strlen(migration_fixture_json) : 0) +
           (entity_fixture_json != NULL ? strlen(entity_fixture_json) : 4) +
           (query_fixture_json != NULL ? strlen(query_fixture_json) : 4) +
           (db_config_json != NULL ? strlen(db_config_json) : 20) +
           (table_checks_json != NULL ? strlen(table_checks_json) : 2) +
           (missing_tables_json != NULL ? strlen(missing_tables_json) : 2) +
           (seed_checks_json != NULL ? strlen(seed_checks_json) : 2) +
           (failed_seed_expectations_json != NULL
                ? strlen(failed_seed_expectations_json)
                : 2) +
           (migration_checks_json != NULL ? strlen(migration_checks_json) : 2) +
           (missing_migrations_json != NULL ? strlen(missing_migrations_json) : 2) +
           (drifted_migrations_json != NULL ? strlen(drifted_migrations_json) : 2) +
           1024;
  result = (char *)malloc(needed);
  if (result != NULL) {
    snprintf(result, needed,
             "{\"report_id\":\"pharos-migrate-verify-v1\","
             "\"target_kind\":\"app\",\"target_id\":%s,"
             "\"backend\":\"sqlite\",\"status\":%s,"
             "\"live_database_verified\":%s,"
             "\"database_present\":%s,\"ledger_table_present\":%s,"
             "\"db_path\":%s,\"schema_version\":%s,"
             "\"preferred_backend\":%s,\"development_backend\":%s,"
             "\"testing_backend\":%s,\"migration_fixture\":%s,"
             "\"entity_fixture\":%s,\"query_fixture\":%s,"
             "\"db_config\":%s,\"verification_contract\":%s,"
             "\"required_tables\":%s,\"required_migration_ids\":%s,"
             "\"seed_expectations\":%s,\"table_checks\":%s,"
             "\"missing_tables\":%s,\"seed_checks\":%s,"
             "\"failed_seed_expectations\":%s,\"migration_checks\":%s,"
             "\"missing_migrations\":%s,\"drifted_migrations\":%s}",
             target_id_json,
             status_json != NULL ? status_json : "\"verification_failed\"",
             verified ? "true" : "false",
             database_present ? "true" : "false",
             ledger_table_present ? "true" : "false",
             sqlite_db_path_json != NULL ? sqlite_db_path_json : "\"\"",
             schema_version_json != NULL ? schema_version_json : "0",
             preferred_backend_json != NULL ? preferred_backend_json : "\"sqlite\"",
             development_backend_json != NULL ? development_backend_json : "\"sqlite\"",
             testing_backend_json != NULL ? testing_backend_json : "\"sqlite\"",
             migration_fixture_json != NULL ? migration_fixture_json : "\"\"",
             entity_fixture_json != NULL ? entity_fixture_json : "null",
             query_fixture_json != NULL ? query_fixture_json : "null",
             db_config_json != NULL ? db_config_json : "{\"backend\":\"sqlite\"}",
             verification_contract_json != NULL ? verification_contract_json : "{}",
             required_tables_json != NULL ? required_tables_json : "[]",
             required_migration_ids_json != NULL ? required_migration_ids_json : "[]",
             seed_expectations_json != NULL ? seed_expectations_json : "[]",
             table_checks_json != NULL ? table_checks_json : "[]",
             missing_tables_json != NULL ? missing_tables_json : "[]",
             seed_checks_json != NULL ? seed_checks_json : "[]",
             failed_seed_expectations_json != NULL ? failed_seed_expectations_json : "[]",
             migration_checks_json != NULL ? migration_checks_json : "[]",
             missing_migrations_json != NULL ? missing_migrations_json : "[]",
             drifted_migrations_json != NULL ? drifted_migrations_json : "[]");
  }
 
cleanup:
  if (result == NULL) {
    char *failure_target_id_json = target_id_json != NULL
                                       ? NULL
                                       : json_string_dup_native(config->target_id != NULL
                                                                    ? config->target_id
                                                                    : app->app_id);
    char *failure_status_json =
        status_json != NULL ? NULL : json_string_dup_native("verification_failed");
    char *failure_db_path_json = sqlite_db_path_json != NULL
                                     ? NULL
                                     : json_string_dup_native(sqlite_db_path != NULL
                                                                  ? sqlite_db_path
                                                                  : "");
    char *failure_migration_fixture_json =
        migration_fixture_json != NULL
            ? NULL
            : native_json_nullable_string_dup(migration_fixture);
    char *failure_entity_fixture_json =
        entity_fixture_json != NULL ? NULL : native_json_nullable_string_dup(entity_fixture);
    char *failure_query_fixture_json =
        query_fixture_json != NULL ? NULL : native_json_nullable_string_dup(query_fixture);
    char *effective_target_id_json =
        target_id_json != NULL ? target_id_json : failure_target_id_json;
    char *effective_status_json =
        status_json != NULL ? status_json : failure_status_json;
    char *effective_db_path_json =
        sqlite_db_path_json != NULL ? sqlite_db_path_json : failure_db_path_json;
    char *effective_migration_fixture_json =
        migration_fixture_json != NULL ? migration_fixture_json : failure_migration_fixture_json;
    char *effective_entity_fixture_json =
        entity_fixture_json != NULL ? entity_fixture_json : failure_entity_fixture_json;
    char *effective_query_fixture_json =
        query_fixture_json != NULL ? query_fixture_json : failure_query_fixture_json;
    if (status_out != NULL && *status_out == NULL) {
      *status_out = native_migrate_verify_strdup("verification_failed");
    }
    if (error_out != NULL && *error_out == NULL) {
      *error_out = native_migrate_verify_strdup("native sqlite migrate verify unavailable");
    }
    if (effective_target_id_json != NULL && effective_status_json != NULL &&
        effective_db_path_json != NULL && effective_migration_fixture_json != NULL &&
        effective_entity_fixture_json != NULL && effective_query_fixture_json != NULL) {
      size_t failure_needed = strlen(effective_target_id_json) +
                              strlen(effective_status_json) +
                              strlen(effective_db_path_json) +
                              strlen(effective_migration_fixture_json) +
                              strlen(effective_entity_fixture_json) +
                              strlen(effective_query_fixture_json) + 2048;
      result = (char *)malloc(failure_needed);
      if (result != NULL) {
        snprintf(result, failure_needed,
                 "{\"report_id\":\"pharos-migrate-verify-v1\","
                 "\"target_kind\":\"app\",\"target_id\":%s,"
                 "\"backend\":\"sqlite\",\"status\":%s,"
                 "\"live_database_verified\":false,"
                 "\"database_present\":%s,\"ledger_table_present\":%s,"
                 "\"db_path\":%s,\"schema_version\":0,"
                 "\"preferred_backend\":\"sqlite\","
                 "\"development_backend\":\"sqlite\","
                 "\"testing_backend\":\"sqlite\","
                 "\"migration_fixture\":%s,\"entity_fixture\":%s,"
                 "\"query_fixture\":%s,\"db_config\":{\"backend\":\"sqlite\"},"
                 "\"verification_contract\":{},\"required_tables\":[],"
                 "\"required_migration_ids\":[],\"seed_expectations\":[],"
                 "\"table_checks\":[],\"missing_tables\":[],"
                 "\"seed_checks\":[],\"failed_seed_expectations\":[],"
                 "\"migration_checks\":[],\"missing_migrations\":[],"
                 "\"drifted_migrations\":[]}",
                 effective_target_id_json, effective_status_json,
                 database_present ? "true" : "false",
                 ledger_table_present ? "true" : "false",
                 effective_db_path_json, effective_migration_fixture_json,
                 effective_entity_fixture_json, effective_query_fixture_json);
      }
    }
    return result;
  }
 
  native_json_doc_free(manifest_doc);
  native_json_doc_free(migration_doc);
 
  free(manifest_path);
  free(migration_fixture_rel);
  free(entity_fixture_rel);
  free(query_fixture_rel);
  free(migration_fixture);
  free(entity_fixture);
  free(query_fixture);
  free(preferred_backend_json);
  free(development_backend_json);
  free(testing_backend_json);
  free(schema_version_json);
  free(required_tables_json);
  free(required_migration_ids_json);
  free(seed_expectations_json);
  free(verification_contract_json);
  free(sqlite_db_path);
  free(sqlite_db_path_json);
  free(target_id_json);
  free(migration_fixture_json);
  free(entity_fixture_json);
  free(query_fixture_json);
  free(db_config_json);
  free(status_json);
 
  if (table_checks_json != NULL && table_checks_json != table_checks.data) {
    free(table_checks_json);
  }
  if (seed_checks_json != NULL && seed_checks_json != seed_checks.data) {
    free(seed_checks_json);
  }
  if (migration_checks_json != NULL &&
      migration_checks_json != migration_checks.data) {
    free(migration_checks_json);
  }
  if (missing_tables_json != NULL && missing_tables_json != missing_tables.data) {
    free(missing_tables_json);
  }
  if (missing_migrations_json != NULL &&
      missing_migrations_json != missing_migrations.data) {
    free(missing_migrations_json);
  }
  if (drifted_migrations_json != NULL &&
      drifted_migrations_json != drifted_migrations.data) {
    free(drifted_migrations_json);
  }
  if (failed_seed_expectations_json != NULL &&
      failed_seed_expectations_json != failed_seed_expectations.data) {
    free(failed_seed_expectations_json);
  }
 
  buffer_free(&table_checks);
  buffer_free(&seed_checks);
  buffer_free(&migration_checks);
  buffer_free(&missing_tables);
  buffer_free(&missing_migrations);
  buffer_free(&drifted_migrations);
  buffer_free(&failed_seed_expectations);
 
  return result;
}
 
#else
 
char *native_capture_migrate_verify_sqlite_report_json(const ServeConfig *config,
                                                       const AppRuntime *app,
                                                       char **status_out,
                                                       char **error_out) {
  (void)config;
  (void)app;
  if (status_out != NULL) {
    *status_out = NULL;
  }
  if (error_out != NULL) {
    *error_out = NULL;
  }
  return NULL;
}
 
#endif