xbintsc 0.5.20 → 0.5.21

package/runtime/xt_async_io.c

@@ -0,0 +1,333 @@
+/*
+ * xbintsc runtime — asynchronous I/O offload pool.
+ *
+ * JavaScript's `await` can suspend an `async` body on a pending promise, but
+ * the host still has to provide the work that eventually settles it. Sockets
+ * and timers are readiness based and live directly on the `select(2)` reactor;
+ * file I/O and DNS have no portable readiness notification, so they run on a
+ * small pool of worker threads and report back through the same reactor.
+ *
+ * The threading contract is the important part:
+ *
+ *   - `job->run` executes on a worker thread and may only touch plain C memory
+ *     (paths, buffers, syscalls). It must never call the `xt_*` value API, the
+ *     collector, `xt_throw`, or the event loop.
+ *   - `job->complete` executes on the main thread after the reactor wakes up.
+ *     That is where results become `xt_value`s, promises settle, and a job may
+ *     submit follow-up work (fetch redirects do exactly that).
+ *   - `job->roots` keeps values needed across the suspension alive. They are
+ *     written on the main thread and scanned by the collector like any other
+ *     root.
+ *
+ * Completion wakes the reactor through a self-pipe (POSIX) or a loopback UDP
+ * socket (Windows, whose `select` only understands sockets). The reactor also
+ * polls the pool every iteration, so a failed wakeup degrades to a short wait
+ * rather than a hang.
+ */
+
+#include "rt_internal.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#if defined(_WIN32)
+#include <winsock2.h>
+#include <windows.h>
+#include <process.h>
+#else
+#include <errno.h>
+#include <fcntl.h>
+#include <pthread.h>
+#include <unistd.h>
+#endif
+
+#define XT_ASYNC_WORKERS 4
+/* A fallback bound for the reactor wait while work is outstanding. With a
+ * working wakeup the wait ends immediately when a job completes. */
+#define XT_ASYNC_POLL_MS 10
+
+static xt_async_job *xt_async_work_head = NULL;
+static xt_async_job *xt_async_work_tail = NULL;
+static xt_async_job *xt_async_done_head = NULL;
+static xt_async_job *xt_async_done_tail = NULL;
+
+/* Every submitted, not-yet-released job. Mutated only on the main thread. */
+static xt_async_job *xt_async_live_head = NULL;
+
+static int xt_async_pending_jobs = 0;
+static int xt_async_workers_started = 0;
+static int xt_async_worker_count = 0;
+static int xt_async_roots_registered = 0;
+static int xt_async_watcher_fd = -1;
+
+#if defined(_WIN32)
+/* Statically initialised like the POSIX primitives below: the reactor polls
+ * the pool on every timer/socket iteration, even when no async job was ever
+ * submitted, so the lock must be usable before `xt_async_submit` runs. */
+static SRWLOCK xt_async_lock = SRWLOCK_INIT;
+static CONDITION_VARIABLE xt_async_cond = CONDITION_VARIABLE_INIT;
+static SOCKET xt_async_wake_socket = INVALID_SOCKET;
+#define XT_ASYNC_LOCK() AcquireSRWLockExclusive(&xt_async_lock)
+#define XT_ASYNC_UNLOCK() ReleaseSRWLockExclusive(&xt_async_lock)
+static void xt_async_cond_wait(void) {
+  SleepConditionVariableSRW(&xt_async_cond, &xt_async_lock, INFINITE, 0);
+}
+static void xt_async_cond_signal(void) { WakeConditionVariable(&xt_async_cond); }
+#else
+static pthread_mutex_t xt_async_lock = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t xt_async_cond = PTHREAD_COND_INITIALIZER;
+static int xt_async_wake_pipe[2] = {-1, -1};
+#define XT_ASYNC_LOCK() pthread_mutex_lock(&xt_async_lock)
+#define XT_ASYNC_UNLOCK() pthread_mutex_unlock(&xt_async_lock)
+static void xt_async_cond_wait(void) { pthread_cond_wait(&xt_async_cond, &xt_async_lock); }
+static void xt_async_cond_signal(void) { pthread_cond_signal(&xt_async_cond); }
+#endif
+
+static void xt_async_scan_roots(void);
+
+/* -- wakeup channel ------------------------------------------------------- */
+
+static int xt_async_wake_fd(void) {
+#if defined(_WIN32)
+  return (int)xt_async_wake_socket;
+#else
+  return xt_async_wake_pipe[0];
+#endif
+}
+
+static void xt_async_wake_create(void) {
+#if defined(_WIN32)
+  if (xt_async_wake_socket != INVALID_SOCKET) return;
+  SOCKET socket_fd = socket(AF_INET, SOCK_DGRAM, 0);
+  if (socket_fd == INVALID_SOCKET) return;
+  struct sockaddr_in address;
+  memset(&address, 0, sizeof(address));
+  address.sin_family = AF_INET;
+  address.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+  address.sin_port = 0;
+  if (bind(socket_fd, (struct sockaddr *)&address, sizeof(address)) != 0) {
+    closesocket(socket_fd);
+    return;
+  }
+  int length = (int)sizeof(address);
+  if (getsockname(socket_fd, (struct sockaddr *)&address, &length) != 0 ||
+      connect(socket_fd, (struct sockaddr *)&address, sizeof(address)) != 0) {
+    closesocket(socket_fd);
+    return;
+  }
+  u_long nonBlocking = 1;
+  ioctlsocket(socket_fd, FIONBIO, &nonBlocking);
+  xt_async_wake_socket = socket_fd;
+#else
+  if (xt_async_wake_pipe[0] >= 0) return;
+  if (pipe(xt_async_wake_pipe) != 0) {
+    xt_async_wake_pipe[0] = -1;
+    xt_async_wake_pipe[1] = -1;
+    return;
+  }
+  for (int i = 0; i < 2; i++) {
+    int flags = fcntl(xt_async_wake_pipe[i], F_GETFL, 0);
+    if (flags >= 0) fcntl(xt_async_wake_pipe[i], F_SETFL, flags | O_NONBLOCK);
+  }
+#endif
+}
+
+/* Called by a worker after it queues a completion. */
+static void xt_async_wakeup(void) {
+#if defined(_WIN32)
+  if (xt_async_wake_socket == INVALID_SOCKET) return;
+  char byte = 1;
+  send(xt_async_wake_socket, &byte, 1, 0);
+#else
+  if (xt_async_wake_pipe[1] < 0) return;
+  char byte = 1;
+  ssize_t ignored = write(xt_async_wake_pipe[1], &byte, 1);
+  (void)ignored;
+#endif
+}
+
+static void xt_async_wake_drain(void) {
+#if defined(_WIN32)
+  if (xt_async_wake_socket == INVALID_SOCKET) return;
+  char buffer[256];
+  while (recv(xt_async_wake_socket, buffer, (int)sizeof(buffer), 0) > 0) {
+  }
+#else
+  if (xt_async_wake_pipe[0] < 0) return;
+  char buffer[256];
+  while (read(xt_async_wake_pipe[0], buffer, sizeof(buffer)) > 0) {
+  }
+#endif
+}
+
+static void xt_async_wake_handler(void *userdata, int events) {
+  (void)userdata;
+  (void)events;
+  xt_async_poll();
+}
+
+/* -- queue helpers (lock held) -------------------------------------------- */
+
+static void xt_async_push_work(xt_async_job *job) {
+  job->next = NULL;
+  if (xt_async_work_tail) xt_async_work_tail->next = job;
+  else xt_async_work_head = job;
+  xt_async_work_tail = job;
+}
+
+static void xt_async_push_done(xt_async_job *job) {
+  job->next = NULL;
+  if (xt_async_done_tail) xt_async_done_tail->next = job;
+  else xt_async_done_head = job;
+  xt_async_done_tail = job;
+}
+
+static xt_async_job *xt_async_pop_work(void) {
+  xt_async_job *job = xt_async_work_head;
+  if (!job) return NULL;
+  xt_async_work_head = job->next;
+  if (!xt_async_work_head) xt_async_work_tail = NULL;
+  return job;
+}
+
+static xt_async_job *xt_async_pop_done(void) {
+  xt_async_job *job = xt_async_done_head;
+  if (!job) return NULL;
+  xt_async_done_head = job->next;
+  if (!xt_async_done_head) xt_async_done_tail = NULL;
+  return job;
+}
+
+/* -- live job registry (main thread only) --------------------------------- */
+
+static void xt_async_live_add(xt_async_job *job) {
+  job->live_prev = NULL;
+  job->live_next = xt_async_live_head;
+  if (xt_async_live_head) xt_async_live_head->live_prev = job;
+  xt_async_live_head = job;
+}
+
+static void xt_async_live_remove(xt_async_job *job) {
+  if (job->live_prev) job->live_prev->live_next = job->live_next;
+  else xt_async_live_head = job->live_next;
+  if (job->live_next) job->live_next->live_prev = job->live_prev;
+  job->live_next = NULL;
+  job->live_prev = NULL;
+}
+
+static void xt_async_scan_roots(void) {
+  for (xt_async_job *job = xt_async_live_head; job; job = job->live_next) {
+    for (int i = 0; i < XT_ASYNC_ROOT_SLOTS; i++) xt_gc_mark_value(job->roots[i]);
+  }
+}
+
+static void xt_async_register_roots(void) {
+  if (xt_async_roots_registered) return;
+  xt_async_roots_registered = 1;
+  xt_gc_register_root_provider(xt_async_scan_roots);
+}
+
+/* -- worker threads -------------------------------------------------------- */
+
+static void xt_async_worker_run(void) {
+  for (;;) {
+    XT_ASYNC_LOCK();
+    xt_async_job *job = xt_async_pop_work();
+    while (!job) {
+      xt_async_cond_wait();
+      job = xt_async_pop_work();
+    }
+    XT_ASYNC_UNLOCK();
+    if (job->run) job->run(job);
+    XT_ASYNC_LOCK();
+    xt_async_push_done(job);
+    XT_ASYNC_UNLOCK();
+    xt_async_wakeup();
+  }
+}
+
+#if defined(_WIN32)
+static unsigned __stdcall xt_async_worker_entry(void *argument) {
+  (void)argument;
+  xt_async_worker_run();
+  return 0;
+}
+#else
+static void *xt_async_worker_entry(void *argument) {
+  (void)argument;
+  xt_async_worker_run();
+  return NULL;
+}
+#endif
+
+/* Spawn the pool lazily. Called with the lock held so a worker that starts
+ * immediately blocks until the queue is published. */
+static void xt_async_start_workers(void) {
+  if (xt_async_workers_started) return;
+  xt_async_workers_started = 1;
+  for (int i = 0; i < XT_ASYNC_WORKERS; i++) {
+#if defined(_WIN32)
+    uintptr_t handle = _beginthreadex(NULL, 0, xt_async_worker_entry, NULL, 0, NULL);
+    if (handle == 0) break;
+    CloseHandle((HANDLE)handle);
+#else
+    pthread_t thread;
+    if (pthread_create(&thread, NULL, xt_async_worker_entry, NULL) != 0) break;
+    pthread_detach(thread);
+#endif
+    xt_async_worker_count++;
+  }
+}
+
+/* -- public API ------------------------------------------------------------ */
+
+int xt_async_pending(void) { return xt_async_pending_jobs; }
+
+void xt_async_submit(xt_async_job *job) {
+  if (!job || !job->run) {
+    if (job && job->release) job->release(job);
+    else free(job);
+    return;
+  }
+  xt_async_register_roots();
+  xt_async_live_add(job);
+  xt_async_pending_jobs++;
+
+  xt_async_wake_create();
+  if (xt_async_watcher_fd < 0 && xt_async_wake_fd() >= 0) {
+    if (xt_loop_add(xt_async_wake_fd(), XT_IO_READ, xt_async_wake_handler, NULL) == 0) {
+      xt_async_watcher_fd = xt_async_wake_fd();
+    }
+  }
+
+  XT_ASYNC_LOCK();
+  xt_async_start_workers();
+  if (xt_async_worker_count > 0) {
+    xt_async_push_work(job);
+    xt_async_cond_signal();
+    XT_ASYNC_UNLOCK();
+    return;
+  }
+  /* No worker could be created: complete on the reactor's next poll. */
+  xt_async_push_done(job);
+  XT_ASYNC_UNLOCK();
+}
+
+void xt_async_poll(void) {
+  if (xt_async_watcher_fd >= 0) xt_async_wake_drain();
+  for (;;) {
+    XT_ASYNC_LOCK();
+    xt_async_job *job = xt_async_pop_done();
+    XT_ASYNC_UNLOCK();
+    if (!job) break;
+    if (job->complete) job->complete(job);
+    xt_async_live_remove(job);
+    if (job->release) job->release(job);
+    else free(job);
+    xt_async_pending_jobs--;
+  }
+  if (xt_async_pending_jobs == 0 && xt_async_watcher_fd >= 0) {
+    xt_loop_remove(xt_async_watcher_fd);
+    xt_async_watcher_fd = -1;
+  }
+}

