rcu.c

Go to the documentation of this file.

 
#include <ascii-chat/options/rcu.h>
#include <ascii-chat/options/schema.h>
#include <ascii-chat/options/registry/core.h>
#include <ascii-chat/options/registry/common.h>
#include <ascii-chat/options/builder.h>
#include <ascii-chat/asciichat_errno.h>
#include <ascii-chat/common.h>
#include <ascii-chat/log/log.h>
#include <ascii-chat/util/lifecycle.h>
#include <ascii-chat/platform/abstraction.h>
#include <ascii-chat/platform/init.h>
#include <ascii-chat/platform/process.h>
 
#include <ascii-chat/atomic.h>
#include <stdlib.h>
#include <string.h>
#ifndef _WIN32
#include <pthread.h>
#endif
 
// ============================================================================
// RCU State: Global Atomic Pointer
// ============================================================================
 
static atomic_ptr_t g_options = {0};
 
static mutex_t g_options_write_mutex;
 
static lifecycle_t g_options_lifecycle = LIFECYCLE_INIT;
// Track the PID to detect fork() - after fork, child needs to reinitialize
static pid_t g_init_pid = -1;
 
static const options_t g_default_options = (options_t){
    // ========================================================================
    // Mode Detection (auto-detected, default here is uninitialized)
    // ========================================================================
    .detected_mode = MODE_INVALID,
 
    // ========================================================================
    // Binary-Level Options (parsed before mode selection)
    // ========================================================================
    .help = OPT_HELP_DEFAULT,
    .version = OPT_VERSION_DEFAULT,
    .config_file = OPT_STRING_EMPTY_DEFAULT,
 
    // ========================================================================
    // Terminal Dimensions
    // ========================================================================
    .width = OPT_WIDTH_DEFAULT,
    .height = OPT_HEIGHT_DEFAULT,
    .auto_width = OPT_AUTO_WIDTH_DEFAULT,
    .auto_height = OPT_AUTO_HEIGHT_DEFAULT,
 
    // ========================================================================
    // Network Options
    // ========================================================================
    .address = OPT_ADDRESS_DEFAULT,
    .address6 = OPT_ADDRESS6_DEFAULT,
    .port = OPT_PORT_INT_DEFAULT,
    .websocket_port = OPT_WEBSOCKET_PORT_SERVER_DEFAULT,
    .max_clients = OPT_MAX_CLIENTS_DEFAULT,
    .session_string = OPT_STRING_EMPTY_DEFAULT,
 
    // ========================================================================
    // Discovery Service (ACDS) Options
    // ========================================================================
    .discovery = OPT_ACDS_DEFAULT,
    .discovery_expose_ip = OPT_ACDS_EXPOSE_IP_DEFAULT,
    .discovery_insecure = OPT_ACDS_INSECURE_DEFAULT,
    .discovery_port = OPT_ACDS_PORT_INT_DEFAULT,
    .discovery_server = OPT_STRING_EMPTY_DEFAULT,
    .discovery_service_key = OPT_STRING_EMPTY_DEFAULT,
    .discovery_database_path = OPT_STRING_EMPTY_DEFAULT,
    .webrtc = OPT_WEBRTC_DEFAULT,
 
    // ========================================================================
    // LAN Discovery & WebRTC Options
    // ========================================================================
    .lan_discovery = OPT_LAN_DISCOVERY_DEFAULT,
    .no_mdns_advertise = OPT_NO_MDNS_ADVERTISE_DEFAULT,
    .enable_upnp = OPT_ENABLE_UPNP_DEFAULT,
 
    // ========================================================================
    // WebRTC Connection Strategy Options
    // ========================================================================
    .prefer_webrtc = OPT_PREFER_WEBRTC_DEFAULT,
    .no_webrtc = OPT_NO_WEBRTC_DEFAULT,
    .webrtc_skip_stun = OPT_WEBRTC_SKIP_STUN_DEFAULT,
    .webrtc_relay_only = false,
    .webrtc_disable_turn = OPT_WEBRTC_DISABLE_TURN_DEFAULT,
    .webrtc_skip_host = OPT_WEBRTC_SKIP_HOST_DEFAULT,
    .webrtc_ice_timeout_ms = OPT_WEBRTC_ICE_TIMEOUT_MS_DEFAULT,
    .webrtc_reconnect_attempts = OPT_WEBRTC_RECONNECT_ATTEMPTS_DEFAULT,
 
    // ========================================================================
    // WebRTC Connectivity Options (ACDS mode)
    // ========================================================================
    .stun_servers = OPT_STUN_SERVERS_DEFAULT,
    .turn_servers = OPT_TURN_SERVERS_DEFAULT,
    .turn_username = OPT_TURN_USERNAME_DEFAULT,
    .turn_credential = OPT_TURN_CREDENTIAL_DEFAULT,
    .turn_secret = OPT_STRING_EMPTY_DEFAULT,
 
    // ========================================================================
    // Encryption & Security Options
    // ========================================================================
    .encrypt_enabled = OPT_ENCRYPT_ENABLED_DEFAULT,
    .no_encrypt = OPT_NO_ENCRYPT_DEFAULT,
    .no_auth = OPT_NO_AUTH_DEFAULT,
    .encrypt_key = OPT_STRING_EMPTY_DEFAULT,
    .encrypt_keyfile = OPT_STRING_EMPTY_DEFAULT,
    .password = OPT_STRING_EMPTY_DEFAULT,
    .server_key = OPT_STRING_EMPTY_DEFAULT,
    .client_keys = OPT_STRING_EMPTY_DEFAULT,
    .require_server_identity = OPT_REQUIRE_SERVER_IDENTITY_DEFAULT,
    .require_client_identity = OPT_REQUIRE_CLIENT_IDENTITY_DEFAULT,
    .require_server_verify = OPT_REQUIRE_SERVER_VERIFY_DEFAULT,
    .require_client_verify = OPT_REQUIRE_CLIENT_VERIFY_DEFAULT,
 
    // ========================================================================
    // Media Options
    // ========================================================================
    .media_file = OPT_STRING_EMPTY_DEFAULT,
    .media_url = OPT_STRING_EMPTY_DEFAULT,
    .media_loop = OPT_MEDIA_LOOP_DEFAULT,
    .media_from_stdin = OPT_MEDIA_FROM_STDIN_DEFAULT,
    .media_seek_timestamp = OPT_MEDIA_SEEK_TIMESTAMP_DEFAULT,
    .pause = OPT_PAUSE_DEFAULT,
    .yt_dlp_options = OPT_STRING_EMPTY_DEFAULT,
 
    // ========================================================================
    // Webcam Options
    // ========================================================================
    .webcam_index = OPT_WEBCAM_INDEX_DEFAULT,
    .test_pattern = OPT_TEST_PATTERN_DEFAULT,
    .no_audio_mixer = OPT_NO_AUDIO_MIXER_DEFAULT,
    .stretch = OPT_STRETCH_DEFAULT,
    .flip_x = OPT_FLIP_X_DEFAULT,
    .flip_y = OPT_FLIP_Y_DEFAULT,
 
    // ========================================================================
    // Display Options
    // ========================================================================
    .color = OPT_COLOR_DEFAULT,
    .color_mode = OPT_COLOR_MODE_DEFAULT,
    .color_filter = OPT_COLOR_FILTER_DEFAULT,
    .color_scheme_name = OPT_COLOR_SCHEME_NAME_DEFAULT,
    .render_mode = OPT_RENDER_MODE_DEFAULT,
    .show_capabilities = OPT_SHOW_CAPABILITIES_DEFAULT,
    .fps = OPT_FPS_DEFAULT,
    .fps_explicitly_set = false,
    .palette_type = OPT_PALETTE_TYPE_DEFAULT,
    .palette_custom = OPT_STRING_EMPTY_DEFAULT,
    .palette_custom_set = OPT_PALETTE_CUSTOM_SET_DEFAULT,
 
    // ========================================================================
    // Compression Options
    // ========================================================================
    .compression_level = OPT_COMPRESSION_LEVEL_DEFAULT,
    .no_compress = OPT_NO_COMPRESS_DEFAULT,
 
    // ========================================================================
    // Audio Options
    // ========================================================================
    .audio_enabled = OPT_AUDIO_ENABLED_DEFAULT,
    .audio_source = OPT_AUDIO_SOURCE_DEFAULT,
    .audio_capture_source = OPT_AUDIO_CAPTURE_SOURCE_DEFAULT,
    .waveform = false,
    .fft = false,
    .microphone_index = OPT_MICROPHONE_INDEX_DEFAULT,
    .speakers_index = OPT_SPEAKERS_INDEX_DEFAULT,
    .microphone_sensitivity = OPT_MICROPHONE_SENSITIVITY_DEFAULT,
    .speakers_volume = OPT_SPEAKERS_VOLUME_DEFAULT,
    .audio_analysis_enabled = OPT_AUDIO_ANALYSIS_ENABLED_DEFAULT,
    .audio_no_playback = OPT_AUDIO_NO_PLAYBACK_DEFAULT,
    .encode_audio = OPT_ENCODE_AUDIO_DEFAULT,
 
    // ========================================================================
    // Terminal & Output Options (consolidated)
    // ========================================================================
    .force_utf8 = OPT_FORCE_UTF8_DEFAULT,
    .quiet = OPT_QUIET_DEFAULT,
    .verbose_level = OPT_VERBOSE_LEVEL_DEFAULT,
    .snapshot_mode = OPT_SNAPSHOT_MODE_DEFAULT,
    .snapshot_delay = OPT_SNAPSHOT_DELAY_DEFAULT,
    .matrix_rain = OPT_MATRIX_RAIN_DEFAULT,
    .strip_ansi = OPT_STRIP_ANSI_DEFAULT,
    .log_file = OPT_STRING_EMPTY_DEFAULT,
    .log_level = OPT_LOG_LEVEL_DEFAULT,
    .grep_pattern = OPT_GREP_PATTERN_DEFAULT,
    .json = OPT_JSON_DEFAULT,
    .log_template = OPT_LOG_TEMPLATE_DEFAULT,
    .log_format_console_only = OPT_LOG_FORMAT_CONSOLE_DEFAULT,
    .enable_keepawake = OPT_ENABLE_KEEPAWAKE_DEFAULT,
    .disable_keepawake = OPT_DISABLE_KEEPAWAKE_DEFAULT,
 
    // ========================================================================
    // UI Screen Options
    // ========================================================================
    .splash_screen = OPT_SPLASH_DEFAULT,
    .status_screen = OPT_STATUS_SCREEN_DEFAULT,
 
    // ========================================================================
    // Remaining Options (zero-initialized by default)
    // ========================================================================
    .reconnect_attempts = OPT_RECONNECT_ATTEMPTS_DEFAULT,
    .splash_screen_explicitly_set = OPT_SPLASH_SCREEN_EXPLICITLY_SET_DEFAULT,
    .status_screen_explicitly_set = OPT_STATUS_SCREEN_EXPLICITLY_SET_DEFAULT,
    .no_check_update = OPT_NO_CHECK_UPDATE_DEFAULT,
 
    // All remaining array fields (identity_keys, num_identity_keys, etc.)
    // are zero-initialized (empty strings, NULL pointers, 0 values, etc.)
    // which is appropriate for their types.
};
 
