native_dynamic_business_logic.c

Go to the documentation of this file.

/**
 * @file
 * @brief Executes framework-owned declarative action contracts for dynamic apps.
 */
 
#include "native_dynamic_business_logic.h"
 
#include "native_dynamic_multipart.h"
#include "native_dynamic_request_fields.h"
#include "native_fs.h"
#include "native_http_response.h"
#include "native_support.h"
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
 
#ifdef _WIN32
#include <winsock2.h>
#include <ws2tcpip.h>
#else
#include <arpa/inet.h>
#include <errno.h>
#include <netdb.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <unistd.h>
#endif
 
static char *request_body_bytes_dup_logic_local(const HttpRequest *request, size_t *out_size) {
  char *body_text = NULL;
  if (out_size != NULL) {
    *out_size = 0;
  }
  if (request == NULL) {
    return strdup("");
  }
  if (request->body != NULL) {
    body_text = strdup(request->body);
  } else if (request->body_file_path != NULL && request->body_file_path[0] != '\0') {
    body_text = read_file_text(request->body_file_path);
  }
  if (body_text == NULL) {
    body_text = strdup("");
  }
  if (out_size != NULL && body_text != NULL) {
    *out_size = strlen(body_text);
  }
  return body_text;
}
 
static char *request_form_value_dup_logic_local(const HttpRequest *request, const char *field_name) {
  if (field_name == NULL || field_name[0] == '\0') {
    return NULL;
  }
  if (request != NULL && request->is_multipart) {
    size_t body_len = 0;
    char *body_bytes = request_body_bytes_dup_logic_local(request, &body_len);
    char *value = NULL;
    if (body_bytes != NULL) {
      value = native_dynamic_multipart_extract_text((const unsigned char *)body_bytes, body_len, request->content_type, field_name);
      free(body_bytes);
    }
    return value;
  }
  {
    char *form_body = request_body_bytes_dup_logic_local(request, NULL);
    char *value = native_dynamic_form_value(form_body != NULL ? form_body : "", field_name);
    free(form_body);
    return value;
  }
}
 
static void write_json_error_logic_local(
  NativeConnection *connection,
  int status,
  const char *status_text,
  const char *error_kind,
  const char *message
) {
  char body[2048];
  int written = snprintf(
    body,
    sizeof(body),
    "{\"error\":\"%s\",\"message\":\"%s\"}",
    error_kind != NULL ? error_kind : "error",
    message != NULL ? message : "An error occurred"
  );
  if (written < 0 || (size_t)written >= sizeof(body)) {
    native_send_text_response(connection, 500, "Internal Server Error", "response formatting error\n");
    return;
  }
  native_connection_printf(
    connection,
    "HTTP/1.1 %d %s\r\n"
    "Content-Type: application/json\r\n"
    "Cache-Control: no-store\r\n"
    "Content-Length: %zu\r\n"
    "Connection: close\r\n"
    "\r\n"
    "%s",
    status,
    status_text != NULL ? status_text : "Error",
    strlen(body),
    body
  );
}
 
static int now_iso_utc_logic_local(char out[20]) {
  time_t now = time(NULL);
  struct tm tm_value;
  if (out == NULL) {
    return 0;
  }
#ifdef _WIN32
  if (gmtime_s(&tm_value, &now) != 0) {
    return 0;
  }
#else
  if (gmtime_r(&now, &tm_value) == NULL) {
    return 0;
  }
#endif
  return strftime(out, 20, "%Y-%m-%d %H:%M:%S", &tm_value) == 19;
}
 
static char *app_manifest_path_dup_logic_local(const AppRuntime *app) {
  if (app == NULL || app->app_root == NULL || app->app_root[0] == '\0') {
    return NULL;
  }
  return path_join(app->app_root, "pharos.app.json");
}
 
static char *fixture_path_dup_logic_local(const AppRuntime *app, const char *fixture_key) {
  char *manifest_path = NULL;
  yyjson_doc *doc = NULL;
  yyjson_val *root = NULL;
  yyjson_val *fixtures = NULL;
  char *relative = NULL;
  char *resolved = NULL;
  if (app == NULL || fixture_key == NULL || fixture_key[0] == '\0') {
    return NULL;
  }
  manifest_path = app_manifest_path_dup_logic_local(app);
  if (manifest_path == NULL) {
    return NULL;
  }
  doc = native_json_doc_load_file(manifest_path);
  free(manifest_path);
  if (doc == NULL) {
    return NULL;
  }
  root = yyjson_doc_get_root(doc);
  fixtures = root != NULL ? native_json_obj_get(root, "fixtures") : NULL;
  if (fixtures != NULL) {
    relative = native_json_obj_get_string_dup(fixtures, fixture_key);
  }
  if (relative != NULL && relative[0] != '\0') {
    if (relative[0] == '/') {
      resolved = relative;
      relative = NULL;
    } else {
      resolved = path_join(app->app_root, relative);
    }
  }
  free(relative);
  native_json_doc_free(doc);
  return resolved;
}
 
static yyjson_doc *load_fixture_doc_logic_local(const AppRuntime *app, const char *fixture_key) {
  char *path = fixture_path_dup_logic_local(app, fixture_key);
  yyjson_doc *doc = NULL;
  if (path != NULL) {
    doc = native_json_doc_load_file(path);
  }
  free(path);
  return doc;
}
 
static yyjson_val *find_action_contract_logic_local(yyjson_val *root, const char *action_id) {
  yyjson_val *actions = root != NULL ? native_json_obj_get(root, "actions") : NULL;
  yyjson_arr_iter iter;
  yyjson_val *item = NULL;
  if (actions == NULL || action_id == NULL || !yyjson_is_arr(actions)) {
    return NULL;
  }
  if (yyjson_arr_iter_init(actions, &iter)) {
    while ((item = yyjson_arr_iter_next(&iter)) != NULL) {
      if (yyjson_is_obj(item) && yyjson_equals_str(native_json_obj_get(item, "action_id"), action_id)) {
        return item;
      }
    }
  }
  return NULL;
}
 
static yyjson_val *find_workflow_transition_logic_local(yyjson_val *root, const char *action_id, yyjson_val **workflow_out) {
  yyjson_val *workflows = root != NULL ? native_json_obj_get(root, "workflows") : NULL;
  yyjson_arr_iter workflow_iter;
  yyjson_val *workflow = NULL;
  if (workflow_out != NULL) {
    *workflow_out = NULL;
  }
  if (workflows == NULL || action_id == NULL || !yyjson_is_arr(workflows)) {
    return NULL;
  }
  if (yyjson_arr_iter_init(workflows, &workflow_iter)) {
    while ((workflow = yyjson_arr_iter_next(&workflow_iter)) != NULL) {
      yyjson_val *transitions = native_json_obj_get(workflow, "transitions");
      yyjson_arr_iter transition_iter;
      yyjson_val *transition = NULL;
      if (transitions == NULL || !yyjson_is_arr(transitions)) {
        continue;
      }
      if (yyjson_arr_iter_init(transitions, &transition_iter)) {
        while ((transition = yyjson_arr_iter_next(&transition_iter)) != NULL) {
          if (yyjson_is_obj(transition) && yyjson_equals_str(native_json_obj_get(transition, "action_id"), action_id)) {
            if (workflow_out != NULL) {
              *workflow_out = workflow;
            }
            return transition;
          }
        }
      }
    }
  }
  return NULL;
}
 
typedef struct {
  char *field_id;
  char *value;
} InputFieldValueLogicLocal;
 
typedef struct {
  InputFieldValueLogicLocal *items;
  size_t count;
} InputFieldMapLogicLocal;
 
typedef struct {
  long anchor_record_id;
  char *anchor_resource_id;
  long last_created_record_id;
  char *last_created_resource_id;
  long last_touched_record_id;
  char *last_touched_resource_id;
  long created_record_count;
  long updated_record_count;
  long matched_record_count;
  long skipped_record_count;
  char *overflow_policy;
} ActionExecutionContextLogicLocal;
 
typedef struct {
  long job_count;
  long webhook_count;
  long notification_count;
} ActionEffectCountsLogicLocal;
 
typedef struct {
  char *scheme;
  char *host;
  int port;
  char *path;
} ParsedHttpUrlLogicLocal;
 
typedef struct {
  int ok;
  long http_status;
  char *error_message;
  char *response_body;
} OutboundHttpResultLogicLocal;
 
static void free_action_execution_context_logic_local(ActionExecutionContextLogicLocal *context) {
  if (context == NULL) {
    return;
  }
  free(context->anchor_resource_id);
  free(context->last_created_resource_id);
  free(context->last_touched_resource_id);
  free(context->overflow_policy);
  memset(context, 0, sizeof(*context));
}
 
static void free_parsed_http_url_logic_local(ParsedHttpUrlLogicLocal *url) {
  if (url == NULL) {
    return;
  }
  free(url->scheme);
  free(url->host);
  free(url->path);
  memset(url, 0, sizeof(*url));
}
 
static void free_outbound_http_result_logic_local(OutboundHttpResultLogicLocal *result) {
  if (result == NULL) {
    return;
  }
  free(result->error_message);
  free(result->response_body);
  memset(result, 0, sizeof(*result));
}
 
static int now_plus_seconds_iso_utc_logic_local(long offset_seconds, char out[20]) {
  time_t now = time(NULL);
  struct tm tm_value;
  if (out == NULL) {
    return 0;
  }
  now += offset_seconds;
#ifdef _WIN32
  if (gmtime_s(&tm_value, &now) != 0) {
    return 0;
  }
#else
  if (gmtime_r(&now, &tm_value) == NULL) {
    return 0;
  }
#endif
  return strftime(out, 20, "%Y-%m-%d %H:%M:%S", &tm_value) == 19;
}
 
static int replace_owned_string_logic_local(char **slot, const char *value) {
  char *copy = NULL;
  if (slot == NULL) {
    return 0;
  }
  if (value != NULL) {
    copy = strdup(value);
    if (copy == NULL) {
      return 0;
    }
  }
  free(*slot);
  *slot = copy;
  return 1;
}
 
static int note_created_record_logic_local(ActionExecutionContextLogicLocal *context, long record_id, const char *resource_id) {
  if (context == NULL || record_id <= 0) {
    return 0;
  }
  if (context->anchor_record_id <= 0) {
    context->anchor_record_id = record_id;
    if (resource_id != NULL && resource_id[0] != '\0' && !replace_owned_string_logic_local(&context->anchor_resource_id, resource_id)) {
      return 0;
    }
  }
  context->last_created_record_id = record_id;
  context->last_touched_record_id = record_id;
  context->created_record_count++;
  if (resource_id != NULL && resource_id[0] != '\0') {
    if (!replace_owned_string_logic_local(&context->last_created_resource_id, resource_id)
        || !replace_owned_string_logic_local(&context->last_touched_resource_id, resource_id)) {
      return 0;
    }
  }
  return 1;
}
 
static int note_updated_record_logic_local(ActionExecutionContextLogicLocal *context, long record_id, const char *resource_id) {
  if (context == NULL || record_id <= 0) {
    return 0;
  }
  context->last_touched_record_id = record_id;
  context->updated_record_count++;
  if (resource_id != NULL && resource_id[0] != '\0' && !replace_owned_string_logic_local(&context->last_touched_resource_id, resource_id)) {
    return 0;
  }
  return 1;
}
 
static int note_bounded_scope_logic_local(
  ActionExecutionContextLogicLocal *context,
  long matched_count,
  long applied_count,
  const char *overflow_policy
) {
  if (context == NULL) {
    return 0;
  }
  context->matched_record_count += matched_count > 0 ? matched_count : 0;
  if (matched_count > applied_count) {
    context->skipped_record_count += matched_count - applied_count;
  }
  if (overflow_policy != NULL && overflow_policy[0] != '\0'
      && !replace_owned_string_logic_local(&context->overflow_policy, overflow_policy)) {
    return 0;
  }
  return 1;
}
 
static void free_input_field_map_logic_local(InputFieldMapLogicLocal *map) {
  size_t index = 0;
  if (map == NULL) {
    return;
  }
  for (index = 0; index < map->count; index++) {
    free(map->items[index].field_id);
    free(map->items[index].value);
  }
  free(map->items);
  map->items = NULL;
  map->count = 0;
}
 
static char *input_field_value_dup_logic_local(const InputFieldMapLogicLocal *map, const char *field_id) {
  size_t index = 0;
  if (map == NULL || field_id == NULL) {
    return NULL;
  }
  for (index = 0; index < map->count; index++) {
    if (map->items[index].field_id != NULL && streq(map->items[index].field_id, field_id)) {
      return map->items[index].value != NULL ? strdup(map->items[index].value) : NULL;
    }
  }
  return NULL;
}
 
static char *action_presentation_string_dup_logic_local(yyjson_val *action_contract, const char *field_name) {
  yyjson_val *presentation = action_contract != NULL ? native_json_obj_get(action_contract, "presentation") : NULL;
  if (presentation == NULL || field_name == NULL || field_name[0] == '\0') {
    return NULL;
  }
  return native_json_obj_get_string_dup(presentation, field_name);
}
 
static char *workflow_presentation_string_dup_logic_local(yyjson_val *transition, const char *field_name) {
  yyjson_val *presentation = transition != NULL ? native_json_obj_get(transition, "presentation") : NULL;
  if (presentation == NULL || field_name == NULL || field_name[0] == '\0') {
    return NULL;
  }
  return native_json_obj_get_string_dup(presentation, field_name);
}
 
static int load_action_inputs_logic_local(
  const HttpRequest *request,
  yyjson_val *action_contract,
  InputFieldMapLogicLocal *map,
  char **error_message_out
) {
  yyjson_val *input_contract = native_json_obj_get(action_contract, "input_contract");
  yyjson_val *fields = input_contract != NULL ? native_json_obj_get(input_contract, "fields") : NULL;
  yyjson_arr_iter iter;
  yyjson_val *item = NULL;
  size_t count = 0;
  size_t index = 0;
  if (error_message_out != NULL) {
    *error_message_out = NULL;
  }
  if (map == NULL) {
    return 0;
  }
  memset(map, 0, sizeof(*map));
  if (fields == NULL || !yyjson_is_arr(fields)) {
    return 1;
  }
  count = yyjson_arr_size(fields);
  if (count == 0) {
    return 1;
  }
  map->items = (InputFieldValueLogicLocal *)calloc(count, sizeof(InputFieldValueLogicLocal));
  if (map->items == NULL) {
    return 0;
  }
  map->count = count;
  if (yyjson_arr_iter_init(fields, &iter)) {
    while ((item = yyjson_arr_iter_next(&iter)) != NULL) {
      char *field_id = native_json_obj_get_string_dup(item, "field_id");
      char *type = native_json_obj_get_string_dup(item, "type");
      int required = yyjson_get_bool(native_json_obj_get(item, "required"));
      char *value = NULL;
      if (field_id == NULL || field_id[0] == '\0') {
        free(field_id);
        free(type);
        free_input_field_map_logic_local(map);
        return 0;
      }
      value = request_form_value_dup_logic_local(request, field_id);
      if (required && (value == NULL || value[0] == '\0')) {
        if (error_message_out != NULL) {
          size_t needed = strlen(field_id) + 64;
          *error_message_out = (char *)malloc(needed);
          if (*error_message_out != NULL) {
            snprintf(*error_message_out, needed, "Missing required field: %s.", field_id);
          }
        }
        free(field_id);
        free(type);
        free(value);
        free_input_field_map_logic_local(map);
        return 1;
      }
      if (type != NULL && streq(type, "integer") && value != NULL && value[0] != '\0') {
        char *end = NULL;
        (void)strtol(value, &end, 10);
        if (end == NULL || *end != '\0') {
          if (error_message_out != NULL) {
            size_t needed = strlen(field_id) + 64;
            *error_message_out = (char *)malloc(needed);
            if (*error_message_out != NULL) {
              snprintf(*error_message_out, needed, "Invalid integer field: %s.", field_id);
            }
          }
          free(field_id);
          free(type);
          free(value);
          free_input_field_map_logic_local(map);
          return 1;
        }
      }
      map->items[index].field_id = field_id;
      map->items[index].value = value != NULL ? value : strdup("");
      free(type);
      index++;
    }
  }
  return 1;
}
 
static char *string_value_from_contract_logic_local(
  yyjson_val *value_contract,
  const InputFieldMapLogicLocal *inputs,
  const ActionExecutionContextLogicLocal *context,
  const char *list_item_text,
  yyjson_val *source_record_context
) {
  char *source = NULL;
  char buffer[64];
  char *result = NULL;
  if (value_contract == NULL) {
    return NULL;
  }
  if (yyjson_is_str(value_contract)) {
    return strdup(yyjson_get_str(value_contract));
  }
  if (yyjson_is_num(value_contract)) {
    snprintf(buffer, sizeof(buffer), "%lld", (long long)yyjson_get_sint(value_contract));
    return strdup(buffer);
  }
  if (yyjson_is_bool(value_contract)) {
    return strdup(yyjson_get_bool(value_contract) ? "true" : "false");
  }
  if (!yyjson_is_obj(value_contract)) {
    return NULL;
  }
  source = native_json_obj_get_string_dup(value_contract, "source");
  if (source != NULL && streq(source, "input")) {
    char *field_name = native_json_obj_get_string_dup(value_contract, "field");
    result = input_field_value_dup_logic_local(inputs, field_name);
    free(field_name);
  } else if (source != NULL && streq(source, "literal")) {
    yyjson_val *literal = native_json_obj_get(value_contract, "value");
    if (literal == NULL || yyjson_is_null(literal)) {
      result = strdup("");
    } else if (yyjson_is_str(literal)) {
      result = strdup(yyjson_get_str(literal));
    } else if (yyjson_is_num(literal)) {
      snprintf(buffer, sizeof(buffer), "%lld", (long long)yyjson_get_sint(literal));
      result = strdup(buffer);
    } else if (yyjson_is_bool(literal)) {
      result = strdup(yyjson_get_bool(literal) ? "true" : "false");
    }
  } else if (source != NULL && streq(source, "list_item")) {
    result = strdup(list_item_text != NULL ? list_item_text : "");
  } else if (source != NULL && streq(source, "context_anchor_created_id")) {
    snprintf(buffer, sizeof(buffer), "%ld", context != NULL ? context->anchor_record_id : 0L);
    result = strdup(buffer);
  } else if (source != NULL && streq(source, "context_last_created_id")) {
    snprintf(buffer, sizeof(buffer), "%ld", context != NULL ? context->last_created_record_id : 0L);
    result = strdup(buffer);
  } else if (source != NULL && streq(source, "context_last_touched_id")) {
    snprintf(buffer, sizeof(buffer), "%ld", context != NULL ? context->last_touched_record_id : 0L);
    result = strdup(buffer);
  } else if (source != NULL && streq(source, "source_record_field")) {
    char *field_name = native_json_obj_get_string_dup(value_contract, "field");
    yyjson_val *current = source_record_context != NULL ? native_json_obj_get(source_record_context, field_name) : NULL;
    if (current == NULL || yyjson_is_null(current)) {
      result = strdup("");
    } else if (yyjson_is_str(current)) {
      result = strdup(yyjson_get_str(current));
    } else if (yyjson_is_num(current)) {
      snprintf(buffer, sizeof(buffer), "%lld", (long long)yyjson_get_sint(current));
      result = strdup(buffer);
    } else if (yyjson_is_bool(current)) {
      result = strdup(yyjson_get_bool(current) ? "true" : "false");
    }
    free(field_name);
  }
  free(source);
  return result;
}
 
