pharos_runtime.c

Go to the documentation of this file.

/**
 * @file
 * @brief Native Pharos runtime entrypoint and orchestration for serve, runtime, website, and ops command flows.
 */
 
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <stdint.h>
#include <stdarg.h>
#include <stdbool.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#ifndef _WIN32
#include <grp.h>
#include <strings.h>
#endif
 
#ifdef _WIN32
#include <direct.h>
#include <io.h>
#include <process.h>
#include <sys/stat.h>
#include <winsock2.h>
#include <ws2tcpip.h>
#define PATH_SEP '\\'
#define PHAROS_SOCKET SOCKET
#define PHAROS_INVALID_SOCKET INVALID_SOCKET
#define pharos_close_socket closesocket
#define pharos_getcwd _getcwd
#define pharos_access _access
#define pharos_stat _stat
#define pharos_mkdir(path, mode) _mkdir(path)
#define pharos_unlink _unlink
#define pharos_strdup _strdup
 
#include <sys/time.h>
 
static int win_gettimeofday(struct timeval *tv, void *tz) {
  FILETIME ft;
  ULARGE_INTEGER li;
  GetSystemTimeAsFileTime(&ft);
  li.LowPart = ft.dwLowDateTime;
  li.HighPart = ft.dwHighDateTime;
  tv->tv_sec = (long)((li.QuadPart - 116444736000000000ULL) / 10000000ULL);
  tv->tv_usec = (long)((li.QuadPart / 10ULL) % 1000000ULL);
  return 0;
}
#define gettimeofday win_gettimeofday
#else
#include <arpa/inet.h>
#include <dirent.h>
#include <netinet/in.h>
#ifndef __wasm__
#include <pthread.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/wait.h>
#endif
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/time.h>
#include <unistd.h>
#define PATH_SEP '/'
#define PHAROS_SOCKET int
#define PHAROS_INVALID_SOCKET -1
#define pharos_close_socket close
#define pharos_getcwd getcwd
#define pharos_access access
#define pharos_stat stat
#define pharos_mkdir mkdir
#define pharos_unlink unlink
#define pharos_strdup strdup
#endif
 
#include "native_support.h"
#include "native_json_config.h"
#include "native_app_config.h"
#include "native_http_log.h"
#include "native_fs.h"
#include "native_app_runtime_paths.h"
#include "native_artifact_emit.h"
#include "native_runtime_types.h"
#include "native_runtime_reports.h"
#include "native_runtime_load.h"
#include "native_runtime_stack.h"
#include "native_runtime_cleanup.h"
#include "native_app_runtime_finalize.h"
#include "native_serve_config.h"
#include "native_shell_bridge.h"
#include "native_http_request.h"
#include "native_http_response.h"
#include "native_http_access_log.h"
#include "native_static_serve.h"
#include "native_request_path.h"
#include "native_spawn_argv.h"
#include "native_spawn_temp_body.h"
#include "native_process_capture.h"
#include "native_listener.h"
#include "native_connection.h"
#include "native_app_runtime_clone.h"
#include "native_ops_bridge.h"
#include "native_backup_restore.h"
#include "native_json_runtime_ops.h"
#include "native_barcode_runtime_ops.h"
#include "native_dynamic_runtime.h"
 
#ifndef PHAROS_TARGET_ID
#define PHAROS_TARGET_ID "source-bootstrap"
#endif
 
#ifndef PHAROS_VERSION
#define PHAROS_VERSION "0.7.23"
#endif
 
/**
 * @brief Per-request worker state used while routing either runtime or app traffic.
 */
typedef struct {
  int is_runtime;
  NativeConnection connection;
  HttpRequest request;
  AppRuntime app;
} WorkerContext;
 
#define PHAROS_NATIVE_DEFAULT_WORKER_COUNT 16
#define PHAROS_NATIVE_MIN_WORKER_COUNT 1
#define PHAROS_NATIVE_MAX_WORKER_COUNT 256
#define PHAROS_NATIVE_MIN_WORK_QUEUE_CAPACITY 32
#define PHAROS_NATIVE_MAX_WORK_QUEUE_CAPACITY 8192
#define PHAROS_NATIVE_DEFAULT_WORK_QUEUE_CAPACITY 128
#define PHAROS_NATIVE_WORK_QUEUE_BYTES_PER_SLOT (8ULL * 1024ULL * 1024ULL)
 
typedef struct {
  WorkerContext **items;
  size_t capacity;
  size_t head;
  size_t tail;
  size_t count;
  int shutting_down;
  size_t worker_count;
#ifdef _WIN32
  CRITICAL_SECTION mutex;
  CONDITION_VARIABLE not_empty;
  HANDLE *threads;
#else
  pthread_mutex_t mutex;
  pthread_cond_t not_empty;
  pthread_t *threads;
#endif
} NativeWorkerPool;
 
/**
 * @brief Release a worker context and every owned request/runtime resource.
 *
 * @param context Per-request worker state to release.
 */
static void free_worker_context_native(WorkerContext *context);
 
/**
 * @brief Execute one accepted request through the active runtime/app handler.
 *
 * @param context Per-request worker state to process.
 */
static void process_worker_context_native(WorkerContext *context);
 
/**
 * @brief Initialize a bounded worker pool for native request serving.
 *
 * @param pool Pool state to initialize.
 * @param worker_count Fixed number of worker threads to create.
 * @param capacity Maximum queued requests.
 * @return 0 on success, non-zero on failure.
 */
static int native_worker_pool_init(NativeWorkerPool *pool, size_t worker_count, size_t capacity);
 
/**
 * @brief Submit accepted request work to the bounded worker pool.
 *
 * @param pool Active worker pool.
 * @param context Per-request work item to enqueue.
 * @return 0 on success, 1 when saturated or shutting down, non-zero on internal failure.
 */
static int native_worker_pool_enqueue(NativeWorkerPool *pool, WorkerContext *context);
 
/**
 * @brief Ask the worker pool to stop after draining queued work.
 *
 * @param pool Active worker pool.
 */
static void native_worker_pool_request_shutdown(NativeWorkerPool *pool);
 
/**
 * @brief Join all worker threads created for the pool.
 *
 * @param pool Active worker pool.
 */
static void native_worker_pool_join(NativeWorkerPool *pool);
 
/**
 * @brief Destroy worker-pool resources after shutdown and join.
 *
 * @param pool Worker pool to destroy.
 */
static void native_worker_pool_destroy(NativeWorkerPool *pool);
 
/**
 * @brief Send the standard overload response for saturated native serving.
 *
 * @param connection Accepted client connection.
 */
static void native_send_worker_pool_overload_response(NativeConnection *connection);
 
/**
 * @brief Recursively write macOS no-index markers through a directory tree.
 *
 * @param root_path Directory tree to mark.
 * @return 0 on success, non-zero on failure.
 */
static int write_noindex_markers_recursive_native(const char *root_path);
 
/**
 * @brief Resolve the fixed worker-thread count for one serve process.
 *
 * @param runtime_conf_path Runtime configuration path to consult for overrides.
 * @return Positive worker-thread count.
 */
static size_t native_resolved_worker_count(const char *runtime_conf_path);
 
/**
 * @brief Resolve the bounded queued-request capacity for one serve process.
 *
 * @param runtime_conf_path Runtime configuration path to consult for overrides.
 * @return Positive queued-request capacity.
 */
static size_t native_resolved_work_queue_capacity(const char *runtime_conf_path);
 
typedef int (*NativeServeHandlerFn)(const ServeConfig *config);
 
static char *global_repo_root = NULL;
static char *global_binary_dir = NULL;
static volatile sig_atomic_t global_shutdown_requested = 0;
static NativeListenerState global_listener_state = { -1, NULL };
 
static void clear_listener_cleanup_registration(void) {
  native_listener_state_init(&global_listener_state);
}
 
static void cleanup_active_listener(void) {
  native_listener_cleanup_active(&global_listener_state);
}
 
static void register_listener_cleanup(const ServeConfig *config, PHAROS_SOCKET server_fd) {
  native_listener_register_cleanup(&global_listener_state, config, (int)server_fd, &global_shutdown_requested);
}
 
#ifndef _WIN32
static void pharos_native_shutdown_signal_handler(int signum) {
  (void)signum;
  global_shutdown_requested = 1;
  cleanup_active_listener();
}
 
static void install_native_signal_handlers(void) {
  signal(SIGINT, pharos_native_shutdown_signal_handler);
  signal(SIGTERM, pharos_native_shutdown_signal_handler);
#ifdef SIGHUP
  signal(SIGHUP, pharos_native_shutdown_signal_handler);
#endif
}
#else
static void install_native_signal_handlers(void) {
}
#endif
 
 
 
static int native_known_website_supported(const char *target_id) {
  (void)target_id;
  return 0;
}
 
static int build_known_website_native(const char *target_id, const char *build_dir, char **report_path_out, char **artifact_dir_out) {
  (void)target_id;
  (void)build_dir;
  (void)report_path_out;
  (void)artifact_dir_out;
  return 78;
}
 
static int build_app_from_root_native(
  const char *app_root,
  const char *build_dir_override,
  const char *state_dir_override,
  const char *state_path_override,
  const char *base_path_override,
  char **report_path_out,
  char **artifact_dir_out
);
static int build_dev_docs_directory_native(const char *app_root, const char *artifact_dir);
static int app_root_has_finalized_artifact_native(const char *app_root);
static int maybe_seed_app_state_native(const ServeConfig *config, const char *app_root, const char *app_id, int force_seed);
 
static int emit_website_status_native(const char *verb, const char *target_id, const char *build_dir, char **report_path_out) {
  char *artifact_dir = native_website_artifact_dir(build_dir, target_id);
  char *index_path = NULL;
  char *report_path = NULL;
  char *report_json = NULL;
  int code = 0;
  const char *report_id = "pharos-end-to-end-site-v1";
  if (artifact_dir == NULL) {
    return 69;
  }
  index_path = path_join(artifact_dir, "index.html");
  if (index_path == NULL) {
    free(artifact_dir);
    return 69;
  }
  if (!path_exists(index_path)) {
    code = build_known_website_native(target_id, build_dir, NULL, NULL);
    if (code != 0) {
      free(artifact_dir);
      free(index_path);
      return code;
    }
  }
  report_path = native_website_report_path(build_dir, verb, target_id);
  if (report_path == NULL) {
    free(artifact_dir);
    free(index_path);
    return 69;
  }
  report_json = build_native_website_status_report_json(report_id, verb, target_id, artifact_dir);
  if (report_json == NULL) {
    free(artifact_dir);
    free(index_path);
    free(report_path);
    return 69;
  }
  code = write_text_file(report_path, report_json);
  free(report_json);
  free(artifact_dir);
  free(index_path);
  if (code != 0) {
    free(report_path);
    return code;
  }
  if (report_path_out != NULL) *report_path_out = report_path; else free(report_path);
  return 0;
}
 
static char *app_runtime_host_profile_native(const char *app_root) {
  char *manifest_path = NULL;
  char *manifest_text = NULL;
  char *host_profile = NULL;
  if (app_root == NULL) {
    return NULL;
  }
  manifest_path = path_join(app_root, "pharos.app.json");
  manifest_text = manifest_path != NULL ? read_file_text(manifest_path) : NULL;
  if (manifest_text != NULL) {
    host_profile = json_find_string_in_section(manifest_text, "runtime", "host_profile");
  }
  free(manifest_text);
  free(manifest_path);
  if (host_profile == NULL) {
    return pharos_strdup("dynamic-app");
  }
  return host_profile;
}
 
 
 
static char *runtime_build_dir_override_native(const ServeConfig *config, const char *app_root) {
  if (config != NULL && config->build_dir != NULL && config->build_dir[0] != '\0') {
    return pharos_strdup(config->build_dir);
  }
  if (global_repo_root != NULL && global_repo_root[0] != '\0') {
    return path_join(global_repo_root, "dist");
  }
  return app_build_dir_local_native(app_root);
}
 
/**
 * @brief Prepares the artifact directory for an app at startup.
 *
 * Both @c dynamic-app and @c static-pages profiles now use the native artifact
 * builder. Static pages are served directly from the finalized artifact and no
 * longer require a shell-built app-local request host during native runtime
 * preparation.
 *
 * @param app_root            Filesystem path to the app root.
 * @param app_id              Application identifier.
 * @param build_dir_override  Build directory override (may be NULL).
 * @param state_dir_override  State directory override (may be NULL).
 * @param state_path_override State file override (may be NULL).
 * @param base_path_override  URL base-path override (may be NULL).
 * @param report_path_out     Receives the build report path (may be NULL).
 * @param artifact_dir_out    Receives the artifact directory on success.
 * @return 0 on success, non-zero on failure.
 */
static int prepare_app_artifact_native(
  const char *app_root,
  const char *app_id,
  const char *build_dir_override,
  const char *state_dir_override,
  const char *state_path_override,
  const char *base_path_override,
  char **report_path_out,
  char **artifact_dir_out
) {
  char *build_dir = NULL;
  int code;
  if (report_path_out != NULL) {
    *report_path_out = NULL;
  }
  if (artifact_dir_out != NULL) {
    *artifact_dir_out = NULL;
  }
  if (app_root == NULL || app_id == NULL) {
    return 66;
  }
  build_dir = effective_app_build_dir_native(app_root, build_dir_override);
  if (build_dir == NULL) {
    return 69;
  }
  (void)app_id;
  code = build_app_from_root_native(app_root, build_dir, state_dir_override, state_path_override, base_path_override, report_path_out, artifact_dir_out);
  free(build_dir);
  return code;
}
 
static const char *dev_docs_directory_index_html_native(void) {
  return "<!DOCTYPE html>\n"
    "<html lang=\"en\">\n"
    "<head>\n"
    "<meta charset=\"UTF-8\">\n"
    "<meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">\n"
    "<title>Pharos Docs</title>\n"
    "<link rel=\"stylesheet\" href=\"/dev_docs/docs/assets/docs.css\">\n"
    "</head>\n"
    "<body>\n"
    "<main>\n"
    "  <section class=\"banner\">\n"
    "    <img src=\"/dev_docs/docs/assets/pharos-framework-wordmark.svg\" alt=\"Pharos Framework\" class=\"wordmark\">\n"
    "  </section>\n"
    "  <section class=\"card\">\n"
    "    <h2>Primary entry points</h2>\n"
    "    <ul>\n"
    "      <li><a href=\"/dev_docs/\">Home</a></li>\n"
    "      <li><a href=\"/dev_docs/docs/pharos_framework.html\">Framework overview</a></li>\n"
    "      <li><a href=\"/dev_docs/docs/how-to-use-pharos-cli.html\">CLI guide</a></li>\n"
    "      <li><a href=\"/dev_docs/docs/operations/runtime-operations.html\">Runtime operations</a></li>\n"
    "      <li><a href=\"/dev_docs/docs/spec.html\">Framework specification</a></li>\n"
    "      <li><a href=\"/dev_docs/docs/platform-vision.html\">Platform vision</a></li>\n"
    "      <li><a href=\"/dev_docs/docs/html/index.html\">Doxygen source reference</a></li>\n"
    "    </ul>\n"
    "  </section>\n"
 
    "</main>\n"
    "</body>\n"
    "</html>\n";
}
 