package/runtime/xt_async_io.h

@@ -0,0 +1,47 @@
+/*
+ * xbintsc runtime — asynchronous I/O offload API.
+ *
+ * Declared separately from `rt_internal.h` so the internal header stays within
+ * the repository's file-size budget. Extensions that offload blocking work
+ * include `rt_internal.h`, which includes this header.
+ */
+#ifndef XT_RT_ASYNC_IO_H
+#define XT_RT_ASYNC_IO_H
+
+#include "rt.h"
+
+/*
+ * Some host operations (file I/O, DNS, a blocking HTTP exchange) have no
+ * portable readiness notification, so they run on a small worker pool and
+ * report back to the main thread. The contract is strict: `run` executes on a
+ * worker and may only touch plain C memory, while `complete` executes on the
+ * main thread and may build/consume `xt_value`s.
+ *
+ * A job begins with this struct. `roots` keeps up to four values alive while
+ * the job is queued or running: the slots are scanned by the collector and are
+ * only written from the main thread. `next` links the work/completion queue and
+ * is owned by the pool; callers never touch it. `release` (optional) frees the
+ * job after `complete` returns.
+ */
+#define XT_ASYNC_ROOT_SLOTS 4
+
+typedef struct xt_async_job xt_async_job;
+
+struct xt_async_job {
+  xt_async_job *next;
+  xt_async_job *live_next;
+  xt_async_job *live_prev;
+  void (*run)(xt_async_job *job);
+  void (*complete)(xt_async_job *job);
+  void (*release)(xt_async_job *job);
+  xt_value roots[XT_ASYNC_ROOT_SLOTS];
+};
+
+/** Queue `job` on a worker (never blocks the caller). Takes ownership. */
+void xt_async_submit(xt_async_job *job);
+/** Number of submitted jobs whose completion has not run yet. */
+int xt_async_pending(void);
+/** Run completed jobs and drop the loop watcher when the queue becomes idle. */
+void xt_async_poll(void);
+
+#endif /* XT_RT_ASYNC_IO_H */