// ============================================================================
// Memory Reclamation Strategy
// ============================================================================
 
#define MAX_DEFERRED_FREES 64
static options_t *g_deferred_frees[MAX_DEFERRED_FREES];
static size_t g_deferred_free_count = 0;
static mutex_t g_deferred_free_mutex;
 
static void deferred_free_add(options_t *old_opts) {
  if (!old_opts) {
    return;
  }
 
  mutex_lock(&g_deferred_free_mutex);
 
  if (g_deferred_free_count < MAX_DEFERRED_FREES) {
    g_deferred_frees[g_deferred_free_count++] = old_opts;
    log_debug("Added options struct %p to deferred free list (count=%zu)", (void *)old_opts, g_deferred_free_count);
  } else {
    // List full - free immediately (risky but unlikely with infrequent updates)
    log_warn("Deferred free list full (%d entries), freeing options struct %p immediately", MAX_DEFERRED_FREES,
             (void *)old_opts);
    SAFE_FREE(old_opts);
  }
 
  mutex_unlock(&g_deferred_free_mutex);
}
 
static void deferred_free_all(void) {
  mutex_lock(&g_deferred_free_mutex);
 
  log_debug("Freeing %zu deferred options structs", g_deferred_free_count);
 
  for (size_t i = 0; i < g_deferred_free_count; i++) {
    SAFE_FREE(g_deferred_frees[i]);
  }
 
  g_deferred_free_count = 0;
  mutex_unlock(&g_deferred_free_mutex);
}
 
// ============================================================================
// Fork Handler Registration
// ============================================================================
 
#ifndef _WIN32
static void options_rcu_atfork_child(void) {
  /* Reset the lifecycle state to allow reinitialization after fork */
  /* This is safe because lifecycle_t is just an atomic int, can be reset directly */
  atomic_store_int(&g_options_lifecycle.state, LIFECYCLE_UNINITIALIZED);
 
  /* Reset the atomic options pointer to avoid dangling references */
  /* The parent's allocated memory is not accessible/valid in the child */
  atomic_ptr_store(&g_options, NULL);
 
  /* Don't reset g_init_pid - we'll detect the fork in options_state_init */
}
 
__attribute__((constructor)) static void register_fork_handlers_constructor(void) {
  // Register the child handler that will be called after fork() in the child process
  pthread_atfork(NULL, NULL, options_rcu_atfork_child);
}
#endif
 
// ============================================================================
// Public API Implementation
// ============================================================================
 