static int build_dev_docs_directory_native(const char *app_root, const char *artifact_dir) {
#ifndef _WIN32
  char *apps_root = NULL;
  char *repo_root = NULL;
  char *repo_docs = NULL;
  char *repo_doxyfile = NULL;
  char *target_docs = NULL;
  char *target_docs_html = NULL;
  char *target_docs_index = NULL;
  char *generated_doxyfile = NULL;
  char *markdown_renderer = NULL;
  char *artifact_noindex = NULL;
  char *target_docs_noindex = NULL;
  char *target_docs_html_noindex = NULL;
  char *doxyfile_text = NULL;
  char *generated_doxyfile_text = NULL;
  char *command = NULL;
  char *output = NULL;
  char *argv_list[4];
  size_t needed = 0;
  int code = 69;
  if (app_root == NULL || artifact_dir == NULL) {
    return 69;
  }
  apps_root = path_dirname(app_root);
  repo_root = apps_root != NULL ? path_dirname(apps_root) : NULL;
  repo_docs = repo_root != NULL ? path_join(repo_root, "docs") : NULL;
  repo_doxyfile = repo_root != NULL ? path_join(repo_root, "Doxyfile") : NULL;
  target_docs = path_join(artifact_dir, "docs");
  target_docs_html = target_docs != NULL ? path_join(target_docs, "html") : NULL;
  target_docs_index = target_docs != NULL ? path_join(target_docs, "index.html") : NULL;
  generated_doxyfile = path_join(artifact_dir, "Doxyfile.dev_docs");
  markdown_renderer = path_join(artifact_dir, "dev_docs_markdown_render.py");
  artifact_noindex = path_join(artifact_dir, ".metadata_never_index");
  target_docs_noindex = path_join(target_docs, ".metadata_never_index");
  target_docs_html_noindex = path_join(target_docs_html, ".metadata_never_index");
  if (repo_root == NULL || repo_docs == NULL || repo_doxyfile == NULL || target_docs == NULL || target_docs_html == NULL || target_docs_index == NULL || generated_doxyfile == NULL || markdown_renderer == NULL || artifact_noindex == NULL || target_docs_noindex == NULL || target_docs_html_noindex == NULL) {
    code = 69;
    goto cleanup;
  }
  if (!path_is_directory(repo_docs) || !path_exists(repo_doxyfile)) {
    code = 66;
    goto cleanup;
  }
  code = copy_directory_recursive(repo_docs, target_docs);
  if (code != 0) {
    goto cleanup;
  }
  remove_directory_recursive(target_docs_html);
#ifdef __APPLE__
  code = write_text_file(artifact_noindex, "");
  if (code != 0) {
    goto cleanup;
  }
  code = write_text_file(target_docs_noindex, "");
  if (code != 0) {
    goto cleanup;
  }
#endif
  {
    static const char *renderer_script =
      "from pathlib import Path\n"
      "import html\n"
      "import re\n"
      "import sys\n"
      "ROOT = Path(sys.argv[1])\n"
      "HTML_TEMPLATE = \"\"\"<!DOCTYPE html>\n"
      "<html lang=\\\"en\\\">\n"
      "<head>\n"
      "<meta charset=\\\"UTF-8\\\">\n"
      "<meta name=\\\"viewport\\\" content=\\\"width=device-width, initial-scale=1.0\\\">\n"
      "<title>{title}</title>\n"
      "<link rel=\"stylesheet\" href=\"{stylesheet_src}\">\n"
      "</head>\n"
      "<body>\n"
      "<main>\n"
      "<section class=\\\"banner\\\">\n"
      "<img src=\\\"{wordmark_src}\\\" alt=\\\"Pharos Framework\\\" class=\\\"wordmark\\\">\n"
      "<p class=\\\"backlink\\\"><a href=\\\"{back_href}\\\">← Back</a></p>\n"
      "{body}\n"
      "</section>\n"
      "</main>\n"
      "</body>\n"
      "</html>\n"
      "\"\"\"\n"
      "LINK_RE = re.compile(r'\\[([^\\]]+)\\]\\(([^)]+)\\)')\n"
      "INLINE_CODE_RE = re.compile(r'`([^`]+)`')\n"
      "BOLD_RE = re.compile(r'\\*\\*([^*]+)\\*\\*')\n"
      "ITALIC_RE = re.compile(r'(?<!\\*)\\*([^*]+)\\*(?!\\*)')\n"
      "def rewrite_href(target):\n"
      "    if target.endswith('.md'): return target[:-3] + '.html'\n"
      "    if '.md#' in target: return target.replace('.md#', '.html#')\n"
      "    return target\n"
      "def inline_markup(text):\n"
      "    escaped = html.escape(text)\n"
      "    escaped = LINK_RE.sub(lambda m: f'<a href=\\\"{html.escape(rewrite_href(m.group(2)), quote=True)}\\\">{m.group(1)}</a>', escaped)\n"
      "    escaped = INLINE_CODE_RE.sub(lambda m: f'<code>{m.group(1)}</code>', escaped)\n"
      "    escaped = BOLD_RE.sub(lambda m: f'<strong>{m.group(1)}</strong>', escaped)\n"
      "    escaped = ITALIC_RE.sub(lambda m: f'<em>{m.group(1)}</em>', escaped)\n"
      "    return escaped\n"
      "def render_markdown(text, rel_path):\n"
      "    lines = text.splitlines()\n"
      "    out = []\n"
      "    in_code = False\n"
      "    code_lines = []\n"
      "    para = []\n"
      "    list_type = None\n"
      "    title = rel_path.stem.replace('-', ' ').replace('_', ' ').title()\n"
      "    def close_paragraph():\n"
      "        nonlocal para\n"
      "        if para:\n"
      "            out.append(f\"<p>{inline_markup(' '.join(para).strip())}</p>\")\n"
      "            para = []\n"
      "    def close_list():\n"
      "        nonlocal list_type\n"
      "        if list_type is not None:\n"
      "            out.append(f'</{list_type}>')\n"
      "            list_type = None\n"
      "    for line in lines:\n"
      "        stripped = line.rstrip('\\n')\n"
      "        if stripped.startswith('```'):\n"
      "            close_paragraph(); close_list()\n"
      "            if in_code:\n"
      "                out.append('<pre><code>' + html.escape('\\n'.join(code_lines)) + '</code></pre>')\n"
      "                code_lines = []\n"
      "                in_code = False\n"
      "            else:\n"
      "                in_code = True\n"
      "            continue\n"
      "        if in_code:\n"
      "            code_lines.append(stripped)\n"
      "            continue\n"
      "        if not stripped.strip():\n"
      "            close_paragraph(); close_list(); continue\n"
      "        heading_match = re.match(r'^(#{1,6})\\s+(.*)$', stripped)\n"
      "        if heading_match:\n"
      "            close_paragraph(); close_list()\n"
      "            level = len(heading_match.group(1))\n"
      "            heading_text = heading_match.group(2).strip()\n"
      "            if level == 1: title = heading_text\n"
      "            out.append(f'<h{level}>{inline_markup(heading_text)}</h{level}>')\n"
      "            continue\n"
      "        unordered_match = re.match(r'^\\s*[-*]\\s+(.*)$', stripped)\n"
      "        ordered_match = re.match(r'^\\s*\\d+\\.\\s+(.*)$', stripped)\n"
      "        if unordered_match or ordered_match:\n"
      "            close_paragraph()\n"
      "            next_type = 'ul' if unordered_match else 'ol'\n"
      "            item_text = unordered_match.group(1) if unordered_match else ordered_match.group(1)\n"
      "            if list_type != next_type:\n"
      "                close_list()\n"
      "                list_type = next_type\n"
      "                out.append(f'<{list_type}>')\n"
      "            out.append(f'<li>{inline_markup(item_text.strip())}</li>')\n"
      "            continue\n"
      "        para.append(stripped.strip())\n"
      "    close_paragraph(); close_list()\n"
      "    if in_code:\n"
      "        out.append('<pre><code>' + html.escape('\\n'.join(code_lines)) + '</code></pre>')\n"
      "    prefix = '' if rel_path.parent == Path('.') else '../' * len(rel_path.parent.parts)\n"
      "    back_href = 'index.html' if rel_path.parent == Path('.') else prefix + 'index.html'\n"
      "    wordmark_src = prefix + 'assets/pharos-framework-wordmark.svg'\n"
      "    stylesheet_src = prefix + 'assets/docs.css'\n"
      "    return HTML_TEMPLATE.format(title=html.escape(title), back_href=html.escape(back_href, quote=True), wordmark_src=html.escape(wordmark_src, quote=True), stylesheet_src=html.escape(stylesheet_src, quote=True), body='\\n'.join(out))\n"
      "def rewrite_html_links(path):\n"
      "    text = path.read_text(encoding='utf-8')\n"
      "    text = text.replace('.md#', '.html#')\n"
      "    text = re.sub(r'([\"\\\'])((?:[^\"\\\']+/)?[^\"\\\']+\\.md)(#[^\"\\\']*)?\\1', lambda m: f'{m.group(1)}{rewrite_href(m.group(2))}{m.group(3) or \"\"}{m.group(1)}', text)\n"
      "    path.write_text(text, encoding='utf-8')\n"
      "markdown_files = sorted(ROOT.rglob('*.md'))\n"
      "for md_path in markdown_files:\n"
      "    rel = md_path.relative_to(ROOT)\n"
      "    html_path = md_path.with_suffix('.html')\n"
      "    html_path.write_text(render_markdown(md_path.read_text(encoding='utf-8'), rel), encoding='utf-8')\n"
      "for html_path in sorted(ROOT.rglob('*.html')):\n"
      "    rewrite_html_links(html_path)\n"
      "for md_path in markdown_files:\n"
      "    md_path.unlink()\n";
    code = write_text_file(markdown_renderer, renderer_script);
    if (code != 0) {
      goto cleanup;
    }
    needed = strlen(markdown_renderer) + strlen(target_docs) + 32;
    command = (char *)malloc(needed);
    if (command == NULL) {
      code = 69;
      goto cleanup;
    }
    snprintf(command, needed, "python3 %s %s", markdown_renderer, target_docs);
    argv_list[0] = "/bin/sh";
    argv_list[1] = "-c";
    argv_list[2] = command;
    argv_list[3] = NULL;
    code = capture_execv_output_native(argv_list, &output, NULL);
    free(command);
    command = NULL;
    free(output);
    output = NULL;
    if (code != 0) {
      goto cleanup;
    }
  }
  code = write_text_file(target_docs_index, dev_docs_directory_index_html_native());
  if (code != 0) {
    goto cleanup;
  }
  doxyfile_text = read_file_text(repo_doxyfile);
  if (doxyfile_text == NULL) {
    code = 66;
    goto cleanup;
  }
  needed = strlen(doxyfile_text) + strlen(target_docs) + 96;
  generated_doxyfile_text = (char *)malloc(needed);
  if (generated_doxyfile_text == NULL) {
    code = 69;
    goto cleanup;
  }
  snprintf(generated_doxyfile_text, needed, "%s\nOUTPUT_DIRECTORY = %s\nHTML_OUTPUT = html\n", doxyfile_text, target_docs);
  code = write_text_file(generated_doxyfile, generated_doxyfile_text);
  if (code != 0) {
    goto cleanup;
  }
  needed = strlen(repo_root) + strlen(generated_doxyfile) + 32;
  command = (char *)malloc(needed);
  if (command == NULL) {
    code = 69;
    goto cleanup;
  }
  snprintf(command, needed, "cd %s && doxygen %s", repo_root, generated_doxyfile);
  argv_list[0] = "/bin/sh";
  argv_list[1] = "-c";
  argv_list[2] = command;
  argv_list[3] = NULL;
  code = capture_execv_output_native(argv_list, &output, NULL);
  if (code != 0 && output != NULL && output[0] != '\0') {
    fprintf(stderr, "%s", output);
  }
#ifdef __APPLE__
  if (code == 0 && path_is_directory(target_docs_html)) {
    int noindex_code = write_text_file(target_docs_html_noindex, "");
    if (noindex_code != 0) {
      code = noindex_code;
    }
  }
#endif
cleanup:
  if (generated_doxyfile != NULL && path_exists(generated_doxyfile)) {
    pharos_unlink(generated_doxyfile);
  }
  if (markdown_renderer != NULL && path_exists(markdown_renderer)) {
    pharos_unlink(markdown_renderer);
  }
  free(apps_root);
  free(repo_root);
  free(repo_docs);
  free(repo_doxyfile);
  free(target_docs);
  free(target_docs_html);
  free(target_docs_index);
  free(generated_doxyfile);
  free(markdown_renderer);
  free(artifact_noindex);
  free(target_docs_noindex);
  free(target_docs_html_noindex);
  free(doxyfile_text);
  free(generated_doxyfile_text);
  free(command);
  free(output);
  return code;
#else
  (void)app_root;
  (void)artifact_dir;
  return 78;
#endif
}
 