package/runtime/xt_fetch/async.inc

@@ -0,0 +1,295 @@
+/* -- asynchronous request/response exchange ------------------------------- */
+
+/*
+ * `fetch` is a state machine over the async I/O pool. The main thread validates
+ * the URL, turns `init.headers` into a `Headers` object and serialises the
+ * request; a worker performs the blocking `getaddrinfo`/connect/send/recv
+ * exchange; the main thread parses the raw response, follows redirects and
+ * builds the `Response`. Nothing observed from JavaScript blocks the reactor, so
+ * timers and sockets keep running while a request is in flight.
+ *
+ * The worker only sees plain C memory. The values that must survive across the
+ * suspension (`promise`, `headers`) are held in the job's `roots` slots and
+ * scanned by the collector.
+ */
+
+typedef struct xt_fetch_state xt_fetch_state;
+
+typedef struct {
+  xt_async_job base;
+  xt_fetch_state *state;
+  char *request;
+  size_t request_length;
+  xt_fetch_buffer raw;
+  int failed;
+} xt_fetch_hop;
+
+struct xt_fetch_state {
+  xt_value promise;
+  xt_value headers_source;
+  char *url;
+  char method[16];
+  char redirect[16];
+  xt_fetch_buffer body;
+  int redirects;
+};
+
+static void xt_fetch_start(xt_fetch_state *state);
+
+static void xt_fetch_state_free(xt_fetch_state *state) {
+  if (!state) return;
+  free(state->url);
+  xt_fetch_buffer_free(&state->body);
+  free(state);
+}
+
+static void xt_fetch_state_reject(xt_fetch_state *state, const char *message) {
+  xt_value argument = xt_string_from_cstr(message);
+  xt_value error = xt_type_error_ctor(1, &argument);
+  xt_value promise = state->promise;
+  xt_fetch_state_free(state);
+  xt_promise_reject_value(promise, error);
+}
+
+static void xt_fetch_hop_release(xt_async_job *job) {
+  xt_fetch_hop *hop = (xt_fetch_hop *)job;
+  free(hop->request);
+  xt_fetch_buffer_free(&hop->raw);
+  free(hop);
+}
+
+/* Worker thread: connect, write the request, read until the response is
+ * complete (or the peer closes). Only plain C memory is touched here. */
+static void xt_fetch_hop_run(xt_async_job *job) {
+  xt_fetch_hop *hop = (xt_fetch_hop *)job;
+  xt_fetch_url parsed;
+  if (xt_fetch_parse_url(hop->state->url, &parsed) != 0) {
+    hop->failed = 1;
+    return;
+  }
+  int fd = xt_fetch_connect(&parsed);
+  if (fd < 0) {
+    hop->failed = 1;
+    return;
+  }
+  if (xt_fetch_send_all(fd, hop->request, hop->request_length) != 0) {
+    xt_fetch_close_socket(fd);
+    hop->failed = 1;
+    return;
+  }
+
+  char chunk[16384];
+  for (;;) {
+    int headEnd = xt_fetch_head_end(&hop->raw);
+    if (headEnd > 0) {
+      int status = 0;
+      char statusText[256];
+      size_t headerStart = 0;
+      if (xt_fetch_parse_status_line(hop->raw.data, hop->raw.length, &status, statusText, sizeof(statusText),
+                                     &headerStart) == 0) {
+        int stop = 0;
+        if (status == 204 || status == 304 || (status >= 100 && status < 200) ||
+            strcmp(hop->state->method, "HEAD") == 0) {
+          stop = 1;
+        } else {
+          size_t contentLength = 0;
+          int hasContentLength = 0;
+          int chunked = 0;
+          xt_fetch_scan_headers(hop->raw.data, headerStart, (size_t)headEnd - 2, &contentLength, &hasContentLength,
+                                &chunked);
+          if (chunked) {
+            size_t decoded = 0;
+            if (xt_fetch_chunked_complete(hop->raw.data, hop->raw.length, (size_t)headEnd, &decoded) == 1) stop = 1;
+          } else if (hasContentLength && hop->raw.length - (size_t)headEnd >= contentLength) {
+            stop = 1;
+          }
+        }
+        if (stop) break;
+      }
+    }
+    int count = xt_fetch_recv(fd, chunk, sizeof(chunk));
+    if (count > 0) {
+      xt_fetch_buffer_append(&hop->raw, chunk, (size_t)count);
+      continue;
+    }
+    break;
+  }
+  xt_fetch_close_socket(fd);
+}
+
+#define XT_FETCH_HOP(c) ((xt_fetch_hop *)(c))
+
+/* Main thread: parse the raw response and either follow a redirect (starting a
+ * fresh hop) or build the `Response` and settle the promise. */
+static void xt_fetch_hop_complete(xt_async_job *job) {
+  xt_fetch_hop *hop = XT_FETCH_HOP(job);
+  xt_fetch_state *state = hop->state;
+  if (hop->failed) {
+    xt_fetch_state_reject(state, "fetch failed");
+    return;
+  }
+
+  xt_fetch_buffer *raw = &hop->raw;
+  int headEnd = xt_fetch_head_end(raw);
+  int status = 0;
+  char statusText[256];
+  size_t headerStart = 0;
+  if (headEnd <= 0 ||
+      xt_fetch_parse_status_line(raw->data, raw->length, &status, statusText, sizeof(statusText), &headerStart) != 0) {
+    xt_fetch_state_reject(state, "fetch failed: invalid response");
+    return;
+  }
+
+  xt_value responseHeaders = xt_headers_new();
+  xt_headers_parse_block(responseHeaders, raw->data + headerStart, (size_t)headEnd - 2 - headerStart);
+
+  int isRedirect = status == 301 || status == 302 || status == 303 || status == 307 || status == 308;
+  if (isRedirect && strcmp(state->redirect, "error") == 0) {
+    xt_fetch_state_reject(state, "fetch failed: redirect not allowed");
+    return;
+  }
+  if (isRedirect && strcmp(state->redirect, "manual") != 0 && state->redirects < 20) {
+    xt_fetch_url parsed;
+    if (xt_fetch_parse_url(state->url, &parsed) == 0) {
+      const char *location = xt_headers_lookup(responseHeaders, "location");
+      char resolved[4096];
+      if (location && xt_fetch_resolve_location(&parsed, location, resolved, sizeof(resolved)) == 0) {
+        if (status == 303 || ((status == 301 || status == 302) && strcmp(state->method, "POST") == 0)) {
+          snprintf(state->method, sizeof(state->method), "GET");
+          state->body.length = 0;
+        }
+        free(state->url);
+        size_t length = strlen(resolved);
+        state->url = (char *)malloc(length + 1);
+        if (!state->url) {
+          xt_fetch_state_reject(state, "fetch failed");
+          return;
+        }
+        memcpy(state->url, resolved, length + 1);
+        state->redirects++;
+        xt_fetch_start(state);
+        return;
+      }
+    }
+  }
+
+  size_t contentLength = 0;
+  int hasContentLength = 0;
+  int chunked = 0;
+  xt_fetch_scan_headers(raw->data, headerStart, (size_t)headEnd - 2, &contentLength, &hasContentLength, &chunked);
+  xt_fetch_buffer responseBody;
+  xt_fetch_buffer_init(&responseBody);
+  if (status == 204 || status == 304 || (status >= 100 && status < 200) || strcmp(state->method, "HEAD") == 0) {
+    /* No body by definition. */
+  } else if (chunked) {
+    xt_fetch_decode_chunked(raw->data, raw->length, (size_t)headEnd, &responseBody);
+  } else if (hasContentLength) {
+    size_t available = raw->length - (size_t)headEnd;
+    size_t take = contentLength < available ? contentLength : available;
+    xt_fetch_buffer_append(&responseBody, raw->data + headEnd, take);
+  } else {
+    xt_fetch_buffer_append(&responseBody, raw->data + headEnd, raw->length - (size_t)headEnd);
+  }
+
+  xt_value response = xt_response_new(responseHeaders, status, statusText, state->url,
+                                      responseBody.data ? responseBody.data : "", responseBody.length);
+  xt_fetch_buffer_free(&responseBody);
+  xt_value promise = state->promise;
+  xt_fetch_state_free(state);
+  xt_promise_fulfill(promise, response);
+}
+
+/* Main thread: validate the current URL and queue one exchange. */
+static void xt_fetch_start(xt_fetch_state *state) {
+  xt_fetch_url parsed;
+  if (xt_fetch_parse_url(state->url, &parsed) != 0) {
+    xt_fetch_state_reject(state, "Failed to parse URL");
+    return;
+  }
+  if (parsed.secure) {
+    xt_fetch_state_reject(state, "fetch failed: https is not supported");
+    return;
+  }
+
+  xt_value requestHeaders = xt_headers_from_source(state->headers_source);
+  xt_fetch_buffer request;
+  xt_fetch_buffer_init(&request);
+  xt_fetch_build_request(state->method, &parsed, requestHeaders, state->body.length > 0 ? &state->body : NULL,
+                         &request);
+
+  xt_fetch_hop *hop = (xt_fetch_hop *)calloc(1, sizeof(xt_fetch_hop));
+  if (!hop) abort();
+  hop->base.roots[0] = state->promise;
+  hop->base.roots[1] = state->headers_source;
+  hop->base.run = xt_fetch_hop_run;
+  hop->base.complete = xt_fetch_hop_complete;
+  hop->base.release = xt_fetch_hop_release;
+  hop->state = state;
+  hop->request = request.data;
+  hop->request_length = request.length;
+  xt_fetch_buffer_init(&hop->raw);
+  xt_async_submit(&hop->base);
+}
+
+/** Implements the global `fetch(input, init)`. The returned promise settles
+ * once a worker has completed the exchange and the reactor dispatches it. */
+xt_value xt_fetch(int32_t argc, xt_value *argv) {
+  xt_value input = xt_arg_at(argc, argv, 0);
+  xt_value init = xt_arg_at(argc, argv, 1);
+  if (input == XT_UNDEFINED || input == XT_NULL) {
+    xt_value argument = xt_string_from_cstr("Failed to parse URL from undefined");
+    return xt_promise_reject(xt_type_error_ctor(1, &argument));
+  }
+
+  xt_value urlValue = input;
+  if (XT_IS_OBJECT(input)) {
+    xt_value candidate = xt_object_get_cstr(input, "url");
+    if (XT_IS_STRING(candidate)) urlValue = candidate;
+  }
+  const char *urlText = xt_string_data(xt_to_string(urlValue));
+  if (!urlText) {
+    xt_value argument = xt_string_from_cstr("Failed to parse URL");
+    return xt_promise_reject(xt_type_error_ctor(1, &argument));
+  }
+
+  xt_fetch_state *state = (xt_fetch_state *)calloc(1, sizeof(xt_fetch_state));
+  if (!state) abort();
+  size_t urlLength = strlen(urlText);
+  state->url = (char *)malloc(urlLength + 1);
+  if (!state->url) abort();
+  memcpy(state->url, urlText, urlLength + 1);
+  snprintf(state->method, sizeof(state->method), "GET");
+  snprintf(state->redirect, sizeof(state->redirect), "follow");
+  xt_fetch_buffer_init(&state->body);
+  state->headers_source = XT_UNDEFINED;
+  state->redirects = 0;
+
+  if (XT_IS_OBJECT(init)) {
+    xt_value methodValue = xt_object_get_cstr(init, "method");
+    if (XT_IS_STRING(methodValue)) {
+      const char *text = xt_string_data(methodValue);
+      size_t i = 0;
+      for (; text && text[i] && i + 1 < sizeof(state->method); i++) {
+        char c = text[i];
+        state->method[i] = (c >= 'a' && c <= 'z') ? (char)(c - 32) : c;
+      }
+      state->method[i] = '\0';
+    }
+    state->headers_source = xt_object_get_cstr(init, "headers");
+    xt_value bodySource = xt_object_get_cstr(init, "body");
+    if (bodySource != XT_UNDEFINED && bodySource != XT_NULL) {
+      xt_value text = xt_to_string(bodySource);
+      const char *data = xt_string_data(text);
+      if (data) xt_fetch_buffer_append(&state->body, data, (size_t)xt_string_length_value(text));
+    }
+    xt_value redirectValue = xt_object_get_cstr(init, "redirect");
+    if (XT_IS_STRING(redirectValue)) {
+      snprintf(state->redirect, sizeof(state->redirect), "%s", xt_string_data(redirectValue));
+    }
+  }
+
+  state->promise = xt_promise_create();
+  xt_value promise = state->promise;
+  xt_fetch_start(state);
+  return promise;
+}