static yyjson_mut_val *field_value_from_contract_logic_local(
  yyjson_mut_doc *doc,
  yyjson_val *value_contract,
  const InputFieldMapLogicLocal *inputs,
  long next_id,
  yyjson_val *record_context,
  const ActionExecutionContextLogicLocal *context,
  const char *list_item_text,
  yyjson_val *source_record_context
) {
  char *source = NULL;
  yyjson_mut_val *result = NULL;
  if (doc == NULL || value_contract == NULL || !yyjson_is_obj(value_contract)) {
    return NULL;
  }
  source = native_json_obj_get_string_dup(value_contract, "source");
  if (source != NULL && streq(source, "input")) {
    char *field_name = native_json_obj_get_string_dup(value_contract, "field");
    char *value = input_field_value_dup_logic_local(inputs, field_name);
    result = yyjson_mut_strcpy(doc, value != NULL ? value : "");
    free(field_name);
    free(value);
  } else if (source != NULL && streq(source, "next_id")) {
    result = yyjson_mut_int(doc, next_id);
  } else if (source != NULL && streq(source, "literal")) {
    yyjson_val *literal = native_json_obj_get(value_contract, "value");
    if (literal == NULL || yyjson_is_null(literal)) {
      result = yyjson_mut_null(doc);
    } else if (yyjson_is_bool(literal)) {
      result = yyjson_mut_bool(doc, yyjson_get_bool(literal));
    } else if (yyjson_is_num(literal)) {
      result = yyjson_mut_sint(doc, yyjson_get_sint(literal));
    } else if (yyjson_is_str(literal)) {
      result = yyjson_mut_strcpy(doc, yyjson_get_str(literal));
    }
  } else if (source != NULL && streq(source, "toggle_boolean")) {
    char *field_name = native_json_obj_get_string_dup(value_contract, "field");
    yyjson_val *current = record_context != NULL ? native_json_obj_get(record_context, field_name) : NULL;
    result = yyjson_mut_bool(doc, current != NULL ? !yyjson_get_bool(current) : 1);
    free(field_name);
  } else if (source != NULL && streq(source, "record_field")) {
    char *field_name = native_json_obj_get_string_dup(value_contract, "field");
    yyjson_val *current = record_context != NULL ? native_json_obj_get(record_context, field_name) : NULL;
    if (current == NULL || yyjson_is_null(current)) {
      result = yyjson_mut_null(doc);
    } else if (yyjson_is_bool(current)) {
      result = yyjson_mut_bool(doc, yyjson_get_bool(current));
    } else if (yyjson_is_num(current)) {
      result = yyjson_mut_sint(doc, yyjson_get_sint(current));
    } else if (yyjson_is_str(current)) {
      result = yyjson_mut_strcpy(doc, yyjson_get_str(current));
    }
    free(field_name);
  } else if (source != NULL && streq(source, "context_anchor_created_id")) {
    result = yyjson_mut_int(doc, context != NULL ? context->anchor_record_id : 0);
  } else if (source != NULL && streq(source, "context_last_created_id")) {
    result = yyjson_mut_int(doc, context != NULL ? context->last_created_record_id : 0);
  } else if (source != NULL && streq(source, "context_last_touched_id")) {
    result = yyjson_mut_int(doc, context != NULL ? context->last_touched_record_id : 0);
  } else if (source != NULL && streq(source, "list_item")) {
    result = yyjson_mut_strcpy(doc, list_item_text != NULL ? list_item_text : "");
  } else if (source != NULL && streq(source, "source_record_field")) {
    char *field_name = native_json_obj_get_string_dup(value_contract, "field");
    yyjson_val *current = source_record_context != NULL ? native_json_obj_get(source_record_context, field_name) : NULL;
    if (current == NULL || yyjson_is_null(current)) {
      result = yyjson_mut_null(doc);
    } else if (yyjson_is_bool(current)) {
      result = yyjson_mut_bool(doc, yyjson_get_bool(current));
    } else if (yyjson_is_num(current)) {
      result = yyjson_mut_sint(doc, yyjson_get_sint(current));
    } else if (yyjson_is_str(current)) {
      result = yyjson_mut_strcpy(doc, yyjson_get_str(current));
    }
    free(field_name);
  }
  free(source);
  return result;
}
 
static int append_list_item_logic_local(char ***items_out, size_t *count_out, const char *start, size_t length) {
  char *item = NULL;
  char **grown = NULL;
  if (items_out == NULL || count_out == NULL) {
    return 0;
  }
  item = dup_range(start, length);
  if (item == NULL) {
    return 0;
  }
  trim_in_place(item);
  if (item[0] == '\0') {
    free(item);
    return 1;
  }
  grown = (char **)realloc(*items_out, sizeof(char *) * (*count_out + 1));
  if (grown == NULL) {
    free(item);
    return 0;
  }
  *items_out = grown;
  (*items_out)[*count_out] = item;
  *count_out = *count_out + 1;
  return 1;
}
 
static void free_split_items_logic_local(char **items, size_t count) {
  size_t index = 0;
  for (index = 0; index < count; index++) {
    free(items[index]);
  }
  free(items);
}
 
static int split_input_list_logic_local(const char *raw_value, const char *delimiter, char ***items_out, size_t *count_out) {
  const char *cursor = NULL;
  const char *next = NULL;
  size_t delimiter_len = 0;
  if (items_out == NULL || count_out == NULL) {
    return 0;
  }
  *items_out = NULL;
  *count_out = 0;
  if (raw_value == NULL) {
    return 1;
  }
  delimiter = (delimiter != NULL && delimiter[0] != '\0') ? delimiter : "\n";
  delimiter_len = strlen(delimiter);
  if (delimiter_len == 0) {
    delimiter = "\n";
    delimiter_len = 1;
  }
  cursor = raw_value;
  while (1) {
    next = strstr(cursor, delimiter);
    if (next == NULL) {
      return append_list_item_logic_local(items_out, count_out, cursor, strlen(cursor));
    }
    if (!append_list_item_logic_local(items_out, count_out, cursor, (size_t)(next - cursor))) {
      return 0;
    }
    cursor = next + delimiter_len;
  }
}
 
static int set_mut_object_field_logic_local(yyjson_mut_doc *doc, yyjson_mut_val *obj, const char *field_name, yyjson_mut_val *value) {
  if (doc == NULL || obj == NULL || field_name == NULL || value == NULL || !yyjson_mut_is_obj(obj)) {
    return 0;
  }
  yyjson_mut_obj_remove_key(obj, field_name);
  return yyjson_mut_obj_put(obj, yyjson_mut_strcpy(doc, field_name), value);
}
 
static char *scoped_resource_id_dup_logic_local(const char *collection_name, const char *field_name, const char *expected_text) {
  size_t needed = 0;
  char *resource_id = NULL;
  if (collection_name == NULL || collection_name[0] == '\0') {
    return NULL;
  }
  if (field_name == NULL || field_name[0] == '\0' || expected_text == NULL || expected_text[0] == '\0') {
    needed = strlen(collection_name) + 8;
    resource_id = (char *)malloc(needed);
    if (resource_id != NULL) {
      snprintf(resource_id, needed, "%s:scope", collection_name);
    }
    return resource_id;
  }
  needed = strlen(collection_name) + strlen(field_name) + strlen(expected_text) + 16;
  resource_id = (char *)malloc(needed);
  if (resource_id != NULL) {
    snprintf(resource_id, needed, "%s:%s:%s", collection_name, field_name, expected_text);
  }
  return resource_id;
}
 
static int record_field_matches_text_value_logic_local(yyjson_val *record, const char *field_name, const char *expected_text) {
  yyjson_val *field = NULL;
  char buffer[64];
  if (record == NULL || field_name == NULL || field_name[0] == '\0' || expected_text == NULL) {
    return 0;
  }
  field = native_json_obj_get(record, field_name);
  if (field == NULL || yyjson_is_null(field)) {
    return 0;
  }
  if (yyjson_is_str(field)) {
    return streq(yyjson_get_str(field), expected_text);
  }
  if (yyjson_is_num(field)) {
    snprintf(buffer, sizeof(buffer), "%lld", (long long)yyjson_get_sint(field));
    return streq(buffer, expected_text);
  }
  if (yyjson_is_bool(field)) {
    return (yyjson_get_bool(field) && (streq(expected_text, "true") || streq(expected_text, "1")))
      || (!yyjson_get_bool(field) && (streq(expected_text, "false") || streq(expected_text, "0")));
  }
  return 0;
}
 
static int record_field_matches_text_logic_local(yyjson_mut_val *record, const char *field_name, const char *expected_text) {
  return record_field_matches_text_value_logic_local((yyjson_val *)record, field_name, expected_text);
}
 
static char *scope_match_expected_text_dup_logic_local(
  yyjson_val *scope_match,
  const InputFieldMapLogicLocal *inputs,
  const ActionExecutionContextLogicLocal *context
) {
  char *from_input = NULL;
  char *result = NULL;
  if (scope_match == NULL || !yyjson_is_obj(scope_match)) {
    return NULL;
  }
  from_input = native_json_obj_get_string_dup(scope_match, "from_input");
  if (from_input != NULL && from_input[0] != '\0') {
    result = input_field_value_dup_logic_local(inputs, from_input);
  } else {
    yyjson_val *literal = native_json_obj_get(scope_match, "literal");
    result = string_value_from_contract_logic_local(literal, inputs, context, NULL, NULL);
  }
  free(from_input);
  return result;
}
 
static long matching_record_count_value_logic_local(
  yyjson_val *collection,
  const char *scope_field,
  const char *expected_text
) {
  size_t index = 0;
  size_t max = 0;
  yyjson_val *record = NULL;
  long matched_count = 0;
  if (collection == NULL || !yyjson_is_arr(collection)
      || scope_field == NULL || scope_field[0] == '\0'
      || expected_text == NULL) {
    return 0;
  }
  yyjson_arr_foreach(collection, index, max, record) {
    if (yyjson_is_obj(record)
        && record_field_matches_text_value_logic_local(record, scope_field, expected_text)) {
      matched_count++;
    }
  }
  return matched_count;
}
 
static long matching_record_count_logic_local(
  yyjson_mut_val *collection,
  const char *scope_field,
  const char *expected_text
) {
  return matching_record_count_value_logic_local((yyjson_val *)collection, scope_field, expected_text);
}
 
static int append_record_primitive_logic_local(
  yyjson_mut_doc *mut_doc,
  yyjson_mut_val *mut_root,
  yyjson_val *primitive,
  const InputFieldMapLogicLocal *inputs,
  const ActionExecutionContextLogicLocal *context,
  long next_id,
  long *created_record_id_out,
  char **resource_id_out
) {
  char *collection_name = native_json_obj_get_string_dup(primitive, "collection");
  yyjson_val *record_contract = native_json_obj_get(primitive, "record_contract");
  yyjson_mut_val *collection = NULL;
  yyjson_mut_val *record = NULL;
  yyjson_obj_iter iter;
  yyjson_val *field_contract = NULL;
  yyjson_val *key = NULL;
  if (created_record_id_out != NULL) {
    *created_record_id_out = 0;
  }
  if (resource_id_out != NULL) {
    *resource_id_out = NULL;
  }
  if (collection_name == NULL || record_contract == NULL || !yyjson_is_obj(record_contract)) {
    free(collection_name);
    return 0;
  }
  collection = yyjson_mut_obj_get(mut_root, collection_name);
  if (collection == NULL) {
    collection = yyjson_mut_arr(mut_doc);
    if (collection == NULL || !yyjson_mut_obj_put(mut_root, yyjson_mut_strcpy(mut_doc, collection_name), collection)) {
      free(collection_name);
      return 0;
    }
  }
  if (!yyjson_mut_is_arr(collection)) {
    free(collection_name);
    return 0;
  }
  record = yyjson_mut_obj(mut_doc);
  if (record == NULL) {
    free(collection_name);
    return 0;
  }
  if (yyjson_obj_iter_init(record_contract, &iter)) {
    while ((key = yyjson_obj_iter_next(&iter)) != NULL) {
      const char *field_name = yyjson_get_str(key);
      field_contract = yyjson_obj_iter_get_val(key);
      if (field_name == NULL || field_contract == NULL) {
        free(collection_name);
        return 0;
      }
      {
        yyjson_mut_val *value = field_value_from_contract_logic_local(mut_doc, field_contract, inputs, next_id, NULL, context, NULL, NULL);
        if (value == NULL || !set_mut_object_field_logic_local(mut_doc, record, field_name, value)) {
          free(collection_name);
          return 0;
        }
      }
    }
  }
  if (!yyjson_mut_arr_append(collection, record)) {
    free(collection_name);
    return 0;
  }
  if (created_record_id_out != NULL) {
    yyjson_mut_val *id_value = yyjson_mut_obj_get(record, "id");
    *created_record_id_out = (id_value != NULL && yyjson_is_num((yyjson_val *)id_value)) ? (long)yyjson_get_sint((yyjson_val *)id_value) : 0;
  }
  if (resource_id_out != NULL && created_record_id_out != NULL && *created_record_id_out > 0) {
    size_t needed = strlen(collection_name) + 32;
    *resource_id_out = (char *)malloc(needed);
    if (*resource_id_out != NULL) {
      snprintf(*resource_id_out, needed, "%s:%ld", collection_name, *created_record_id_out);
    }
  }
  free(collection_name);
  return 1;
}
 
static yyjson_mut_val *find_mut_record_by_long_field_logic_local(yyjson_mut_val *array, const char *field_name, long match_value) {
  size_t index = 0;
  size_t max = 0;
  yyjson_mut_val *item = NULL;
  if (array == NULL || field_name == NULL || !yyjson_mut_is_arr(array)) {
    return NULL;
  }
  yyjson_mut_arr_foreach(array, index, max, item) {
    yyjson_mut_val *field = yyjson_mut_obj_get(item, field_name);
    if (yyjson_mut_is_obj(item) && field != NULL && yyjson_is_num((yyjson_val *)field) && yyjson_get_sint((yyjson_val *)field) == match_value) {
      return item;
    }
  }
  return NULL;
}
 
static int append_records_from_input_list_primitive_logic_local(
  yyjson_mut_doc *mut_doc,
  yyjson_mut_val *mut_root,
  yyjson_val *primitive,
  const InputFieldMapLogicLocal *inputs,
  ActionExecutionContextLogicLocal *context,
  long next_id,
  long *created_count_out,
  char **resource_id_out
) {
  char *collection_name = native_json_obj_get_string_dup(primitive, "collection");
  yyjson_val *list_source = native_json_obj_get(primitive, "list_source");
  yyjson_val *record_contract = native_json_obj_get(primitive, "record_contract");
  char *field_name = list_source != NULL ? native_json_obj_get_string_dup(list_source, "from_input") : NULL;
  char *delimiter = list_source != NULL ? native_json_obj_get_string_dup(list_source, "delimiter") : NULL;
  char *raw_list = input_field_value_dup_logic_local(inputs, field_name);
  char **items = NULL;
  size_t item_count = 0;
  size_t index = 0;
  yyjson_mut_val *collection = NULL;
  if (created_count_out != NULL) {
    *created_count_out = 0;
  }
  if (resource_id_out != NULL) {
    *resource_id_out = NULL;
  }
  if (collection_name == NULL || list_source == NULL || record_contract == NULL || !yyjson_is_obj(record_contract)) {
    free(collection_name);
    free(field_name);
    free(delimiter);
    free(raw_list);
    return 0;
  }
  if (!split_input_list_logic_local(raw_list != NULL ? raw_list : "", delimiter, &items, &item_count) || item_count == 0) {
    free(collection_name);
    free(field_name);
    free(delimiter);
    free(raw_list);
    free_split_items_logic_local(items, item_count);
    return 0;
  }
  collection = yyjson_mut_obj_get(mut_root, collection_name);
  if (collection == NULL) {
    collection = yyjson_mut_arr(mut_doc);
    if (collection == NULL || !yyjson_mut_obj_put(mut_root, yyjson_mut_strcpy(mut_doc, collection_name), collection)) {
      free(collection_name);
      free(field_name);
      free(delimiter);
      free(raw_list);
      free_split_items_logic_local(items, item_count);
      return 0;
    }
  }
  if (!yyjson_mut_is_arr(collection)) {
    free(collection_name);
    free(field_name);
    free(delimiter);
    free(raw_list);
    free_split_items_logic_local(items, item_count);
    return 0;
  }
  for (index = 0; index < item_count; index++) {
    yyjson_mut_val *record = yyjson_mut_obj(mut_doc);
    yyjson_obj_iter iter;
    yyjson_val *field_contract = NULL;
    yyjson_val *key = NULL;
    long record_id = 0;
    char *item_resource_id = NULL;
    if (record == NULL) {
      free(collection_name);
      free(field_name);
      free(delimiter);
      free(raw_list);
      free_split_items_logic_local(items, item_count);
      return 0;
    }
    if (yyjson_obj_iter_init(record_contract, &iter)) {
      while ((key = yyjson_obj_iter_next(&iter)) != NULL) {
        const char *record_field_name = yyjson_get_str(key);
        field_contract = yyjson_obj_iter_get_val(key);
        yyjson_mut_val *value = NULL;
        if (record_field_name == NULL || field_contract == NULL) {
          free(collection_name);
          free(field_name);
          free(delimiter);
          free(raw_list);
          free_split_items_logic_local(items, item_count);
          return 0;
        }
        value = field_value_from_contract_logic_local(mut_doc, field_contract, inputs, next_id + (long)index, NULL, context, items[index], NULL);
        if (value == NULL || !set_mut_object_field_logic_local(mut_doc, record, record_field_name, value)) {
          free(collection_name);
          free(field_name);
          free(delimiter);
          free(raw_list);
          free_split_items_logic_local(items, item_count);
          return 0;
        }
      }
    }
    if (!yyjson_mut_arr_append(collection, record)) {
      free(collection_name);
      free(field_name);
      free(delimiter);
      free(raw_list);
      free_split_items_logic_local(items, item_count);
      return 0;
    }
    {
      yyjson_mut_val *id_value = yyjson_mut_obj_get(record, "id");
      record_id = (id_value != NULL && yyjson_is_num((yyjson_val *)id_value)) ? (long)yyjson_get_sint((yyjson_val *)id_value) : 0;
    }
    if (record_id > 0) {
      size_t needed = strlen(collection_name) + 32;
      item_resource_id = (char *)malloc(needed);
      if (item_resource_id == NULL) {
        free(collection_name);
        free(field_name);
        free(delimiter);
        free(raw_list);
        free_split_items_logic_local(items, item_count);
        return 0;
      }
      snprintf(item_resource_id, needed, "%s:%ld", collection_name, record_id);
      if (!note_created_record_logic_local(context, record_id, item_resource_id)) {
        free(item_resource_id);
        free(collection_name);
        free(field_name);
        free(delimiter);
        free(raw_list);
        free_split_items_logic_local(items, item_count);
        return 0;
      }
      if (resource_id_out != NULL) {
        free(*resource_id_out);
        *resource_id_out = item_resource_id;
        item_resource_id = NULL;
      }
      free(item_resource_id);
    }
  }
  if (created_count_out != NULL) {
    *created_count_out = (long)item_count;
  }
  free(collection_name);
  free(field_name);
  free(delimiter);
  free(raw_list);
  free_split_items_logic_local(items, item_count);
  return 1;
}
 