static int build_app_from_root_native(
  const char *app_root,
  const char *build_dir_override,
  const char *state_dir_override,
  const char *state_path_override,
  const char *base_path_override,
  char **report_path_out,
  char **artifact_dir_out
) {
  char *manifest_path = path_join(app_root, "pharos.app.json");
  char *manifest_text = NULL;
  char *app_id = NULL;
  char *compiled_entrypoint = NULL;
  char *host_profile = NULL;
  char *state_path = NULL;
  char *base_path = NULL;
  char *payload_dir_rel = NULL;
  char *static_dir_rel = NULL;
  char *media_dir_rel = NULL;
  char *log_path = NULL;
  char *log_format = NULL;
  char *error_report_path = NULL;
  char *debug = NULL;
  char *route_fixture_rel = NULL;
  char *surface_fixture_rel = NULL;
  char *workflow_fixture_rel = NULL;
  char *form_fixture_rel = NULL;
  char *policy_fixture_rel = NULL;
  char *entity_fixture_rel = NULL;
  char *query_fixture_rel = NULL;
  char *migration_fixture_rel = NULL;
  char *seed_sources_text = NULL;
  char *preferred_backend = NULL;
  char *development_backend = NULL;
  char *testing_backend = NULL;
  char *build_dir = NULL;
  char *artifact_dir = NULL;
  char *report_path = NULL;
  char *index_path = NULL;
  char *build_dir_noindex = NULL;
 
  char *payload_dir = NULL;
  char *static_dir = NULL;
  char *media_dir = NULL;
  char *templates_dir = NULL;
  char *data_dir = NULL;
  char *fixtures_dir = NULL;
  char *app_manifest_source_path = NULL;
  char *app_conf_source_path = NULL;
  char *pharos_conf_source_path = NULL;
  char *start_script_source_path = NULL;
  char *app_manifest_target_path = NULL;
  char *app_conf_target_path = NULL;
  char *start_script_target_path = NULL;
  char *target_static = NULL;
  char *target_media = NULL;
 
  char *index_html = NULL;
  char *artifact_local_app_manifest_json = NULL;
 
  char *route_fixture = NULL;
  char *surface_fixture = NULL;
  char *workflow_fixture = NULL;
  char *form_fixture = NULL;
  char *policy_fixture = NULL;
  char *entity_fixture = NULL;
  char *query_fixture = NULL;
  char *migration_fixture = NULL;
  char *route_fixture_text = NULL;
  char *surface_fixture_text = NULL;
  char *workflow_fixture_text = NULL;
  int route_count = 0;
  int surface_count = 0;
  int workflow_count = 0;
  int code = 0;
  if (manifest_path == NULL || !path_exists(manifest_path)) {
    free(manifest_path);
    return 66;
  }
  manifest_text = read_file_text(manifest_path);
  if (manifest_text == NULL) {
    free(manifest_path);
    return 66;
  }
  app_id = json_find_string(manifest_text, "app_id");
  compiled_entrypoint = json_find_string_in_section(manifest_text, "runtime", "compiled_entrypoint");
  host_profile = json_find_string_in_section(manifest_text, "runtime", "host_profile");
  payload_dir_rel = json_find_string_in_section(manifest_text, "assets", "payload_dir");
  static_dir_rel = json_find_string_in_section(manifest_text, "assets", "static_dir");
  media_dir_rel = json_find_string_in_section(manifest_text, "assets", "media_dir");
  route_fixture_rel = json_find_string_in_section(manifest_text, "fixtures", "route_fixture");
  surface_fixture_rel = json_find_string_in_section(manifest_text, "fixtures", "surface_fixture");
  workflow_fixture_rel = json_find_string_in_section(manifest_text, "fixtures", "workflow_fixture");
  form_fixture_rel = json_find_string_in_section(manifest_text, "fixtures", "form_fixture");
  policy_fixture_rel = json_find_string_in_section(manifest_text, "fixtures", "policy_fixture");
  entity_fixture_rel = json_find_string_in_section(manifest_text, "database", "entity_fixture");
  query_fixture_rel = json_find_string_in_section(manifest_text, "database", "query_fixture");
  migration_fixture_rel = json_find_string_in_section(manifest_text, "database", "migration_fixture");
  seed_sources_text = json_extract_array_in_section(manifest_text, "database", "seed_sources");
  preferred_backend = json_find_string_in_section(manifest_text, "database", "preferred_backend");
  development_backend = json_find_string_in_section(manifest_text, "database", "development_backend");
  testing_backend = json_find_string_in_section(manifest_text, "database", "testing_backend");
  if (app_id == NULL) {
    code = 66;
    goto cleanup;
  }
  build_dir = effective_app_build_dir_native(app_root, build_dir_override);
  artifact_dir = effective_app_artifact_dir_native(app_root, build_dir, app_id);
  payload_dir = payload_dir_rel != NULL ? path_join(app_root, payload_dir_rel) : NULL;
  static_dir = static_dir_rel != NULL ? path_join(app_root, static_dir_rel) : NULL;
  media_dir = media_dir_rel != NULL ? path_join(app_root, media_dir_rel) : NULL;
  templates_dir = path_join(app_root, "templates");
  data_dir = path_join(app_root, "data");
  fixtures_dir = path_join(app_root, "fixtures");
  app_manifest_source_path = path_join(app_root, "pharos.app.json");
  app_conf_source_path = path_join(app_root, "app.conf");
  pharos_conf_source_path = path_join(app_root, "pharos.conf");
  start_script_source_path = path_join(app_root, "start.sh");
  app_manifest_target_path = path_join(artifact_dir, "pharos.app.json");
  app_conf_target_path = path_join(artifact_dir, "app.conf");
  start_script_target_path = path_join(artifact_dir, "start.sh");
  target_static = path_join(artifact_dir, "static");
  target_media = path_join(artifact_dir, "media");
  index_path = path_join(artifact_dir, "index.html");
  report_path = native_website_report_path(build_dir, "build-app", app_id);
  build_dir_noindex = path_join(build_dir, ".metadata_never_index");
  if (build_dir == NULL || artifact_dir == NULL || target_static == NULL || target_media == NULL || index_path == NULL || report_path == NULL || build_dir_noindex == NULL || app_manifest_source_path == NULL || app_manifest_target_path == NULL || app_conf_target_path == NULL || start_script_source_path == NULL || start_script_target_path == NULL) {
    code = 69;
    goto cleanup;
  }
  remove_directory_recursive(artifact_dir);
  if (ensure_directory(artifact_dir) != 0) {
    code = 69;
    goto cleanup;
  }
#ifdef __APPLE__
  code = write_text_file(build_dir_noindex, "");
  if (code != 0) {
    goto cleanup;
  }
#endif
 
  if (path_exists(app_conf_source_path)) {
    code = copy_file_binary(app_conf_source_path, app_conf_target_path);
    if (code != 0) goto cleanup;
  } else if (path_exists(pharos_conf_source_path)) {
    code = copy_file_binary(pharos_conf_source_path, app_conf_target_path);
    if (code != 0) goto cleanup;
  }
  if (path_exists(start_script_source_path)) {
    code = copy_file_binary(start_script_source_path, start_script_target_path);
    if (code != 0) goto cleanup;
  }
  if (data_dir != NULL && path_is_directory(data_dir)) {
    char *target_data = path_join(artifact_dir, "data");
    if (target_data == NULL) {
      code = 69;
      goto cleanup;
    }
    code = copy_directory_recursive(data_dir, target_data);
    free(target_data);
    if (code != 0) goto cleanup;
  }
  if (fixtures_dir != NULL && path_is_directory(fixtures_dir)) {
    char *target_fixtures = path_join(artifact_dir, "fixtures");
    if (target_fixtures == NULL) {
      code = 69;
      goto cleanup;
    }
    code = copy_directory_recursive(fixtures_dir, target_fixtures);
    free(target_fixtures);
    if (code != 0) goto cleanup;
  }
  if (payload_dir != NULL && path_is_directory(payload_dir)) {
    code = copy_directory_recursive(payload_dir, artifact_dir);
    if (code != 0) goto cleanup;
  }
  if (static_dir != NULL && path_is_directory(static_dir)) {
    code = copy_directory_recursive(static_dir, target_static);
    if (code != 0) goto cleanup;
  }
  if (media_dir != NULL && path_is_directory(media_dir)) {
    code = copy_directory_recursive(media_dir, target_media);
    if (code != 0) goto cleanup;
  }
  if (templates_dir != NULL && path_is_directory(templates_dir)) {
    char *target_templates = path_join(artifact_dir, "templates");
    if (target_templates == NULL) {
      code = 69;
      goto cleanup;
    }
    code = copy_directory_recursive(templates_dir, target_templates);
    free(target_templates);
    if (code != 0) goto cleanup;
  }
  if (streq(app_id, "dev_docs")) {
    code = build_dev_docs_directory_native(app_root, artifact_dir);
    if (code != 0) goto cleanup;
  }
  route_fixture = route_fixture_rel != NULL ? path_join(app_root, route_fixture_rel) : NULL;
  surface_fixture = surface_fixture_rel != NULL ? path_join(app_root, surface_fixture_rel) : NULL;
  workflow_fixture = workflow_fixture_rel != NULL ? path_join(app_root, workflow_fixture_rel) : NULL;
  form_fixture = form_fixture_rel != NULL ? path_join(app_root, form_fixture_rel) : NULL;
  policy_fixture = policy_fixture_rel != NULL ? path_join(app_root, policy_fixture_rel) : NULL;
  entity_fixture = entity_fixture_rel != NULL ? path_join(app_root, entity_fixture_rel) : NULL;
  query_fixture = query_fixture_rel != NULL ? path_join(app_root, query_fixture_rel) : NULL;
  migration_fixture = migration_fixture_rel != NULL ? path_join(app_root, migration_fixture_rel) : NULL;
  route_fixture_text = route_fixture != NULL ? read_file_text(route_fixture) : NULL;
  surface_fixture_text = surface_fixture != NULL ? read_file_text(surface_fixture) : NULL;
  workflow_fixture_text = workflow_fixture != NULL ? read_file_text(workflow_fixture) : NULL;
  route_count = count_substring_occurrences(route_fixture_text, "\"route_id\"");
  surface_count = count_substring_occurrences(surface_fixture_text, "\"surface_id\"");
  workflow_count = count_substring_occurrences(workflow_fixture_text, "\"workflow_id\"");
  state_path = effective_app_state_path_native(app_root, build_dir, app_id, state_path_override, state_dir_override);
  base_path = effective_app_base_path_native(app_root, base_path_override);
  log_path = effective_app_log_path_native(app_root, app_id, NULL);
  log_format = effective_app_log_format_native(app_root);
  error_report_path = effective_app_error_report_path_native(app_root, app_id);
  debug = effective_app_debug_native(app_root, NULL);
  if (compiled_entrypoint != NULL && compiled_entrypoint[0] != '\0' && (
#ifdef _WIN32
      !(strlen(compiled_entrypoint) > 2 && compiled_entrypoint[1] == ':') &&
#endif
      compiled_entrypoint[0] != '/'
  )) {
    char *resolved = path_join(app_root, compiled_entrypoint);
    free(compiled_entrypoint);
    compiled_entrypoint = resolved;
  }
  index_html = build_native_app_index_html(app_id);
  artifact_local_app_manifest_json = build_artifact_local_app_manifest_json(
    manifest_text,
    "pharos-native-runtime",
    state_path,
    base_path,
    log_path,
    log_format,
    error_report_path,
    debug,
    "",
    route_count,
    surface_count,
    workflow_count
  );
  if (index_html == NULL || artifact_local_app_manifest_json == NULL) {
    code = 69;
    goto cleanup;
  }
  if (!path_exists(index_path)) {
    code = write_text_file(index_path, index_html);
  }
  if (code == 0) code = write_text_file(app_manifest_target_path, artifact_local_app_manifest_json);
  if (code == 0) {
    char *report_json = build_native_app_build_report_json(artifact_dir, app_id, state_path, base_path, log_path, log_format, error_report_path, debug, host_profile, compiled_entrypoint);
    if (report_json == NULL) {
      code = 69;
      goto cleanup;
    }
    code = write_text_file(report_path, report_json);
    free(report_json);
  }
cleanup:
  free(manifest_path);
    free(manifest_text);
    free(app_id);
    free(compiled_entrypoint);
    free(host_profile);
    free(state_path);
    free(base_path);
    free(log_path);
    free(log_format);
    free(error_report_path);
    free(debug);
    free(payload_dir_rel);
    free(static_dir_rel);
    free(media_dir_rel);
    free(route_fixture_rel);
    free(surface_fixture_rel);
    free(workflow_fixture_rel);
    free(form_fixture_rel);
    free(policy_fixture_rel);
    free(entity_fixture_rel);
    free(query_fixture_rel);
    free(migration_fixture_rel);
    free(seed_sources_text);
    free(preferred_backend);
    free(development_backend);
    free(testing_backend);
    free(build_dir);
    free(index_path);
    free(build_dir_noindex);
    free(payload_dir);
    free(static_dir);
    free(media_dir);
    free(templates_dir);
    free(data_dir);
    free(fixtures_dir);
    free(app_manifest_source_path);
    free(app_conf_source_path);
    free(pharos_conf_source_path);
    free(start_script_source_path);
    free(app_manifest_target_path);
    free(app_conf_target_path);
    free(start_script_target_path);
    free(target_static);
    free(target_media);
 
    free(index_html);
    free(artifact_local_app_manifest_json);
    free(route_fixture);
    free(surface_fixture);
    free(workflow_fixture);
    free(form_fixture);
    free(policy_fixture);
    free(entity_fixture);
    free(query_fixture);
    free(migration_fixture);
    free(route_fixture_text);
    free(surface_fixture_text);
    free(workflow_fixture_text);
  if (code != 0) {
    free(artifact_dir);
    free(report_path);
    return code;
  }
  if (report_path_out != NULL) *report_path_out = report_path; else free(report_path);
  if (artifact_dir_out != NULL) *artifact_dir_out = artifact_dir; else free(artifact_dir);
  return 0;
}
 
 
 
static int add_runtime_app_native(RuntimeStack *stack, const ServeConfig *config, const char *app_root, const char *app_id_hint) {
  AppRuntime app;
  char *app_id = NULL;
  char *build_dir = NULL;
  char *artifact_dir = NULL;
 
  if (stack->count >= MAX_APPS) {
    return 0;
  }
  if (app_id_hint != NULL && app_id_hint[0] != '\0') {
    app_id = pharos_strdup(app_id_hint);
  } else {
    char *manifest_path = path_join(app_root, "pharos.app.json");
    char *manifest_text = manifest_path != NULL ? read_file_text(manifest_path) : NULL;
    if (manifest_text != NULL) {
      app_id = json_find_string(manifest_text, "app_id");
    }
    free(manifest_path);
    free(manifest_text);
  }
  if (app_id == NULL) {
    return 66;
  }
  build_dir = runtime_build_dir_override_native(config, app_root);
  if (build_dir == NULL) {
    free(app_id);
    return 69;
  }
  if (maybe_seed_app_state_native(config, app_root, app_id, 1) != 0) {
    free(app_id);
    free(build_dir);
    return 69;
  }
  if (app_root_has_finalized_artifact_native(app_root)) {
    int load_existing_code = load_app_runtime_from_artifact_native(app_root, &app);
    if (load_existing_code == 0) {
      if (finalize_loaded_app_runtime_native(&app, config, app_root, build_dir) != 0) {
        free_app_runtime(&app);
        free(app_id);
        free(build_dir);
        return 69;
      }
      stack->apps[stack->count++] = app;
      free(app_id);
      free(build_dir);
      return 0;
    }
  }
  artifact_dir = effective_app_artifact_dir_native(app_root, build_dir, app_id);
  if (artifact_dir != NULL) {
    int load_existing_code = load_app_runtime_from_artifact_native(artifact_dir, &app);
    if (load_existing_code == 0) {
      if (finalize_loaded_app_runtime_native(&app, config, app_root, build_dir) != 0) {
        free_app_runtime(&app);
        free(app_id);
        free(build_dir);
        free(artifact_dir);
        return 69;
      }
      stack->apps[stack->count++] = app;
      free(app_id);
      free(build_dir);
      free(artifact_dir);
      return 0;
    }
    free(artifact_dir);
    artifact_dir = NULL;
  }
  {
    int prepare_code = prepare_app_artifact_native(app_root, app_id, build_dir, config != NULL ? config->state_dir : NULL, config != NULL ? config->state_path : NULL, config != NULL ? config->base_path : NULL, NULL, &artifact_dir);
    if (prepare_code != 0) {
      free(app_id);
      free(build_dir);
      return 66;
    }
  }
  if (artifact_dir == NULL) {
    free(app_id);
    free(build_dir);
    return 69;
  }
  {
    int load_code = load_app_runtime_from_artifact_native(artifact_dir, &app);
    if (load_code == 0) {
      if (finalize_loaded_app_runtime_native(&app, config, app_root, build_dir) != 0) {
        free_app_runtime(&app);
        free(app_id);
        free(build_dir);
        free(artifact_dir);
        return 69;
      }
      stack->apps[stack->count++] = app;
      free(app_id);
      free(build_dir);
      free(artifact_dir);
      return 0;
    }
  }
  free(app_id);
  free(build_dir);
  free(artifact_dir);
  return 66;
}
 
static char *executable_dir_from_argv0(const char *argv0) {
  char *cwd;
  char *path;
  char *dir;
  char *canonical;
  if (argv0 == NULL) {
    return current_working_directory();
  }
  if (
#ifdef _WIN32
      (strlen(argv0) > 2 && argv0[1] == ':') ||
#endif
      argv0[0] == '/' || argv0[0] == '.'
  ) {
    path = pharos_strdup(argv0);
  } else {
    cwd = current_working_directory();
    path = path_join(cwd, argv0);
    free(cwd);
  }
  dir = path_dirname(path);
  free(path);
  canonical = path_canonicalize(dir);
  free(dir);
  return canonical;
}
 
static char *find_repo_root(const char *argv0) {
  char *search_dir = executable_dir_from_argv0(argv0);
  while (search_dir != NULL) {
    char *scripts = path_join(search_dir, "scripts/pharos_runtime.sh");
    char *nested = path_join(search_dir, "pharos/scripts/pharos_runtime.sh");
    if (scripts != NULL && path_exists(scripts)) {
      char *repo = path_canonicalize(search_dir);
      free(nested);
      free(scripts);
      free(search_dir);
      return repo;
    }
    if (nested != NULL && path_exists(nested)) {
      char *repo = path_join(search_dir, "pharos");
      char *canonical_repo = path_canonicalize(repo);
      free(repo);
      free(nested);
      free(scripts);
      free(search_dir);
      return canonical_repo;
    }
    free(nested);
    free(scripts);
    if (streq(search_dir, "/") || streq(search_dir, ".") || strlen(search_dir) <= 1) {
      break;
    }
#ifdef _WIN32
    if (strlen(search_dir) == 3 && search_dir[1] == ':' && (search_dir[2] == '\\' || search_dir[2] == '/')) {
      break;
    }
#endif
    {
      char *parent = path_dirname(search_dir);
      if (parent == NULL || streq(parent, search_dir)) {
        free(parent);
        break;
      }
      free(search_dir);
      search_dir = parent;
    }
  }
  free(search_dir);
  search_dir = current_working_directory();
  while (search_dir != NULL) {
    char *scripts = path_join(search_dir, "scripts/pharos_runtime.sh");
    char *nested = path_join(search_dir, "pharos/scripts/pharos_runtime.sh");
    if (scripts != NULL && path_exists(scripts)) {
      char *repo = path_canonicalize(search_dir);
      free(nested);
      free(scripts);
      free(search_dir);
      return repo;
    }
    if (nested != NULL && path_exists(nested)) {
      char *repo = path_join(search_dir, "pharos");
      char *canonical_repo = path_canonicalize(repo);
      free(repo);
      free(nested);
      free(scripts);
      free(search_dir);
      return canonical_repo;
    }
    free(nested);
    free(scripts);
    if (streq(search_dir, "/") || streq(search_dir, ".") || strlen(search_dir) <= 1) {
      break;
    }
#ifdef _WIN32
    if (strlen(search_dir) == 3 && search_dir[1] == ':' && (search_dir[2] == '\\' || search_dir[2] == '/')) {
      break;
    }
#endif
    {
      char *parent = path_dirname(search_dir);
      if (parent == NULL || streq(parent, search_dir)) {
        free(parent);
        break;
      }
      free(search_dir);
      search_dir = parent;
    }
  }
  free(search_dir);
  return NULL;
}
 
static char *resolve_value_or_default(const char *value, const char *fallback) {
  if (value == NULL || value[0] == '\0') {
    return pharos_strdup(fallback);
  }
  return pharos_strdup(value);
}
 