asciichat_error_t options_state_init(void) {
  // RCU setters validate against the option registry, including when callers
  // use the state API directly in tests or embedded integrations. Initialize
  // the registry here so those callers observe the same metadata as the CLI.
  registry_init_size();
 
  // Detect fork: after fork(), child process must reinitialize
  pid_t current_pid = platform_get_pid();
  if ((lifecycle_is_initialized(&g_options_lifecycle) || g_init_pid != -1) && g_init_pid != current_pid) {
    log_debug("Detected fork in options_state_init (parent PID %d, child PID %d) - resetting lifecycle", g_init_pid,
              current_pid);
    /* Reset lifecycle to allow reinitialization after fork */
    lifecycle_shutdown(&g_options_lifecycle);
    g_init_pid = current_pid;
  }
 
  // Check if already initialized in this process using lifecycle
  if (lifecycle_is_initialized(&g_options_lifecycle) && g_init_pid == current_pid &&
      atomic_ptr_load(&g_options) != NULL) {
    log_warn("Options state already initialized");
    return ASCIICHAT_OK;
  }
  if (lifecycle_is_initialized(&g_options_lifecycle) && atomic_ptr_load(&g_options) == NULL) {
    lifecycle_shutdown(&g_options_lifecycle);
  }
 
  /* Use lifecycle to serialize initialization */
  if (!lifecycle_init(&g_options_lifecycle, "options")) {
    /* Another thread is initializing or already initialized */
    if (lifecycle_is_initialized(&g_options_lifecycle)) {
      return ASCIICHAT_OK;
    }
    return SET_ERRNO(ERROR_INVALID_STATE, "Failed to acquire options initialization lock");
  }
 
  // Initialize write mutex
  if (mutex_init(&g_options_write_mutex, "options_write") != 0) {
    lifecycle_shutdown(&g_options_lifecycle);
    return SET_ERRNO(ERROR_THREAD, "Failed to initialize options write mutex");
  }
 
  // Initialize deferred free mutex
  if (mutex_init(&g_deferred_free_mutex, "deferred_free") != 0) {
    mutex_destroy(&g_options_write_mutex);
    lifecycle_shutdown(&g_options_lifecycle);
    return SET_ERRNO(ERROR_THREAD, "Failed to initialize deferred free mutex");
  }
 
  // Allocate initial options struct (will be populated later by options_state_populate_from_globals)
  options_t *initial_opts = SAFE_MALLOC(sizeof(options_t), options_t *);
  if (!initial_opts) {
    mutex_destroy(&g_options_write_mutex);
    mutex_destroy(&g_deferred_free_mutex);
    lifecycle_shutdown(&g_options_lifecycle);
    return SET_ERRNO(ERROR_MEMORY, "Failed to allocate initial options struct");
  }
 
  // Initialize all defaults using options_t_new()
  *initial_opts = options_t_new();
 
  // Publish initial struct (release semantics - make all fields visible to readers)
  atomic_ptr_store(&g_options, initial_opts);
 
  g_init_pid = current_pid; // Record PID to detect fork later
  log_dev("Options state initialized with RCU pattern (PID %d)", current_pid);
 
  return ASCIICHAT_OK;
}
 
asciichat_error_t options_state_set(const options_t *opts) {
  if (!opts) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "opts is NULL");
  }
 
  // Check initialization state using lifecycle
  if (!lifecycle_is_initialized(&g_options_lifecycle)) {
    return SET_ERRNO(ERROR_INVALID_STATE, "Options state not initialized (call options_state_init first)");
  }
 
  // Get current struct (should be the initial zero-initialized one during startup)
  options_t *current = atomic_ptr_load(&g_options);
 
  // Copy provided options into current struct
  // Note: No need for RCU update here since this is called during initialization
  // before any reader threads exist
  memcpy(current, opts, sizeof(options_t));
 
  log_debug("Options state set from parsed struct");
  return ASCIICHAT_OK;
}
 
void options_state_destroy(void) {
  // Check if initialized using lifecycle
  if (!lifecycle_is_initialized(&g_options_lifecycle)) {
    return;
  }
 
  /* Shutdown lifecycle to mark as no longer initialized */
  lifecycle_shutdown(&g_options_lifecycle);
 
  // Get current options pointer
  options_t *current = atomic_ptr_load(&g_options);
 
  // Clear the atomic pointer (prevent further reads)
  atomic_ptr_store(&g_options, NULL);
 
  // Free current struct
  SAFE_FREE(current);
 
  // Free all deferred structs
  deferred_free_all();
 
  // Cleanup schema (frees all dynamically allocated config strings)
  config_schema_destroy();
 
  // Destroy dynamically created mutexes
  mutex_destroy(&g_options_write_mutex);
  mutex_destroy(&g_deferred_free_mutex);
 
  log_debug("Options state shutdown complete");
}
 
void options_cleanup_schema(void) {
  config_schema_destroy();
}
 
const options_t *options_get(void) {
  // Lock-free read with acquire semantics
  // Guarantees we see all writes made before the pointer was published
  options_t *current = atomic_ptr_load(&g_options);
 
  // If options not yet published or after destruction, return safe static default.
  // This is a critical fallback that:
  // 1. Allows early startup code (before options_state_init) to work safely
  // 2. Allows atexit handlers and cleanup code to call GET_OPTION() safely
  // 3. Never crashes due to NULL pointer access
  // 4. Provides sensible defaults for all option fields
  //
  // The static default options are:
  // - Allocated once at startup (static storage)
  // - Never freed (outlives all dynamically allocated options)
  // - Thread-safe to read (immutable const data)
  // - Complete with all OPT_*_DEFAULT values matching options_t_new()
  if (!current) {
    return (const options_t *)&g_default_options;
  }
 
  return current;
}
 
static asciichat_error_t options_update(void (*updater)(options_t *, void *), void *context) {
  if (!updater) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "updater function is NULL");
  }
 
  // The state pointer may remain valid in a forked child even though the
  // lifecycle marker was reset. Recreate a standalone state for that case.
  bool lock_writers = lifecycle_is_initialized(&g_options_lifecycle);
 
  // 1. Load current options (acquire semantics)
  options_t *old_opts = atomic_ptr_load(&g_options);
  if (!old_opts) {
    old_opts = SAFE_MALLOC(sizeof(options_t), options_t *);
    if (!old_opts) {
      return SET_ERRNO(ERROR_MEMORY, "Failed to allocate initial options struct");
    }
    *old_opts = options_t_new();
    atomic_ptr_store(&g_options, old_opts);
  }
 
  // Serialize writers with mutex when the lifecycle owns an initialized one.
  if (lock_writers) {
    mutex_lock(&g_options_write_mutex);
  }
 
  // 2. Allocate new options struct
  options_t *new_opts = SAFE_MALLOC(sizeof(options_t), options_t *);
  if (!new_opts) {
    if (lock_writers) {
      mutex_unlock(&g_options_write_mutex);
    }
    return SET_ERRNO(ERROR_MEMORY, "Failed to allocate new options struct");
  }
 
  // 3. Copy current values to new struct
  memcpy(new_opts, old_opts, sizeof(options_t));
 
  // 4. Call user updater to modify the new struct
  updater(new_opts, context);
 
  // 5. Atomically swap global pointer (release semantics)
  // This makes the new struct visible to all readers
  atomic_ptr_store(&g_options, new_opts);
 
  // 6. Add old struct to deferred free list
  deferred_free_add(old_opts);
 
  if (lock_writers) {
    mutex_unlock(&g_options_write_mutex);
  }
 
  log_debug("Options updated via RCU (old=%p, new=%p)", (void *)old_opts, (void *)new_opts);
  return ASCIICHAT_OK;
}
 
// ============================================================================
// Generic Option Setters
// ============================================================================
 
typedef struct {
  const char *field;  
  const char *option; 
} field_option_map_t;
 