static yyjson_mut_val *find_mut_record_by_id_logic_local(yyjson_mut_val *collection, long record_id) {
  size_t index = 0;
  size_t max = 0;
  yyjson_mut_val *record = NULL;
  if (collection == NULL || !yyjson_mut_is_arr(collection) || record_id <= 0) {
    return NULL;
  }
  yyjson_mut_arr_foreach(collection, index, max, record) {
    yyjson_mut_val *id_value = NULL;
    if (!yyjson_mut_is_obj(record)) {
      continue;
    }
    id_value = yyjson_mut_obj_get(record, "id");
    if (id_value != NULL && yyjson_is_num((yyjson_val *)id_value)
        && (long)yyjson_get_sint((yyjson_val *)id_value) == record_id) {
      return record;
    }
  }
  return NULL;
}
 
static int append_records_from_related_collection_primitive_logic_local(
  yyjson_mut_doc *mut_doc,
  yyjson_mut_val *mut_root,
  yyjson_val *source_root,
  yyjson_val *primitive,
  const InputFieldMapLogicLocal *inputs,
  ActionExecutionContextLogicLocal *context,
  long next_id,
  long *created_count_out,
  char **resource_id_out
) {
  char *collection_name = native_json_obj_get_string_dup(primitive, "collection");
  char *source_collection_name = native_json_obj_get_string_dup(primitive, "source_collection");
  yyjson_val *scope_match = native_json_obj_get(primitive, "scope_match");
  yyjson_val *record_contract = native_json_obj_get(primitive, "record_contract");
  char *scope_field = scope_match != NULL ? native_json_obj_get_string_dup(scope_match, "field") : NULL;
  char *expected_text = scope_match_expected_text_dup_logic_local(scope_match, inputs, context);
  char *overflow_policy = native_json_obj_get_string_dup(primitive, "overflow_policy");
  long max_records = native_json_obj_get_long_default(primitive, "max_records", 100, NULL);
  yyjson_mut_val *target_collection = NULL;
  yyjson_val *source_collection = NULL;
  size_t index = 0;
  size_t max = 0;
  yyjson_val *source_record = NULL;
  long matched_count = 0;
  long created_count = 0;
  if (created_count_out != NULL) {
    *created_count_out = 0;
  }
  if (resource_id_out != NULL) {
    *resource_id_out = NULL;
  }
  if (source_collection_name == NULL || source_collection_name[0] == '\0') {
    free(source_collection_name);
    source_collection_name = collection_name != NULL ? strdup(collection_name) : NULL;
  }
  if (overflow_policy == NULL || overflow_policy[0] == '\0') {
    free(overflow_policy);
    overflow_policy = strdup("truncate");
  }
  if (collection_name == NULL || source_collection_name == NULL || scope_field == NULL || expected_text == NULL
      || record_contract == NULL || !yyjson_is_obj(record_contract) || overflow_policy == NULL) {
    free(collection_name);
    free(source_collection_name);
    free(scope_field);
    free(expected_text);
    free(overflow_policy);
    return 0;
  }
  target_collection = yyjson_mut_obj_get(mut_root, collection_name);
  if (target_collection == NULL) {
    target_collection = yyjson_mut_arr(mut_doc);
    if (target_collection == NULL || !yyjson_mut_obj_put(mut_root, yyjson_mut_strcpy(mut_doc, collection_name), target_collection)) {
      free(collection_name);
      free(source_collection_name);
      free(scope_field);
      free(expected_text);
      free(overflow_policy);
      return 0;
    }
  }
  source_collection = source_root != NULL ? native_json_obj_get(source_root, source_collection_name) : NULL;
  if (!yyjson_mut_is_arr(target_collection) || source_collection == NULL || !yyjson_is_arr(source_collection)) {
    free(collection_name);
    free(source_collection_name);
    free(scope_field);
    free(expected_text);
    free(overflow_policy);
    return -1;
  }
  matched_count = matching_record_count_value_logic_local(source_collection, scope_field, expected_text);
  if (matched_count <= 0) {
    free(collection_name);
    free(source_collection_name);
    free(scope_field);
    free(expected_text);
    free(overflow_policy);
    return -1;
  }
  if (streq(overflow_policy, "fail") && matched_count > max_records) {
    free(collection_name);
    free(source_collection_name);
    free(scope_field);
    free(expected_text);
    free(overflow_policy);
    return -2;
  }
  yyjson_arr_foreach(source_collection, index, max, source_record) {
    yyjson_mut_val *record = NULL;
    yyjson_obj_iter iter;
    yyjson_val *key = NULL;
    yyjson_val *field_contract = NULL;
    yyjson_mut_val *id_value = NULL;
    long record_id = 0;
    char *record_resource_id = NULL;
    if (created_count >= max_records) {
      break;
    }
    if (!yyjson_is_obj(source_record)
        || !record_field_matches_text_value_logic_local(source_record, scope_field, expected_text)) {
      continue;
    }
    record = yyjson_mut_obj(mut_doc);
    if (record == NULL) {
      free(collection_name);
      free(source_collection_name);
      free(scope_field);
      free(expected_text);
      free(overflow_policy);
      return 0;
    }
    if (yyjson_obj_iter_init(record_contract, &iter)) {
      while ((key = yyjson_obj_iter_next(&iter)) != NULL) {
        const char *record_field_name = yyjson_get_str(key);
        yyjson_mut_val *value = NULL;
        field_contract = yyjson_obj_iter_get_val(key);
        if (record_field_name == NULL || field_contract == NULL) {
          free(collection_name);
          free(source_collection_name);
          free(scope_field);
          free(expected_text);
          free(overflow_policy);
          return 0;
        }
        value = field_value_from_contract_logic_local(mut_doc, field_contract, inputs, next_id + created_count, NULL, context, NULL, source_record);
        if (value == NULL || !set_mut_object_field_logic_local(mut_doc, record, record_field_name, value)) {
          free(collection_name);
          free(source_collection_name);
          free(scope_field);
          free(expected_text);
          free(overflow_policy);
          return 0;
        }
      }
    }
    if (!yyjson_mut_arr_append(target_collection, record)) {
      free(collection_name);
      free(source_collection_name);
      free(scope_field);
      free(expected_text);
      free(overflow_policy);
      return 0;
    }
    id_value = yyjson_mut_obj_get(record, "id");
    record_id = (id_value != NULL && yyjson_is_num((yyjson_val *)id_value)) ? (long)yyjson_get_sint((yyjson_val *)id_value) : 0;
    if (record_id > 0) {
      size_t needed = strlen(collection_name) + 32;
      record_resource_id = (char *)malloc(needed);
      if (record_resource_id == NULL) {
        free(collection_name);
        free(source_collection_name);
        free(scope_field);
        free(expected_text);
        free(overflow_policy);
        return 0;
      }
      snprintf(record_resource_id, needed, "%s:%ld", collection_name, record_id);
      if (!note_created_record_logic_local(context, record_id, record_resource_id)) {
        free(record_resource_id);
        free(collection_name);
        free(source_collection_name);
        free(scope_field);
        free(expected_text);
        free(overflow_policy);
        return 0;
      }
      if (resource_id_out != NULL) {
        free(*resource_id_out);
        *resource_id_out = record_resource_id;
        record_resource_id = NULL;
      }
      free(record_resource_id);
    }
    created_count++;
  }
  if (created_count == 0) {
    free(collection_name);
    free(source_collection_name);
    free(scope_field);
    free(expected_text);
    free(overflow_policy);
    return -1;
  }
  if (context != NULL && !note_bounded_scope_logic_local(context, matched_count, created_count, overflow_policy)) {
    free(collection_name);
    free(source_collection_name);
    free(scope_field);
    free(expected_text);
    free(overflow_policy);
    return 0;
  }
  if (resource_id_out != NULL && *resource_id_out == NULL) {
    *resource_id_out = scoped_resource_id_dup_logic_local(source_collection_name, scope_field, expected_text);
  }
  if (created_count_out != NULL) {
    *created_count_out = created_count;
  }
  free(collection_name);
  free(source_collection_name);
  free(scope_field);
  free(expected_text);
  free(overflow_policy);
  return 1;
}
 
static int update_record_primitive_logic_local(
  yyjson_mut_doc *mut_doc,
  yyjson_mut_val *mut_root,
  yyjson_val *primitive,
  const InputFieldMapLogicLocal *inputs,
  ActionExecutionContextLogicLocal *context,
  char **resource_id_out,
  char **from_state_out,
  char **to_state_out
) {
  char *collection_name = native_json_obj_get_string_dup(primitive, "collection");
  yyjson_val *match = native_json_obj_get(primitive, "match");
  yyjson_val *updates = native_json_obj_get(primitive, "updates");
  char *match_field = match != NULL ? native_json_obj_get_string_dup(match, "field") : NULL;
  char *from_input = match != NULL ? native_json_obj_get_string_dup(match, "from_input") : NULL;
  char *input_value = input_field_value_dup_logic_local(inputs, from_input);
  long match_id = input_value != NULL ? strtol(input_value, NULL, 10) : 0;
  yyjson_mut_val *collection = NULL;
  yyjson_mut_val *record = NULL;
  yyjson_obj_iter iter;
  yyjson_val *key = NULL;
  yyjson_val *field_contract = NULL;
  if (resource_id_out != NULL) {
    *resource_id_out = NULL;
  }
  if (from_state_out != NULL) {
    *from_state_out = NULL;
  }
  if (to_state_out != NULL) {
    *to_state_out = NULL;
  }
  if (collection_name == NULL || match_field == NULL || from_input == NULL || updates == NULL || !yyjson_is_obj(updates) || match_id <= 0) {
    free(collection_name);
    free(match_field);
    free(from_input);
    free(input_value);
    return 0;
  }
  collection = yyjson_mut_obj_get(mut_root, collection_name);
  record = find_mut_record_by_long_field_logic_local(collection, match_field, match_id);
  if (record == NULL) {
    free(collection_name);
    free(match_field);
    free(from_input);
    free(input_value);
    return -1;
  }
  if (from_state_out != NULL) {
    yyjson_mut_val *current = yyjson_mut_obj_get(record, "workflow_state");
    if (current != NULL && yyjson_is_str((yyjson_val *)current)) {
      *from_state_out = strdup(yyjson_get_str((yyjson_val *)current));
    }
  }
  if (yyjson_obj_iter_init(updates, &iter)) {
    while ((key = yyjson_obj_iter_next(&iter)) != NULL) {
      const char *field_name = yyjson_get_str(key);
      field_contract = yyjson_obj_iter_get_val(key);
      if (field_name == NULL || field_contract == NULL) {
        free(collection_name);
        free(match_field);
        free(from_input);
        free(input_value);
        return 0;
      }
      {
        yyjson_mut_val *value = field_value_from_contract_logic_local(mut_doc, field_contract, inputs, 0, (yyjson_val *)record, context, NULL, NULL);
        if (value == NULL || !set_mut_object_field_logic_local(mut_doc, record, field_name, value)) {
          free(collection_name);
          free(match_field);
          free(from_input);
          free(input_value);
          return 0;
        }
        if (to_state_out != NULL && streq(field_name, "workflow_state") && yyjson_mut_is_str(value)) {
          free(*to_state_out);
          *to_state_out = strdup(yyjson_get_str((yyjson_val *)value));
        }
      }
    }
  }
  if (resource_id_out != NULL) {
    size_t needed = strlen(collection_name) + 32;
    *resource_id_out = (char *)malloc(needed);
    if (*resource_id_out != NULL) {
      snprintf(*resource_id_out, needed, "%s:%ld", collection_name, match_id);
    }
  }
  if (context != NULL && !note_updated_record_logic_local(context, match_id, resource_id_out != NULL ? *resource_id_out : NULL)) {
    free(collection_name);
    free(match_field);
    free(from_input);
    free(input_value);
    return 0;
  }
  free(collection_name);
  free(match_field);
  free(from_input);
  free(input_value);
  return 1;
}
 
static int scoped_reassignment_primitive_logic_local(
  yyjson_mut_doc *mut_doc,
  yyjson_mut_val *mut_root,
  yyjson_val *source_root,
  yyjson_val *primitive,
  const InputFieldMapLogicLocal *inputs,
  ActionExecutionContextLogicLocal *context,
  char **resource_id_out
) {
  char *collection_name = native_json_obj_get_string_dup(primitive, "collection");
  yyjson_val *scope_match = native_json_obj_get(primitive, "scope_match");
  yyjson_val *value_contract = native_json_obj_get(primitive, "value_contract");
  char *scope_field = scope_match != NULL ? native_json_obj_get_string_dup(scope_match, "field") : NULL;
  char *expected_text = scope_match_expected_text_dup_logic_local(scope_match, inputs, context);
  char *target_field = native_json_obj_get_string_dup(primitive, "target_field");
  char *overflow_policy = native_json_obj_get_string_dup(primitive, "overflow_policy");
  long max_records = native_json_obj_get_long_default(primitive, "max_records", 100, NULL);
  yyjson_mut_val *collection = NULL;
  yyjson_val *source_collection = NULL;
  size_t index = 0;
  size_t max = 0;
  yyjson_val *source_record = NULL;
  long updated_count = 0;
  long matched_count = 0;
  if (resource_id_out != NULL) {
    *resource_id_out = NULL;
  }
  if (overflow_policy == NULL || overflow_policy[0] == '\0') {
    free(overflow_policy);
    overflow_policy = strdup("truncate");
  }
  if (collection_name == NULL || scope_field == NULL || target_field == NULL || value_contract == NULL || expected_text == NULL || overflow_policy == NULL) {
    free(collection_name);
    free(scope_field);
    free(expected_text);
    free(target_field);
    free(overflow_policy);
    return 0;
  }
  collection = yyjson_mut_obj_get(mut_root, collection_name);
  source_collection = source_root != NULL ? native_json_obj_get(source_root, collection_name) : NULL;
  if (collection == NULL || !yyjson_mut_is_arr(collection)
      || source_collection == NULL || !yyjson_is_arr(source_collection)) {
    free(collection_name);
    free(scope_field);
    free(expected_text);
    free(target_field);
    free(overflow_policy);
    return -1;
  }
  matched_count = matching_record_count_value_logic_local(source_collection, scope_field, expected_text);
  if (matched_count <= 0) {
    free(collection_name);
    free(scope_field);
    free(expected_text);
    free(target_field);
    free(overflow_policy);
    return -1;
  }
  if (streq(overflow_policy, "fail") && matched_count > max_records) {
    free(collection_name);
    free(scope_field);
    free(expected_text);
    free(target_field);
    free(overflow_policy);
    return -2;
  }
  yyjson_arr_foreach(source_collection, index, max, source_record) {
    yyjson_val *source_id_value = NULL;
    yyjson_mut_val *record = NULL;
    long record_id = 0;
    char *record_resource_id = NULL;
    yyjson_mut_val *value = NULL;
    if (updated_count >= max_records) {
      break;
    }
    if (!yyjson_is_obj(source_record)
        || !record_field_matches_text_value_logic_local(source_record, scope_field, expected_text)) {
      continue;
    }
    source_id_value = native_json_obj_get(source_record, "id");
    record_id = (source_id_value != NULL && yyjson_is_num(source_id_value)) ? (long)yyjson_get_sint(source_id_value) : 0;
    record = find_mut_record_by_id_logic_local(collection, record_id);
    if (record == NULL) {
      free(collection_name);
      free(scope_field);
      free(expected_text);
      free(target_field);
      free(overflow_policy);
      return 0;
    }
    value = field_value_from_contract_logic_local(mut_doc, value_contract, inputs, 0, source_record, context, NULL, NULL);
    if (value == NULL || !set_mut_object_field_logic_local(mut_doc, record, target_field, value)) {
      free(collection_name);
      free(scope_field);
      free(expected_text);
      free(target_field);
      free(overflow_policy);
      return 0;
    }
    if (record_id > 0) {
      size_t needed = strlen(collection_name) + 32;
      record_resource_id = (char *)malloc(needed);
      if (record_resource_id == NULL) {
        free(collection_name);
        free(scope_field);
        free(expected_text);
        free(target_field);
        free(overflow_policy);
        return 0;
      }
      snprintf(record_resource_id, needed, "%s:%ld", collection_name, record_id);
      if (context != NULL && !note_updated_record_logic_local(context, record_id, record_resource_id)) {
        free(record_resource_id);
        free(collection_name);
        free(scope_field);
        free(expected_text);
        free(target_field);
        free(overflow_policy);
        return 0;
      }
      free(record_resource_id);
    }
    updated_count++;
  }
  if (updated_count == 0) {
    free(collection_name);
    free(scope_field);
    free(expected_text);
    free(target_field);
    free(overflow_policy);
    return -1;
  }
  if (context != NULL
      && !note_bounded_scope_logic_local(context, matched_count, updated_count, overflow_policy)) {
    free(collection_name);
    free(scope_field);
    free(expected_text);
    free(target_field);
    free(overflow_policy);
    return 0;
  }
  if (resource_id_out != NULL) {
    *resource_id_out = scoped_resource_id_dup_logic_local(collection_name, scope_field, expected_text);
  }
  free(collection_name);
  free(scope_field);
  free(expected_text);
  free(target_field);
  free(overflow_policy);
  return 1;
}
 