static int app_root_has_finalized_artifact_native(const char *app_root) {
  char *manifest_path = NULL;
  int ready = 0;
  if (app_root == NULL || app_root[0] == '\0') {
    return 0;
  }
  manifest_path = path_join(app_root, "pharos.app.json");
  if (manifest_path != NULL && path_exists(manifest_path)) {
    ready = 1;
  }
  free(manifest_path);
  return ready;
}
 
static char *resolve_runtime_socket_path_native(const ServeConfig *config, const char *runtime_conf_path, const char *runtime_conf_dir) {
  char *socket_value = NULL;
  char *resolved_socket_path = NULL;
  if (config != NULL && config->socket_path != NULL) {
    return pharos_strdup(config->socket_path);
  }
  if (runtime_conf_path == NULL) {
    return NULL;
  }
  socket_value = conf_lookup_value(runtime_conf_path, "socket_path");
  if (socket_value == NULL) {
    return NULL;
  }
  resolved_socket_path = resolve_relative_to(runtime_conf_dir, socket_value);
  free(socket_value);
  return resolved_socket_path;
}
 
static int emit_text_file_to_stdout_native(const char *file_path) {
  char *content = NULL;
  if (file_path == NULL) {
    return 0;
  }
  content = read_file_text(file_path);
  if (content == NULL) {
    return 69;
  }
  fputs(content, stdout);
  free(content);
  return 0;
}
 
static char *resolve_seed_entrypoint_native(const char *app_root, const char *target_id, const char *build_dir_override) {
  char *host_profile = NULL;
  char *manifest_path = NULL;
  char *manifest_text = NULL;
  char *seed_entrypoint = NULL;
  if (app_root == NULL || target_id == NULL) {
    return NULL;
  }
  host_profile = app_runtime_host_profile_native(app_root);
  /**
   * Static-pages apps are now built and served directly from their finalized
   * artifacts in the native runtime path and do not require seed-entrypoint
   * compatibility hosts because they have no app-owned mutable runtime state.
   */
  if (host_profile != NULL && streq(host_profile, "static-pages")) {
    free(host_profile);
    return NULL;
  }
  free(host_profile);
  manifest_path = path_join(app_root, "pharos.app.json");
  manifest_text = manifest_path != NULL ? read_file_text(manifest_path) : NULL;
  free(manifest_path);
  if (manifest_text != NULL) {
    seed_entrypoint = json_find_string_in_section(manifest_text, "runtime", "compiled_entrypoint");
    free(manifest_text);
  }
  if (seed_entrypoint == NULL || seed_entrypoint[0] == '\0') {
    char buffer[4096];
    free(seed_entrypoint);
    snprintf(buffer, sizeof(buffer), "%s/runtime/%s_native_host", app_root, target_id);
    return pharos_strdup(buffer);
  }
  if (seed_entrypoint[0] == '/') {
    return seed_entrypoint;
  }
  {
    char *resolved_seed = path_join(app_root, seed_entrypoint);
    free(seed_entrypoint);
    return resolved_seed;
  }
}
 
static int maybe_seed_app_state_native(const ServeConfig *config, const char *app_root, const char *app_id, int force_seed) {
  char *seed_entrypoint;
  char *resolved_state;
  char *resolved_base;
  char *build_dir = NULL;
  char *pharos_bin_path = NULL;
  char *argv_list[9];
  const char *env_keys[2];
  const char *env_values[2];
  size_t env_count = 0;
  char *output = NULL;
  int argc = 0;
  int code = 0;
  if (config == NULL || app_root == NULL || app_id == NULL || app_id[0] == '\0' || (!config->seed_state && !force_seed)) {
    return 0;
  }
  build_dir = runtime_build_dir_override_native(config, app_root);
  seed_entrypoint = resolve_seed_entrypoint_native(app_root, app_id, build_dir);
  if (seed_entrypoint == NULL || !path_exists(seed_entrypoint)) {
    free(build_dir);
    free(seed_entrypoint);
    return 0;
  }
  resolved_state = effective_app_state_path_native(
    app_root,
    build_dir != NULL ? build_dir : "dist",
    app_id,
    config->state_path,
    config->state_dir
  );
  resolved_base = effective_app_base_path_native(app_root, config->base_path);
  argv_list[argc++] = seed_entrypoint;
  argv_list[argc++] = "--build-dir";
  argv_list[argc++] = build_dir != NULL ? build_dir : "dist";
  argv_list[argc++] = "--state-path";
  argv_list[argc++] = resolved_state != NULL ? resolved_state : "";
  argv_list[argc++] = "--base-path";
  argv_list[argc++] = resolved_base != NULL ? resolved_base : "/";
  argv_list[argc++] = "--seed-state";
  argv_list[argc] = NULL;
  if (global_binary_dir != NULL && global_binary_dir[0] != '\0') {
    pharos_bin_path = path_join(global_binary_dir, "pharos");
    if (pharos_bin_path != NULL && path_exists(pharos_bin_path)) {
      env_keys[env_count] = "PHAROS_BIN";
      env_values[env_count] = pharos_bin_path;
      env_count++;
    }
  }
  if (config->conf_path != NULL && config->conf_path[0] != '\0') {
    env_keys[env_count] = "PHAROS_RUNTIME_CONF_PATH";
    env_values[env_count] = config->conf_path;
    env_count++;
  }
  code = capture_execv_output_env_native(argv_list, env_keys, env_values, env_count, &output, NULL);
  if (code != 0 && output != NULL && output[0] != '\0') {
    fprintf(stderr, "%s", output);
  }
  free(output);
  free(pharos_bin_path);
  free(build_dir);
  free(resolved_state);
  free(resolved_base);
  free(seed_entrypoint);
  return code;
}
 
static int load_app_runtime_for_single_app(const ServeConfig *config, AppRuntime *app) {
  char *app_root = NULL;
  char *artifact_dir_native = NULL;
  char *status_output = NULL;
  char *artifact_dir;
  int code;
  if (config != NULL && config->app_dir != NULL && config->app_dir[0] != '\0' && config->target_id != NULL) {
    char *direct_manifest = path_join(config->app_dir, "pharos.app.json");
    char *direct_manifest_text = direct_manifest != NULL ? read_file_text(direct_manifest) : NULL;
    char *direct_app_id = direct_manifest_text != NULL ? json_find_string(direct_manifest_text, "app_id") : NULL;
    char *direct_build_artifact_dir = direct_manifest_text != NULL ? json_find_string_in_section(direct_manifest_text, "runtime", "build_artifact_dir") : NULL;
    if (direct_app_id != NULL && streq(direct_app_id, config->target_id) && direct_build_artifact_dir != NULL && streq(direct_build_artifact_dir, ".")) {
      char *direct_root = path_canonicalize(config->app_dir);
      char *direct_build_dir = NULL;
      if (direct_root == NULL) {
        direct_root = pharos_strdup(config->app_dir);
      }
      if (direct_root != NULL) {
        direct_build_dir = effective_app_build_dir_native(direct_root, config->build_dir);
      }
      if (direct_root != NULL && direct_build_dir != NULL) {
        code = load_app_runtime_from_artifact_native(direct_root, app);
        if (code == 0) {
          if (finalize_loaded_app_runtime_native(app, config, direct_root, direct_build_dir) == 0) {
            free(direct_build_artifact_dir);
            free(direct_app_id);
            free(direct_manifest_text);
            free(direct_manifest);
            free(direct_build_dir);
            free(direct_root);
            return 0;
          }
          free_app_runtime(app);
        }
      }
      free(direct_build_dir);
      free(direct_root);
    } else if (direct_app_id != NULL && streq(direct_app_id, config->target_id)) {
      app_root = path_canonicalize(config->app_dir);
      if (app_root == NULL) {
        app_root = pharos_strdup(config->app_dir);
      }
    }
    free(direct_build_artifact_dir);
    free(direct_app_id);
    free(direct_manifest_text);
    free(direct_manifest);
  }
  if (app_root == NULL) {
    app_root = find_app_root_for_target(config->target_id, config->app_dir, global_repo_root, global_binary_dir);
  }
  if (app_root != NULL) {
    char *build_dir = effective_app_build_dir_native(app_root, config->build_dir);
    AppLocalConfigNative local_config;
    int packaged_artifact_mode = 0;
    memset(&local_config, 0, sizeof(local_config));
    if (build_dir == NULL) {
      free(app_root);
      return 69;
    }
    if (load_app_local_config_native(app_root, &local_config) == 0) {
      if (local_config.manifest_build_artifact_dir != NULL && streq(local_config.manifest_build_artifact_dir, ".")) {
        packaged_artifact_mode = 1;
      }
      free_app_local_config_native(&local_config);
    }
    if (packaged_artifact_mode) {
      code = load_app_runtime_from_artifact_native(app_root, app);
      if (code == 0) {
        if (finalize_loaded_app_runtime_native(app, config, app_root, build_dir) != 0) {
          free(build_dir);
          free(app_root);
          return 69;
        }
        free(build_dir);
        free(app_root);
        return 0;
      }
    } else {
      if (maybe_seed_app_state_native(config, app_root, config->target_id, 1) != 0) {
        free(build_dir);
        free(app_root);
        return 69;
      }
      code = prepare_app_artifact_native(app_root, config->target_id, build_dir, config->state_dir, config->state_path, config->base_path, NULL, &artifact_dir_native);
      if (code == 0 && artifact_dir_native != NULL) {
        code = load_app_runtime_from_artifact_native(artifact_dir_native, app);
        free(artifact_dir_native);
        artifact_dir_native = NULL;
        if (code == 0) {
          if (finalize_loaded_app_runtime_native(app, config, app_root, build_dir) != 0) {
            free(build_dir);
            free(app_root);
            return 69;
          }
          free(build_dir);
          free(app_root);
          return 0;
        }
      }
    }
    free(build_dir);
    free(app_root);
  }
  code = shell_status_or_build_native(global_repo_root, config, 0, &status_output);
  if (code != 0) {
    fprintf(stderr, "%s", status_output != NULL ? status_output : "failed to build/status Pharos app\n");
    free(status_output);
    return code;
  }
  artifact_dir = json_find_string(status_output, "artifact_dir");
  free(status_output);
  if (artifact_dir == NULL) {
    return 66;
  }
  code = load_app_runtime_from_artifact_native(artifact_dir, app);
  free(artifact_dir);
  if (code != 0) {
    return code;
  }
  if (finalize_loaded_app_runtime_native(app, config, NULL, NULL) != 0) {
    return 69;
  }
  return 0;
}
 
#ifndef _WIN32
static int spawn_app_request(const AppRuntime *app, const HttpRequest *request, char **response, size_t *response_len, char **stderr_text, size_t *stderr_len) {
  char *temp_body_path = NULL;
  char *argv_list[PHAROS_APP_REQUEST_ARGV_CAPACITY];
  const char *env_keys[2];
  const char *env_values[2];
  size_t env_count = 0;
  size_t argc = 0;
  int code;
  if (stderr_text != NULL) {
    *stderr_text = NULL;
  }
  if (stderr_len != NULL) {
    *stderr_len = 0;
  }
  if (request->body_file_path != NULL && request->body_file_path[0] != '\0') {
    temp_body_path = pharos_strdup(request->body_file_path);
    if (temp_body_path == NULL) {
      return 69;
    }
  } else if (request->body_len > 0) {
    if (write_native_temp_body_file(request->body, request->body_len, &temp_body_path) != 0) {
      return 69;
    }
  }
  if (build_native_app_request_argv(
        app,
        request->method,
        request->target,
        request->cookie,
        request->headers,
        request->content_type,
        request->body,
        request->is_multipart,
        temp_body_path,
        argv_list,
        PHAROS_APP_REQUEST_ARGV_CAPACITY,
        &argc
      ) != 0) {
    cleanup_native_temp_body_file(&temp_body_path);
    return 69;
  }
  if (app->runtime_conf_path != NULL && app->runtime_conf_path[0] != '\0') {
    env_keys[env_count] = "PHAROS_RUNTIME_CONF_PATH";
    env_values[env_count] = app->runtime_conf_path;
    env_count++;
  }
  if (global_binary_dir != NULL && global_binary_dir[0] != '\0') {
    static char pharos_bin_path[4096];
#ifdef _WIN32
    snprintf(pharos_bin_path, sizeof(pharos_bin_path), "%s\\pharos.exe", global_binary_dir);
#else
    snprintf(pharos_bin_path, sizeof(pharos_bin_path), "%s/pharos", global_binary_dir);
#endif
    env_keys[env_count] = "PHAROS_BIN";
    env_values[env_count] = pharos_bin_path;
    env_count++;
  }
  code = capture_execv_output_split_env_native(argv_list, env_keys, env_values, env_count, response, response_len, stderr_text, stderr_len);
  cleanup_native_temp_body_file(&temp_body_path);
  return code;
}
#else
static int spawn_app_request(const AppRuntime *app, const HttpRequest *request, char **response, size_t *response_len, char **stderr_text, size_t *stderr_len) {
  (void)app;
  (void)request;
  (void)response;
  (void)response_len;
  (void)stderr_text;
  (void)stderr_len;
  return 78;
}
#endif
 
static char *resolve_website_root(const ServeConfig *config) {
  char *native_artifact_dir = NULL;
  char *status_output = NULL;
  char *artifact_dir = NULL;
  int code = shell_status_or_build_native(global_repo_root, config, 0, &status_output);
  if (config != NULL && native_known_website_supported(config->target_id)) {
    if (build_known_website_native(config->target_id, config->build_dir != NULL ? config->build_dir : "dist", NULL, &native_artifact_dir) == 0) {
      return native_artifact_dir;
    }
  }
  if (code != 0) {
    fprintf(stderr, "%s", status_output != NULL ? status_output : "failed to build/status Pharos website\n");
    free(status_output);
    return NULL;
  }
  artifact_dir = json_find_string(status_output, "artifact_dir");
  free(status_output);
  return artifact_dir;
}
 