static const field_option_map_t g_field_to_option[] = { // INT fields
    {"width", "width"},
    {"height", "height"},
    {"max_clients", "max-clients"},
    {"compression_level", "compression-level"},
    {"reconnect_attempts", "reconnect"},
    {"microphone_index", "microphone-index"},
    {"speakers_index", "speakers-index"},
    {"discovery_port", "discovery-service-port"},
    {"port", "port"},
    {"fps", "fps"},
    {"color_mode", "color-mode"},
    {"color_filter", "color-filter"},
    {"render_mode", "render-mode"},
    {"log_level", "log-level"},
    {"palette_type", "palette"},
    // DOUBLE fields
    {"snapshot_delay", "snapshot-delay"},
    {"microphone_sensitivity", "microphone-volume"},
    {"speakers_volume", "speakers-volume"},
    // STRING fields with registry entries
    {"address", "address"},
    {"log_file", "log-file"},
    {"password", "password"},
    {NULL, NULL}};
 
static asciichat_error_t rcu_validate_field(const char *field_name, const options_t *new_opts) {
  // Look up option name from field name
  const char *opt_name = NULL;
  for (int i = 0; g_field_to_option[i].field; i++) {
    if (strcmp(g_field_to_option[i].field, field_name) == 0) {
      opt_name = g_field_to_option[i].option;
      break;
    }
  }
  if (!opt_name)
    return ASCIICHAT_OK; // No mapping → skip validation
 
  const registry_entry_t *entry = registry_find_entry_by_name(opt_name);
  if (!entry) {
    return ASCIICHAT_OK; // Not in registry → skip
  }
 
  // Cross-field validate_fn (future-proofing)
  if (entry->validate_fn) {
    char *error_msg = NULL;
    if (!entry->validate_fn(new_opts, &error_msg)) {
      log_error("Option '%s' rejected by validator: %s", opt_name, error_msg ? error_msg : "unknown error");
      SAFE_FREE(error_msg);
      return SET_ERRNO(ERROR_INVALID_PARAM, "Option '%s' failed validation", opt_name);
    }
    SAFE_FREE(error_msg);
  }
 
  // Numeric range check. Float-valued callback options store their value as a
  // float; reading those bytes as an int produces nondeterministic validation
  // failures (and can read beyond the field on some layouts).
  int min = entry->metadata.numeric_range.min;
  int max = entry->metadata.numeric_range.max;
  if (min != 0 || max != 0) {
    if (entry->type == OPTION_TYPE_CALLBACK && entry->default_value_size == sizeof(float)) {
      float val = *(const float *)((const char *)new_opts + entry->offset);
      if (val < (float)min || val > (float)max) {
        log_error("Option '%s' value %f out of range [%d, %d]", opt_name, val, min, max);
        return SET_ERRNO(ERROR_INVALID_PARAM, "Option '%s' value %f out of range [%d, %d]", opt_name, val, min, max);
      }
    } else {
      int val = *(const int *)((const char *)new_opts + entry->offset);
      if (val < min || val > max) {
        log_error("Option '%s' value %d out of range [%d, %d]", opt_name, val, min, max);
        return SET_ERRNO(ERROR_INVALID_PARAM, "Option '%s' value %d out of range [%d, %d]", opt_name, val, min, max);
      }
    }
  }
 
  // Enum validation: check value against known enum values
  size_t enum_count = 0;
  if (entry->metadata.enum_values) {
    for (size_t i = 0; entry->metadata.enum_values[i]; i++) {
      enum_count++;
    }
  }
 
  if (enum_count > 0 && entry->metadata.input_type == OPTION_INPUT_ENUM) {
    int val = *(const int *)((const char *)new_opts + entry->offset);
    if (entry->metadata.enum_integer_values) {
      // Validate against actual enum integer values (handles non-sequential enums like color_mode with AUTO=-1)
      bool found = false;
      for (size_t i = 0; i < enum_count; i++) {
        if (strcmp(field_name, "color_mode") == 0 && entry->metadata.enum_integer_values[i] == TERM_COLOR_AUTO) {
          continue;
        }
        if (val == entry->metadata.enum_integer_values[i]) {
          found = true;
          break;
        }
      }
      if (!found) {
        log_error("Option '%s' value %d is not a valid enum value", opt_name, val);
        return SET_ERRNO(ERROR_INVALID_PARAM, "Option '%s' value %d is not a valid enum", opt_name, val);
      }
    } else {
      // Fallback: assume 0-based sequential enum values
      if (val < 0 || (size_t)val >= enum_count) {
        log_error("Option '%s' value %d is not a valid enum (0..%zu)", opt_name, val, enum_count - 1);
        return SET_ERRNO(ERROR_INVALID_PARAM, "Option '%s' value %d is not a valid enum", opt_name, val);
      }
    }
  }
 
  return ASCIICHAT_OK;
}
 
typedef struct {
  const char *field_name; 
  int value;              
} int_field_ctx_t;
 
static void int_field_updater(options_t *opts, void *context) {
  int_field_ctx_t *ctx = (int_field_ctx_t *)context;
  if (strcmp(ctx->field_name, "width") == 0)
    opts->width = ctx->value;
  else if (strcmp(ctx->field_name, "height") == 0)
    opts->height = ctx->value;
  else if (strcmp(ctx->field_name, "max_clients") == 0)
    opts->max_clients = ctx->value;
  else if (strcmp(ctx->field_name, "compression_level") == 0)
    opts->compression_level = ctx->value;
  else if (strcmp(ctx->field_name, "reconnect_attempts") == 0)
    opts->reconnect_attempts = ctx->value;
  else if (strcmp(ctx->field_name, "microphone_index") == 0)
    opts->microphone_index = ctx->value;
  else if (strcmp(ctx->field_name, "speakers_index") == 0)
    opts->speakers_index = ctx->value;
  else if (strcmp(ctx->field_name, "discovery_port") == 0)
    opts->discovery_port = ctx->value;
  else if (strcmp(ctx->field_name, "port") == 0)
    opts->port = ctx->value;
  else if (strcmp(ctx->field_name, "fps") == 0)
    opts->fps = ctx->value;
  else if (strcmp(ctx->field_name, "color_mode") == 0)
    opts->color_mode = (terminal_color_mode_t)ctx->value;
  else if (strcmp(ctx->field_name, "color_filter") == 0)
    opts->color_filter = (color_filter_t)ctx->value;
  else if (strcmp(ctx->field_name, "render_mode") == 0)
    opts->render_mode = (render_mode_t)ctx->value;
  else if (strcmp(ctx->field_name, "log_level") == 0)
    opts->log_level = (log_level_t)ctx->value;
  else if (strcmp(ctx->field_name, "palette_type") == 0)
    opts->palette_type = (palette_type_t)ctx->value;
}
 