static int bulk_update_primitive_logic_local(
  yyjson_mut_doc *mut_doc,
  yyjson_mut_val *mut_root,
  yyjson_val *primitive,
  const InputFieldMapLogicLocal *inputs,
  ActionExecutionContextLogicLocal *context,
  char **resource_id_out,
  char **from_state_out,
  char **to_state_out
) {
  char *collection_name = native_json_obj_get_string_dup(primitive, "collection");
  yyjson_val *scope_match = native_json_obj_get(primitive, "scope_match");
  yyjson_val *updates = native_json_obj_get(primitive, "updates");
  char *scope_field = scope_match != NULL ? native_json_obj_get_string_dup(scope_match, "field") : NULL;
  char *expected_text = scope_match_expected_text_dup_logic_local(scope_match, inputs, context);
  char *overflow_policy = native_json_obj_get_string_dup(primitive, "overflow_policy");
  long max_records = native_json_obj_get_long_default(primitive, "max_records", 100, NULL);
  yyjson_mut_val *collection = NULL;
  size_t index = 0;
  size_t max = 0;
  yyjson_mut_val *record = NULL;
  long updated_count = 0;
  long matched_count = 0;
  if (resource_id_out != NULL) {
    *resource_id_out = NULL;
  }
  if (from_state_out != NULL) {
    *from_state_out = NULL;
  }
  if (to_state_out != NULL) {
    *to_state_out = NULL;
  }
  if (overflow_policy == NULL || overflow_policy[0] == '\0') {
    free(overflow_policy);
    overflow_policy = strdup("truncate");
  }
  if (collection_name == NULL || scope_field == NULL || expected_text == NULL || updates == NULL || !yyjson_is_obj(updates) || overflow_policy == NULL) {
    free(collection_name);
    free(scope_field);
    free(expected_text);
    free(overflow_policy);
    return 0;
  }
  collection = yyjson_mut_obj_get(mut_root, collection_name);
  if (collection == NULL || !yyjson_mut_is_arr(collection)) {
    free(collection_name);
    free(scope_field);
    free(expected_text);
    free(overflow_policy);
    return -1;
  }
  matched_count = matching_record_count_logic_local(collection, scope_field, expected_text);
  if (matched_count <= 0) {
    free(collection_name);
    free(scope_field);
    free(expected_text);
    free(overflow_policy);
    return -1;
  }
  if (streq(overflow_policy, "fail") && matched_count > max_records) {
    free(collection_name);
    free(scope_field);
    free(expected_text);
    free(overflow_policy);
    return -2;
  }
  yyjson_mut_arr_foreach(collection, index, max, record) {
    yyjson_obj_iter iter;
    yyjson_val *key = NULL;
    yyjson_val *field_contract = NULL;
    yyjson_mut_val *id_value = NULL;
    long record_id = 0;
    char *record_resource_id = NULL;
    if (updated_count >= max_records) {
      break;
    }
    if (!yyjson_mut_is_obj(record) || !record_field_matches_text_logic_local(record, scope_field, expected_text)) {
      continue;
    }
    if (from_state_out != NULL && *from_state_out == NULL) {
      yyjson_mut_val *current = yyjson_mut_obj_get(record, "workflow_state");
      if (current != NULL && yyjson_is_str((yyjson_val *)current)) {
        *from_state_out = strdup(yyjson_get_str((yyjson_val *)current));
      }
    }
    if (yyjson_obj_iter_init(updates, &iter)) {
      while ((key = yyjson_obj_iter_next(&iter)) != NULL) {
        const char *field_name = yyjson_get_str(key);
        field_contract = yyjson_obj_iter_get_val(key);
        yyjson_mut_val *value = NULL;
        if (field_name == NULL || field_contract == NULL) {
          free(collection_name);
          free(scope_field);
          free(expected_text);
          free(overflow_policy);
          return 0;
        }
        value = field_value_from_contract_logic_local(mut_doc, field_contract, inputs, 0, (yyjson_val *)record, context, NULL, NULL);
        if (value == NULL || !set_mut_object_field_logic_local(mut_doc, record, field_name, value)) {
          free(collection_name);
          free(scope_field);
          free(expected_text);
          free(overflow_policy);
          return 0;
        }
        if (to_state_out != NULL && streq(field_name, "workflow_state") && yyjson_mut_is_str(value)) {
          free(*to_state_out);
          *to_state_out = strdup(yyjson_get_str((yyjson_val *)value));
        }
      }
    }
    id_value = yyjson_mut_obj_get(record, "id");
    record_id = (id_value != NULL && yyjson_is_num((yyjson_val *)id_value)) ? (long)yyjson_get_sint((yyjson_val *)id_value) : 0;
    if (record_id > 0) {
      size_t needed = strlen(collection_name) + 32;
      record_resource_id = (char *)malloc(needed);
      if (record_resource_id == NULL) {
        free(collection_name);
        free(scope_field);
        free(expected_text);
        free(overflow_policy);
        return 0;
      }
      snprintf(record_resource_id, needed, "%s:%ld", collection_name, record_id);
      if (context != NULL && !note_updated_record_logic_local(context, record_id, record_resource_id)) {
        free(record_resource_id);
        free(collection_name);
        free(scope_field);
        free(expected_text);
        free(overflow_policy);
        return 0;
      }
      free(record_resource_id);
    }
    updated_count++;
  }
  if (updated_count == 0) {
    free(collection_name);
    free(scope_field);
    free(expected_text);
    free(overflow_policy);
    return -1;
  }
  if (context != NULL
      && !note_bounded_scope_logic_local(context, matched_count, updated_count, overflow_policy)) {
    free(collection_name);
    free(scope_field);
    free(expected_text);
    free(overflow_policy);
    return 0;
  }
  if (resource_id_out != NULL) {
    *resource_id_out = scoped_resource_id_dup_logic_local(collection_name, scope_field, expected_text);
  }
  free(collection_name);
  free(scope_field);
  free(expected_text);
  free(overflow_policy);
  return 1;
}
 
static int set_root_fields_primitive_logic_local(
  yyjson_mut_doc *mut_doc,
  yyjson_mut_val *mut_root,
  yyjson_val *primitive,
  const InputFieldMapLogicLocal *inputs,
  const ActionExecutionContextLogicLocal *context,
  long next_id
) {
  yyjson_val *fields = native_json_obj_get(primitive, "fields");
  yyjson_obj_iter iter;
  yyjson_val *key = NULL;
  yyjson_val *field_contract = NULL;
  if (fields == NULL || !yyjson_is_obj(fields)) {
    return 0;
  }
  if (yyjson_obj_iter_init(fields, &iter)) {
    while ((key = yyjson_obj_iter_next(&iter)) != NULL) {
      const char *field_name = yyjson_get_str(key);
      field_contract = yyjson_obj_iter_get_val(key);
      if (field_name == NULL || field_contract == NULL) {
        return 0;
      }
      {
        yyjson_mut_val *value = field_value_from_contract_logic_local(mut_doc, field_contract, inputs, next_id, NULL, context, NULL, NULL);
        if (value == NULL || !set_mut_object_field_logic_local(mut_doc, mut_root, field_name, value)) {
          return 0;
        }
      }
    }
  }
  return 1;
}
 
static long next_section_id_logic_local(yyjson_mut_val *root, const char *section_name) {
  yyjson_mut_val *array = root != NULL ? yyjson_mut_obj_get(root, section_name) : NULL;
  size_t index = 0;
  size_t max = 0;
  yyjson_mut_val *item = NULL;
  long max_id = 0;
  if (array == NULL || !yyjson_mut_is_arr(array)) {
    return 1;
  }
  yyjson_mut_arr_foreach(array, index, max, item) {
    yyjson_mut_val *id_value = yyjson_mut_obj_get(item, "id");
    if (id_value != NULL && yyjson_is_num((yyjson_val *)id_value) && yyjson_get_sint((yyjson_val *)id_value) > max_id) {
      max_id = (long)yyjson_get_sint((yyjson_val *)id_value);
    }
  }
  return max_id + 1;
}
 
static yyjson_mut_val *ensure_mut_array_field_logic_local(yyjson_mut_doc *doc, yyjson_mut_val *root, const char *field_name) {
  yyjson_mut_val *array = root != NULL ? yyjson_mut_obj_get(root, field_name) : NULL;
  if (array != NULL && yyjson_mut_is_arr(array)) {
    return array;
  }
  array = yyjson_mut_arr(doc);
  if (array == NULL || !yyjson_mut_obj_put(root, yyjson_mut_strcpy(doc, field_name), array)) {
    return NULL;
  }
  return array;
}
 
static int append_mut_object_to_array_logic_local(yyjson_mut_doc *doc, yyjson_mut_val *root, const char *section_name, yyjson_mut_val *obj) {
  yyjson_mut_val *array = ensure_mut_array_field_logic_local(doc, root, section_name);
  if (array == NULL || obj == NULL) {
    return 0;
  }
  return yyjson_mut_arr_append(array, obj);
}
 
static yyjson_val *find_integration_adapter_logic_local(yyjson_val *root, const char *adapter_id) {
  yyjson_val *adapters = root != NULL ? native_json_obj_get(root, "adapters") : NULL;
  yyjson_arr_iter iter;
  yyjson_val *item = NULL;
  if (adapters == NULL || adapter_id == NULL || adapter_id[0] == '\0' || !yyjson_is_arr(adapters)) {
    return NULL;
  }
  if (yyjson_arr_iter_init(adapters, &iter)) {
    while ((item = yyjson_arr_iter_next(&iter)) != NULL) {
      if (yyjson_is_obj(item) && yyjson_equals_str(native_json_obj_get(item, "adapter_id"), adapter_id)) {
        return item;
      }
    }
  }
  return NULL;
}
 
static char *integration_adapter_target_url_dup_logic_local(yyjson_val *adapter) {
  char *target_url = NULL;
  char *target_url_env = NULL;
  if (adapter == NULL || !yyjson_is_obj(adapter)) {
    return NULL;
  }
  target_url = native_json_obj_get_string_dup(adapter, "target_url");
  if (target_url != NULL && target_url[0] != '\0') {
    return target_url;
  }
  free(target_url);
  target_url_env = native_json_obj_get_string_dup(adapter, "target_url_env");
  if (target_url_env != NULL && target_url_env[0] != '\0') {
    const char *env_value = getenv(target_url_env);
    free(target_url_env);
    if (env_value != NULL && env_value[0] != '\0') {
      return strdup(env_value);
    }
    return NULL;
  }
  free(target_url_env);
  return NULL;
}
 
static int parse_http_url_logic_local(const char *url, ParsedHttpUrlLogicLocal *parsed) {
  const char *remainder = NULL;
  const char *slash = NULL;
  const char *colon = NULL;
  size_t host_len = 0;
  if (parsed == NULL) {
    return 0;
  }
  memset(parsed, 0, sizeof(*parsed));
  if (url == NULL || strncmp(url, "http://", 7) != 0) {
    return 0;
  }
  parsed->scheme = strdup("http");
  remainder = url + 7;
  slash = strchr(remainder, '/');
  if (slash == NULL) {
    slash = remainder + strlen(remainder);
    parsed->path = strdup("/");
  } else {
    parsed->path = strdup(slash[0] != '\0' ? slash : "/");
  }
  colon = NULL;
  {
    const char *cursor = remainder;
    while (cursor < slash) {
      if (*cursor == ':') {
        colon = cursor;
      }
      cursor++;
    }
  }
  if (colon != NULL) {
    host_len = (size_t)(colon - remainder);
    parsed->port = atoi(colon + 1);
  } else {
    host_len = (size_t)(slash - remainder);
    parsed->port = 80;
  }
  parsed->host = dup_range(remainder, host_len);
  if (parsed->scheme == NULL || parsed->host == NULL || parsed->path == NULL || parsed->host[0] == '\0' || parsed->port <= 0) {
    free_parsed_http_url_logic_local(parsed);
    return 0;
  }
  return 1;
}
 
static int append_bytes_logic_local(char **buffer, size_t *length, size_t *capacity, const char *chunk, size_t chunk_len) {
  char *grown = NULL;
  size_t needed = 0;
  if (buffer == NULL || length == NULL || capacity == NULL || chunk == NULL) {
    return 0;
  }
  needed = *length + chunk_len + 1;
  if (needed > *capacity) {
    size_t next_capacity = *capacity == 0 ? 1024 : *capacity;
    while (next_capacity < needed) {
      next_capacity *= 2;
    }
    grown = (char *)realloc(*buffer, next_capacity);
    if (grown == NULL) {
      return 0;
    }
    *buffer = grown;
    *capacity = next_capacity;
  }
  memcpy(*buffer + *length, chunk, chunk_len);
  *length += chunk_len;
  (*buffer)[*length] = '\0';
  return 1;
}
 
static int outbound_http_post_logic_local(
  const char *target_url,
  const char *content_type,
  const char *payload_json,
  OutboundHttpResultLogicLocal *result
) {
  ParsedHttpUrlLogicLocal parsed;
  struct addrinfo hints;
  struct addrinfo *records = NULL;
  struct addrinfo *current = NULL;
  char port_text[16];
  char *request = NULL;
  size_t request_length = 0;
  int fd = -1;
  int connected = 0;
  char response_chunk[4096];
  char *response_text = NULL;
  size_t response_length = 0;
  size_t response_capacity = 0;
  if (result == NULL) {
    return 0;
  }
  memset(result, 0, sizeof(*result));
  if (!parse_http_url_logic_local(target_url, &parsed)) {
    result->error_message = strdup("unsupported_target_url");
    return 0;
  }
  snprintf(port_text, sizeof(port_text), "%d", parsed.port);
  memset(&hints, 0, sizeof(hints));
  hints.ai_family = AF_UNSPEC;
  hints.ai_socktype = SOCK_STREAM;
  if (getaddrinfo(parsed.host, port_text, &hints, &records) != 0) {
    free_parsed_http_url_logic_local(&parsed);
    result->error_message = strdup("resolve_failed");
    return 0;
  }
  for (current = records; current != NULL; current = current->ai_next) {
    fd = socket(current->ai_family, current->ai_socktype, current->ai_protocol);
    if (fd < 0) {
      continue;
    }
#ifndef _WIN32
    {
      struct timeval timeout;
      timeout.tv_sec = 10;
      timeout.tv_usec = 0;
      setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
      setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout));
    }
#endif
    if (connect(fd, current->ai_addr, current->ai_addrlen) == 0) {
      connected = 1;
      break;
    }
#ifndef _WIN32
    close(fd);
#else
    closesocket(fd);
#endif
    fd = -1;
  }
  freeaddrinfo(records);
  if (!connected || fd < 0) {
    free_parsed_http_url_logic_local(&parsed);
    result->error_message = strdup("connect_failed");
    return 0;
  }
  {
    size_t needed = strlen(parsed.path) + strlen(parsed.host) + strlen(content_type != NULL ? content_type : "application/json")
      + strlen(payload_json != NULL ? payload_json : "{}") + 256;
    request = (char *)malloc(needed);
    if (request == NULL) {
#ifndef _WIN32
      close(fd);
#else
      closesocket(fd);
#endif
      free_parsed_http_url_logic_local(&parsed);
      result->error_message = strdup("allocation_failed");
      return 0;
    }
    request_length = (size_t)snprintf(
      request,
      needed,
      "POST %s HTTP/1.1\r\nHost: %s\r\nContent-Type: %s\r\nContent-Length: %zu\r\nConnection: close\r\n\r\n%s",
      parsed.path,
      parsed.host,
      content_type != NULL ? content_type : "application/json",
      strlen(payload_json != NULL ? payload_json : "{}"),
      payload_json != NULL ? payload_json : "{}"
    );
  }
  if (request == NULL) {
#ifndef _WIN32
    close(fd);
#else
    closesocket(fd);
#endif
    free_parsed_http_url_logic_local(&parsed);
    result->error_message = strdup("request_build_failed");
    return 0;
  }
  {
    size_t sent = 0;
    while (sent < request_length) {
      ssize_t wrote = send(fd, request + sent, request_length - sent, 0);
      if (wrote <= 0) {
        free(request);
#ifndef _WIN32
        close(fd);
#else
        closesocket(fd);
#endif
        free_parsed_http_url_logic_local(&parsed);
        free(response_text);
        result->error_message = strdup("send_failed");
        return 0;
      }
      sent += (size_t)wrote;
    }
  }
  free(request);
  while (1) {
    ssize_t read_count = recv(fd, response_chunk, sizeof(response_chunk), 0);
    if (read_count == 0) {
      break;
    }
    if (read_count < 0) {
      free(response_text);
#ifndef _WIN32
      close(fd);
#else
      closesocket(fd);
#endif
      free_parsed_http_url_logic_local(&parsed);
      result->error_message = strdup("recv_failed");
      return 0;
    }
    if (!append_bytes_logic_local(&response_text, &response_length, &response_capacity, response_chunk, (size_t)read_count)) {
      free(response_text);
#ifndef _WIN32
      close(fd);
#else
      closesocket(fd);
#endif
      free_parsed_http_url_logic_local(&parsed);
      result->error_message = strdup("response_buffer_failed");
      return 0;
    }
  }
#ifndef _WIN32
  close(fd);
#else
  closesocket(fd);