static int load_runtime_stack(const ServeConfig *config, RuntimeStack *stack) {
  char *runtime_conf_path = NULL;
  char *runtime_conf_dir = NULL;
  char *apps_dir_value = NULL;
  char *build_dir_value = NULL;
  char *state_dir_value = NULL;
  char *state_path_value = NULL;
  char *base_path_value = NULL;
  char *resolved_build_dir = NULL;
  char *resolved_state_dir = NULL;
  char *resolved_state_path = NULL;
  ServeConfig effective_config;
  memset(stack, 0, sizeof(*stack));
  memset(&effective_config, 0, sizeof(effective_config));
  if (config != NULL) {
    effective_config = *config;
  }
  if (config->conf_path != NULL) {
    runtime_conf_path = resolve_relative_to(current_working_directory(), config->conf_path);
    runtime_conf_dir = path_dirname(runtime_conf_path);
    apps_dir_value = conf_lookup_value(runtime_conf_path, "apps_dir");
    if (config->build_dir == NULL || config->build_dir[0] == '\0') {
      build_dir_value = conf_lookup_value(runtime_conf_path, "build_dir");
      resolved_build_dir = build_dir_value != NULL ? resolve_relative_to(runtime_conf_dir, build_dir_value) : NULL;
      effective_config.build_dir = resolved_build_dir;
    }
    if (config->state_dir == NULL || config->state_dir[0] == '\0') {
      state_dir_value = conf_lookup_value(runtime_conf_path, "state_dir");
      resolved_state_dir = state_dir_value != NULL ? resolve_relative_to(runtime_conf_dir, state_dir_value) : NULL;
      effective_config.state_dir = resolved_state_dir;
    }
    if (config->state_path == NULL || config->state_path[0] == '\0') {
      state_path_value = conf_lookup_value(runtime_conf_path, "state_path");
      resolved_state_path = state_path_value != NULL ? resolve_relative_to(runtime_conf_dir, state_path_value) : NULL;
      effective_config.state_path = resolved_state_path;
    }
    if (config->base_path == NULL || config->base_path[0] == '\0') {
      base_path_value = conf_lookup_value(runtime_conf_path, "base_path");
      effective_config.base_path = base_path_value;
    }
  }
  {
    char *apps_dir = apps_dir_value != NULL ? resolve_relative_to(runtime_conf_dir, apps_dir_value) : current_working_directory();
    free(apps_dir_value);
    stack->host = runtime_conf_path != NULL ? resolve_value_or_default(config->host, conf_lookup_value(runtime_conf_path, "host")) : resolve_value_or_default(config->host, "127.0.0.1");
    stack->port = runtime_conf_path != NULL ? resolve_value_or_default(config->port, conf_lookup_value(runtime_conf_path, "port")) : resolve_value_or_default(config->port, "7323");
    stack->socket_path = resolve_runtime_socket_path_native(config, runtime_conf_path, runtime_conf_dir);
#ifndef _WIN32
    DIR *dir = opendir(apps_dir);
    struct dirent *entry;
    if (dir == NULL) {
      free(apps_dir);
      free(runtime_conf_path);
      free(runtime_conf_dir);
      return 66;
    }
    {
      char *root_manifest = path_join(apps_dir, "pharos.app.json");
      char *root_manifest_text = root_manifest != NULL ? read_file_text(root_manifest) : NULL;
      char *root_app_id = root_manifest_text != NULL ? json_find_string(root_manifest_text, "app_id") : NULL;
      if (root_app_id != NULL && root_app_id[0] != '\0') {
        add_runtime_app_native(stack, &effective_config, apps_dir, root_app_id);
      }
      free(root_manifest);
      free(root_manifest_text);
      free(root_app_id);
    }
    while ((entry = readdir(dir)) != NULL && stack->count < MAX_APPS) {
      char *app_root;
      char *app_manifest_path;
      char *app_manifest_text;
      char *app_id;
      if (streq(entry->d_name, ".") || streq(entry->d_name, "..")) {
        continue;
      }
      app_root = path_join(apps_dir, entry->d_name);
      if (!path_is_directory(app_root)) {
        free(app_root);
        continue;
      }
      app_manifest_path = path_join(app_root, "pharos.app.json");
      if (!path_exists(app_manifest_path)) {
        free(app_root);
        free(app_manifest_path);
        continue;
      }
      app_manifest_text = read_file_text(app_manifest_path);
      free(app_manifest_path);
      if (app_manifest_text == NULL) {
        free(app_root);
        continue;
      }
      app_id = json_find_string(app_manifest_text, "app_id");
      free(app_manifest_text);
      if (app_id == NULL) {
        free(app_root);
        continue;
      }
      add_runtime_app_native(stack, &effective_config, app_root, app_id);
      free(app_root);
      free(app_id);
    }
    closedir(dir);
#endif
    free(apps_dir);
  }
  free(runtime_conf_path);
  free(runtime_conf_dir);
  free(build_dir_value);
  free(state_dir_value);
  free(state_path_value);
  free(base_path_value);
  free(resolved_build_dir);
  free(resolved_state_dir);
  free(resolved_state_path);
  if (stack->count == 0) {
    return 66;
  }
  return 0;
}
 
 
 
static void handle_app_or_runtime_request(WorkerContext *context) {
  char *response = NULL;
  char *stderr_text = NULL;
  char *static_target = NULL;
  char *request_target = NULL;
  char *log_target = NULL;
  char *response_status = NULL;
  size_t response_len = 0;
  size_t stderr_len = 0;
  if (streq(context->app.host_profile != NULL ? context->app.host_profile : "", "static-pages")) {
    if (!streq(context->request.method, "GET") && !streq(context->request.method, "HEAD")) {
      native_send_text_response(&context->connection, 405, "Method Not Allowed", "method not allowed\n");
    } else {
      static_target = native_request_target_for_mount(context->app.base_path, context->request.target);
      if (static_target == NULL) {
        native_send_text_response(&context->connection, 500, "Internal Server Error", "memory allocation failed\n");
      } else {
        native_serve_static_file(&context->connection, context->app.artifact_dir, static_target, &context->request, context->app.log_path);
      }
    }
  } else if (streq(context->app.host_profile != NULL ? context->app.host_profile : "", "dynamic-app")) {
    HttpRequest dynamic_request = context->request;
    request_target = native_request_target_for_mount(context->app.base_path, context->request.target);
    log_target = request_target != NULL ? pharos_strdup(request_target) : NULL;
    if (request_target != NULL) {
      dynamic_request.target = request_target;
    }
    int dyn_status = native_dynamic_runtime_handle_request(&context->app, &dynamic_request, &context->connection);
    if (dyn_status >= 200 && dyn_status < 400) {
      native_write_access_log(
        context->app.log_path,
        &context->request,
        log_target != NULL ? log_target : context->request.target,
        dyn_status
      );
    } else {
      char dyn_detail[128];
      snprintf(dyn_detail, sizeof(dyn_detail), "native_dynamic_status=%d", dyn_status);
      native_write_error_log(
        context->app.log_path,
        context->app.error_report_path,
        context->app.app_id,
        &context->request,
        log_target != NULL ? log_target : context->request.target,
        dyn_status >= 200 && dyn_status < 300 ? "200 OK" : (dyn_status == 404 ? "404 Not Found" : "500 Internal Server Error"),
        "native_dynamic_runtime",
        log_target != NULL ? log_target : context->request.target,
        dyn_detail
      );
    }
  } else {
    HttpRequest spawned_request = context->request;
    request_target = native_request_target_for_mount(context->app.base_path, context->request.target);
    log_target = request_target != NULL ? pharos_strdup(request_target) : NULL;
    if (request_target != NULL) {
      spawned_request.target = request_target;
    }
    int code = spawn_app_request(&context->app, &spawned_request, &response, &response_len, &stderr_text, &stderr_len);
    if (code != 0 || response == NULL || response_len == 0) {
      char exit_detail[512];
      if (response != NULL && response_len > 0) {
        snprintf(
          exit_detail,
          sizeof(exit_detail),
          "host_exit_code=%d output_len=%zu entrypoint=%s",
          (int)code,
          response_len,
          context->app.compiled_entrypoint != NULL ? context->app.compiled_entrypoint : ""
        );
      } else {
        snprintf(
          exit_detail,
          sizeof(exit_detail),
          "host_exit_code=%d no_output entrypoint=%s",
          (int)code,
          context->app.compiled_entrypoint != NULL ? context->app.compiled_entrypoint : ""
        );
      }
      native_send_text_response(&context->connection, 502, "Bad Gateway", "Pharos compiled host request failed\n");
      native_write_error_log(
        context->app.log_path,
        context->app.error_report_path,
        context->app.app_id,
        &context->request,
        log_target != NULL ? log_target : context->request.target,
        "502 Bad Gateway",
        "app_host_exit",
        log_target != NULL ? log_target : context->request.target,
        exit_detail
      );
      if (stderr_text != NULL && stderr_len > 0) {
        native_write_error_log(
          context->app.log_path,
          context->app.error_report_path,
          context->app.app_id,
          &context->request,
          log_target != NULL ? log_target : context->request.target,
          "502 Bad Gateway",
          "app_host_stderr",
          log_target != NULL ? log_target : context->request.target,
          stderr_text
        );
      }
    } else {
      native_connection_write(&context->connection, response, response_len);
      response_status = http_status_line_from_response_native(response);
      if (stderr_text != NULL && stderr_len > 0) {
        native_write_error_log(
          context->app.log_path,
          context->app.error_report_path,
          context->app.app_id,
          &context->request,
          log_target != NULL ? log_target : context->request.target,
          response_status != NULL ? response_status : "200 OK",
          "app_host_stderr",
          log_target != NULL ? log_target : context->request.target,
          stderr_text
        );
      }
      if (response_status != NULL) {
        int response_code = http_status_code_from_response_native(response);
        if (response_code >= 200 && response_code < 400) {
          native_write_access_log(
            context->app.log_path,
            &context->request,
            log_target != NULL ? log_target : context->request.target,
            response_code
          );
        } else {
          native_write_error_log(
            context->app.log_path,
            context->app.error_report_path,
            context->app.app_id,
            &context->request,
            log_target != NULL ? log_target : context->request.target,
            response_status,
            "http_response",
            log_target != NULL ? log_target : context->request.target,
            NULL
          );
        }
      }
    }
  }
  free(response_status);
  free(log_target);
  free(request_target);
  free(static_target);
  free(response);
  free(stderr_text);
}
 
/**
 * @brief Release a worker context and every owned request/runtime resource.
 *
 * @param context Per-request worker state to release.
 */
static void free_worker_context_native(WorkerContext *context) {
  if (context == NULL) {
    return;
  }
  free_http_request_native(&context->request);
  free_app_runtime(&context->app);
  native_connection_close(&context->connection);
  free(context);
}
 
/**
 * @brief Clamp one size value into an inclusive range.
 *
 * @param value Candidate value.
 * @param minimum Inclusive lower bound.
 * @param maximum Inclusive upper bound.
 * @return Clamped size value.
 */
static size_t native_clamp_size_value(size_t value, size_t minimum, size_t maximum) {
  if (value < minimum) {
    return minimum;
  }
  if (value > maximum) {
    return maximum;
  }
  return value;
}
 
/**
 * @brief Parse one positive size_t from config text.
 *
 * @param text Raw config value text.
 * @param value_out Parsed positive value on success.
 * @return 1 on success, 0 on invalid or missing input.
 */
static int native_parse_positive_size_value(const char *text, size_t *value_out) {
  char *end = NULL;
  unsigned long long parsed;
  if (text == NULL || text[0] == '\0' || value_out == NULL) {
    return 0;
  }
  errno = 0;
  parsed = strtoull(text, &end, 10);
  if (errno != 0 || end == text || end == NULL || *end != '\0' || parsed == 0ULL) {
    return 0;
  }
  if (parsed > (unsigned long long)SIZE_MAX) {
    return 0;
  }
  *value_out = (size_t)parsed;
  return 1;
}
 
/**
 * @brief Read the configured positive size value for one runtime key.
 *
 * @param runtime_conf_path Runtime configuration path.
 * @param key Config key to read.
 * @param value_out Parsed positive value on success.
 * @return 1 on success, 0 when missing or invalid.
 */
static int native_conf_positive_size_value(const char *runtime_conf_path, const char *key, size_t *value_out) {
  char *raw_value = NULL;
  int parsed_ok = 0;
  if (runtime_conf_path == NULL || runtime_conf_path[0] == '\0' || key == NULL || key[0] == '\0') {
    return 0;
  }
  raw_value = conf_lookup_value(runtime_conf_path, key);
  parsed_ok = native_parse_positive_size_value(raw_value, value_out);
  free(raw_value);
  return parsed_ok;
}
 
/**
 * @brief Detect total physical memory visible to the current host.
 *
 * @return Physical memory bytes, or 0 when unavailable.
 */
static unsigned long long native_detect_physical_memory_bytes(void) {
#ifdef _WIN32
  MEMORYSTATUSEX statex;
  memset(&statex, 0, sizeof(statex));
  statex.dwLength = sizeof(statex);
  if (GlobalMemoryStatusEx(&statex)) {
    return (unsigned long long)statex.ullTotalPhys;
  }
  return 0ULL;
#else
#ifdef _SC_PHYS_PAGES
#ifdef _SC_PAGESIZE
  {
    long pages = sysconf(_SC_PHYS_PAGES);
    long page_size = sysconf(_SC_PAGESIZE);
    if (pages > 0L && page_size > 0L) {
      return (unsigned long long)pages * (unsigned long long)page_size;
    }
  }
#endif
#endif
  return 0ULL;
#endif
}
 
/**
 * @brief Resolve the default worker-thread count when config does not override it.
 *
 * @return Positive worker-thread count.
 */
static size_t native_default_worker_count(void) {
#ifdef _WIN32
  SYSTEM_INFO system_info;
  GetSystemInfo(&system_info);
  if (system_info.dwNumberOfProcessors > 0U) {
    return native_clamp_size_value((size_t)system_info.dwNumberOfProcessors, PHAROS_NATIVE_MIN_WORKER_COUNT, PHAROS_NATIVE_MAX_WORKER_COUNT);
  }
#else
#ifdef _SC_NPROCESSORS_ONLN
  {
    long cpu_count = sysconf(_SC_NPROCESSORS_ONLN);
    if (cpu_count > 0L) {
      return native_clamp_size_value((size_t)cpu_count, PHAROS_NATIVE_MIN_WORKER_COUNT, PHAROS_NATIVE_MAX_WORKER_COUNT);
    }
  }
#endif
#endif
  return PHAROS_NATIVE_DEFAULT_WORKER_COUNT;
}
 
/**
 * @brief Resolve the default queue capacity from physical memory.
 *
 * @return Positive queued-request capacity.
 */
static size_t native_default_work_queue_capacity(void) {
  unsigned long long memory_bytes = native_detect_physical_memory_bytes();
  if (memory_bytes == 0ULL) {
    return PHAROS_NATIVE_DEFAULT_WORK_QUEUE_CAPACITY;
  }
  {
    unsigned long long slots = memory_bytes / PHAROS_NATIVE_WORK_QUEUE_BYTES_PER_SLOT;
    size_t bounded_slots;
    if (slots == 0ULL) {
      return PHAROS_NATIVE_MIN_WORK_QUEUE_CAPACITY;
    }
    if (slots > (unsigned long long)SIZE_MAX) {
      bounded_slots = PHAROS_NATIVE_MAX_WORK_QUEUE_CAPACITY;
    } else {
      bounded_slots = (size_t)slots;
    }
    return native_clamp_size_value(
      bounded_slots,
      PHAROS_NATIVE_MIN_WORK_QUEUE_CAPACITY,
      PHAROS_NATIVE_MAX_WORK_QUEUE_CAPACITY
    );
  }
}
 
/**
 * @brief Resolve the fixed worker-thread count for one serve process.
 *
 * @param runtime_conf_path Runtime configuration path to consult for overrides.
 * @return Positive worker-thread count.
 */
static size_t native_resolved_worker_count(const char *runtime_conf_path) {
  size_t configured = 0;
  if (native_conf_positive_size_value(runtime_conf_path, "worker_count", &configured)) {
    return native_clamp_size_value(configured, PHAROS_NATIVE_MIN_WORKER_COUNT, PHAROS_NATIVE_MAX_WORKER_COUNT);
  }
  return native_default_worker_count();
}
 
/**
 * @brief Resolve the bounded queued-request capacity for one serve process.
 *
 * @param runtime_conf_path Runtime configuration path to consult for overrides.
 * @return Positive queued-request capacity.
 */
static size_t native_resolved_work_queue_capacity(const char *runtime_conf_path) {
  size_t configured = 0;
  if (native_conf_positive_size_value(runtime_conf_path, "worker_queue_capacity", &configured)) {
    return native_clamp_size_value(
      configured,
      PHAROS_NATIVE_MIN_WORK_QUEUE_CAPACITY,
      PHAROS_NATIVE_MAX_WORK_QUEUE_CAPACITY
    );
  }
  return native_default_work_queue_capacity();
}
 
/**
 * @brief Execute one accepted request through the active runtime/app handler.
 *
 * @param context Per-request worker state to process.
 */
static void process_worker_context_native(WorkerContext *context) {
  if (context == NULL) {
    return;
  }
  handle_app_or_runtime_request(context);
  free_worker_context_native(context);
}
 
/**
 * @brief Send the standard overload response for saturated native serving.
 *
 * @param connection Accepted client connection.
 */
static void native_send_worker_pool_overload_response(NativeConnection *connection) {
  native_send_text_response(connection, 503, "Service Unavailable", "native worker pool saturated\n");
}
 
#ifdef _WIN32
/**
 * @brief Run queued request work items until the worker pool shuts down.
 *
 * @param opaque Active worker pool.
 * @return Windows thread exit code.
 */
static unsigned __stdcall native_worker_pool_thread_main(void *opaque) {
  NativeWorkerPool *pool = (NativeWorkerPool *)opaque;
  for (;;) {
    WorkerContext *context = NULL;
    EnterCriticalSection(&pool->mutex);
    while (pool->count == 0 && !pool->shutting_down) {
      SleepConditionVariableCS(&pool->not_empty, &pool->mutex, INFINITE);
    }
    if (pool->count > 0) {
      context = pool->items[pool->head];
      pool->items[pool->head] = NULL;
      pool->head = (pool->head + 1U) % pool->capacity;
      pool->count--;
    } else if (pool->shutting_down) {
      LeaveCriticalSection(&pool->mutex);
      break;
    }
    LeaveCriticalSection(&pool->mutex);
    process_worker_context_native(context);
  }
  return 0;
}
#else
/**
 * @brief Run queued request work items until the worker pool shuts down.
 *
 * @param opaque Active worker pool.
 * @return Unused thread return pointer.
 */