asciichat_error_t options_set_int(const char *field_name, int value) {
  if (!field_name) {
    SET_ERRNO(ERROR_INVALID_PARAM, "field_name is NULL");
    return ERROR_INVALID_PARAM;
  }
 
  if (strcmp(field_name, "width") != 0 && strcmp(field_name, "height") != 0 && strcmp(field_name, "max_clients") != 0 &&
      strcmp(field_name, "compression_level") != 0 && strcmp(field_name, "reconnect_attempts") != 0 &&
      strcmp(field_name, "microphone_index") != 0 && strcmp(field_name, "speakers_index") != 0 &&
      strcmp(field_name, "discovery_port") != 0 && strcmp(field_name, "port") != 0 && strcmp(field_name, "fps") != 0 &&
      strcmp(field_name, "color_mode") != 0 && strcmp(field_name, "color_filter") != 0 &&
      strcmp(field_name, "render_mode") != 0 && strcmp(field_name, "log_level") != 0 &&
      strcmp(field_name, "palette_type") != 0) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Unknown integer field: %s", field_name);
    return ERROR_INVALID_PARAM;
  }
 
  // Keep the state API's public invariants explicit even when the registry
  // has not yet been populated by the command-line parser.
  if (strcmp(field_name, "port") == 0 && (value < 1 || value > 65535)) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Option 'port' value %d out of range [1, 65535]", value);
  }
  if (strcmp(field_name, "color_mode") == 0 && value == TERM_COLOR_AUTO) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "Option 'color_mode' value %d is not valid for the state API", value);
  }
 
  // Pre-validate against registry metadata
  {
    const options_t *cur = options_get();
 
    // Skip RCU update if value is already set (avoids unnecessary alloc+deferred-free)
    int cur_value = 0;
    if (strcmp(field_name, "width") == 0)
      cur_value = cur->width;
    else if (strcmp(field_name, "height") == 0)
      cur_value = cur->height;
    else if (strcmp(field_name, "max_clients") == 0)
      cur_value = cur->max_clients;
    else if (strcmp(field_name, "compression_level") == 0)
      cur_value = cur->compression_level;
    else if (strcmp(field_name, "reconnect_attempts") == 0)
      cur_value = cur->reconnect_attempts;
    else if (strcmp(field_name, "microphone_index") == 0)
      cur_value = cur->microphone_index;
    else if (strcmp(field_name, "speakers_index") == 0)
      cur_value = cur->speakers_index;
    else if (strcmp(field_name, "discovery_port") == 0)
      cur_value = cur->discovery_port;
    else if (strcmp(field_name, "port") == 0)
      cur_value = cur->port;
    else if (strcmp(field_name, "fps") == 0)
      cur_value = cur->fps;
    else if (strcmp(field_name, "color_mode") == 0)
      cur_value = (int)cur->color_mode;
    else if (strcmp(field_name, "color_filter") == 0)
      cur_value = (int)cur->color_filter;
    else if (strcmp(field_name, "render_mode") == 0)
      cur_value = (int)cur->render_mode;
    else if (strcmp(field_name, "log_level") == 0)
      cur_value = (int)cur->log_level;
    else if (strcmp(field_name, "palette_type") == 0)
      cur_value = (int)cur->palette_type;
    if (cur_value == value)
      return ASCIICHAT_OK;
 
    options_t temp = *cur;
    // Manually set the field in temp to validate
    if (strcmp(field_name, "width") == 0)
      temp.width = value;
    else if (strcmp(field_name, "height") == 0)
      temp.height = value;
    else if (strcmp(field_name, "max_clients") == 0)
      temp.max_clients = value;
    else if (strcmp(field_name, "compression_level") == 0)
      temp.compression_level = value;
    else if (strcmp(field_name, "reconnect_attempts") == 0)
      temp.reconnect_attempts = value;
    else if (strcmp(field_name, "microphone_index") == 0)
      temp.microphone_index = value;
    else if (strcmp(field_name, "speakers_index") == 0)
      temp.speakers_index = value;
    else if (strcmp(field_name, "discovery_port") == 0)
      temp.discovery_port = value;
    else if (strcmp(field_name, "port") == 0)
      temp.port = value;
    else if (strcmp(field_name, "fps") == 0)
      temp.fps = value;
    else if (strcmp(field_name, "color_mode") == 0)
      temp.color_mode = (terminal_color_mode_t)value;
    else if (strcmp(field_name, "color_filter") == 0)
      temp.color_filter = (color_filter_t)value;
    else if (strcmp(field_name, "render_mode") == 0)
      temp.render_mode = (render_mode_t)value;
    else if (strcmp(field_name, "log_level") == 0)
      temp.log_level = (log_level_t)value;
    else if (strcmp(field_name, "palette_type") == 0)
      temp.palette_type = (palette_type_t)value;
 
    asciichat_error_t err = rcu_validate_field(field_name, &temp);
    if (err != ASCIICHAT_OK)
      return err;
  }
 
  int_field_ctx_t ctx = {.field_name = field_name, .value = value};
  asciichat_error_t update_result = options_update(int_field_updater, &ctx);
  return update_result;
}
 
typedef struct {
  const char *field_name; 
  bool value;             
} bool_field_ctx_t;
 
static void bool_field_updater(options_t *opts, void *context) {
  bool_field_ctx_t *ctx = (bool_field_ctx_t *)context;
  if (strcmp(ctx->field_name, "no_compress") == 0)
    opts->no_compress = ctx->value;
  else if (strcmp(ctx->field_name, "encode_audio") == 0)
    opts->encode_audio = ctx->value;
  else if (strcmp(ctx->field_name, "flip_x") == 0)
    opts->flip_x = ctx->value;
  else if (strcmp(ctx->field_name, "flip_y") == 0)
    opts->flip_y = ctx->value;
  else if (strcmp(ctx->field_name, "test_pattern") == 0)
    opts->test_pattern = ctx->value;
  else if (strcmp(ctx->field_name, "no_audio_mixer") == 0)
    opts->no_audio_mixer = ctx->value;
  else if (strcmp(ctx->field_name, "show_capabilities") == 0)
    opts->show_capabilities = ctx->value;
  else if (strcmp(ctx->field_name, "force_utf8") == 0)
    opts->force_utf8 = ctx->value;
  else if (strcmp(ctx->field_name, "audio_enabled") == 0)
    opts->audio_enabled = ctx->value;
  else if (strcmp(ctx->field_name, "audio_analysis_enabled") == 0)
    opts->audio_analysis_enabled = ctx->value;
  else if (strcmp(ctx->field_name, "audio_no_playback") == 0)
    opts->audio_no_playback = ctx->value;
  else if (strcmp(ctx->field_name, "stretch") == 0)
    opts->stretch = ctx->value;
  else if (strcmp(ctx->field_name, "snapshot_mode") == 0)
    opts->snapshot_mode = ctx->value;
  else if (strcmp(ctx->field_name, "strip_ansi") == 0)
    opts->strip_ansi = ctx->value;
  else if (strcmp(ctx->field_name, "quiet") == 0)
    opts->quiet = ctx->value;
  else if (strcmp(ctx->field_name, "encrypt_enabled") == 0)
    opts->encrypt_enabled = ctx->value;
  else if (strcmp(ctx->field_name, "no_encrypt") == 0)
    opts->no_encrypt = ctx->value;
  else if (strcmp(ctx->field_name, "discovery") == 0)
    opts->discovery = ctx->value;
  else if (strcmp(ctx->field_name, "discovery_expose_ip") == 0)
    opts->discovery_expose_ip = ctx->value;
  else if (strcmp(ctx->field_name, "discovery_insecure") == 0)
    opts->discovery_insecure = ctx->value;
  else if (strcmp(ctx->field_name, "webrtc") == 0)
    opts->webrtc = ctx->value;
  else if (strcmp(ctx->field_name, "lan_discovery") == 0)
    opts->lan_discovery = ctx->value;
  else if (strcmp(ctx->field_name, "no_mdns_advertise") == 0)
    opts->no_mdns_advertise = ctx->value;
  else if (strcmp(ctx->field_name, "prefer_webrtc") == 0)
    opts->prefer_webrtc = ctx->value;
  else if (strcmp(ctx->field_name, "no_webrtc") == 0)
    opts->no_webrtc = ctx->value;
  else if (strcmp(ctx->field_name, "webrtc_skip_stun") == 0)
    opts->webrtc_skip_stun = ctx->value;
  else if (strcmp(ctx->field_name, "webrtc_relay_only") == 0)
    opts->webrtc_relay_only = ctx->value;
  else if (strcmp(ctx->field_name, "webrtc_disable_turn") == 0)
    opts->webrtc_disable_turn = ctx->value;
  else if (strcmp(ctx->field_name, "enable_upnp") == 0)
    opts->enable_upnp = ctx->value;
  else if (strcmp(ctx->field_name, "require_server_identity") == 0)
    opts->require_server_identity = ctx->value;
  else if (strcmp(ctx->field_name, "require_client_identity") == 0)
    opts->require_client_identity = ctx->value;
  else if (strcmp(ctx->field_name, "require_server_verify") == 0)
    opts->require_server_verify = ctx->value;
  else if (strcmp(ctx->field_name, "require_client_verify") == 0)
    opts->require_client_verify = ctx->value;
  else if (strcmp(ctx->field_name, "palette_custom_set") == 0)
    opts->palette_custom_set = ctx->value;
  else if (strcmp(ctx->field_name, "media_loop") == 0)
    opts->media_loop = ctx->value;
  else if (strcmp(ctx->field_name, "media_from_stdin") == 0)
    opts->media_from_stdin = ctx->value;
  else if (strcmp(ctx->field_name, "auto_width") == 0)
    opts->auto_width = ctx->value;
  else if (strcmp(ctx->field_name, "auto_height") == 0)
    opts->auto_height = ctx->value;
  else if (strcmp(ctx->field_name, "splash_screen") == 0)
    opts->splash_screen = ctx->value;
  else if (strcmp(ctx->field_name, "status_screen") == 0)
    opts->status_screen = ctx->value;
  else if (strcmp(ctx->field_name, "matrix_rain") == 0)
    opts->matrix_rain = ctx->value;
  else if (strcmp(ctx->field_name, "waveform") == 0)
    opts->waveform = ctx->value;
  else if (strcmp(ctx->field_name, "fft") == 0)
    opts->fft = ctx->value;
  else if (strcmp(ctx->field_name, "fps_counter") == 0)
    opts->fps_counter = ctx->value;
}
 