#endif
  free_parsed_http_url_logic_local(&parsed);
  if (response_text != NULL) {
    char *body_start = strstr(response_text, "\r\n\r\n");
    char *status_line_end = strstr(response_text, "\r\n");
    if (status_line_end != NULL) {
      char *first_space = strchr(response_text, ' ');
      if (first_space != NULL) {
        result->http_status = strtol(first_space + 1, NULL, 10);
      }
    }
    if (body_start != NULL) {
      result->response_body = strdup(body_start + 4);
    } else {
      result->response_body = strdup("");
    }
  }
  result->ok = result->http_status >= 200 && result->http_status < 300;
  if (!result->ok && result->error_message == NULL) {
    char buffer[64];
    snprintf(buffer, sizeof(buffer), "http_%ld", result->http_status);
    result->error_message = strdup(buffer);
  }
  free(response_text);
  return result->ok ? 1 : 0;
}
 
static char *effect_payload_json_dup_logic_local(
  const char *action_id,
  const char *adapter_id,
  const char *resource_id,
  const char *replay_trace_id,
  const char *created_at
) {
  yyjson_mut_doc *doc = yyjson_mut_doc_new(NULL);
  yyjson_mut_val *root = yyjson_mut_obj(doc);
  char *result = NULL;
  if (doc == NULL || root == NULL) {
    yyjson_mut_doc_free(doc);
    return NULL;
  }
  if (!yyjson_mut_obj_add_strcpy(doc, root, "action_id", action_id != NULL ? action_id : "")
      || !yyjson_mut_obj_add_strcpy(doc, root, "adapter_id", adapter_id != NULL ? adapter_id : "")
      || !yyjson_mut_obj_add_strcpy(doc, root, "resource_id", resource_id != NULL ? resource_id : "")
      || !yyjson_mut_obj_add_strcpy(doc, root, "replay_trace_id", replay_trace_id != NULL ? replay_trace_id : "")
      || !yyjson_mut_obj_add_strcpy(doc, root, "created_at", created_at != NULL ? created_at : "")) {
    yyjson_mut_doc_free(doc);
    return NULL;
  }
  yyjson_mut_doc_set_root(doc, root);
  result = yyjson_mut_write(doc, YYJSON_WRITE_NOFLAG, NULL);
  yyjson_mut_doc_free(doc);
  return result;
}
 
static int append_job_attempt_logic_local(
  yyjson_mut_doc *mut_doc,
  yyjson_mut_val *mut_root,
  long job_execution_id,
  const char *execution_status,
  const char *payload_json,
  const char *created_at,
  const char *error_message
) {
  yyjson_mut_val *attempts = ensure_mut_array_field_logic_local(mut_doc, mut_root, "job_execution_attempts");
  yyjson_mut_val *attempt = yyjson_mut_obj(mut_doc);
  long attempt_id = next_section_id_logic_local(mut_root, "job_execution_attempts");
  yyjson_doc *payload_doc = payload_json != NULL ? native_json_doc_load_text(payload_json) : NULL;
  yyjson_val *payload_root = payload_doc != NULL ? yyjson_doc_get_root(payload_doc) : NULL;
  int ok = attempts != NULL && attempt != NULL
    && yyjson_mut_obj_add_int(mut_doc, attempt, "id", attempt_id)
    && yyjson_mut_obj_add_int(mut_doc, attempt, "job_execution_id", job_execution_id)
    && yyjson_mut_obj_add_int(mut_doc, attempt, "attempt_number", 1)
    && yyjson_mut_obj_add_strcpy(mut_doc, attempt, "execution_status", execution_status != NULL ? execution_status : "succeeded")
    && yyjson_mut_obj_add_strcpy(mut_doc, attempt, "error_message", error_message != NULL ? error_message : "")
    && yyjson_mut_obj_add_strcpy(mut_doc, attempt, "started_at", created_at != NULL ? created_at : "")
    && yyjson_mut_obj_add_strcpy(mut_doc, attempt, "finished_at", created_at != NULL ? created_at : "")
    && (payload_root == NULL || yyjson_mut_obj_put(attempt, yyjson_mut_strcpy(mut_doc, "payload_json"), yyjson_val_mut_copy(mut_doc, payload_root)))
    && yyjson_mut_arr_append(attempts, attempt);
  native_json_doc_free(payload_doc);
  return ok;
}
 
static int process_webhook_delivery_logic_local(
  yyjson_mut_doc *mut_doc,
  yyjson_mut_val *mut_root,
  yyjson_mut_val *delivery,
  const char *created_at,
  const char *payload_json
) {
  yyjson_mut_val *attempts = ensure_mut_array_field_logic_local(mut_doc, mut_root, "integration_delivery_attempts");
  yyjson_mut_val *attempt = yyjson_mut_obj(mut_doc);
  long attempt_id = next_section_id_logic_local(mut_root, "integration_delivery_attempts");
  char next_attempt_at[20];
  long delivery_id = 0;
  long attempt_count = 0;
  long max_attempts = 0;
  long backoff_seconds = 0;
  char *target_url = NULL;
  char *delivery_status = NULL;
  char *error_message = NULL;
  OutboundHttpResultLogicLocal result;
  memset(&result, 0, sizeof(result));
  if (delivery == NULL || attempts == NULL || attempt == NULL) {
    return 0;
  }
  delivery_id = (long)yyjson_get_sint((yyjson_val *)yyjson_mut_obj_get(delivery, "id"));
  attempt_count = native_json_obj_get_long_default((yyjson_val *)delivery, "attempt_count", 0, NULL) + 1;
  max_attempts = native_json_obj_get_long_default((yyjson_val *)delivery, "max_attempts", 1, NULL);
  backoff_seconds = native_json_obj_get_long_default((yyjson_val *)delivery, "backoff_seconds", 5, NULL);
  target_url = native_json_obj_get_string_dup((yyjson_val *)delivery, "target_url");
  if (target_url != NULL && outbound_http_post_logic_local(target_url, "application/json", payload_json, &result)) {
    delivery_status = strdup("succeeded");
  } else if (attempt_count < max_attempts) {
    delivery_status = strdup("retryable");
  } else {
    delivery_status = strdup("failed");
  }
  error_message = result.error_message != NULL ? strdup(result.error_message) : strdup("");
  if (!now_plus_seconds_iso_utc_logic_local(backoff_seconds, next_attempt_at)) {
    snprintf(next_attempt_at, sizeof(next_attempt_at), "%s", created_at != NULL ? created_at : "");
  }
  if (delivery_status == NULL || error_message == NULL
      || !yyjson_mut_obj_add_int(mut_doc, attempt, "id", attempt_id)
      || !yyjson_mut_obj_add_int(mut_doc, attempt, "delivery_id", delivery_id)
      || !yyjson_mut_obj_add_strcpy(mut_doc, attempt, "attempt_status", result.ok ? "succeeded" : "failed")
      || !yyjson_mut_obj_add_int(mut_doc, attempt, "http_status", result.http_status)
      || !yyjson_mut_obj_add_strcpy(mut_doc, attempt, "error_message", error_message)
      || !yyjson_mut_obj_add_strcpy(mut_doc, attempt, "response_body", result.response_body != NULL ? result.response_body : "")
      || !yyjson_mut_obj_add_strcpy(mut_doc, attempt, "started_at", created_at != NULL ? created_at : "")
      || !yyjson_mut_obj_add_strcpy(mut_doc, attempt, "finished_at", created_at != NULL ? created_at : "")
      || !yyjson_mut_arr_append(attempts, attempt)
      || !set_mut_object_field_logic_local(mut_doc, delivery, "delivery_status", yyjson_mut_strcpy(mut_doc, delivery_status))
      || !set_mut_object_field_logic_local(mut_doc, delivery, "attempt_count", yyjson_mut_int(mut_doc, attempt_count))
      || !set_mut_object_field_logic_local(mut_doc, delivery, "last_http_status", yyjson_mut_int(mut_doc, result.http_status))
      || !set_mut_object_field_logic_local(mut_doc, delivery, "last_error", yyjson_mut_strcpy(mut_doc, error_message))
      || !set_mut_object_field_logic_local(mut_doc, delivery, "updated_at", yyjson_mut_strcpy(mut_doc, created_at != NULL ? created_at : ""))
      || !set_mut_object_field_logic_local(mut_doc, delivery, "next_attempt_at", yyjson_mut_strcpy(mut_doc, streq(delivery_status, "retryable") ? next_attempt_at : ""))
      || !set_mut_object_field_logic_local(mut_doc, delivery, "completed_at", yyjson_mut_strcpy(mut_doc, streq(delivery_status, "succeeded") ? (created_at != NULL ? created_at : "") : ""))) {
    free(target_url);
    free(delivery_status);
    free(error_message);
    free_outbound_http_result_logic_local(&result);
    return 0;
  }
  free(target_url);
  free(delivery_status);
  free(error_message);
  free_outbound_http_result_logic_local(&result);
  return 1;
}
 
static int process_due_integration_deliveries_logic_local(
  yyjson_mut_doc *mut_doc,
  yyjson_mut_val *mut_root,
  const char *created_at,
  const char *payload_json
) {
  yyjson_mut_val *deliveries = ensure_mut_array_field_logic_local(mut_doc, mut_root, "integration_deliveries");
  size_t index = 0;
  size_t max = 0;
  yyjson_mut_val *delivery = NULL;
  if (deliveries == NULL) {
    return 0;
  }
  yyjson_mut_arr_foreach(deliveries, index, max, delivery) {
    char *status = native_json_obj_get_string_dup((yyjson_val *)delivery, "delivery_status");
    char *next_attempt_at = native_json_obj_get_string_dup((yyjson_val *)delivery, "next_attempt_at");
    int due = 0;
    if (status != NULL && (streq(status, "queued") || streq(status, "retryable"))) {
      if (next_attempt_at == NULL || next_attempt_at[0] == '\0' || created_at == NULL || strcmp(next_attempt_at, created_at) <= 0) {
        due = 1;
      }
    }
    free(status);
    free(next_attempt_at);
    if (!due) {
      continue;
    }
    if (!process_webhook_delivery_logic_local(mut_doc, mut_root, delivery, created_at, payload_json)) {
      return 0;
    }
  }
  return 1;
}
 
static int append_action_report_logic_local(
  yyjson_mut_doc *mut_doc,
  yyjson_mut_val *mut_root,
  yyjson_val *action_contract,
  yyjson_val *workflow,
  yyjson_val *transition,
  const ActionExecutionContextLogicLocal *context,
  const ActionEffectCountsLogicLocal *effect_counts,
  const char *resource_id,
  const char *from_state,
  const char *to_state,
  const char *created_at,
  const char *policy_gate,
  const char *success_message,
  const char *operator_summary,
  const char *transition_label,
  const char *from_state_label,
  const char *to_state_label,
  long workflow_execution_id,
  long created_record_id,
  char **report_json_out,
  char **replay_trace_id_out
) {
  yyjson_mut_val *action_reports = NULL;
  yyjson_mut_val *report = NULL;
  char *action_id = native_json_obj_get_string_dup(action_contract, "action_id");
  char *workflow_id = workflow != NULL ? native_json_obj_get_string_dup(workflow, "workflow_id") : NULL;
  char *transition_id = transition != NULL ? native_json_obj_get_string_dup(transition, "transition_id") : NULL;
  char *event_name = transition != NULL ? native_json_obj_get_string_dup(transition, "emits_event") : NULL;
  char replay_trace_buffer[256];
  if (report_json_out != NULL) {
    *report_json_out = NULL;
  }
  if (replay_trace_id_out != NULL) {
    *replay_trace_id_out = NULL;
  }
  action_reports = ensure_mut_array_field_logic_local(mut_doc, mut_root, "action_reports");
  report = yyjson_mut_obj(mut_doc);
  if (action_reports == NULL || report == NULL || action_id == NULL) {
    free(action_id);
    free(workflow_id);
    free(transition_id);
    free(event_name);
    return 0;
  }
  snprintf(replay_trace_buffer, sizeof(replay_trace_buffer), "trace:%s:%s:%ld", action_id, resource_id != NULL ? resource_id : "resource", workflow_execution_id);
  if (replay_trace_id_out != NULL) {
    *replay_trace_id_out = strdup(replay_trace_buffer);
  }
  if (!yyjson_mut_obj_add_strcpy(mut_doc, report, "report_id", "pharos-action-execution-v2")
      || !yyjson_mut_obj_add_strcpy(mut_doc, report, "action_id", action_id)
      || !yyjson_mut_obj_add_strcpy(mut_doc, report, "policy_gate", policy_gate != NULL ? policy_gate : "public")
      || !yyjson_mut_obj_add_strcpy(mut_doc, report, "resource_id", resource_id != NULL ? resource_id : "")
      || !yyjson_mut_obj_add_strcpy(mut_doc, report, "from_state", from_state != NULL ? from_state : "none")
      || !yyjson_mut_obj_add_strcpy(mut_doc, report, "to_state", to_state != NULL ? to_state : "applied")
      || !yyjson_mut_obj_add_int(mut_doc, report, "workflow_execution_id", workflow_execution_id)
      || !yyjson_mut_obj_add_int(mut_doc, report, "created_record_id", created_record_id)
      || !yyjson_mut_obj_add_strcpy(mut_doc, report, "created_at", created_at != NULL ? created_at : "")
      || !yyjson_mut_obj_add_strcpy(mut_doc, report, "replay_trace_id", replay_trace_buffer)
      || !yyjson_mut_obj_add_strcpy(mut_doc, report, "workflow_id", workflow_id != NULL ? workflow_id : "")
      || !yyjson_mut_obj_add_strcpy(mut_doc, report, "transition_id", transition_id != NULL ? transition_id : "")
      || !yyjson_mut_obj_add_strcpy(mut_doc, report, "event_name", event_name != NULL ? event_name : "")
      || !yyjson_mut_obj_add_int(mut_doc, report, "anchor_record_id", context != NULL ? context->anchor_record_id : 0)
      || !yyjson_mut_obj_add_int(mut_doc, report, "last_created_record_id", context != NULL ? context->last_created_record_id : 0)
      || !yyjson_mut_obj_add_int(mut_doc, report, "last_touched_record_id", context != NULL ? context->last_touched_record_id : 0)
      || !yyjson_mut_obj_add_int(mut_doc, report, "created_record_count", context != NULL ? context->created_record_count : 0)
      || !yyjson_mut_obj_add_int(mut_doc, report, "updated_record_count", context != NULL ? context->updated_record_count : 0)
      || !yyjson_mut_obj_add_int(mut_doc, report, "matched_record_count", context != NULL ? context->matched_record_count : 0)
      || !yyjson_mut_obj_add_int(mut_doc, report, "skipped_record_count", context != NULL ? context->skipped_record_count : 0)
      || !yyjson_mut_obj_add_strcpy(mut_doc, report, "overflow_policy", context != NULL && context->overflow_policy != NULL ? context->overflow_policy : "")
      || !yyjson_mut_obj_add_strcpy(mut_doc, report, "operator_message", success_message != NULL ? success_message : "")
      || !yyjson_mut_obj_add_strcpy(mut_doc, report, "operator_summary", operator_summary != NULL ? operator_summary : "")
      || !yyjson_mut_obj_add_strcpy(mut_doc, report, "transition_label", transition_label != NULL ? transition_label : "")
      || !yyjson_mut_obj_add_strcpy(mut_doc, report, "from_state_label", from_state_label != NULL ? from_state_label : (from_state != NULL ? from_state : "none"))
      || !yyjson_mut_obj_add_strcpy(mut_doc, report, "to_state_label", to_state_label != NULL ? to_state_label : (to_state != NULL ? to_state : "applied"))
      || !yyjson_mut_obj_add_int(mut_doc, report, "queued_job_count", effect_counts != NULL ? effect_counts->job_count : 0)
      || !yyjson_mut_obj_add_int(mut_doc, report, "queued_webhook_count", effect_counts != NULL ? effect_counts->webhook_count : 0)
      || !yyjson_mut_obj_add_int(mut_doc, report, "queued_notification_count", effect_counts != NULL ? effect_counts->notification_count : 0)
      || !yyjson_mut_arr_append(action_reports, report)) {
    free(action_id);
    free(workflow_id);
    free(transition_id);
    free(event_name);
    return 0;
  }
  {
    yyjson_mut_val *summary = yyjson_mut_obj(mut_doc);
    if (summary == NULL
        || !yyjson_mut_obj_add_strcpy(mut_doc, summary, "action_id", action_id)
        || !yyjson_mut_obj_add_strcpy(mut_doc, summary, "policy_gate", policy_gate != NULL ? policy_gate : "public")
        || !yyjson_mut_obj_add_strcpy(mut_doc, summary, "resource_id", resource_id != NULL ? resource_id : "")
        || !yyjson_mut_obj_add_strcpy(mut_doc, summary, "from_state", from_state != NULL ? from_state : "none")
        || !yyjson_mut_obj_add_strcpy(mut_doc, summary, "to_state", to_state != NULL ? to_state : "applied")
        || !yyjson_mut_obj_add_int(mut_doc, summary, "workflow_execution_id", workflow_execution_id)
        || !yyjson_mut_obj_add_int(mut_doc, summary, "created_record_id", created_record_id)
        || !yyjson_mut_obj_add_strcpy(mut_doc, summary, "created_at", created_at != NULL ? created_at : "")
        || !yyjson_mut_obj_add_strcpy(mut_doc, summary, "replay_trace_id", replay_trace_buffer)
        || !yyjson_mut_obj_add_strcpy(mut_doc, summary, "workflow_id", workflow_id != NULL ? workflow_id : "")
        || !yyjson_mut_obj_add_strcpy(mut_doc, summary, "transition_id", transition_id != NULL ? transition_id : "")
        || !yyjson_mut_obj_add_strcpy(mut_doc, summary, "event_name", event_name != NULL ? event_name : "")
        || !yyjson_mut_obj_add_int(mut_doc, summary, "anchor_record_id", context != NULL ? context->anchor_record_id : 0)
        || !yyjson_mut_obj_add_int(mut_doc, summary, "last_created_record_id", context != NULL ? context->last_created_record_id : 0)
        || !yyjson_mut_obj_add_int(mut_doc, summary, "last_touched_record_id", context != NULL ? context->last_touched_record_id : 0)
        || !yyjson_mut_obj_add_int(mut_doc, summary, "created_record_count", context != NULL ? context->created_record_count : 0)
        || !yyjson_mut_obj_add_int(mut_doc, summary, "updated_record_count", context != NULL ? context->updated_record_count : 0)
        || !yyjson_mut_obj_add_int(mut_doc, summary, "matched_record_count", context != NULL ? context->matched_record_count : 0)
        || !yyjson_mut_obj_add_int(mut_doc, summary, "skipped_record_count", context != NULL ? context->skipped_record_count : 0)
        || !yyjson_mut_obj_add_strcpy(mut_doc, summary, "overflow_policy", context != NULL && context->overflow_policy != NULL ? context->overflow_policy : "")
        || !yyjson_mut_obj_add_strcpy(mut_doc, summary, "operator_message", success_message != NULL ? success_message : "")
        || !yyjson_mut_obj_add_strcpy(mut_doc, summary, "operator_summary", operator_summary != NULL ? operator_summary : "")
        || !yyjson_mut_obj_add_strcpy(mut_doc, summary, "transition_label", transition_label != NULL ? transition_label : "")
        || !yyjson_mut_obj_add_strcpy(mut_doc, summary, "from_state_label", from_state_label != NULL ? from_state_label : (from_state != NULL ? from_state : "none"))
        || !yyjson_mut_obj_add_strcpy(mut_doc, summary, "to_state_label", to_state_label != NULL ? to_state_label : (to_state != NULL ? to_state : "applied"))
        || !yyjson_mut_obj_add_int(mut_doc, summary, "queued_job_count", effect_counts != NULL ? effect_counts->job_count : 0)
        || !yyjson_mut_obj_add_int(mut_doc, summary, "queued_webhook_count", effect_counts != NULL ? effect_counts->webhook_count : 0)
        || !yyjson_mut_obj_add_int(mut_doc, summary, "queued_notification_count", effect_counts != NULL ? effect_counts->notification_count : 0)
        || !set_mut_object_field_logic_local(mut_doc, mut_root, "last_action_report", summary)) {
      free(action_id);
      free(workflow_id);
      free(transition_id);
      free(event_name);
      return 0;
    }
    if (report_json_out != NULL) {
      size_t needed = strlen(action_id) + strlen(policy_gate != NULL ? policy_gate : "public")
        + strlen(resource_id != NULL ? resource_id : "") + strlen(from_state != NULL ? from_state : "none")
        + strlen(to_state != NULL ? to_state : "applied") + strlen(replay_trace_buffer)
        + strlen(workflow_id != NULL ? workflow_id : "") + strlen(transition_id != NULL ? transition_id : "")
        + strlen(event_name != NULL ? event_name : "") + strlen(created_at != NULL ? created_at : "")
        + strlen(success_message != NULL ? success_message : "") + strlen(operator_summary != NULL ? operator_summary : "")
        + strlen(transition_label != NULL ? transition_label : "")
        + strlen(from_state_label != NULL ? from_state_label : (from_state != NULL ? from_state : "none"))
        + strlen(to_state_label != NULL ? to_state_label : (to_state != NULL ? to_state : "applied")) + 896;
      *report_json_out = (char *)malloc(needed);
      if (*report_json_out == NULL) {
        free(action_id);
        free(workflow_id);
        free(transition_id);
        free(event_name);
        return 0;
      }
      snprintf(
        *report_json_out,
        needed,
        "{\"action_id\":\"%s\",\"policy_gate\":\"%s\",\"resource_id\":\"%s\",\"from_state\":\"%s\",\"to_state\":\"%s\",\"workflow_execution_id\":%ld,\"created_record_id\":%ld,\"created_at\":\"%s\",\"replay_trace_id\":\"%s\",\"workflow_id\":\"%s\",\"transition_id\":\"%s\",\"event_name\":\"%s\",\"anchor_record_id\":%ld,\"last_created_record_id\":%ld,\"last_touched_record_id\":%ld,\"created_record_count\":%ld,\"updated_record_count\":%ld,\"matched_record_count\":%ld,\"skipped_record_count\":%ld,\"overflow_policy\":\"%s\",\"operator_message\":\"%s\",\"operator_summary\":\"%s\",\"transition_label\":\"%s\",\"from_state_label\":\"%s\",\"to_state_label\":\"%s\",\"queued_job_count\":%ld,\"queued_webhook_count\":%ld,\"queued_notification_count\":%ld}",
        action_id,
        policy_gate != NULL ? policy_gate : "public",
        resource_id != NULL ? resource_id : "",
        from_state != NULL ? from_state : "none",
        to_state != NULL ? to_state : "applied",
        workflow_execution_id,
        created_record_id,
        created_at != NULL ? created_at : "",
        replay_trace_buffer,
        workflow_id != NULL ? workflow_id : "",
        transition_id != NULL ? transition_id : "",
        event_name != NULL ? event_name : "",
        context != NULL ? context->anchor_record_id : 0,
        context != NULL ? context->last_created_record_id : 0,
        context != NULL ? context->last_touched_record_id : 0,
        context != NULL ? context->created_record_count : 0,
        context != NULL ? context->updated_record_count : 0,
        context != NULL ? context->matched_record_count : 0,
        context != NULL ? context->skipped_record_count : 0,
        context != NULL && context->overflow_policy != NULL ? context->overflow_policy : "",
        success_message != NULL ? success_message : "",
        operator_summary != NULL ? operator_summary : "",
        transition_label != NULL ? transition_label : "",
        from_state_label != NULL ? from_state_label : (from_state != NULL ? from_state : "none"),
        to_state_label != NULL ? to_state_label : (to_state != NULL ? to_state : "applied"),
        effect_counts != NULL ? effect_counts->job_count : 0,
        effect_counts != NULL ? effect_counts->webhook_count : 0,
        effect_counts != NULL ? effect_counts->notification_count : 0
      );
    }
  }
  free(action_id);
  free(workflow_id);
  free(transition_id);
  free(event_name);
  return 1;
}
 