static void *native_worker_pool_thread_main(void *opaque) {
  NativeWorkerPool *pool = (NativeWorkerPool *)opaque;
  for (;;) {
    WorkerContext *context = NULL;
    pthread_mutex_lock(&pool->mutex);
    while (pool->count == 0 && !pool->shutting_down) {
      pthread_cond_wait(&pool->not_empty, &pool->mutex);
    }
    if (pool->count > 0) {
      context = pool->items[pool->head];
      pool->items[pool->head] = NULL;
      pool->head = (pool->head + 1U) % pool->capacity;
      pool->count--;
    } else if (pool->shutting_down) {
      pthread_mutex_unlock(&pool->mutex);
      break;
    }
    pthread_mutex_unlock(&pool->mutex);
    process_worker_context_native(context);
  }
  return NULL;
}
#endif
 
/**
 * @brief Initialize a bounded worker pool for native request serving.
 *
 * @param pool Pool state to initialize.
 * @param worker_count Fixed number of worker threads to create.
 * @param capacity Maximum queued requests.
 * @return 0 on success, non-zero on failure.
 */
static int native_worker_pool_init(NativeWorkerPool *pool, size_t worker_count, size_t capacity) {
  size_t index;
  if (pool == NULL || worker_count == 0 || capacity == 0) {
    return 69;
  }
  memset(pool, 0, sizeof(*pool));
  pool->items = (WorkerContext **)calloc(capacity, sizeof(WorkerContext *));
  if (pool->items == NULL) {
    return 69;
  }
  pool->capacity = capacity;
  pool->worker_count = worker_count;
#ifdef _WIN32
  pool->threads = (HANDLE *)calloc(worker_count, sizeof(HANDLE));
  if (pool->threads == NULL) {
    free(pool->items);
    memset(pool, 0, sizeof(*pool));
    return 69;
  }
  InitializeCriticalSection(&pool->mutex);
  InitializeConditionVariable(&pool->not_empty);
  for (index = 0; index < worker_count; index++) {
    uintptr_t thread_handle = _beginthreadex(NULL, 0, native_worker_pool_thread_main, pool, 0, NULL);
    if (thread_handle == 0) {
      pool->worker_count = index;
      native_worker_pool_request_shutdown(pool);
      native_worker_pool_join(pool);
      native_worker_pool_destroy(pool);
      return 69;
    }
    pool->threads[index] = (HANDLE)thread_handle;
  }
#else
  pool->threads = (pthread_t *)calloc(worker_count, sizeof(pthread_t));
  if (pool->threads == NULL) {
    free(pool->items);
    memset(pool, 0, sizeof(*pool));
    return 69;
  }
  if (pthread_mutex_init(&pool->mutex, NULL) != 0) {
    free(pool->threads);
    free(pool->items);
    memset(pool, 0, sizeof(*pool));
    return 69;
  }
  if (pthread_cond_init(&pool->not_empty, NULL) != 0) {
    pthread_mutex_destroy(&pool->mutex);
    free(pool->threads);
    free(pool->items);
    memset(pool, 0, sizeof(*pool));
    return 69;
  }
  for (index = 0; index < worker_count; index++) {
    if (pthread_create(&pool->threads[index], NULL, native_worker_pool_thread_main, pool) != 0) {
      pool->worker_count = index;
      native_worker_pool_request_shutdown(pool);
      native_worker_pool_join(pool);
      native_worker_pool_destroy(pool);
      return 69;
    }
  }
#endif
  return 0;
}
 
/**
 * @brief Submit accepted request work to the bounded worker pool.
 *
 * @param pool Active worker pool.
 * @param context Per-request work item to enqueue.
 * @return 0 on success, 1 when saturated or shutting down, non-zero on internal failure.
 */
static int native_worker_pool_enqueue(NativeWorkerPool *pool, WorkerContext *context) {
  int result = 0;
  if (pool == NULL || context == NULL) {
    return 69;
  }
#ifdef _WIN32
  EnterCriticalSection(&pool->mutex);
  if (pool->shutting_down || pool->count >= pool->capacity) {
    result = 1;
  } else {
    pool->items[pool->tail] = context;
    pool->tail = (pool->tail + 1U) % pool->capacity;
    pool->count++;
    WakeConditionVariable(&pool->not_empty);
  }
  LeaveCriticalSection(&pool->mutex);
#else
  if (pthread_mutex_lock(&pool->mutex) != 0) {
    return 69;
  }
  if (pool->shutting_down || pool->count >= pool->capacity) {
    result = 1;
  } else {
    pool->items[pool->tail] = context;
    pool->tail = (pool->tail + 1U) % pool->capacity;
    pool->count++;
    pthread_cond_signal(&pool->not_empty);
  }
  pthread_mutex_unlock(&pool->mutex);
#endif
  return result;
}
 
/**
 * @brief Ask the worker pool to stop after draining queued work.
 *
 * @param pool Active worker pool.
 */
static void native_worker_pool_request_shutdown(NativeWorkerPool *pool) {
  if (pool == NULL) {
    return;
  }
#ifdef _WIN32
  EnterCriticalSection(&pool->mutex);
  pool->shutting_down = 1;
  WakeAllConditionVariable(&pool->not_empty);
  LeaveCriticalSection(&pool->mutex);
#else
  if (pthread_mutex_lock(&pool->mutex) != 0) {
    return;
  }
  pool->shutting_down = 1;
  pthread_cond_broadcast(&pool->not_empty);
  pthread_mutex_unlock(&pool->mutex);
#endif
}
 
/**
 * @brief Join all worker threads created for the pool.
 *
 * @param pool Active worker pool.
 */
static void native_worker_pool_join(NativeWorkerPool *pool) {
  size_t index;
  if (pool == NULL || pool->threads == NULL) {
    return;
  }
#ifdef _WIN32
  for (index = 0; index < pool->worker_count; index++) {
    if (pool->threads[index] != NULL) {
      WaitForSingleObject(pool->threads[index], INFINITE);
      CloseHandle(pool->threads[index]);
      pool->threads[index] = NULL;
    }
  }
#else
  for (index = 0; index < pool->worker_count; index++) {
    pthread_join(pool->threads[index], NULL);
  }
#endif
}
 
/**
 * @brief Destroy worker-pool resources after shutdown and join.
 *
 * @param pool Worker pool to destroy.
 */
static void native_worker_pool_destroy(NativeWorkerPool *pool) {
  size_t index;
  if (pool == NULL) {
    return;
  }
  if (pool->items != NULL) {
    for (index = 0; index < pool->count; index++) {
      size_t item_index = (pool->head + index) % pool->capacity;
      free_worker_context_native(pool->items[item_index]);
    }
  }
#ifdef _WIN32
  DeleteCriticalSection(&pool->mutex);
#else
  pthread_cond_destroy(&pool->not_empty);
  pthread_mutex_destroy(&pool->mutex);
#endif
  free(pool->threads);
  free(pool->items);
  memset(pool, 0, sizeof(*pool));
}
 
static int write_noindex_markers_recursive_native(const char *root_path) {
#ifdef __APPLE__
  DIR *dir = NULL;
  struct dirent *entry;
  char *marker_path = NULL;
  int code = 0;
  if (root_path == NULL || root_path[0] == '\0' || !path_is_directory(root_path)) {
    return 66;
  }
  marker_path = path_join(root_path, ".metadata_never_index");
  if (marker_path == NULL) {
    return 69;
  }
  code = write_text_file(marker_path, "");
  free(marker_path);
  if (code != 0) {
    return code;
  }
  dir = opendir(root_path);
  if (dir == NULL) {
    return 69;
  }
  while ((entry = readdir(dir)) != NULL) {
    char *child_path;
    if (streq(entry->d_name, ".") || streq(entry->d_name, "..")) {
      continue;
    }
    child_path = path_join(root_path, entry->d_name);
    if (child_path == NULL) {
      code = 69;
      break;
    }
    if (path_is_directory(child_path)) {
      code = write_noindex_markers_recursive_native(child_path);
    }
    free(child_path);
    if (code != 0) {
      break;
    }
  }
  closedir(dir);
  return code;
#else
  (void)root_path;
  return 78;
#endif
}
 
static void print_version(void) {
  printf("pharos %s %s\n", PHAROS_VERSION, PHAROS_TARGET_ID);
}
 
static void print_help(void) {
  printf("pharos runtime\n\n");
  printf("command families:\n");
  printf("  targets bootstrap host target native json barcode\n");
  printf("  migrate db jobs integrations backup restore deploy drift\n");
  printf("  api admin build verify status run serve probe smoke doctor maintenance noindex\n\n");
  printf("usage:\n");
  printf("  pharos --help\n");
  printf("  pharos --version\n");
  printf("  pharos targets [text|json]\n");
  printf("  pharos bootstrap build [out-dir]\n");
  printf("  pharos bootstrap install [install-dir]\n");
  printf("  pharos host detect\n");
  printf("  pharos host build [source-bootstrap|native] [out-root]\n");
  printf("  pharos target build-all [source-bootstrap|native] [out-root]\n");
  printf("  pharos target build <target-id> [source-bootstrap|native] [out-root]\n");
  printf("  pharos native build-target <target-id> [out-root]\n");
  printf("  pharos native build-all [out-root]\n");
  printf("  pharos native verify-target <target-id> [out-root]\n");
  printf("  pharos native verify-all [out-root]\n");
  printf("  pharos native smoke-target <target-id> [out-root]\n");
  printf("  pharos native smoke-server <target-id> [out-root] [port] [site-root]\n");
  printf("  pharos native package-release [out-root]\n");
  printf("  pharos native verify-release-bundle [out-root]\n");
  printf("  pharos native toolchain\n");
  printf("  pharos json bundle manifest-slice-order --manifest PATH\n");
  printf("  pharos json bundle manifest-layer-for-slice --manifest PATH --slice NAME\n");
  printf("  pharos barcode decode IMAGE_PATH\n");
  printf("  pharos noindex PATH\n");
  printf("  pharos migrate <plan|status|seed|verify|apply|rollback> app <target-id> [--conf PATH] [--app-dir PATH] [--build-dir PATH] [--backend sqlite|postgresql] [--text]\n");
  printf("  pharos db seed app <target-id> [--conf PATH] [--app-dir PATH] [--build-dir PATH] [--backend sqlite|postgresql] [--text]\n");
  printf("  pharos jobs <inspect|run|replay> app <target-id> [--conf PATH] [--app-dir PATH] [--build-dir PATH] [--backend sqlite|postgresql] [--case CASE_ID] [--workflow WORKFLOW_ID] [--transition TRANSITION_ID] [--subject-id SUBJECT_ID] [--resource-id RESOURCE_ID] [--from-state STATE] [--idempotency-key KEY] [--trace-id TRACE_ID] [--execution-id ID] [--max-jobs N] [--retry-failed] [--requeue-stuck] [--text]\n");
  printf("  pharos integrations <inspect|deliver> app <target-id> [--conf PATH] [--app-dir PATH] [--build-dir PATH] [--state-dir PATH|--state-path PATH] [--adapter-id ADAPTER_ID] [--delivery-id ID] [--event-kind KIND] [--resource-id RESOURCE_ID] [--tenant-id TENANT_ID] [--subject-id SUBJECT_ID] [--payload-json JSON] [--retry-failed] [--max-deliveries N] [--text]\n");
  printf("  pharos backup app <target-id> [--conf PATH] [--build-dir PATH] [--backend sqlite|postgresql] [--output-dir PATH] [--text]\n");
  printf("  pharos restore app <target-id> [--conf PATH] [--build-dir PATH] [--backend sqlite|postgresql] --input-dir PATH [--text]\n");
  printf("  pharos deploy check app <target-id> [--conf PATH] [--build-dir PATH] [--backend sqlite|postgresql] [--text]\n");
  printf("  pharos deploy package deb --binary PATH --target-id TARGET_ID [--output-dir PATH] [--text]\n");
  printf("  pharos drift check app <target-id> [--conf PATH] [--build-dir PATH] [--backend sqlite|postgresql] [--text]\n");
  printf("  pharos api <generate|schema> app <target-id> [--build-dir PATH] [--surface SURFACE_ID] [--text]\n");
  printf("  pharos admin generate app <target-id> [--build-dir PATH] [--surface SURFACE_ID] [--text]\n");
  printf("  pharos build runtime <runtime-id> --conf PATH [--text]\n");
  printf("  pharos status runtime <runtime-id> --conf PATH [--text]\n");
  printf("  pharos serve runtime <runtime-id> --conf PATH [--socket-path PATH]\n");
  printf("  pharos build <website|app> <target-id> [--conf PATH] [--app-dir PATH] [--build-dir PATH] [--state-dir PATH|--state-path PATH] [--base-path PATH] [--log-path PATH] [--error-report-path PATH] [--debug BOOL] [--text]\n");
  printf("  pharos verify <website|app> <target-id> [--conf PATH] [--app-dir PATH] [--build-dir PATH] [--state-dir PATH|--state-path PATH] [--base-path PATH] [--log-path PATH] [--error-report-path PATH] [--debug BOOL] [--text]\n");
  printf("  pharos status <website|app> <target-id> [--conf PATH] [--app-dir PATH] [--build-dir PATH] [--state-dir PATH|--state-path PATH] [--base-path PATH] [--log-path PATH] [--error-report-path PATH] [--debug BOOL] [--text]\n");
  printf("  pharos run <website|app> <target-id> [--conf PATH] [--app-dir PATH] [--build-dir PATH] [--state-dir PATH|--state-path PATH] [--base-path PATH] [--log-path PATH] [--error-report-path PATH] [--debug BOOL] [--text]\n");
  printf("  pharos serve <website|app> <target-id> [--conf PATH] [--app-dir PATH] [--build-dir PATH] [--state-dir PATH|--state-path PATH] [--base-path PATH] [--log-path PATH] [--error-report-path PATH] [--debug BOOL] [--socket-path PATH] [--host HOST] [--port PORT]\n");
  printf("  pharos probe app <target-id> [--conf PATH] [--app-dir PATH] [--build-dir PATH] [--text]\n");
  printf("  pharos smoke app <target-id> [--conf PATH] [--app-dir PATH] [--build-dir PATH] [--text]\n");
  printf("  pharos doctor app <target-id> [--conf PATH] [--app-dir PATH] [--build-dir PATH] [--text]\n");
  printf("  pharos maintenance app <target-id> <action> [--conf PATH] [--app-dir PATH] [--build-dir PATH] [--state-dir PATH|--state-path PATH] [--base-path PATH] [--text]\n");
}
 
 
 
static const char *native_http_parse_reason_phrase(int status_code) {
  switch (status_code) {
    case 400:
      return "Bad Request";
    case 413:
      return "Payload Too Large";
    case 414:
      return "URI Too Long";
    case 431:
      return "Request Header Fields Too Large";
    case 501:
      return "Not Implemented";
    default:
      return "Bad Request";
  }
}
 
static const char *native_http_parse_error_body(int status_code) {
  switch (status_code) {
    case 413:
      return "request body exceeds native runtime limits\n";
    case 414:
      return "request target exceeds native runtime limits\n";
    case 431:
      return "request headers exceed native runtime limits\n";
    case 501:
      return "transfer encoding not supported\n";
    case 400:
    default:
      return "malformed request\n";
  }
}
 
static int accept_http_request_native(int server_fd, NativeConnection *connection, HttpRequest *request) {
  int accept_status = native_connection_accept_next(server_fd, &global_shutdown_requested, connection);
  int parse_status;
  if (accept_status == 0) {
    return 0;
  }
  if (accept_status < 0) {
    return -1;
  }
  parse_status = parse_http_request_native(connection, request);
  if (parse_status != 0) {
    if (parse_status >= 400 && parse_status < 600) {
      native_send_text_response(
        connection,
        parse_status,
        native_http_parse_reason_phrase(parse_status),
        native_http_parse_error_body(parse_status)
      );
    }
    native_connection_close(connection);
    return -1;
  }
  return 1;
}
 
static WorkerContext *build_worker_context_native(NativeConnection *connection, HttpRequest *request, const AppRuntime *source_app) {
  WorkerContext *worker = (WorkerContext *)calloc(1, sizeof(WorkerContext));
  if (worker == NULL) {
    return NULL;
  }
  native_connection_init(&worker->connection);
  worker->connection = *connection;
  native_connection_init(connection);
  worker->request = *request;
  memset(request, 0, sizeof(*request));
  if (clone_app_runtime_native(source_app, &worker->app) != 0) {
    native_connection_close(&worker->connection);
    free(worker);
    return NULL;
  }
  return worker;
}
 