asciichat_error_t options_set_bool(const char *field_name, bool value) {
  if (!field_name) {
    SET_ERRNO(ERROR_INVALID_PARAM, "field_name is NULL");
    return ERROR_INVALID_PARAM;
  }
 
  // Validate field exists
  if (strcmp(field_name, "no_compress") != 0 && strcmp(field_name, "encode_audio") != 0 &&
      strcmp(field_name, "flip_x") != 0 && strcmp(field_name, "flip_y") != 0 &&
      strcmp(field_name, "test_pattern") != 0 && strcmp(field_name, "no_audio_mixer") != 0 &&
      strcmp(field_name, "show_capabilities") != 0 && strcmp(field_name, "force_utf8") != 0 &&
      strcmp(field_name, "audio_enabled") != 0 && strcmp(field_name, "audio_analysis_enabled") != 0 &&
      strcmp(field_name, "audio_no_playback") != 0 && strcmp(field_name, "stretch") != 0 &&
      strcmp(field_name, "snapshot_mode") != 0 && strcmp(field_name, "strip_ansi") != 0 &&
      strcmp(field_name, "quiet") != 0 && strcmp(field_name, "encrypt_enabled") != 0 &&
      strcmp(field_name, "no_encrypt") != 0 && strcmp(field_name, "discovery") != 0 &&
      strcmp(field_name, "discovery_expose_ip") != 0 && strcmp(field_name, "discovery_insecure") != 0 &&
      strcmp(field_name, "webrtc") != 0 && strcmp(field_name, "lan_discovery") != 0 &&
      strcmp(field_name, "no_mdns_advertise") != 0 && strcmp(field_name, "prefer_webrtc") != 0 &&
      strcmp(field_name, "no_webrtc") != 0 && strcmp(field_name, "webrtc_skip_stun") != 0 &&
      strcmp(field_name, "webrtc_relay_only") != 0 && strcmp(field_name, "webrtc_disable_turn") != 0 &&
      strcmp(field_name, "enable_upnp") != 0 && strcmp(field_name, "require_server_identity") != 0 &&
      strcmp(field_name, "require_client_identity") != 0 && strcmp(field_name, "require_server_verify") != 0 &&
      strcmp(field_name, "require_client_verify") != 0 && strcmp(field_name, "palette_custom_set") != 0 &&
      strcmp(field_name, "media_loop") != 0 && strcmp(field_name, "media_from_stdin") != 0 &&
      strcmp(field_name, "auto_width") != 0 && strcmp(field_name, "auto_height") != 0 &&
      strcmp(field_name, "splash_screen") != 0 && strcmp(field_name, "status_screen") != 0 &&
      strcmp(field_name, "matrix_rain") != 0 && strcmp(field_name, "fps_counter") != 0 &&
      strcmp(field_name, "waveform") != 0 && strcmp(field_name, "fft") != 0) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Unknown boolean field: %s", field_name);
    return ERROR_INVALID_PARAM;
  }
 
  // Pre-validate against registry metadata (for cross-field validators)
  {
    const options_t *cur = options_get();
 
    // Skip RCU update if value is already set
    bool cur_value = false;
    if (strcmp(field_name, "no_compress") == 0)
      cur_value = cur->no_compress;
    else if (strcmp(field_name, "encode_audio") == 0)
      cur_value = cur->encode_audio;
    else if (strcmp(field_name, "flip_x") == 0)
      cur_value = cur->flip_x;
    else if (strcmp(field_name, "flip_y") == 0)
      cur_value = cur->flip_y;
    else if (strcmp(field_name, "test_pattern") == 0)
      cur_value = cur->test_pattern;
    else if (strcmp(field_name, "matrix_rain") == 0)
      cur_value = cur->matrix_rain;
    else if (strcmp(field_name, "waveform") == 0)
      cur_value = cur->waveform;
    else if (strcmp(field_name, "fft") == 0)
      cur_value = cur->fft;
    else if (strcmp(field_name, "fps_counter") == 0)
      cur_value = cur->fps_counter;
    else if (strcmp(field_name, "splash_screen") == 0)
      cur_value = cur->splash_screen;
    else if (strcmp(field_name, "status_screen") == 0)
      cur_value = cur->status_screen;
    // For less common fields, always update (safe default)
    else
      cur_value = !value;
    if (cur_value == value)
      return ASCIICHAT_OK;
 
    options_t temp = *cur;
    // Manually set the field in temp to validate
    if (strcmp(field_name, "no_compress") == 0)
      temp.no_compress = value;
    else if (strcmp(field_name, "encode_audio") == 0)
      temp.encode_audio = value;
    else if (strcmp(field_name, "flip_x") == 0)
      temp.flip_x = value;
    else if (strcmp(field_name, "flip_y") == 0)
      temp.flip_y = value;
    else if (strcmp(field_name, "test_pattern") == 0)
      temp.test_pattern = value;
    else if (strcmp(field_name, "no_audio_mixer") == 0)
      temp.no_audio_mixer = value;
    else if (strcmp(field_name, "show_capabilities") == 0)
      temp.show_capabilities = value;
    else if (strcmp(field_name, "force_utf8") == 0)
      temp.force_utf8 = value;
    else if (strcmp(field_name, "audio_enabled") == 0)
      temp.audio_enabled = value;
    else if (strcmp(field_name, "audio_analysis_enabled") == 0)
      temp.audio_analysis_enabled = value;
    else if (strcmp(field_name, "audio_no_playback") == 0)
      temp.audio_no_playback = value;
    else if (strcmp(field_name, "stretch") == 0)
      temp.stretch = value;
    else if (strcmp(field_name, "snapshot_mode") == 0)
      temp.snapshot_mode = value;
    else if (strcmp(field_name, "strip_ansi") == 0)
      temp.strip_ansi = value;
    else if (strcmp(field_name, "quiet") == 0)
      temp.quiet = value;
    else if (strcmp(field_name, "encrypt_enabled") == 0)
      temp.encrypt_enabled = value;
    else if (strcmp(field_name, "no_encrypt") == 0)
      temp.no_encrypt = value;
    else if (strcmp(field_name, "discovery") == 0)
      temp.discovery = value;
    else if (strcmp(field_name, "discovery_expose_ip") == 0)
      temp.discovery_expose_ip = value;
    else if (strcmp(field_name, "discovery_insecure") == 0)
      temp.discovery_insecure = value;
    else if (strcmp(field_name, "webrtc") == 0)
      temp.webrtc = value;
    else if (strcmp(field_name, "lan_discovery") == 0)
      temp.lan_discovery = value;
    else if (strcmp(field_name, "no_mdns_advertise") == 0)
      temp.no_mdns_advertise = value;
    else if (strcmp(field_name, "prefer_webrtc") == 0)
      temp.prefer_webrtc = value;
    else if (strcmp(field_name, "no_webrtc") == 0)
      temp.no_webrtc = value;
    else if (strcmp(field_name, "webrtc_skip_stun") == 0)
      temp.webrtc_skip_stun = value;
    else if (strcmp(field_name, "webrtc_relay_only") == 0)
      temp.webrtc_relay_only = value;
    else if (strcmp(field_name, "webrtc_disable_turn") == 0)
      temp.webrtc_disable_turn = value;
    else if (strcmp(field_name, "enable_upnp") == 0)
      temp.enable_upnp = value;
    else if (strcmp(field_name, "require_server_identity") == 0)
      temp.require_server_identity = value;
    else if (strcmp(field_name, "require_client_identity") == 0)
      temp.require_client_identity = value;
    else if (strcmp(field_name, "require_server_verify") == 0)
      temp.require_server_verify = value;
    else if (strcmp(field_name, "require_client_verify") == 0)
      temp.require_client_verify = value;
    else if (strcmp(field_name, "palette_custom_set") == 0)
      temp.palette_custom_set = value;
    else if (strcmp(field_name, "media_loop") == 0)
      temp.media_loop = value;
    else if (strcmp(field_name, "media_from_stdin") == 0)
      temp.media_from_stdin = value;
    else if (strcmp(field_name, "auto_width") == 0)
      temp.auto_width = value;
    else if (strcmp(field_name, "auto_height") == 0)
      temp.auto_height = value;
    else if (strcmp(field_name, "splash_screen") == 0)
      temp.splash_screen = value;
    else if (strcmp(field_name, "status_screen") == 0)
      temp.status_screen = value;
    else if (strcmp(field_name, "matrix_rain") == 0)
      temp.matrix_rain = value;
    else if (strcmp(field_name, "waveform") == 0)
      temp.waveform = value;
    else if (strcmp(field_name, "fft") == 0)
      temp.fft = value;
    else if (strcmp(field_name, "fps_counter") == 0)
      temp.fps_counter = value;
 
    asciichat_error_t err = rcu_validate_field(field_name, &temp);
    if (err != ASCIICHAT_OK)
      return err;
  }
 
  bool_field_ctx_t ctx = {.field_name = field_name, .value = value};
  return options_update(bool_field_updater, &ctx);
}
 