static int append_workflow_and_effects_logic_local(
  const AppRuntime *app,
  yyjson_mut_doc *mut_doc,
  yyjson_mut_val *mut_root,
  yyjson_val *action_contract,
  yyjson_val *workflow,
  yyjson_val *transition,
  const InputFieldMapLogicLocal *inputs,
  const ActionExecutionContextLogicLocal *context,
  const char *policy_gate,
  const char *resource_id,
  const char *from_state,
  const char *to_state,
  const char *created_at,
  const char *replay_trace_id,
  long *workflow_execution_id_out,
  ActionEffectCountsLogicLocal *effect_counts_out
) {
  yyjson_val *effect_hooks = native_json_obj_get(action_contract, "effect_hooks");
  yyjson_val *jobs = effect_hooks != NULL ? native_json_obj_get(effect_hooks, "scheduled_jobs") : NULL;
  yyjson_val *webhooks = effect_hooks != NULL ? native_json_obj_get(effect_hooks, "webhook_dispatch") : NULL;
  yyjson_val *notifications = effect_hooks != NULL ? native_json_obj_get(effect_hooks, "notifications") : NULL;
  yyjson_mut_val *workflow_executions = ensure_mut_array_field_logic_local(mut_doc, mut_root, "workflow_executions");
  yyjson_mut_val *workflow_events = ensure_mut_array_field_logic_local(mut_doc, mut_root, "workflow_execution_events");
  yyjson_mut_val *job_executions = ensure_mut_array_field_logic_local(mut_doc, mut_root, "job_executions");
  yyjson_mut_val *job_execution_attempts = ensure_mut_array_field_logic_local(mut_doc, mut_root, "job_execution_attempts");
  yyjson_mut_val *webhook_receipts = ensure_mut_array_field_logic_local(mut_doc, mut_root, "webhook_receipts");
  yyjson_mut_val *notification_deliveries = ensure_mut_array_field_logic_local(mut_doc, mut_root, "notification_deliveries");
  yyjson_mut_val *integration_deliveries = ensure_mut_array_field_logic_local(mut_doc, mut_root, "integration_deliveries");
  yyjson_mut_val *integration_delivery_attempts = ensure_mut_array_field_logic_local(mut_doc, mut_root, "integration_delivery_attempts");
  yyjson_mut_val *execution = yyjson_mut_obj(mut_doc);
  yyjson_mut_val *event = yyjson_mut_obj(mut_doc);
  yyjson_arr_iter iter;
  yyjson_val *item = NULL;
  yyjson_doc *integration_doc = load_fixture_doc_logic_local(app, "integration_fixture");
  yyjson_val *integration_root = integration_doc != NULL ? yyjson_doc_get_root(integration_doc) : NULL;
  long workflow_execution_id = next_section_id_logic_local(mut_root, "workflow_executions");
  long workflow_event_id = next_section_id_logic_local(mut_root, "workflow_execution_events");
  long job_id = next_section_id_logic_local(mut_root, "job_executions");
  long webhook_id = next_section_id_logic_local(mut_root, "webhook_receipts");
  long notification_id = next_section_id_logic_local(mut_root, "notification_deliveries");
  long queued_jobs = jobs != NULL && yyjson_is_arr(jobs) ? (long)yyjson_arr_size(jobs) : 0;
  long queued_webhooks = webhooks != NULL && yyjson_is_arr(webhooks) ? (long)yyjson_arr_size(webhooks) : 0;
  long queued_notifications = notifications != NULL && yyjson_is_arr(notifications) ? (long)yyjson_arr_size(notifications) : 0;
  char *workflow_id = workflow != NULL ? native_json_obj_get_string_dup(workflow, "workflow_id") : NULL;
  char *transition_id = transition != NULL ? native_json_obj_get_string_dup(transition, "transition_id") : NULL;
  char *event_name = transition != NULL ? native_json_obj_get_string_dup(transition, "emits_event") : NULL;
  (void)job_execution_attempts;
  (void)integration_delivery_attempts;
  if (workflow_execution_id_out != NULL) {
    *workflow_execution_id_out = 0;
  }
  if (effect_counts_out != NULL) {
    memset(effect_counts_out, 0, sizeof(*effect_counts_out));
  }
  if (workflow_executions == NULL || workflow_events == NULL || job_executions == NULL || job_execution_attempts == NULL || webhook_receipts == NULL || notification_deliveries == NULL || integration_deliveries == NULL || integration_delivery_attempts == NULL || execution == NULL || event == NULL) {
    free(workflow_id);
    free(transition_id);
    free(event_name);
    native_json_doc_free(integration_doc);
    return 0;
  }
  if (!yyjson_mut_obj_add_int(mut_doc, execution, "id", workflow_execution_id)
      || !yyjson_mut_obj_add_strcpy(mut_doc, execution, "workflow_id", workflow_id != NULL ? workflow_id : "framework_action")
      || !yyjson_mut_obj_add_strcpy(mut_doc, execution, "transition_id", transition_id != NULL ? transition_id : "action_applied")
      || !yyjson_mut_obj_add_strcpy(mut_doc, execution, "subject_id", "anonymous_or_session")
      || !yyjson_mut_obj_add_strcpy(mut_doc, execution, "resource_id", resource_id != NULL ? resource_id : "")
      || !yyjson_mut_obj_add_strcpy(mut_doc, execution, "from_state", from_state != NULL ? from_state : "none")
      || !yyjson_mut_obj_add_strcpy(mut_doc, execution, "to_state", to_state != NULL ? to_state : "applied")
      || !yyjson_mut_obj_add_strcpy(mut_doc, execution, "idempotency_key", replay_trace_id != NULL ? replay_trace_id : "")
      || !yyjson_mut_obj_add_strcpy(mut_doc, execution, "replay_trace_id", replay_trace_id != NULL ? replay_trace_id : "")
      || !yyjson_mut_obj_add_strcpy(mut_doc, execution, "policy_gate", policy_gate != NULL ? policy_gate : "public")
      || !yyjson_mut_obj_add_strcpy(mut_doc, execution, "execution_status", "applied")
      || !yyjson_mut_obj_add_int(mut_doc, execution, "executed_by_user_id", 0)
      || !yyjson_mut_obj_add_int(mut_doc, execution, "queued_job_count", queued_jobs)
      || !yyjson_mut_obj_add_int(mut_doc, execution, "queued_webhook_count", queued_webhooks)
      || !yyjson_mut_obj_add_int(mut_doc, execution, "queued_notification_count", queued_notifications)
      || !yyjson_mut_obj_add_strcpy(mut_doc, execution, "created_at", created_at != NULL ? created_at : "")
      || !yyjson_mut_obj_add_strcpy(mut_doc, execution, "completed_at", created_at != NULL ? created_at : "")
      || !yyjson_mut_arr_append(workflow_executions, execution)) {
    free(workflow_id);
    free(transition_id);
    free(event_name);
    return 0;
  }
  if (!yyjson_mut_obj_add_int(mut_doc, event, "id", workflow_event_id)
      || !yyjson_mut_obj_add_int(mut_doc, event, "workflow_execution_id", workflow_execution_id)
      || !yyjson_mut_obj_add_strcpy(mut_doc, event, "event_kind", "transition_applied")
      || !yyjson_mut_obj_add_strcpy(mut_doc, event, "event_key", transition_id != NULL ? transition_id : "action_applied")
      || !yyjson_mut_obj_add_strcpy(mut_doc, event, "created_at", created_at != NULL ? created_at : "")) {
    free(workflow_id);
    free(transition_id);
    free(event_name);
    return 0;
  }
  {
    yyjson_mut_val *payload = yyjson_mut_obj(mut_doc);
    if (payload == NULL
        || !yyjson_mut_obj_add_strcpy(mut_doc, payload, "workflow_id", workflow_id != NULL ? workflow_id : "framework_action")
        || !yyjson_mut_obj_add_strcpy(mut_doc, payload, "transition_id", transition_id != NULL ? transition_id : "action_applied")
        || !yyjson_mut_obj_add_strcpy(mut_doc, payload, "resource_id", resource_id != NULL ? resource_id : "")
        || !yyjson_mut_obj_add_strcpy(mut_doc, payload, "from_state", from_state != NULL ? from_state : "none")
        || !yyjson_mut_obj_add_strcpy(mut_doc, payload, "to_state", to_state != NULL ? to_state : "applied")
        || !yyjson_mut_obj_add_strcpy(mut_doc, payload, "replay_trace_id", replay_trace_id != NULL ? replay_trace_id : "")
        || !yyjson_mut_obj_put(event, yyjson_mut_strcpy(mut_doc, "payload_json"), payload)
        || !yyjson_mut_arr_append(workflow_events, event)) {
      free(workflow_id);
      free(transition_id);
      free(event_name);
      return 0;
    }
  }
  if (event_name != NULL && event_name[0] != '\0') {
    yyjson_mut_val *emitted = yyjson_mut_obj(mut_doc);
    yyjson_mut_val *payload = yyjson_mut_obj(mut_doc);
    if (emitted == NULL || payload == NULL
        || !yyjson_mut_obj_add_int(mut_doc, emitted, "id", workflow_event_id + 1)
        || !yyjson_mut_obj_add_int(mut_doc, emitted, "workflow_execution_id", workflow_execution_id)
        || !yyjson_mut_obj_add_strcpy(mut_doc, emitted, "event_kind", "event_emitted")
        || !yyjson_mut_obj_add_strcpy(mut_doc, emitted, "event_key", event_name)
        || !yyjson_mut_obj_add_strcpy(mut_doc, emitted, "created_at", created_at != NULL ? created_at : "")
        || !yyjson_mut_obj_add_strcpy(mut_doc, payload, "event", event_name)
        || !yyjson_mut_obj_add_strcpy(mut_doc, payload, "resource_id", resource_id != NULL ? resource_id : "")
        || !yyjson_mut_obj_add_strcpy(mut_doc, payload, "replay_trace_id", replay_trace_id != NULL ? replay_trace_id : "")
        || !yyjson_mut_obj_put(emitted, yyjson_mut_strcpy(mut_doc, "payload_json"), payload)
        || !yyjson_mut_arr_append(workflow_events, emitted)) {
      free(workflow_id);
      free(transition_id);
      free(event_name);
      return 0;
    }
    workflow_event_id++;
  }
  if (jobs != NULL && yyjson_is_arr(jobs) && yyjson_arr_iter_init(jobs, &iter)) {
    while ((item = yyjson_arr_iter_next(&iter)) != NULL) {
      const char *job_name = yyjson_is_str(item) ? yyjson_get_str(item) : "job";
      yyjson_mut_val *job = yyjson_mut_obj(mut_doc);
      yyjson_mut_val *job_event = yyjson_mut_obj(mut_doc);
      yyjson_mut_val *job_payload = yyjson_mut_obj(mut_doc);
      if (job == NULL || job_event == NULL || job_payload == NULL
          || !yyjson_mut_obj_add_int(mut_doc, job, "id", job_id)
          || !yyjson_mut_obj_add_int(mut_doc, job, "workflow_execution_id", workflow_execution_id)
          || !yyjson_mut_obj_add_strcpy(mut_doc, job, "queue_name", "default")
          || !yyjson_mut_obj_add_strcpy(mut_doc, job, "job_id", job_name)
          || !yyjson_mut_obj_add_strcpy(mut_doc, job, "handler_id", job_name)
          || !yyjson_mut_obj_add_strcpy(mut_doc, job, "execution_status", "succeeded")
          || !yyjson_mut_obj_add_strcpy(mut_doc, job, "idempotency_key", replay_trace_id != NULL ? replay_trace_id : "")
          || !yyjson_mut_obj_add_strcpy(mut_doc, job, "scheduled_for", created_at != NULL ? created_at : "")
          || !yyjson_mut_obj_add_strcpy(mut_doc, job, "available_at", created_at != NULL ? created_at : "")
          || !yyjson_mut_obj_add_strcpy(mut_doc, job, "claimed_at", created_at != NULL ? created_at : "")
          || !yyjson_mut_obj_add_strcpy(mut_doc, job, "lease_expires_at", created_at != NULL ? created_at : "")
          || !yyjson_mut_obj_add_strcpy(mut_doc, job, "completed_at", created_at != NULL ? created_at : "")
          || !yyjson_mut_obj_add_strcpy(mut_doc, job, "failed_at", "")
          || !yyjson_mut_obj_add_int(mut_doc, job, "attempt_count", 1)
          || !yyjson_mut_obj_add_int(mut_doc, job, "max_attempts", 3)
          || !yyjson_mut_obj_add_int(mut_doc, job, "backoff_seconds", 5)
          || !yyjson_mut_obj_add_strcpy(mut_doc, job, "replay_trace_id", replay_trace_id != NULL ? replay_trace_id : "")
          || !yyjson_mut_obj_add_strcpy(mut_doc, job, "last_error", "")
          || !yyjson_mut_obj_add_strcpy(mut_doc, job, "created_at", created_at != NULL ? created_at : "")
          || !yyjson_mut_arr_append(job_executions, job)
          || !append_job_attempt_logic_local(mut_doc, mut_root, job_id, "succeeded", "{}", created_at, "")
          || !yyjson_mut_obj_add_int(mut_doc, job_event, "id", workflow_event_id + 1)
          || !yyjson_mut_obj_add_int(mut_doc, job_event, "workflow_execution_id", workflow_execution_id)
          || !yyjson_mut_obj_add_strcpy(mut_doc, job_event, "event_kind", "job_queued")
          || !yyjson_mut_obj_add_strcpy(mut_doc, job_event, "event_key", job_name)
          || !yyjson_mut_obj_add_strcpy(mut_doc, job_event, "created_at", created_at != NULL ? created_at : "")
          || !yyjson_mut_obj_add_strcpy(mut_doc, job_payload, "job_id", job_name)
          || !yyjson_mut_obj_add_strcpy(mut_doc, job_payload, "resource_id", resource_id != NULL ? resource_id : "")
          || !yyjson_mut_obj_add_strcpy(mut_doc, job_payload, "replay_trace_id", replay_trace_id != NULL ? replay_trace_id : "")
          || !yyjson_mut_obj_add_int(mut_doc, job_payload, "max_attempts", 3)
          || !yyjson_mut_obj_add_int(mut_doc, job_payload, "backoff_seconds", 5)
          || !yyjson_mut_obj_put(job_event, yyjson_mut_strcpy(mut_doc, "payload_json"), job_payload)
          || !yyjson_mut_arr_append(workflow_events, job_event)) {
        free(workflow_id);
        free(transition_id);
        free(event_name);
        return 0;
      }
      if (effect_counts_out != NULL) {
        effect_counts_out->job_count++;
      }
      job_id++;
      workflow_event_id++;
    }
  }
  if (webhooks != NULL && yyjson_is_arr(webhooks) && yyjson_arr_iter_init(webhooks, &iter)) {
    while ((item = yyjson_arr_iter_next(&iter)) != NULL) {
      const char *adapter_id = yyjson_is_str(item) ? yyjson_get_str(item) : "webhook";
      yyjson_mut_val *receipt = yyjson_mut_obj(mut_doc);
      yyjson_val *adapter = find_integration_adapter_logic_local(integration_root, adapter_id);
      char *target_url = integration_adapter_target_url_dup_logic_local(adapter);
      char *payload_json = effect_payload_json_dup_logic_local(yyjson_get_str(native_json_obj_get(action_contract, "action_id")), adapter_id, resource_id, replay_trace_id, created_at);
      long delivery_id = next_section_id_logic_local(mut_root, "integration_deliveries");
      yyjson_mut_val *integration_delivery = yyjson_mut_obj(mut_doc);
      if (receipt == NULL || integration_delivery == NULL || payload_json == NULL
          || !yyjson_mut_obj_add_int(mut_doc, receipt, "id", webhook_id)
          || !yyjson_mut_obj_add_strcpy(mut_doc, receipt, "adapter_id", adapter_id)
          || !yyjson_mut_obj_add_strcpy(mut_doc, receipt, "delivery_status", "queued")
          || !yyjson_mut_obj_add_strcpy(mut_doc, receipt, "resource_id", resource_id != NULL ? resource_id : "")
          || !yyjson_mut_obj_add_strcpy(mut_doc, receipt, "replay_trace_id", replay_trace_id != NULL ? replay_trace_id : "")
          || !yyjson_mut_obj_add_strcpy(mut_doc, receipt, "created_at", created_at != NULL ? created_at : "")
          || !yyjson_mut_arr_append(webhook_receipts, receipt)
          || !yyjson_mut_obj_add_int(mut_doc, integration_delivery, "id", delivery_id)
          || !yyjson_mut_obj_add_strcpy(mut_doc, integration_delivery, "adapter_id", adapter_id)
          || !yyjson_mut_obj_add_strcpy(mut_doc, integration_delivery, "target_url", target_url != NULL ? target_url : "")
          || !yyjson_mut_obj_add_strcpy(mut_doc, integration_delivery, "resource_id", resource_id != NULL ? resource_id : "")
          || !yyjson_mut_obj_add_strcpy(mut_doc, integration_delivery, "delivery_status", "queued")
          || !yyjson_mut_obj_add_int(mut_doc, integration_delivery, "attempt_count", 0)
          || !yyjson_mut_obj_add_int(mut_doc, integration_delivery, "max_attempts", adapter != NULL ? native_json_obj_get_long_default(adapter, "max_attempts", 3, NULL) : 3)
          || !yyjson_mut_obj_add_int(mut_doc, integration_delivery, "backoff_seconds", adapter != NULL ? native_json_obj_get_long_default(adapter, "backoff_seconds", 5, NULL) : 5)
          || !yyjson_mut_obj_add_int(mut_doc, integration_delivery, "timeout_seconds", adapter != NULL ? native_json_obj_get_long_default(adapter, "timeout_seconds", 10, NULL) : 10)
          || !yyjson_mut_obj_add_strcpy(mut_doc, integration_delivery, "last_error", "")
          || !yyjson_mut_obj_add_int(mut_doc, integration_delivery, "last_http_status", 0)
          || !yyjson_mut_obj_add_strcpy(mut_doc, integration_delivery, "next_attempt_at", created_at != NULL ? created_at : "")
          || !yyjson_mut_obj_add_strcpy(mut_doc, integration_delivery, "created_at", created_at != NULL ? created_at : "")
          || !yyjson_mut_obj_add_strcpy(mut_doc, integration_delivery, "updated_at", created_at != NULL ? created_at : "")
          || !yyjson_mut_obj_add_strcpy(mut_doc, integration_delivery, "completed_at", "")
          || !yyjson_mut_arr_append(integration_deliveries, integration_delivery)) {
        free(target_url);
        free(payload_json);
        free(workflow_id);
        free(transition_id);
        free(event_name);
        native_json_doc_free(integration_doc);
        return 0;
      }
      free(target_url);
      free(payload_json);
      if (effect_counts_out != NULL) {
        effect_counts_out->webhook_count++;
      }
      webhook_id++;
    }
  }
  if (notifications != NULL && yyjson_is_arr(notifications) && yyjson_arr_iter_init(notifications, &iter)) {
    while ((item = yyjson_arr_iter_next(&iter)) != NULL) {
      char *adapter_id = NULL;
      char *channel = NULL;
      char *recipient = NULL;
      char *template_id = NULL;
      yyjson_mut_val *delivery = yyjson_mut_obj(mut_doc);
      yyjson_mut_val *notification_event = yyjson_mut_obj(mut_doc);
      yyjson_mut_val *notification_payload = yyjson_mut_obj(mut_doc);
      if (yyjson_is_str(item)) {
        adapter_id = strdup(yyjson_get_str(item));
      } else if (yyjson_is_obj(item)) {
        adapter_id = native_json_obj_get_string_dup(item, "adapter_id");
        channel = native_json_obj_get_string_dup(item, "channel");
        recipient = string_value_from_contract_logic_local(native_json_obj_get(item, "recipient"), inputs, context, NULL, NULL);
        template_id = string_value_from_contract_logic_local(native_json_obj_get(item, "template_id"), inputs, context, NULL, NULL);
      }
      if (adapter_id == NULL) {
        adapter_id = strdup("notification");
      }
      if (channel == NULL) {
        channel = strdup("generic");
      }
      if (recipient == NULL) {
        recipient = strdup("");
      }
      if (template_id == NULL) {
        template_id = strdup("");
      }
      if (delivery == NULL || notification_event == NULL || notification_payload == NULL
          || adapter_id == NULL || channel == NULL || recipient == NULL || template_id == NULL
          || !yyjson_mut_obj_add_int(mut_doc, delivery, "id", notification_id)
          || !yyjson_mut_obj_add_int(mut_doc, delivery, "workflow_execution_id", workflow_execution_id)
          || !yyjson_mut_obj_add_strcpy(mut_doc, delivery, "adapter_id", adapter_id)
          || !yyjson_mut_obj_add_strcpy(mut_doc, delivery, "channel", channel)
          || !yyjson_mut_obj_add_strcpy(mut_doc, delivery, "recipient", recipient)
          || !yyjson_mut_obj_add_strcpy(mut_doc, delivery, "template_id", template_id)
          || !yyjson_mut_obj_add_strcpy(mut_doc, delivery, "delivery_status", "succeeded")
          || !yyjson_mut_obj_add_strcpy(mut_doc, delivery, "resource_id", resource_id != NULL ? resource_id : "")
          || !yyjson_mut_obj_add_strcpy(mut_doc, delivery, "replay_trace_id", replay_trace_id != NULL ? replay_trace_id : "")
          || !yyjson_mut_obj_add_strcpy(mut_doc, delivery, "created_at", created_at != NULL ? created_at : "")
          || !yyjson_mut_obj_add_strcpy(mut_doc, delivery, "delivered_at", created_at != NULL ? created_at : "")
          || !yyjson_mut_arr_append(notification_deliveries, delivery)
          || !yyjson_mut_obj_add_int(mut_doc, notification_event, "id", workflow_event_id + 1)
          || !yyjson_mut_obj_add_int(mut_doc, notification_event, "workflow_execution_id", workflow_execution_id)
          || !yyjson_mut_obj_add_strcpy(mut_doc, notification_event, "event_kind", "notification_delivered")
          || !yyjson_mut_obj_add_strcpy(mut_doc, notification_event, "event_key", adapter_id)
          || !yyjson_mut_obj_add_strcpy(mut_doc, notification_event, "created_at", created_at != NULL ? created_at : "")
          || !yyjson_mut_obj_add_strcpy(mut_doc, notification_payload, "adapter_id", adapter_id)
          || !yyjson_mut_obj_add_strcpy(mut_doc, notification_payload, "channel", channel)
          || !yyjson_mut_obj_add_strcpy(mut_doc, notification_payload, "recipient", recipient)
          || !yyjson_mut_obj_add_strcpy(mut_doc, notification_payload, "template_id", template_id)
          || !yyjson_mut_obj_add_strcpy(mut_doc, notification_payload, "resource_id", resource_id != NULL ? resource_id : "")
          || !yyjson_mut_obj_add_strcpy(mut_doc, notification_payload, "replay_trace_id", replay_trace_id != NULL ? replay_trace_id : "")
          || !yyjson_mut_obj_put(notification_event, yyjson_mut_strcpy(mut_doc, "payload_json"), notification_payload)
          || !yyjson_mut_arr_append(workflow_events, notification_event)) {
        free(adapter_id);
        free(channel);
        free(recipient);
        free(template_id);
        free(workflow_id);
        free(transition_id);
        free(event_name);
        return 0;
      }
      if (effect_counts_out != NULL) {
        effect_counts_out->notification_count++;
      }
      free(adapter_id);
      free(channel);
      free(recipient);
      free(template_id);
      notification_id++;
      workflow_event_id++;
    }
  }
  if (workflow_execution_id_out != NULL) {
    *workflow_execution_id_out = workflow_execution_id;
  }
  free(workflow_id);
  free(transition_id);
  free(event_name);
  native_json_doc_free(integration_doc);
  return 1;
}
 