static int handle_static_root_builtin_request(NativeConnection *connection, const HttpRequest *request) {
  char body[128];
  if (strcmp(request->target, "/health") == 0) {
    native_send_text_response(connection, 200, "OK", "server_status=green\n");
    return 1;
  }
  if (strcmp(request->target, "/version") != 0) {
    return 0;
  }
  snprintf(body, sizeof(body), "pharos %s %s\n", PHAROS_VERSION, PHAROS_TARGET_ID);
  native_send_text_response(connection, 200, "OK", body);
  return 1;
}
 
static int serve_static_root(const ServeConfig *config) {
  int code = 0;
  int server_fd = native_listener_open(config);
  if (server_fd < 0) {
    fprintf(stderr, "failed to open listener\n");
    return 69;
  }
  register_listener_cleanup(config, (PHAROS_SOCKET)server_fd);
  printf("pharos native server listening on %s root=%s\n", native_listener_endpoint(config), config->root);
  fflush(stdout);
  for (;;) {
    NativeConnection connection;
    HttpRequest request;
    native_connection_init(&connection);
    int request_status = accept_http_request_native(server_fd, &connection, &request);
    if (request_status == 0) {
      break;
    }
    if (request_status < 0) {
      continue;
    }
    if (strcmp(request.method, "GET") != 0 && strcmp(request.method, "HEAD") != 0 && !(strcmp(request.method, "POST") == 0 && starts_with(request.target, "/api/projects/"))) {
      native_send_text_response(&connection, 405, "Method Not Allowed", "method not allowed\n");
      free_http_request_native(&request);
      native_connection_close(&connection);
      continue;
    }
    if (handle_static_root_builtin_request(&connection, &request)) {
      free_http_request_native(&request);
      native_connection_close(&connection);
      continue;
    }
    native_serve_static_file(&connection, config->root, request.target, &request, config->log_path);
    free_http_request_native(&request);
    native_connection_close(&connection);
  }
  cleanup_active_listener();
  clear_listener_cleanup_registration();
  return code;
}
 
static int serve_single_app(const ServeConfig *config) {
  AppRuntime app;
  NativeWorkerPool pool;
  size_t worker_count;
  size_t queue_capacity;
  int code = 0;
  int server_fd;
  memset(&pool, 0, sizeof(pool));
  if (load_app_runtime_for_single_app(config, &app) != 0) {
    fprintf(stderr, "failed to load Pharos app runtime for %s\n", config->target_id);
    return 66;
  }
  worker_count = native_resolved_worker_count(app.runtime_conf_path != NULL ? app.runtime_conf_path : config->conf_path);
  queue_capacity = native_resolved_work_queue_capacity(app.runtime_conf_path != NULL ? app.runtime_conf_path : config->conf_path);
  if (native_worker_pool_init(&pool, worker_count, queue_capacity) != 0) {
    free_app_runtime(&app);
    fprintf(stderr, "failed to initialize native worker pool\n");
    return 69;
  }
  server_fd = native_listener_open(config);
  if (server_fd < 0) {
    native_worker_pool_request_shutdown(&pool);
    native_worker_pool_join(&pool);
    native_worker_pool_destroy(&pool);
    free_app_runtime(&app);
    fprintf(stderr, "failed to open listener\n");
    return 69;
  }
  register_listener_cleanup(config, (PHAROS_SOCKET)server_fd);
  printf(
    "pharos native app runtime listening on %s target=%s worker_pool=true workers=%zu queue_capacity=%zu\n",
    native_listener_endpoint(config),
    app.app_id,
    worker_count,
    queue_capacity
  );
  fflush(stdout);
  for (;;) {
    NativeConnection connection;
    HttpRequest request;
    WorkerContext *worker;
    native_connection_init(&connection);
    int request_status = accept_http_request_native(server_fd, &connection, &request);
    if (request_status == 0) {
      break;
    }
    if (request_status < 0) {
      continue;
    }
    worker = build_worker_context_native(&connection, &request, &app);
    if (worker == NULL) {
      native_send_text_response(&connection, 500, "Internal Server Error", "worker allocation failed\n");
      free_http_request_native(&request);
      native_connection_close(&connection);
      continue;
    }
    int enqueue_status = native_worker_pool_enqueue(&pool, worker);
    if (enqueue_status == 1) {
      native_send_worker_pool_overload_response(&worker->connection);
      free_worker_context_native(worker);
      continue;
    }
    if (enqueue_status != 0) {
      native_send_text_response(&worker->connection, 500, "Internal Server Error", "failed to enqueue worker\n");
      free_worker_context_native(worker);
    }
  }
  cleanup_active_listener();
  clear_listener_cleanup_registration();
  native_worker_pool_request_shutdown(&pool);
  native_worker_pool_join(&pool);
  native_worker_pool_destroy(&pool);
  free_app_runtime(&app);
  return code;
}
 
static int serve_runtime_stack_native(const ServeConfig *config) {
  RuntimeStack stack;
  NativeWorkerPool pool;
  size_t worker_count;
  size_t queue_capacity;
  int code = 0;
  int server_fd;
  struct timeval load_started;
  struct timeval load_finished;
  char *apps_dir = NULL;
  char *fingerprint = NULL;
  memset(&pool, 0, sizeof(pool));
  gettimeofday(&load_started, NULL);
  if (load_runtime_stack(config, &stack) != 0) {
    fprintf(stderr, "failed to load Pharos runtime stack\n");
    return 66;
  }
  gettimeofday(&load_finished, NULL);
  worker_count = native_resolved_worker_count(config->conf_path);
  queue_capacity = native_resolved_work_queue_capacity(config->conf_path);
  if (native_worker_pool_init(&pool, worker_count, queue_capacity) != 0) {
    free_runtime_stack(&stack);
    fprintf(stderr, "failed to initialize native worker pool\n");
    return 69;
  }
  server_fd = native_listener_open(config);
  if (server_fd < 0) {
    native_worker_pool_request_shutdown(&pool);
    native_worker_pool_join(&pool);
    native_worker_pool_destroy(&pool);
    free_runtime_stack(&stack);
    fprintf(stderr, "failed to open listener\n");
    return 69;
  }
  register_listener_cleanup(config, (PHAROS_SOCKET)server_fd);
  apps_dir = runtime_apps_dir_native(config->conf_path);
  fingerprint = runtime_apps_fingerprint_native(apps_dir);
  {
    long startup_ms = (long)((load_finished.tv_sec - load_started.tv_sec) * 1000L + (load_finished.tv_usec - load_started.tv_usec) / 1000L);
    runtime_log_banner_native(&stack, config, startup_ms);
  }
  fprintf(
    stdout,
    "pharos native runtime worker_pool=true workers=%zu queue_capacity=%zu\n",
    worker_count,
    queue_capacity
  );
  fflush(stdout);
  for (;;) {
    char *next_fingerprint = runtime_apps_fingerprint_native(apps_dir);
    if (next_fingerprint != NULL && (fingerprint == NULL || strcmp(next_fingerprint, fingerprint) != 0)) {
      RuntimeStack refreshed_stack;
      memset(&refreshed_stack, 0, sizeof(refreshed_stack));
      if (load_runtime_stack(config, &refreshed_stack) == 0) {
        free_runtime_stack(&stack);
        stack = refreshed_stack;
        free(fingerprint);
        fingerprint = next_fingerprint;
        runtime_log_banner_native(&stack, config, 0L);
      } else {
        free_runtime_stack(&refreshed_stack);
        fprintf(stderr, "failed to refresh Pharos runtime stack\n");
        free(next_fingerprint);
      }
    } else {
      free(next_fingerprint);
    }
    NativeConnection connection;
    HttpRequest request;
    AppRuntime *matched;
    WorkerContext *worker;
    char *path_only;
    char *query;
    native_connection_init(&connection);
    int request_status = accept_http_request_native(server_fd, &connection, &request);
    if (request_status == 0) {
      break;
    }
    if (request_status < 0) {
      continue;
    }
    path_only = native_request_path_without_query(request.target);
    query = NULL;
    matched = path_only != NULL ? runtime_match_app_native(&stack, path_only) : NULL;
    free(path_only);
    (void)query;
    if (matched == NULL) {
      native_send_text_response(&connection, 404, "Not Found", "Not Found");
      free_http_request_native(&request);
      native_connection_close(&connection);
      continue;
    }
    worker = build_worker_context_native(&connection, &request, matched);
    if (worker == NULL) {
      native_send_text_response(&connection, 500, "Internal Server Error", "worker allocation failed\n");
      free_http_request_native(&request);
      native_connection_close(&connection);
      continue;
    }
    int enqueue_status = native_worker_pool_enqueue(&pool, worker);
    if (enqueue_status == 1) {
      native_send_worker_pool_overload_response(&worker->connection);
      free_worker_context_native(worker);
      continue;
    }
    if (enqueue_status != 0) {
      native_send_text_response(&worker->connection, 500, "Internal Server Error", "failed to enqueue worker\n");
      free_worker_context_native(worker);
    }
  }
  cleanup_active_listener();
  clear_listener_cleanup_registration();
  native_worker_pool_request_shutdown(&pool);
  native_worker_pool_join(&pool);
  native_worker_pool_destroy(&pool);
  free(fingerprint);
  free(apps_dir);
  free_runtime_stack(&stack);
  return code;
}
 
static int serve_website_target(const ServeConfig *config) {
  ServeConfig config_copy = *config;
  int code;
  char *artifact_root = resolve_website_root(&config_copy);
  if (artifact_root == NULL) {
    return 66;
  }
  free(config_copy.root);
  config_copy.root = artifact_root;
  code = serve_static_root(&config_copy);
  config_copy.root = NULL;
  return code;
}
 
static NativeServeHandlerFn find_serve_handler_native(const char *kind) {
  static const struct {
    const char *kind;
    NativeServeHandlerFn handler;
  } handler_map[] = {
    { "website", serve_website_target },
    { "app", serve_single_app },
    { "runtime", serve_runtime_stack_native }
  };
  size_t index;
  for (index = 0; index < sizeof(handler_map) / sizeof(handler_map[0]); index++) {
    if (streq(kind, handler_map[index].kind)) {
      return handler_map[index].handler;
    }
  }
  return NULL;
}
 
static int handle_serve(int argc, char **argv) {
  ServeConfig config;
  NativeServeHandlerFn handler;
  int code;
  parse_serve_config_native(argc, argv, &config);
  apply_serve_config_defaults_from_conf_native(&config);
  if (config.kind == NULL) {
    if (config.root == NULL) {
      print_help();
      free_serve_config_native(&config);
      return 64;
    }
    code = serve_static_root(&config);
    free_serve_config_native(&config);
    return code;
  }
  if (config.target_id == NULL) {
    fprintf(stderr, "missing target id for serve %s\n", config.kind);
    free_serve_config_native(&config);
    return 64;
  }
  handler = find_serve_handler_native(config.kind);
  if (handler == NULL) {
    free_serve_config_native(&config);
    return 64;
  }
  code = handler(&config);
  free_serve_config_native(&config);
  return code;
}
 
static int website_verb_mode_native(const char *verb) {
  static const char *status_like_verbs[] = {
    "status", "verify", "run", "probe", "smoke", "doctor", "release",
    "restore", "compare", "snapshot", "export", "import", "diff",
    "sync", "clean"
  };
  size_t index;
  if (streq(verb, "build")) {
    return 1;
  }
  for (index = 0; index < sizeof(status_like_verbs) / sizeof(status_like_verbs[0]); index++) {
    if (streq(verb, status_like_verbs[index])) {
      return 2;
    }
  }
  return 0;
}
 
static int handle_native_website_command(int argc, char **argv) {
  const char *verb;
  const char *target_kind;
  const char *target_id;
  const char *build_dir = "dist";
  int index;
  char *report_path = NULL;
  int code;
  if (argc < 3) {
    return 78;
  }
  verb = argv[0];
  target_kind = argv[1];
  target_id = argv[2];
  if (!streq(target_kind, "website") || !native_known_website_supported(target_id)) {
    return 78;
  }
  for (index = 3; index < argc; index++) {
    if (streq(argv[index], "--build-dir") && index + 1 < argc) {
      build_dir = argv[index + 1];
      index++;
    }
  }
  switch (website_verb_mode_native(verb)) {
    case 1:
      code = build_known_website_native(target_id, build_dir, &report_path, NULL);
      break;
    case 2:
      code = emit_website_status_native(verb, target_id, build_dir, &report_path);
      break;
    default:
      return 78;
  }
  if (code != 0) {
    return code;
  }
  if (report_path != NULL) {
    char *content = read_file_text(report_path);
    if (content != NULL) {
      fputs(content, stdout);
      free(content);
    }
    free(report_path);
  }
  return 0;
}
 
static int runtime_verb_supported_native(const char *verb) {
  static const char *supported_verbs[] = {
    "build", "status", "verify", "run", "probe", "smoke", "doctor"
  };
  size_t index;
  for (index = 0; index < sizeof(supported_verbs) / sizeof(supported_verbs[0]); index++) {
    if (streq(verb, supported_verbs[index])) {
      return 1;
    }
  }
  return 0;
}
 
static const char *native_app_runtime_report_id(const char *verb) {
  static const struct {
    const char *verb;
    const char *report_id;
  } report_map[] = {
    { "status", "pharos-status-v1" },
    { "verify", "pharos-local-app-build-v1" },
    { "run", "pharos-local-app-runtime-v1" },
    { "probe", "pharos-local-app-runtime-v1" },
    { "smoke", "pharos-local-app-runtime-v1" },
    { "doctor", "pharos-doctor-v1" }
  };
  size_t index;
  for (index = 0; index < sizeof(report_map) / sizeof(report_map[0]); index++) {
    if (streq(verb, report_map[index].verb)) {
      return report_map[index].report_id;
    }
  }
  return "pharos-local-app-runtime-v1";
}
 
static int handle_native_runtime_app_command(const char *verb, ServeConfig *config) {
  AppRuntime app;
  char *app_root = NULL;
  char *artifact_dir = NULL;
  char *report_path = NULL;
  char *report_json = NULL;
  char *resolved_build_dir = NULL;
  char *build_dir_override = NULL;
  const char *report_id = native_app_runtime_report_id(verb);
  int code;
  if (verb == NULL || config == NULL || config->target_id == NULL) {
    return 78;
  }
  app_root = find_app_root_for_target(
    config->target_id,
    config->app_dir,
    global_repo_root,
    global_binary_dir
  );
  if (app_root == NULL) {
    fprintf(stderr, "unable to locate app root for app target: %s\n", config->target_id);
    return 66;
  }
  memset(&app, 0, sizeof(app));
  build_dir_override = runtime_build_dir_override_native(config, app_root);
  code = prepare_app_artifact_native(
    app_root,
    config->target_id,
    build_dir_override,
    config->state_dir,
    config->state_path,
    config->base_path,
    &report_path,
    &artifact_dir
  );
  if (code != 0) {
    free(build_dir_override);
    free(artifact_dir);
    free(app_root);
    return code;
  }
  if (maybe_seed_app_state_native(config, app_root, config->target_id, config->seed_state ? 1 : 0) != 0) {
    free(build_dir_override);
    free(report_path);
    free(artifact_dir);
    free(app_root);
    return 69;
  }
  code = load_app_runtime_from_artifact_native(artifact_dir, &app);
  if (code != 0) {
    free(build_dir_override);
    free(report_path);
    free(artifact_dir);
    free(app_root);
    return code;
  }
  resolved_build_dir = build_dir_override;
  if (resolved_build_dir == NULL ||
      finalize_loaded_app_runtime_native(&app, config, app_root, resolved_build_dir) != 0) {
    free(resolved_build_dir);
    free_app_runtime(&app);
    free(report_path);
    free(artifact_dir);
    free(app_root);
    return 69;
  }
  free(resolved_build_dir);
  if (streq(verb, "build")) {
    report_json = build_native_app_build_report_json(
      artifact_dir,
      app.app_id,
      app.state_path,
      app.base_path,
      app.log_path,
      app.log_format,
      app.error_report_path,
      app.debug,
      app.host_profile,
      app.compiled_entrypoint
    );
    if (report_json != NULL && report_path != NULL) {
      if (write_text_file(report_path, report_json) != 0) {
        free(report_json);
        free_app_runtime(&app);
        free(report_path);
        free(artifact_dir);
        free(app_root);
        return 69;
      }
    }
  } else if (streq(verb, "doctor")) {
    report_json = build_native_app_doctor_report_local_json(
      global_repo_root,
      config,
      artifact_dir,
      &app,
      PHAROS_TARGET_ID
    );
  } else {
    report_json = build_native_app_runtime_report_json(
      report_id,
      verb,
      PHAROS_TARGET_ID,
      "native-host-target",
      artifact_dir,
      &app
    );
  }
  free_app_runtime(&app);
  free(report_path);
  free(artifact_dir);
  free(app_root);
  if (report_json == NULL) {
    return 69;
  }
  fputs(report_json, stdout);
  free(report_json);
  return 0;
}
 