typedef struct {
  const char *field_name; 
  const char *value;      
} string_field_ctx_t;
 
static void string_field_updater(options_t *opts, void *context) {
  string_field_ctx_t *ctx = (string_field_ctx_t *)context;
  if (strcmp(ctx->field_name, "address") == 0)
    SAFE_STRNCPY(opts->address, ctx->value, sizeof(opts->address));
  else if (strcmp(ctx->field_name, "address6") == 0)
    SAFE_STRNCPY(opts->address6, ctx->value, sizeof(opts->address6));
  else if (strcmp(ctx->field_name, "encrypt_key") == 0)
    SAFE_STRNCPY(opts->encrypt_key, ctx->value, sizeof(opts->encrypt_key));
  else if (strcmp(ctx->field_name, "password") == 0)
    SAFE_STRNCPY(opts->password, ctx->value, sizeof(opts->password));
  else if (strcmp(ctx->field_name, "encrypt_keyfile") == 0)
    SAFE_STRNCPY(opts->encrypt_keyfile, ctx->value, sizeof(opts->encrypt_keyfile));
  else if (strcmp(ctx->field_name, "server_key") == 0)
    SAFE_STRNCPY(opts->server_key, ctx->value, sizeof(opts->server_key));
  else if (strcmp(ctx->field_name, "client_keys") == 0)
    SAFE_STRNCPY(opts->client_keys, ctx->value, sizeof(opts->client_keys));
  else if (strcmp(ctx->field_name, "discovery_server") == 0)
    SAFE_STRNCPY(opts->discovery_server, ctx->value, sizeof(opts->discovery_server));
  else if (strcmp(ctx->field_name, "discovery_service_key") == 0)
    SAFE_STRNCPY(opts->discovery_service_key, ctx->value, sizeof(opts->discovery_service_key));
  else if (strcmp(ctx->field_name, "discovery_database_path") == 0)
    SAFE_STRNCPY(opts->discovery_database_path, ctx->value, sizeof(opts->discovery_database_path));
  else if (strcmp(ctx->field_name, "log_file") == 0)
    SAFE_STRNCPY(opts->log_file, ctx->value, sizeof(opts->log_file));
  else if (strcmp(ctx->field_name, "media_file") == 0)
    SAFE_STRNCPY(opts->media_file, ctx->value, sizeof(opts->media_file));
  else if (strcmp(ctx->field_name, "palette_custom") == 0)
    SAFE_STRNCPY(opts->palette_custom, ctx->value, sizeof(opts->palette_custom));
  else if (strcmp(ctx->field_name, "stun_servers") == 0)
    SAFE_STRNCPY(opts->stun_servers, ctx->value, sizeof(opts->stun_servers));
  else if (strcmp(ctx->field_name, "turn_servers") == 0)
    SAFE_STRNCPY(opts->turn_servers, ctx->value, sizeof(opts->turn_servers));
  else if (strcmp(ctx->field_name, "turn_username") == 0)
    SAFE_STRNCPY(opts->turn_username, ctx->value, sizeof(opts->turn_username));
  else if (strcmp(ctx->field_name, "turn_credential") == 0)
    SAFE_STRNCPY(opts->turn_credential, ctx->value, sizeof(opts->turn_credential));
  else if (strcmp(ctx->field_name, "turn_secret") == 0)
    SAFE_STRNCPY(opts->turn_secret, ctx->value, sizeof(opts->turn_secret));
  else if (strcmp(ctx->field_name, "session_string") == 0)
    SAFE_STRNCPY(opts->session_string, ctx->value, sizeof(opts->session_string));
}
 