static int append_audit_event_logic_local(
  yyjson_mut_doc *mut_doc,
  yyjson_mut_val *mut_root,
  yyjson_val *transition,
  const char *resource_id,
  const char *created_at,
  const char *replay_trace_id,
  const char *report_json,
  const char *from_state,
  const char *to_state
) {
  yyjson_mut_val *audit_log = ensure_mut_array_field_logic_local(mut_doc, mut_root, "audit_log");
  yyjson_mut_val *audit = yyjson_mut_obj(mut_doc);
  yyjson_mut_val *payload = yyjson_mut_obj(mut_doc);
  char *event_name = transition != NULL ? native_json_obj_get_string_dup(transition, "emits_event") : NULL;
  if (audit_log == NULL || audit == NULL || payload == NULL) {
    free(event_name);
    return 0;
  }
  if (!yyjson_mut_obj_add_strcpy(mut_doc, audit, "event", event_name != NULL ? event_name : "action_applied")
      || !yyjson_mut_obj_add_strcpy(mut_doc, audit, "created_at", created_at != NULL ? created_at : "")
      || !yyjson_mut_obj_add_strcpy(mut_doc, payload, "resource_id", resource_id != NULL ? resource_id : "")
      || !yyjson_mut_obj_add_strcpy(mut_doc, payload, "replay_trace_id", replay_trace_id != NULL ? replay_trace_id : "")
      || !yyjson_mut_obj_add_strcpy(mut_doc, payload, "from_state", from_state != NULL ? from_state : "none")
      || !yyjson_mut_obj_add_strcpy(mut_doc, payload, "to_state", to_state != NULL ? to_state : "applied")) {
    free(event_name);
    return 0;
  }
  if (report_json != NULL && report_json[0] != '\0') {
    yyjson_doc *report_doc = native_json_doc_load_text(report_json);
    yyjson_val *report_root = report_doc != NULL ? yyjson_doc_get_root(report_doc) : NULL;
    if (report_root != NULL && !yyjson_mut_obj_put(payload, yyjson_mut_strcpy(mut_doc, "action_report"), yyjson_val_mut_copy(mut_doc, report_root))) {
      native_json_doc_free(report_doc);
      free(event_name);
      return 0;
    }
    native_json_doc_free(report_doc);
  }
  if (!yyjson_mut_obj_put(audit, yyjson_mut_strcpy(mut_doc, "payload_json"), payload)
      || !yyjson_mut_arr_append(audit_log, audit)) {
    free(event_name);
    return 0;
  }
  free(event_name);
  return 1;
}
 
static int persist_mut_doc_logic_local(const AppRuntime *app, yyjson_mut_doc *mut_doc) {
  char *text = NULL;
  int code = 69;
  if (app == NULL || mut_doc == NULL) {
    return 69;
  }
  text = yyjson_mut_write(mut_doc, YYJSON_WRITE_NOFLAG, NULL);
  if (text == NULL) {
    return 69;
  }
  code = write_text_file(app->state_path, text);
  free(text);
  return code == 0 ? 0 : 69;
}
 
/**
 * @brief Resolves a minimal HTTP reason phrase for framework-owned responses.
 *
 * @param status HTTP status code.
 * @return Static reason phrase string.
 */
static const char *http_reason_phrase_logic_local(int status) {
  switch (status) {
    case 200:
      return "OK";
    case 201:
      return "Created";
    case 202:
      return "Accepted";
    case 204:
      return "No Content";
    case 303:
      return "See Other";
    case 400:
      return "Bad Request";
    case 404:
      return "Not Found";
    case 422:
      return "Unprocessable Entity";
    default:
      return "OK";
  }
}
 
/**
 * @brief Sends a declarative redirect response contract.
 *
 * @param connection Connection receiving the response.
 * @param app Finalized app runtime metadata.
 * @param response_contract Declarative response contract object.
 * @return HTTP status code written to the connection.
 */
static int send_redirect_logic_local(NativeConnection *connection, const AppRuntime *app, yyjson_val *response_contract) {
  char *location = response_contract != NULL ? native_json_obj_get_string_dup(response_contract, "location") : NULL;
  const char *base_path = app != NULL && app->base_path != NULL ? app->base_path : "";
  int status = 303;
  if (location == NULL || location[0] == '\0') {
    location = strdup("/");
  }
  native_connection_printf(
    connection,
    "HTTP/1.1 %d See Other\r\n"
    "Location: %s%s\r\n"
    "Cache-Control: no-store\r\n"
    "Content-Length: 0\r\n"
    "Connection: close\r\n"
    "\r\n",
    status,
    base_path,
    location != NULL ? location : "/"
  );
  free(location);
  return status;
}
 
/**
 * @brief Sends a declarative JSON action-result response contract.
 *
 * The response is framework-owned and exposes a stable generic envelope with
 * action metadata, the persisted action report, and optional post-action state.
 *
 * @param connection Connection receiving the response.
 * @param response_contract Declarative response contract object.
 * @param action_id Executed action identifier.
 * @param resource_id Touched or created resource identifier.
 * @param workflow_execution_id Persisted workflow execution identifier.
 * @param report_json Serialized framework action report JSON.
 * @param mut_doc Mutated state document after the action applied.
 * @return HTTP status code written to the connection, or 500 on formatting failure.
 */