static int handle_native_runtime_command(int argc, char **argv) {
  const char *verb;
  ServeConfig config;
  RuntimeStack stack;
  char *apps_dir = NULL;
  char *report_path = NULL;
  char *report_json = NULL;
  int code = 0;
  if (argc < 2) {
    return 78;
  }
  verb = argv[0];
  if (!runtime_verb_supported_native(verb)) {
    return 78;
  }
  parse_serve_config_native(argc - 1, argv + 1, &config);
  if (config.kind == NULL || config.target_id == NULL) {
    free_serve_config_native(&config);
    return 78;
  }
  if (streq(config.kind, "app")) {
    code = handle_native_runtime_app_command(verb, &config);
    free_serve_config_native(&config);
    return code;
  }
  if (!streq(config.kind, "runtime")) {
    free_serve_config_native(&config);
    return 78;
  }
  memset(&stack, 0, sizeof(stack));
  code = load_runtime_stack(&config, &stack);
  if (code != 0) {
    free_serve_config_native(&config);
    return code;
  }
  apps_dir = runtime_apps_dir_native(config.conf_path);
  report_path = native_website_report_path(
    config.build_dir != NULL ? config.build_dir : "dist",
    verb,
    config.target_id
  );
  if (report_path == NULL) {
    free(apps_dir);
    free_runtime_stack(&stack);
    free_serve_config_native(&config);
    return 69;
  }
  report_json = streq(verb, "build")
    ? build_native_runtime_build_report_json(config.target_id, config.conf_path, apps_dir, stack.count)
    : build_native_runtime_status_report_json(&stack, apps_dir);
  if (report_json == NULL) {
    free(report_path);
    free(apps_dir);
    free_runtime_stack(&stack);
    free_serve_config_native(&config);
    return 69;
  }
  code = write_text_file(report_path, report_json);
  free(report_json);
  if (code == 0) {
    code = emit_text_file_to_stdout_native(report_path);
  }
  free(report_path);
  free(apps_dir);
  free_runtime_stack(&stack);
  free_serve_config_native(&config);
  return code;
}
 
static int prepare_finalized_app_from_config(const ServeConfig *config, char **artifact_dir_out, AppRuntime *app_out) {
  char *app_root = NULL;
  char *artifact_dir = NULL;
  char *report_path = NULL;
  char *resolved_build_dir = NULL;
  int code;
  if (artifact_dir_out != NULL) {
    *artifact_dir_out = NULL;
  }
  if (app_out == NULL || config == NULL || config->target_id == NULL) {
    return 69;
  }
  memset(app_out, 0, sizeof(*app_out));
  app_root = find_app_root_for_target(config->target_id, config->app_dir, global_repo_root, global_binary_dir);
  if (app_root == NULL) {
    return 66;
  }
  code = prepare_app_artifact_native(app_root, config->target_id, config->build_dir, config->state_dir, config->state_path, config->base_path, &report_path, &artifact_dir);
  if (code != 0) {
    free(report_path);
    free(artifact_dir);
    free(app_root);
    return code;
  }
  code = load_app_runtime_from_artifact_native(artifact_dir, app_out);
  if (code != 0) {
    free(report_path);
    free(artifact_dir);
    free(app_root);
    return code;
  }
  resolved_build_dir = effective_app_build_dir_native(app_root, config->build_dir);
  if (resolved_build_dir == NULL || finalize_loaded_app_runtime_native(app_out, config, app_root, resolved_build_dir) != 0) {
    free(resolved_build_dir);
    free_app_runtime(app_out);
    free(report_path);
    free(artifact_dir);
    free(app_root);
    return 69;
  }
  free(resolved_build_dir);
  free(report_path);
  free(app_root);
  if (artifact_dir_out != NULL) {
    *artifact_dir_out = artifact_dir;
  } else {
    free(artifact_dir);
  }
  return 0;
}
 
static char *native_option_value(int argc, char **argv, const char *first_name, const char *second_name) {
  int index;
  for (index = 0; index < argc - 1; index++) {
    if ((first_name != NULL && streq(argv[index], first_name)) || (second_name != NULL && streq(argv[index], second_name))) {
      return argv[index + 1];
    }
  }
  return NULL;
}
 
static int apply_deb_package_option_native(
  const char *option,
  const char *value,
  char **binary_path,
  char **target_id,
  char **output_dir
) {
  if (option == NULL || value == NULL) {
    return 0;
  }
  if (streq(option, "--binary")) {
    *binary_path = (char *)value;
    return 1;
  }
  if (streq(option, "--target-id")) {
    *target_id = (char *)value;
    return 1;
  }
  if (streq(option, "--output") || streq(option, "--output-dir")) {
    *output_dir = (char *)value;
    return 1;
  }
  return 0;
}
 
static int handle_native_deploy_package_deb_command(int argc, char **argv) {
  char *script = path_join(global_repo_root, "scripts/package_deb.sh");
  char *binary_path = NULL;
  char *target_id = NULL;
  char *output_dir = NULL;
  char *argv_list[17];
  char *output = NULL;
  char *package_path_json;
  char *binary_json;
  char *target_json;
  char *report_json = NULL;
  int child_argc = 0;
  int index;
  int code;
  if (argc < 3 || argv == NULL || script == NULL) {
    free(script);
    return 64;
  }
  for (index = 3; index < argc; index++) {
    if (index + 1 >= argc) {
      continue;
    }
    if (apply_deb_package_option_native(
          argv[index],
          argv[index + 1],
          &binary_path,
          &target_id,
          &output_dir
        )) {
      index++;
    }
  }
  if (binary_path == NULL || target_id == NULL) {
    free(script);
    return 64;
  }
  argv_list[child_argc++] = "/bin/sh";
  argv_list[child_argc++] = script;
  argv_list[child_argc++] = "--binary";
  argv_list[child_argc++] = binary_path;
  argv_list[child_argc++] = "--target-id";
  argv_list[child_argc++] = target_id;
  if (output_dir != NULL) {
    argv_list[child_argc++] = "--output";
    argv_list[child_argc++] = output_dir;
  }
  argv_list[child_argc] = NULL;
  code = run_process_capture_native(argv_list, &output);
  free(script);
  if (output != NULL) {
    trim_in_place(output);
  }
  if (code != 0 || output == NULL || output[0] == '\0') {
    free(output);
    return code == 0 ? 69 : code;
  }
  package_path_json = json_string_dup_native(output);
  binary_json = json_string_dup_native(binary_path);
  target_json = json_string_dup_native(target_id);
  if (package_path_json != NULL && binary_json != NULL && target_json != NULL) {
    size_t needed = strlen(package_path_json) + strlen(binary_json) + strlen(target_json) + 192;
    report_json = (char *)malloc(needed);
    if (report_json != NULL) {
      snprintf(report_json, needed, "{\"report_id\":\"pharos-deploy-package-v1\",\"format\":\"deb\",\"target_id\":%s,\"binary\":%s,\"package_path\":%s,\"status\":\"packaged\"}", target_json, binary_json, package_path_json);
    }
  }
  free(output);
  free(package_path_json);
  free(binary_json);
  free(target_json);
  if (report_json == NULL) {
    return 69;
  }
  fputs(report_json, stdout);
  free(report_json);
  return 0;
}
 
static int parse_native_app_ops_config(int argc, char **argv, int skip_args, ServeConfig *config) {
  parse_serve_config_native(argc - skip_args, argv + skip_args, config);
  if (config->kind == NULL || config->target_id == NULL || !streq(config->kind, "app")) {
    free_serve_config_native(config);
    return 78;
  }
  return 0;
}
 
static int prepare_native_app_ops_runtime(
  int argc,
  char **argv,
  int skip_args,
  ServeConfig *config,
  char **artifact_dir,
  AppRuntime *app
) {
  int code = parse_native_app_ops_config(argc, argv, skip_args, config);
  if (code != 0) {
    return code;
  }
  code = prepare_finalized_app_from_config(config, artifact_dir, app);
  if (code != 0) {
    free_serve_config_native(config);
  }
  return code;
}
 
static int emit_native_report_json(const char *report_json) {
  if (report_json == NULL) {
    return 69;
  }
  fputs(report_json, stdout);
  return 0;
}
 
static int handle_native_backup_restore_ops_command(int argc, char **argv) {
  ServeConfig config;
  AppRuntime app;
  char *artifact_dir = NULL;
  char *report_json = NULL;
  char *backend_override;
  char *output_dir_override;
  char *input_dir;
  char *error_text = NULL;
  int code;
  code = prepare_native_app_ops_runtime(argc, argv, 1, &config, &artifact_dir, &app);
  if (code != 0) {
    return code;
  }
  backend_override = native_option_value(argc, argv, "--backend", NULL);
  output_dir_override = native_option_value(argc, argv, "--output-dir", "--output");
  input_dir = native_option_value(argc, argv, "--input-dir", NULL);
  report_json = streq(argv[0], "backup")
    ? build_native_backup_report_local_json(&config, &app, backend_override, output_dir_override, &error_text)
    : build_native_restore_report_local_json(&config, &app, backend_override, input_dir, &error_text);
  free_app_runtime(&app);
  free(artifact_dir);
  free_serve_config_native(&config);
  if (report_json != NULL) {
    code = emit_native_report_json(report_json);
    free(report_json);
    free(error_text);
    return code;
  }
  if (error_text != NULL && error_text[0] != '\0') {
    fprintf(stderr, "%s\n", error_text);
  }
  free(error_text);
  return 69;
}
 
static int handle_native_drift_check_ops_command(int argc, char **argv) {
  ServeConfig config;
  AppRuntime app;
  char *artifact_dir = NULL;
  char *report_json = NULL;
  int code = prepare_native_app_ops_runtime(argc, argv, 2, &config, &artifact_dir, &app);
  if (code != 0) {
    return code;
  }
  report_json = build_native_app_drift_report_local_json(global_repo_root, &config, &app);
  free_app_runtime(&app);
  free(artifact_dir);
  free_serve_config_native(&config);
  if (report_json == NULL) {
    return 69;
  }
  code = emit_native_report_json(report_json);
  free(report_json);
  return code;
}
 
static int handle_native_deploy_check_ops_command(int argc, char **argv) {
  ServeConfig config;
  AppRuntime app;
  char *artifact_dir = NULL;
  char *report_json = NULL;
  int code = prepare_native_app_ops_runtime(argc, argv, 2, &config, &artifact_dir, &app);
  if (code != 0) {
    return code;
  }
  report_json = build_native_app_deploy_check_report_local_json(
    global_repo_root,
    &config,
    artifact_dir,
    &app,
    PHAROS_TARGET_ID
  );
  free_app_runtime(&app);
  free(artifact_dir);
  free_serve_config_native(&config);
  if (report_json == NULL) {
    return 69;
  }
  code = emit_native_report_json(report_json);
  free(report_json);
  return code;
}
 
static int match_native_ops_command(
  int argc,
  char **argv,
  const char *first,
  const char *second,
  const char *third,
  int min_argc
) {
  if (argc < min_argc || argv == NULL || argv[0] == NULL) {
    return 0;
  }
  if (first != NULL && !streq(argv[0], first)) {
    return 0;
  }
  if (second != NULL && (argc < 2 || !streq(argv[1], second))) {
    return 0;
  }
  if (third != NULL && (argc < 3 || !streq(argv[2], third))) {
    return 0;
  }
  return 1;
}
 
static int handle_native_noindex_command(int argc, char **argv) {
  char *target_path;
  int code;
  if (argc != 2 || argv == NULL || argv[0] == NULL || argv[1] == NULL || !streq(argv[0], "noindex")) {
    return 78;
  }
  target_path = path_canonicalize(argv[1]);
  if (target_path == NULL) {
    target_path = pharos_strdup(argv[1]);
  }
  if (target_path == NULL) {
    return 69;
  }
  code = write_noindex_markers_recursive_native(target_path);
  if (code == 0) {
    printf("marked noindex: %s\n", target_path);
  }
  free(target_path);
  return code;
}
 
static int handle_native_ops_command(int argc, char **argv) {
  static const struct {
    const char *first;
    const char *second;
    const char *third;
    int min_argc;
    int (*handler)(int argc, char **argv);
  } dispatch_table[] = {
    { "backup", "app", NULL, 3, handle_native_backup_restore_ops_command },
    { "restore", "app", NULL, 3, handle_native_backup_restore_ops_command },
    { "drift", "check", NULL, 4, handle_native_drift_check_ops_command },
    { "deploy", "check", NULL, 4, handle_native_deploy_check_ops_command },
    { "deploy", "package", "deb", 3, handle_native_deploy_package_deb_command }
  };
  size_t index;
  for (index = 0; index < sizeof(dispatch_table) / sizeof(dispatch_table[0]); index++) {
    if (match_native_ops_command(
          argc,
          argv,
          dispatch_table[index].first,
          dispatch_table[index].second,
          dispatch_table[index].third,
          dispatch_table[index].min_argc
        )) {
      return dispatch_table[index].handler(argc, argv);
    }
  }
  return 78;
}
 
/**
 * @brief Native Pharos CLI entrypoint.
 *
 * The runtime resolves the repository and binary roots, dispatches command families,
 * and starts the native serving path when requested.
 */
int main(int argc, char **argv) {
  int website_code;
  int runtime_code;
  int ops_code;
  install_native_signal_handlers();
  if (argc <= 1) {
    print_help();
    return 64;
  }
  global_repo_root = find_repo_root(argv[0]);
  global_binary_dir = executable_dir_from_argv0(argv[0]);
  if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-h") == 0) {
    print_help();
    free(global_repo_root);
    free(global_binary_dir);
    return 0;
  }
  if (strcmp(argv[1], "--version") == 0) {
    print_version();
    free(global_repo_root);
    free(global_binary_dir);
    return 0;
  }
  if (strcmp(argv[1], "serve") == 0) {
    int code = handle_serve(argc - 2, argv + 2);
    free(global_repo_root);
    free(global_binary_dir);
    return code;
  }
  if (strcmp(argv[1], "json") == 0) {
    int code = handle_native_json_command(argc - 2, argv + 2);
    free(global_repo_root);
    free(global_binary_dir);
    return code;
  }
  {
    int barcode_code = handle_native_barcode_command(argc - 1, argv + 1);
    if (barcode_code != 78) {
      free(global_repo_root);
      free(global_binary_dir);
      return barcode_code;
    }
  }
  {
    int noindex_code = handle_native_noindex_command(argc - 1, argv + 1);
    if (noindex_code != 78) {
      free(global_repo_root);
      free(global_binary_dir);
      return noindex_code;
    }
  }
  ops_code = handle_native_ops_command(argc - 1, argv + 1);
  if (ops_code != 78) {
    free(global_repo_root);
    free(global_binary_dir);
    return ops_code;
  }
  website_code = handle_native_website_command(argc - 1, argv + 1);
  if (website_code != 78) {
    free(global_repo_root);
    free(global_binary_dir);
    return website_code;
  }
  runtime_code = handle_native_runtime_command(argc - 1, argv + 1);
  if (runtime_code != 78) {
    free(global_repo_root);
    free(global_binary_dir);
    return runtime_code;
  }
  if (global_repo_root == NULL) {
    fprintf(stderr, "unable to locate pharos repo root for launcher delegation\n");
    free(global_binary_dir);
    return 72;
  }
  website_code = exec_runtime_script_native(global_repo_root, argc, argv);
  free(global_repo_root);
  free(global_binary_dir);
  return website_code;
}