asciichat_error_t options_set_string(const char *field_name, const char *value) {
  if (!field_name) {
    SET_ERRNO(ERROR_INVALID_PARAM, "field_name is NULL");
    return ERROR_INVALID_PARAM;
  }
 
  if (!value) {
    SET_ERRNO(ERROR_INVALID_PARAM, "value is NULL");
    return ERROR_INVALID_PARAM;
  }
 
  // Validate field exists
  if (strcmp(field_name, "address") != 0 && strcmp(field_name, "address6") != 0 &&
      strcmp(field_name, "encrypt_key") != 0 && strcmp(field_name, "password") != 0 &&
      strcmp(field_name, "encrypt_keyfile") != 0 && strcmp(field_name, "server_key") != 0 &&
      strcmp(field_name, "client_keys") != 0 && strcmp(field_name, "discovery_server") != 0 &&
      strcmp(field_name, "discovery_service_key") != 0 && strcmp(field_name, "discovery_database_path") != 0 &&
      strcmp(field_name, "log_file") != 0 && strcmp(field_name, "media_file") != 0 &&
      strcmp(field_name, "palette_custom") != 0 && strcmp(field_name, "stun_servers") != 0 &&
      strcmp(field_name, "turn_servers") != 0 && strcmp(field_name, "turn_username") != 0 &&
      strcmp(field_name, "turn_credential") != 0 && strcmp(field_name, "turn_secret") != 0 &&
      strcmp(field_name, "session_string") != 0) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Unknown string field: %s", field_name);
    return ERROR_INVALID_PARAM;
  }
 
  // Pre-validate against registry metadata (for cross-field validators)
  {
    const options_t *cur = options_get();
    options_t temp = *cur;
    // Manually set the field in temp to validate
    if (strcmp(field_name, "address") == 0)
      SAFE_STRNCPY(temp.address, value, sizeof(temp.address));
    else if (strcmp(field_name, "address6") == 0)
      SAFE_STRNCPY(temp.address6, value, sizeof(temp.address6));
    else if (strcmp(field_name, "encrypt_key") == 0)
      SAFE_STRNCPY(temp.encrypt_key, value, sizeof(temp.encrypt_key));
    else if (strcmp(field_name, "password") == 0)
      SAFE_STRNCPY(temp.password, value, sizeof(temp.password));
    else if (strcmp(field_name, "encrypt_keyfile") == 0)
      SAFE_STRNCPY(temp.encrypt_keyfile, value, sizeof(temp.encrypt_keyfile));
    else if (strcmp(field_name, "server_key") == 0)
      SAFE_STRNCPY(temp.server_key, value, sizeof(temp.server_key));
    else if (strcmp(field_name, "client_keys") == 0)
      SAFE_STRNCPY(temp.client_keys, value, sizeof(temp.client_keys));
    else if (strcmp(field_name, "discovery_server") == 0)
      SAFE_STRNCPY(temp.discovery_server, value, sizeof(temp.discovery_server));
    else if (strcmp(field_name, "discovery_service_key") == 0)
      SAFE_STRNCPY(temp.discovery_service_key, value, sizeof(temp.discovery_service_key));
    else if (strcmp(field_name, "discovery_database_path") == 0)
      SAFE_STRNCPY(temp.discovery_database_path, value, sizeof(temp.discovery_database_path));
    else if (strcmp(field_name, "log_file") == 0)
      SAFE_STRNCPY(temp.log_file, value, sizeof(temp.log_file));
    else if (strcmp(field_name, "media_file") == 0)
      SAFE_STRNCPY(temp.media_file, value, sizeof(temp.media_file));
    else if (strcmp(field_name, "palette_custom") == 0)
      SAFE_STRNCPY(temp.palette_custom, value, sizeof(temp.palette_custom));
    else if (strcmp(field_name, "stun_servers") == 0)
      SAFE_STRNCPY(temp.stun_servers, value, sizeof(temp.stun_servers));
    else if (strcmp(field_name, "turn_servers") == 0)
      SAFE_STRNCPY(temp.turn_servers, value, sizeof(temp.turn_servers));
    else if (strcmp(field_name, "turn_username") == 0)
      SAFE_STRNCPY(temp.turn_username, value, sizeof(temp.turn_username));
    else if (strcmp(field_name, "turn_credential") == 0)
      SAFE_STRNCPY(temp.turn_credential, value, sizeof(temp.turn_credential));
    else if (strcmp(field_name, "turn_secret") == 0)
      SAFE_STRNCPY(temp.turn_secret, value, sizeof(temp.turn_secret));
    else if (strcmp(field_name, "session_string") == 0)
      SAFE_STRNCPY(temp.session_string, value, sizeof(temp.session_string));
 
    asciichat_error_t err = rcu_validate_field(field_name, &temp);
    if (err != ASCIICHAT_OK)
      return err;
  }
 
  string_field_ctx_t ctx = {.field_name = field_name, .value = value};
  return options_update(string_field_updater, &ctx);
}
 
typedef struct {
  const char *field_name; 
  double value;           
} double_field_ctx_t;
 
static void double_field_updater(options_t *opts, void *context) {
  double_field_ctx_t *ctx = (double_field_ctx_t *)context;
  if (strcmp(ctx->field_name, "snapshot_delay") == 0)
    opts->snapshot_delay = ctx->value;
  else if (strcmp(ctx->field_name, "microphone_sensitivity") == 0)
    opts->microphone_sensitivity = ctx->value;
  else if (strcmp(ctx->field_name, "speakers_volume") == 0)
    opts->speakers_volume = ctx->value;
}
 
asciichat_error_t options_set_double(const char *field_name, double value) {
  if (!field_name) {
    SET_ERRNO(ERROR_INVALID_PARAM, "field_name is NULL");
    return ERROR_INVALID_PARAM;
  }
 
  // Normalize option names to internal field names
  const char *internal_name = field_name;
  if (strcmp(field_name, "microphone-volume") == 0 || strcmp(field_name, "ivolume") == 0) {
    internal_name = "microphone_sensitivity";
  } else if (strcmp(field_name, "speakers-volume") == 0 || strcmp(field_name, "volume") == 0) {
    internal_name = "speakers_volume";
  }
 
  if (strcmp(internal_name, "snapshot_delay") != 0 && strcmp(internal_name, "microphone_sensitivity") != 0 &&
      strcmp(internal_name, "speakers_volume") != 0) {
    SET_ERRNO(ERROR_INVALID_PARAM, "Unknown double field: %s", field_name);
    return ERROR_INVALID_PARAM;
  }
 
  // Pre-validate against registry metadata (if available)
  {
    const options_t *cur = options_get();
    options_t temp = *cur;
    // Manually set the field in temp to validate
    if (strcmp(internal_name, "snapshot_delay") == 0)
      temp.snapshot_delay = value;
    else if (strcmp(internal_name, "microphone_sensitivity") == 0)
      temp.microphone_sensitivity = value;
    else if (strcmp(internal_name, "speakers_volume") == 0)
      temp.speakers_volume = value;
 
    asciichat_error_t err = rcu_validate_field(internal_name, &temp);
    if (err != ASCIICHAT_OK)
      return err;
  }
 
  double_field_ctx_t ctx = {.field_name = internal_name, .value = value};
  return options_update(double_field_updater, &ctx);
}