static int send_json_action_result_logic_local(
  NativeConnection *connection,
  yyjson_val *response_contract,
  const char *action_id,
  const char *resource_id,
  long workflow_execution_id,
  const char *report_json,
  yyjson_mut_doc *mut_doc
) {
  yyjson_mut_doc *response_doc = NULL;
  yyjson_mut_val *response_root = NULL;
  yyjson_doc *report_doc = NULL;
  yyjson_val *report_root = NULL;
  yyjson_doc *state_doc = NULL;
  yyjson_val *state_root = NULL;
  char *body = NULL;
  int include_state = yyjson_get_bool(response_contract != NULL ? native_json_obj_get(response_contract, "include_state") : NULL);
  int status = (int)native_json_obj_get_long_default(response_contract, "status", 200, NULL);
  const char *reason = http_reason_phrase_logic_local(status);
  size_t body_length = 0;
  if (connection == NULL || report_json == NULL || mut_doc == NULL) {
    return 500;
  }
  response_doc = yyjson_mut_doc_new(NULL);
  response_root = response_doc != NULL ? yyjson_mut_obj(response_doc) : NULL;
  report_doc = native_json_doc_load_text(report_json);
  report_root = report_doc != NULL ? yyjson_doc_get_root(report_doc) : NULL;
  if (response_doc != NULL && response_root != NULL) {
    yyjson_mut_doc_set_root(response_doc, response_root);
  }
  if (response_doc == NULL || response_root == NULL || report_root == NULL
      || !yyjson_mut_obj_add_bool(response_doc, response_root, "ok", 1)
      || !yyjson_mut_obj_add_strcpy(response_doc, response_root, "action_id", action_id != NULL ? action_id : "")
      || !yyjson_mut_obj_add_strcpy(response_doc, response_root, "resource_id", resource_id != NULL ? resource_id : "")
      || !yyjson_mut_obj_add_int(response_doc, response_root, "workflow_execution_id", workflow_execution_id)
      || !yyjson_mut_obj_put(response_root, yyjson_mut_strcpy(response_doc, "report"), yyjson_val_mut_copy(response_doc, report_root))) {
    native_json_doc_free(report_doc);
    yyjson_mut_doc_free(response_doc);
    native_send_text_response(connection, 500, "Internal Server Error", "response formatting error\n");
    return 500;
  }
  if (include_state) {
    char *state_text = yyjson_mut_write(mut_doc, YYJSON_WRITE_NOFLAG, NULL);
    if (state_text == NULL) {
      native_json_doc_free(report_doc);
      yyjson_mut_doc_free(response_doc);
      native_send_text_response(connection, 500, "Internal Server Error", "response formatting error\n");
      return 500;
    }
    state_doc = native_json_doc_load_text(state_text);
    free(state_text);
    state_root = state_doc != NULL ? yyjson_doc_get_root(state_doc) : NULL;
    if (state_root == NULL || !yyjson_mut_obj_put(response_root, yyjson_mut_strcpy(response_doc, "state"), yyjson_val_mut_copy(response_doc, state_root))) {
      native_json_doc_free(state_doc);
      native_json_doc_free(report_doc);
      yyjson_mut_doc_free(response_doc);
      native_send_text_response(connection, 500, "Internal Server Error", "response formatting error\n");
      return 500;
    }
  }
  body = yyjson_mut_write(response_doc, YYJSON_WRITE_NOFLAG, NULL);
  body_length = body != NULL ? strlen(body) : 0;
  if (body == NULL) {
    native_json_doc_free(state_doc);
    native_json_doc_free(report_doc);
    yyjson_mut_doc_free(response_doc);
    native_send_text_response(connection, 500, "Internal Server Error", "response formatting error\n");
    return 500;
  }
  native_connection_printf(
    connection,
    "HTTP/1.1 %d %s\r\n"
    "Content-Type: application/json\r\n"
    "Cache-Control: no-store\r\n"
    "Content-Length: %zu\r\n"
    "Connection: close\r\n"
    "\r\n"
    "%s",
    status,
    reason,
    body_length,
    body
  );
  free(body);
  native_json_doc_free(state_doc);
  native_json_doc_free(report_doc);
  yyjson_mut_doc_free(response_doc);
  return status;
}
 
/**
 * @brief Sends the configured declarative response contract for an action.
 *
 * @param connection Connection receiving the response.
 * @param app Finalized app runtime metadata.
 * @param response_contract Declarative response contract object.
 * @param action_id Executed action identifier.
 * @param resource_id Touched or created resource identifier.
 * @param workflow_execution_id Persisted workflow execution identifier.
 * @param report_json Serialized framework action report JSON.
 * @param mut_doc Mutated state document after the action applied.
 * @return HTTP status code written to the connection.
 */
static int send_action_response_logic_local(
  NativeConnection *connection,
  const AppRuntime *app,
  yyjson_val *response_contract,
  const char *action_id,
  const char *resource_id,
  long workflow_execution_id,
  const char *report_json,
  yyjson_mut_doc *mut_doc
) {
  char *response_kind = response_contract != NULL ? native_json_obj_get_string_dup(response_contract, "response_kind") : NULL;
  int status = 0;
  if (response_kind != NULL && streq(response_kind, "json")) {
    status = send_json_action_result_logic_local(connection, response_contract, action_id, resource_id, workflow_execution_id, report_json, mut_doc);
  } else {
    status = send_redirect_logic_local(connection, app, response_contract);
  }
  free(response_kind);
  return status;
}
 
int native_dynamic_action_presentation_dup(
  const AppRuntime *app,
  const char *action_id,
  char **submit_label_out,
  char **summary_out
) {
  yyjson_doc *action_doc = load_fixture_doc_logic_local(app, "action_fixture");
  yyjson_val *action_root = action_doc != NULL ? yyjson_doc_get_root(action_doc) : NULL;
  yyjson_val *action_contract = find_action_contract_logic_local(action_root, action_id);
  yyjson_val *presentation = action_contract != NULL ? native_json_obj_get(action_contract, "presentation") : NULL;
  if (submit_label_out != NULL) {
    *submit_label_out = presentation != NULL ? native_json_obj_get_string_dup(presentation, "submit_label") : NULL;
  }
  if (summary_out != NULL) {
    *summary_out = presentation != NULL ? native_json_obj_get_string_dup(presentation, "summary") : NULL;
  }
  native_json_doc_free(action_doc);
  return action_contract != NULL ? 1 : 0;
}
 
int native_dynamic_execute_declarative_action(
  NativeConnection *connection,
  const AppRuntime *app,
  const HttpRequest *request,
  const char *action_id
) {
  yyjson_doc *action_doc = NULL;
  yyjson_doc *workflow_doc = NULL;
  yyjson_doc *state_doc = NULL;
  yyjson_val *action_root = NULL;
  yyjson_val *workflow_root = NULL;
  yyjson_val *state_root = NULL;
  yyjson_val *action_contract = NULL;
  yyjson_val *workflow = NULL;
  yyjson_val *transition = NULL;
  yyjson_mut_doc *mut_doc = NULL;
  yyjson_mut_val *mut_root = NULL;
  InputFieldMapLogicLocal inputs = {0};
  ActionExecutionContextLogicLocal context = {0};
  ActionEffectCountsLogicLocal effect_counts = {0};
  char *input_error = NULL;
  char *policy_gate = NULL;
  char *success_message = NULL;
  char *failure_message = NULL;
  char *operator_summary = NULL;
  char *transition_label = NULL;
  char *from_state_label = NULL;
  char *to_state_label = NULL;
  char *created_at = NULL;
  char *resource_id = NULL;
  char *from_state = NULL;
  char *to_state = NULL;
  char *report_json = NULL;
  char *replay_trace_id = NULL;
  yyjson_val *mutation_primitives = NULL;
  yyjson_arr_iter primitive_iter;
  yyjson_val *primitive = NULL;
  long next_id = 1;
  long created_record_id = 0;
  long workflow_execution_id = 0;
  int status = 0;
  char created_at_buffer[20];
  action_doc = load_fixture_doc_logic_local(app, "action_fixture");
  workflow_doc = load_fixture_doc_logic_local(app, "workflow_fixture");
  if (action_doc == NULL) {
    return 0;
  }
  action_root = yyjson_doc_get_root(action_doc);
  workflow_root = workflow_doc != NULL ? yyjson_doc_get_root(workflow_doc) : NULL;
  action_contract = find_action_contract_logic_local(action_root, action_id);
  if (action_contract == NULL) {
    native_json_doc_free(action_doc);
    native_json_doc_free(workflow_doc);
    return 0;
  }
  transition = find_workflow_transition_logic_local(workflow_root, action_id, &workflow);
  policy_gate = native_json_obj_get_string_dup(action_contract, "policy_gate");
  success_message = action_presentation_string_dup_logic_local(action_contract, "success_message");
  failure_message = action_presentation_string_dup_logic_local(action_contract, "failure_message");
  operator_summary = action_presentation_string_dup_logic_local(action_contract, "operator_summary");
  transition_label = workflow_presentation_string_dup_logic_local(transition, "transition_label");
  from_state_label = workflow_presentation_string_dup_logic_local(transition, "from_label");
  to_state_label = workflow_presentation_string_dup_logic_local(transition, "to_label");
  if (!load_action_inputs_logic_local(request, action_contract, &inputs, &input_error)) {
    status = 500;
    write_json_error_logic_local(connection, 500, "Internal Server Error", "action_input_error", "Failed to load action inputs.");
    goto cleanup;
  }
  if (input_error != NULL) {
    status = 422;
    write_json_error_logic_local(
      connection,
      422,
      "Unprocessable Entity",
      "invalid_action_input",
      failure_message != NULL && failure_message[0] != '\0' ? failure_message : input_error
    );
    goto cleanup;
  }
  state_doc = native_json_doc_load_file(app->state_path);
  state_root = state_doc != NULL ? yyjson_doc_get_root(state_doc) : NULL;
  if (state_root == NULL || !yyjson_is_obj(state_root)) {
    status = 500;
    write_json_error_logic_local(connection, 500, "Internal Server Error", "state_unavailable", "Declarative action state is unavailable.");
    goto cleanup;
  }
  mut_doc = yyjson_doc_mut_copy(state_doc, NULL);
  mut_root = yyjson_mut_doc_get_root(mut_doc);
  if (mut_doc == NULL || mut_root == NULL || !yyjson_mut_is_obj(mut_root) || !now_iso_utc_logic_local(created_at_buffer)) {
    status = 500;
    write_json_error_logic_local(connection, 500, "Internal Server Error", "action_runtime_error", "Declarative action runtime initialization failed.");
    goto cleanup;
  }
  created_at = strdup(created_at_buffer);
  next_id = native_json_obj_get_long_default(state_root, "next_id", 1, NULL);
  mutation_primitives = native_json_obj_get(action_contract, "mutation_primitives");
  if (mutation_primitives == NULL || !yyjson_is_arr(mutation_primitives)) {
    status = 500;
    write_json_error_logic_local(connection, 500, "Internal Server Error", "missing_mutation_primitives", "Declarative action is missing mutation primitives.");
    goto cleanup;
  }
  if (yyjson_arr_iter_init(mutation_primitives, &primitive_iter)) {
    while ((primitive = yyjson_arr_iter_next(&primitive_iter)) != NULL) {
      char *kind = native_json_obj_get_string_dup(primitive, "primitive_kind");
      char *primitive_resource_id = NULL;
      int primitive_code = 0;
      long created_count = 0;
      if (kind != NULL && streq(kind, "append_record")) {
        primitive_code = append_record_primitive_logic_local(mut_doc, mut_root, primitive, &inputs, &context, next_id, &created_record_id, &primitive_resource_id);
        if (primitive_code == 1) {
          if (created_record_id > 0 && !note_created_record_logic_local(&context, created_record_id, primitive_resource_id)) {
            free(primitive_resource_id);
            free(kind);
            status = 500;
            write_json_error_logic_local(connection, 500, "Internal Server Error", "action_runtime_error", "Failed to record created action context.");
            goto cleanup;
          }
          next_id++;
          if (!set_mut_object_field_logic_local(mut_doc, mut_root, "next_id", yyjson_mut_int(mut_doc, next_id))) {
            free(primitive_resource_id);
            free(kind);
            status = 500;
            write_json_error_logic_local(connection, 500, "Internal Server Error", "action_runtime_error", "Failed to advance next_id.");
            goto cleanup;
          }
          if (from_state == NULL) {
            from_state = strdup("none");
          }
          if (to_state == NULL) {
            to_state = strdup("created");
          }
        }
      } else if (kind != NULL && streq(kind, "append_records_from_input_list")) {
        primitive_code = append_records_from_input_list_primitive_logic_local(mut_doc, mut_root, primitive, &inputs, &context, next_id, &created_count, &primitive_resource_id);
        if (primitive_code == 1 && created_count > 0) {
          next_id += created_count;
          if (!set_mut_object_field_logic_local(mut_doc, mut_root, "next_id", yyjson_mut_int(mut_doc, next_id))) {
            free(primitive_resource_id);
            free(kind);
            status = 500;
            write_json_error_logic_local(connection, 500, "Internal Server Error", "action_runtime_error", "Failed to advance next_id.");
            goto cleanup;
          }
          if (from_state == NULL) {
            from_state = strdup("none");
          }
          if (to_state == NULL) {
            to_state = strdup("created");
          }
        }
      } else if (kind != NULL && streq(kind, "append_records_from_related_collection")) {
        primitive_code = append_records_from_related_collection_primitive_logic_local(mut_doc, mut_root, state_root, primitive, &inputs, &context, next_id, &created_count, &primitive_resource_id);
        if (primitive_code == 1 && created_count > 0) {
          next_id += created_count;
          if (!set_mut_object_field_logic_local(mut_doc, mut_root, "next_id", yyjson_mut_int(mut_doc, next_id))) {
            free(primitive_resource_id);
            free(kind);
            status = 500;
            write_json_error_logic_local(connection, 500, "Internal Server Error", "action_runtime_error", "Failed to advance next_id.");
            goto cleanup;
          }
          if (from_state == NULL) {
            from_state = strdup("none");
          }
          if (to_state == NULL) {
            to_state = strdup("created");
          }
        }
      } else if (kind != NULL && streq(kind, "update_record")) {
        primitive_code = update_record_primitive_logic_local(mut_doc, mut_root, primitive, &inputs, &context, &primitive_resource_id, &from_state, &to_state);
      } else if (kind != NULL && streq(kind, "scoped_reassignment")) {
        primitive_code = scoped_reassignment_primitive_logic_local(mut_doc, mut_root, state_root, primitive, &inputs, &context, &primitive_resource_id);
      } else if (kind != NULL && streq(kind, "bulk_update")) {
        primitive_code = bulk_update_primitive_logic_local(mut_doc, mut_root, primitive, &inputs, &context, &primitive_resource_id, &from_state, &to_state);
      } else if (kind != NULL && streq(kind, "set_root_fields")) {
        primitive_code = set_root_fields_primitive_logic_local(mut_doc, mut_root, primitive, &inputs, &context, next_id);
      }
      if (primitive_resource_id != NULL) {
        if (resource_id == NULL) {
          resource_id = primitive_resource_id;
          primitive_resource_id = NULL;
        }
        free(primitive_resource_id);
      }
      free(kind);
      if (primitive_code == -2) {
        status = 422;
        write_json_error_logic_local(
          connection,
          422,
          "Unprocessable Entity",
          "action_scope_overflow",
          failure_message != NULL && failure_message[0] != '\0'
            ? failure_message
            : "Matching scope exceeded the configured action bound."
        );
        goto cleanup;
      }
      if (primitive_code == -1) {
        status = 404;
        write_json_error_logic_local(
          connection,
          404,
          "Not Found",
          "action_target_not_found",
          failure_message != NULL && failure_message[0] != '\0'
            ? failure_message
            : "Action target record not found."
        );
        goto cleanup;
      }
      if (primitive_code == 0) {
        status = 500;
        write_json_error_logic_local(connection, 500, "Internal Server Error", "action_runtime_error", "Declarative action primitive failed.");
        goto cleanup;
      }
    }
  }
  if (transition != NULL && context.created_record_count > 0
      && from_state != NULL && to_state != NULL
      && streq(from_state, "none") && streq(to_state, "created")) {
    char *transition_from_state = native_json_obj_get_string_dup(transition, "from_state");
    char *transition_to_state = native_json_obj_get_string_dup(transition, "to_state");
    if (transition_from_state != NULL && transition_from_state[0] != '\0') {
      free(from_state);
      from_state = transition_from_state;
      transition_from_state = NULL;
    }
    if (transition_to_state != NULL && transition_to_state[0] != '\0') {
      free(to_state);
      to_state = transition_to_state;
      transition_to_state = NULL;
    }
    free(transition_from_state);
    free(transition_to_state);
  }
  if (from_state == NULL && transition != NULL) {
    from_state = native_json_obj_get_string_dup(transition, "from_state");
  }
  if (to_state == NULL && transition != NULL) {
    to_state = native_json_obj_get_string_dup(transition, "to_state");
  }
  if (from_state == NULL) {
    from_state = strdup("none");
  }
  if (to_state == NULL) {
    to_state = strdup("applied");
  }
  if (created_record_id <= 0) {
    created_record_id = context.anchor_record_id > 0 ? context.anchor_record_id : context.last_created_record_id;
  }
  if (resource_id == NULL && context.anchor_resource_id != NULL) {
    resource_id = strdup(context.anchor_resource_id);
  }
  if (resource_id == NULL && context.last_touched_resource_id != NULL) {
    resource_id = strdup(context.last_touched_resource_id);
  }
  if (resource_id == NULL && created_record_id > 0) {
    size_t needed = 32;
    resource_id = (char *)malloc(needed);
    if (resource_id != NULL) {
      snprintf(resource_id, needed, "record:%ld", created_record_id);
    }
  }
  if (resource_id == NULL) {
    resource_id = strdup("resource:unknown");
  }
  if (!append_workflow_and_effects_logic_local(app, mut_doc, mut_root, action_contract, workflow, transition, &inputs, &context, policy_gate, resource_id, from_state, to_state, created_at, NULL, &workflow_execution_id, &effect_counts)) {
    status = 500;
    write_json_error_logic_local(connection, 500, "Internal Server Error", "workflow_recording_failed", "Failed to record workflow execution.");
    goto cleanup;
  }
  if (!append_action_report_logic_local(
        mut_doc,
        mut_root,
        action_contract,
        workflow,
        transition,
        &context,
        &effect_counts,
        resource_id,
        from_state,
        to_state,
        created_at,
        policy_gate,
        success_message,
        operator_summary,
        transition_label,
        from_state_label,
        to_state_label,
        workflow_execution_id,
        created_record_id,
        &report_json,
        &replay_trace_id)) {
    status = 500;
    write_json_error_logic_local(connection, 500, "Internal Server Error", "action_reporting_failed", "Failed to record action report.");
    goto cleanup;
  }
  if (!append_audit_event_logic_local(mut_doc, mut_root, transition, resource_id, created_at, replay_trace_id, report_json, from_state, to_state)) {
    status = 500;
    write_json_error_logic_local(connection, 500, "Internal Server Error", "audit_recording_failed", "Failed to append audit event.");
    goto cleanup;
  }
  if (persist_mut_doc_logic_local(app, mut_doc) != 0) {
    status = 500;
    write_json_error_logic_local(connection, 500, "Internal Server Error", "state_persist_failed", "Failed to persist declarative action state.");
    goto cleanup;
  }
  status = send_action_response_logic_local(
    connection,
    app,
    native_json_obj_get(action_contract, "response_contract"),
    action_id,
    resource_id,
    workflow_execution_id,
    report_json,
    mut_doc
  );
 
cleanup:
  native_json_doc_free(action_doc);
  native_json_doc_free(workflow_doc);
  native_json_doc_free(state_doc);
  yyjson_mut_doc_free(mut_doc);
  free_input_field_map_logic_local(&inputs);
  free(input_error);
  free(policy_gate);
  free(success_message);
  free(failure_message);
  free(operator_summary);
  free(transition_label);
  free(from_state_label);
  free(to_state_label);
  free(created_at);
  free(resource_id);
  free(from_state);
  free(to_state);
  free(report_json);
  free(replay_trace_id);
  free_action_execution_context_logic_local(&context);
  return status;
}