@scriptc/cli-darwin-arm64 0.2.0 → 0.2.2

package/dist/lib/runtime-sources/src/scr_error.c

@@ -135,6 +135,7 @@ void scr_error_init(void *obj, int kind, ScrStr *message) {
   const char *n = scr_error_names[kind];
   e->name = scr_str_new(n, strlen(n));
   e->message = message ? scr_str_retain(message) : scr_str_new("", 0);
+  e->message_present = message != NULL;
   e->stack_frames = scr_stack_capture();
 }
 
@@ -172,9 +173,28 @@ ScrError *scr_error_new(int kind, ScrStr *message) {
   return e;
 }
 
-ScrStr *scr_error_to_string(ScrError *e) {
-  /* ECMA-262 Error.prototype.toString over the two fields (no prototype
-   * chain exists: constructors always initialize both) — except Node's
+static SCR_TL ScrStr *(*scr_error_message_reader)(ScrError *);
+static SCR_TL ScrStr *(*scr_error_name_reader)(ScrError *);
+
+void scr_error_install_message_reader(ScrStr *(*reader)(ScrError *)) {
+  scr_error_message_reader = reader;
+}
+
+void scr_error_install_name_reader(ScrStr *(*reader)(ScrError *)) {
+  scr_error_name_reader = reader;
+}
+
+ScrStr *scr_error_default_name(const ScrError *e) {
+  for (int i = 1; i < SCR_ERR_COUNT; i++) {
+    if (i == SCR_ERR_DOMEX) continue;
+    if (scr_error_vts[i].pre <= e->vt->pre && e->vt->pre <= scr_error_vts[i].post)
+      return scr_str_new(scr_error_names[i], strlen(scr_error_names[i]));
+  }
+  return scr_str_new("Error", 5);
+}
+
+static ScrStr *scr_error_format(ScrError *e, ScrStr *name, ScrStr *message) {
+  /* ECMA-262 Error.prototype.toString over the resolved properties — except Node's
    * OWN error classes: AssertionError's toString and the NodeError
    * family's construction-time name both render "name [code]: message".
    * Every ERR_*-coded error this runtime mints IS one of those classes
@@ -182,8 +202,6 @@ ScrStr *scr_error_to_string(ScrError *e) {
    * the code-prefix test is exact for runtime-thrown errors; a user
    * assigning an ERR_* code onto a plain Error would bracket here where
    * Node would not (documented — user code owns that spelling). */
-  ScrStr *name = e->name;
-  ScrStr *message = e->message;
   bool assertion = name && e->code && e->code->len >= 4 &&
                    memcmp(e->code->data, "ERR_", 4) == 0;
   if (!name || name->len == 0) {
@@ -214,9 +232,36 @@ ScrStr *scr_error_to_string(ScrError *e) {
   return out;
 }
 
+ScrStr *scr_error_to_string(ScrError *e) {
+  // Diagnostic formatting can run with the original error still pending.
+  // Accessors execute with a clear cell, and cannot replace that error.
+  ScrCaught *pending = scr_exc_pending() ? scr_exc_take() : NULL;
+  ScrStr *name = !e->name_present && scr_error_name_reader
+    ? scr_error_name_reader(scr_error_retain(e)) : scr_str_retain(e->name);
+  ScrStr *message = scr_exc_pending() ? NULL : !e->message_present && scr_error_message_reader
+    ? scr_error_message_reader(scr_error_retain(e)) : scr_str_retain(e->message);
+  if (pending) {
+    if (scr_exc_pending()) {
+      scr_exc_clear();
+      scr_str_release(message);
+      message = scr_str_retain(e->message);
+      scr_str_release(name);
+      name = scr_str_retain(e->name);
+    }
+    scr_rethrow(pending);
+    scr_caught_release(pending);
+  }
+  if (!name || !message) { scr_str_release(name); scr_str_release(message); return NULL; }
+  ScrStr *result = scr_error_format(e, name, message);
+  scr_str_release(name);
+  scr_str_release(message);
+  return result;
+}
+
 ScrStr *scr_error_stack(ScrError *e) {
   if (!e->stack) {
     ScrStr *heading = scr_error_to_string(e);
+    if (!heading) return NULL;
     e->stack = e->stack_frames ? scr_str_concat(heading, e->stack_frames) : scr_str_retain(heading);
     scr_str_release(heading);
   }
@@ -367,6 +412,8 @@ void scr_throw_error_named(ScrStr *name, ScrStr *message) {
   ScrError *e = scr_error_alloc(kind);
   e->name = name;       /* ownership moves in (engine names may be custom) */
   e->message = message; /* ownership moves in */
+  e->name_present = kind == SCR_ERR_ERROR && !(name->len == 5 && memcmp(name->data, "Error", 5) == 0);
+  e->message_present = true;
   scr_throw_obj(e, &scr_error_retain_v, &scr_error_release_v,
                  scr_error_traced ? &scr_error_trace : NULL);
 }

package/dist/lib/runtime-sources/src/scr_exception.c

@@ -139,11 +139,24 @@ void scr_exc_clear(void) { scr_exc_reset(); }
 
 /* ── catch bindings (ScrCaught — contract in scr_runtime.h) ──────────── */
 
-ScrCaught *scr_exc_take(void) {
-  ScrCaught *c = calloc(1, sizeof *c);
-  if (!c) {
-    scr_trap("scriptc: out of memory\n");
+void scr_caught_trace_v(void *object, ScrTraceVisit visit, void *ctx) {
+  ScrCaught *c = object;
+  if (c->payload && c->trace_fn) visit(c->payload, ctx);
+}
+
+static void scr_caught_gcfree(void *object) {
+  ScrCaught *c = object;
+  if (c->kind == SCR_EXC_STR) {
+    scr_str_release((ScrStr *)c->payload);
+  } else if (c->payload && c->release_fn && !c->trace_fn) {
+    c->release_fn(c->payload);
   }
+  scr_obj_free_note();
+  scr_cyc_free(c);
+}
+
+ScrCaught *scr_exc_take(void) {
+  ScrCaught *c = scr_cyc_alloc(sizeof *c, scr_caught_trace_v, scr_caught_gcfree);
   c->rc = 1;
   c->kind = scr_exc_kind;
   c->f64 = scr_exc_f64;
@@ -169,6 +182,7 @@ ScrCaught *scr_caught_retain(ScrCaught *c) {
 void scr_caught_release(ScrCaught *c) {
   if (!c) return;
   if (--c->rc == 0) {
+    scr_cyc_on_dead(c);
     if (c->kind == SCR_EXC_STR) {
       scr_str_release((ScrStr *)c->payload);
     } else if (c->kind == SCR_EXC_REF || c->kind == SCR_EXC_OBJ ||
@@ -176,7 +190,9 @@ void scr_caught_release(ScrCaught *c) {
       c->release_fn(c->payload);
     }
     scr_obj_free_note();
-    free(c);
+    scr_cyc_free(c);
+  } else {
+    scr_cyc_on_release(c);
   }
 }
 

package/dist/lib/runtime-sources/src/scr_fetch.c

@@ -92,7 +92,11 @@
 #include <stdlib.h>
 #include <string.h>
 
+#ifndef SCR_FETCH_SIGNAL_ONLY
 #include <zlib.h>
+#else
+static void sf_signal_install(void);
+#endif
 
 /*
  * The static tier is a small native Web-platform island of its own:
@@ -289,6 +293,7 @@ struct SfResponse {
   bool null_body;
 };
 
+#ifndef SCR_FETCH_SIGNAL_ONLY
 struct SfTransfer {
   size_t rc;                 /* live registry + one per listener closure */
   ScrPromise *promise;       /* owned */
@@ -323,12 +328,15 @@ struct SfTransfer {
 };
 
 static SfTransfer *sf_live;
+#endif
 /* Weak registries: owners unlink themselves on destruction. They let the
  * fetch teardown sever opaque native→dyn edges before final cycle collection,
  * including otherwise-untraceable callback/reason→handle backedges. */
 static SfSignal *sf_callback_signals;
 static SfSignal *sf_reason_signals;
+#ifndef SCR_FETCH_SIGNAL_ONLY
 static SfStream *sf_callback_streams;
+#endif
 
 static void sf_oom(void) {
   fputs("scriptc: out of memory\n", stderr);
@@ -484,6 +492,9 @@ static void sf_signal_drop_reason(SfSignal *s) {
 }
 
 static SfSignal *sf_signal_new(void) {
+#ifdef SCR_FETCH_SIGNAL_ONLY
+  sf_signal_install();
+#endif
   SfSignal *s = calloc(1, sizeof *s);
   if (!s) sf_oom();
   s->rc = 1;
@@ -1340,6 +1351,8 @@ static bool sf_signal_set(void *ptr, const char *key, size_t len,
 
 /* ── ReadableStream ──────────────────────────────────────────────── */
 
+#ifndef SCR_FETCH_SIGNAL_ONLY
+
 static void sf_stream_track_callbacks(SfStream *s) {
   if (s->callbacks_tracked || (!s->pull_cb && !s->cancel_cb)) return;
   s->callbacks_tracked = true;
@@ -3176,6 +3189,7 @@ static SfResponse *sf_response_retain(SfResponse *r) {
 
 static void sf_response_release(SfResponse *r) {
   if (!r || --r->rc > 0) return;
+  scr_weak_dispose(r);
   sf_stream_release(r->body);
   sf_headers_release(r->headers);
   scr_str_release(r->url);
@@ -4057,11 +4071,17 @@ static ScrArr *sf_headers_convert_init(const ScrDyn *headers) {
   if (headers->kind == SCR_DYN_ARR) {
     for (size_t i = 0; i < headers->v.arr.len; i++) {
       ScrDyn *pair = scr_dyn_retain(headers->v.arr.items[i]);
+      if (pair->kind == SCR_DYN_TYPED_REF) {
+        ScrDyn *materialized = scr_dyn_typed_ref_materialize(pair);
+        scr_dyn_release(pair);
+        pair = materialized;
+      }
       if (pair->kind != SCR_DYN_ARR || pair->v.arr.len != 2) {
+        bool sequence = pair->kind == SCR_DYN_ARR;
         size_t pair_len = pair->kind == SCR_DYN_ARR ? pair->v.arr.len : 0;
         scr_dyn_release(pair);
         if (!scr_exc_pending()) {
-          if (pair_len > 0 || headers->v.arr.items[i]->kind == SCR_DYN_ARR) {
+          if (sequence) {
             sf_headers_pair_length_error(pair_len);
           } else {
             sf_headers_constructor_type_error();
@@ -5169,7 +5189,250 @@ fail:
   return NULL;
 }
 
+/* Request uses the same body stream and Headers ownership as Response. */
+typedef struct SfRequest {
+  size_t rc;
+  SfResponse *payload;
+  ScrStr *url;
+  ScrStr *method;
+  ScrStr *redirect;
+  SfSignal *signal;
+} SfRequest;
+
+static void *sf_request_retain_v(void *ptr) {
+  SfRequest *r = ptr; r->rc++; return r;
+}
+static void sf_request_release_v(void *ptr) {
+  SfRequest *r = ptr;
+  if (--r->rc) return;
+  scr_weak_dispose(r);
+  sf_response_release(r->payload);
+  scr_str_release(r->url); scr_str_release(r->method); scr_str_release(r->redirect);
+  sf_signal_release(r->signal); free(r);
+}
+static ScrDyn *sf_request_get(void *ptr, const char *key, size_t len) {
+  SfRequest *r = ptr;
+  if (sf_name(key, len, "url")) return scr_dyn_new_str(r->url);
+  if (sf_name(key, len, "method")) return scr_dyn_new_str(r->method);
+  if (sf_name(key, len, "redirect")) return scr_dyn_new_str(r->redirect);
+  if (sf_name(key, len, "signal")) return scr_dyn_new_handle(r->signal, SCR_DYNH_ABORT_SIGNAL);
+  if (sf_name(key, len, "duplex")) { ScrStr *s = scr_str_new("half", 4); ScrDyn *v = scr_dyn_new_str(s); scr_str_release(s); return v; }
+  const char *default_value = NULL;
+  if (sf_name(key, len, "destination") || sf_name(key, len, "integrity") || sf_name(key, len, "referrerPolicy")) default_value = "";
+  if (sf_name(key, len, "mode")) default_value = "cors";
+  if (sf_name(key, len, "credentials")) default_value = "same-origin";
+  if (sf_name(key, len, "cache")) default_value = "default";
+  if (sf_name(key, len, "referrer")) default_value = "about:client";
+  if (default_value) { ScrStr *s = scr_str_new(default_value, strlen(default_value)); ScrDyn *v = scr_dyn_new_str(s); scr_str_release(s); return v; }
+  if (sf_name(key, len, "keepalive") || sf_name(key, len, "isReloadNavigation") || sf_name(key, len, "isHistoryNavigation")) return scr_dyn_new_bool(false);
+  if (sf_name(key, len, "body") || sf_name(key, len, "bodyUsed") || sf_name(key, len, "headers")) return sf_response_get(r->payload, key, len);
+  return scr_dyn_undefined();
+}
+static ScrDyn *sf_request_invoke(void *ptr, ScrDyn *self, const char *method, ScrDyn *const *args, size_t argc, const char *what) {
+  SfRequest *r = ptr;
+  return sf_response_invoke(r->payload, self, method, args, argc, what);
+}
+
+ScrDyn *scr_fetch_headers_new(ScrDyn *init) {
+  ScrArr *converted = sf_headers_convert_init(init);
+  if (!converted) return NULL;
+  ScrArr *pairs = scr_arr_new(SCR_ELEM_STR, 8);
+  bool ok = sf_add_converted_headers(pairs, converted, false);
+  scr_arr_release(converted);
+  if (!ok) { scr_arr_release(pairs); return NULL; }
+  SfHeaders *headers = sf_headers_new(pairs, false);
+  ScrDyn *result = scr_dyn_new_handle(headers, SCR_DYNH_FETCH_HEADERS);
+  sf_headers_release(headers);
+  return result;
+}
+
+ScrDyn *scr_fetch_request_new(ScrDyn *input, ScrDyn *init) {
+  SfRequest *source = input && input->kind == SCR_DYN_HANDLE && input->v.handle.tag == SCR_DYNH_FETCH_REQUEST ? input->v.handle.ptr : NULL;
+  if (init && init->kind != SCR_DYN_UNDEF && init->kind != SCR_DYN_NULL && !sf_response_init_object_like(init)) {
+    sf_type_error("Request constructor init must be an object"); return NULL;
+  }
+  ScrStr *url_text = source ? scr_str_retain(source->url) : scr_dyn_string_coerce_js(input);
+  if (!url_text) return NULL;
+  ScrUrl *url = scr_url_new(url_text);
+  scr_str_release(url_text);
+  if (!url) return NULL;
+  if (url->userinfo->len) { scr_url_release(url); sf_type_error("Request cannot be constructed from a URL that includes credentials"); return NULL; }
+  ScrDyn *dictionary = scr_dyn_new_obj();
+  ScrDyn *method = sf_response_init_get(init, "method", 6);
+  if ((!method || method->kind == SCR_DYN_UNDEF) && source) { scr_dyn_release(method); method = scr_dyn_new_str(source->method); }
+  if (method) scr_dyn_obj_set(dictionary, "method", 6, method);
+  ScrStr *method_text = sf_method_value(dictionary);
+  scr_dyn_release(dictionary);
+  if (!method_text || !sf_method_validate(&method_text)) { scr_str_release(method_text); scr_url_release(url); return NULL; }
+  ScrDyn *body = sf_response_init_get(init, "body", 4);
+  bool supplied = body && body->kind != SCR_DYN_UNDEF && body->kind != SCR_DYN_NULL;
+  if (!supplied && source && !source->payload->null_body) {
+    if (source->payload->body->disturbed || source->payload->body->reader || source->payload->body->internal_lock) {
+      scr_dyn_release(body); scr_str_release(method_text); scr_url_release(url);
+      sf_type_error("Cannot construct a Request with a Request object that has already been used."); return NULL;
+    }
+    scr_dyn_release(body); body = scr_dyn_new_handle(source->payload->body, SCR_DYNH_WEB_STREAM);
+  }
+  bool has_body = body && body->kind != SCR_DYN_UNDEF && body->kind != SCR_DYN_NULL;
+  if (has_body && (sf_name(method_text->data, method_text->len, "GET") || sf_name(method_text->data, method_text->len, "HEAD"))) {
+    scr_dyn_release(body); scr_str_release(method_text); scr_url_release(url); sf_type_error("Request with GET/HEAD method cannot have body."); return NULL;
+  }
+  if (supplied && body->kind == SCR_DYN_HANDLE && body->v.handle.tag == SCR_DYNH_WEB_STREAM) {
+    ScrDyn *duplex = sf_response_init_get(init, "duplex", 6);
+    ScrStr *text = duplex && duplex->kind != SCR_DYN_UNDEF ? scr_dyn_string_coerce_js(duplex) : NULL;
+    scr_dyn_release(duplex);
+    bool half = text && sf_name(text->data, text->len, "half"); scr_str_release(text);
+    if (!half) { scr_dyn_release(body); scr_str_release(method_text); scr_url_release(url); sf_type_error("RequestInit: duplex option is required when sending a body."); return NULL; }
+  }
+  ScrDyn *headers = sf_response_init_get(init, "headers", 7);
+  if ((!headers || headers->kind == SCR_DYN_UNDEF) && source) { scr_dyn_release(headers); headers = scr_dyn_new_handle(source->payload->headers, SCR_DYNH_FETCH_HEADERS); }
+  ScrDyn *payload_init = scr_dyn_new_obj();
+  if (headers) scr_dyn_obj_set(payload_init, "headers", 7, headers);
+  ScrDyn *payload = scr_fetch_response_new(body, payload_init);
+  scr_dyn_release(payload_init); scr_dyn_release(body);
+  if (!payload) { scr_str_release(method_text); scr_url_release(url); return NULL; }
+  ScrDyn *signal = sf_response_init_get(init, "signal", 6);
+  if ((!signal || signal->kind == SCR_DYN_UNDEF) && source) { scr_dyn_release(signal); signal = scr_dyn_new_handle(source->signal, SCR_DYNH_ABORT_SIGNAL); }
+  SfSignal *following = NULL;
+  if (signal && signal->kind != SCR_DYN_UNDEF && signal->kind != SCR_DYN_NULL) {
+    ScrDyn *signals = scr_dyn_new_arr(); scr_dyn_arr_push(signals, scr_dyn_retain(signal));
+    ScrDyn *dependent = scr_fetch_abort_any(signals); scr_dyn_release(signals);
+    if (dependent) { following = sf_signal_retain(dependent->v.handle.ptr); scr_dyn_release(dependent); }
+  } else following = sf_signal_new();
+  scr_dyn_release(signal);
+  if (!following) { scr_dyn_release(payload); scr_str_release(method_text); scr_url_release(url); return NULL; }
+  ScrDyn *redirect = sf_response_init_get(init, "redirect", 8);
+  ScrStr *redirect_text = redirect && redirect->kind != SCR_DYN_UNDEF ? scr_dyn_string_coerce_js(redirect) : source ? scr_str_retain(source->redirect) : scr_str_new("follow", 6);
+  scr_dyn_release(redirect);
+  if (!redirect_text || !(sf_name(redirect_text->data, redirect_text->len, "follow") || sf_name(redirect_text->data, redirect_text->len, "manual") || sf_name(redirect_text->data, redirect_text->len, "error"))) {
+    scr_str_release(redirect_text); sf_signal_release(following); scr_dyn_release(payload); scr_str_release(method_text); scr_url_release(url); sf_type_error("Invalid Request redirect value"); return NULL;
+  }
+  SfRequest *r = calloc(1, sizeof *r); if (!r) sf_oom();
+  r->rc = 1; r->payload = sf_response_retain(payload->v.handle.ptr); scr_dyn_release(payload);
+  r->url = scr_url_href(url); scr_url_release(url); r->method = method_text; r->redirect = redirect_text; r->signal = following;
+  ScrDyn *result = scr_dyn_new_handle(r, SCR_DYNH_FETCH_REQUEST); sf_request_release_v(r); return result;
+}
+
+ScrPromise *scr_fetch_input(ScrDyn *input, ScrDyn *init) {
+  if (init && init->kind == SCR_DYN_TYPED_REF) {
+    ScrDyn *view = scr_dyn_typed_ref_materialize(init);
+    if (scr_exc_pending()) { scr_dyn_release(view); ScrPromise *p = scr_promise_new(); scr_promise_reject_pending(p); return p; }
+    ScrPromise *result = scr_fetch_input(input, view);
+    scr_dyn_release(view);
+    return result;
+  }
+  if (input && input->kind == SCR_DYN_HANDLE && input->v.handle.tag == SCR_DYNH_FETCH_REQUEST) {
+    ScrDyn *converted = scr_fetch_request_new(input, init);
+    if (!converted) { ScrPromise *p = scr_promise_new(); scr_promise_reject_pending(p); return p; }
+    SfRequest *r = converted->v.handle.ptr;
+    ScrDyn *dictionary = scr_dyn_new_obj();
+    scr_dyn_obj_set(dictionary, "method", 6, scr_dyn_new_str(r->method));
+    scr_dyn_obj_set(dictionary, "headers", 7, scr_dyn_new_handle(r->payload->headers, SCR_DYNH_FETCH_HEADERS));
+    scr_dyn_obj_set(dictionary, "signal", 6, scr_dyn_new_handle(r->signal, SCR_DYNH_ABORT_SIGNAL));
+    scr_dyn_obj_set(dictionary, "redirect", 8, scr_dyn_new_str(r->redirect));
+    if (!r->payload->null_body) {
+      scr_dyn_obj_set(dictionary, "body", 4, scr_dyn_new_handle(r->payload->body, SCR_DYNH_WEB_STREAM));
+      ScrStr *half = scr_str_new("half", 4); scr_dyn_obj_set(dictionary, "duplex", 6, scr_dyn_new_str(half)); scr_str_release(half);
+    }
+    ScrPromise *result = scr_fetch_static(r->url, dictionary);
+    scr_dyn_release(dictionary); scr_dyn_release(converted); return result;
+  }
+  ScrStr *url = scr_dyn_string_coerce_js(input);
+  if (!url) { ScrPromise *p = scr_promise_new(); scr_promise_reject_pending(p); return p; }
+  ScrPromise *result = scr_fetch_static(url, init); scr_str_release(url); return result;
+}
+
+static ScrDyn *sf_fetch_function_call(ScrClosure *closure, ScrDyn *const *args, size_t argc) {
+  (void)closure;
+  ScrPromise *p = scr_fetch_input(argc ? args[0] : scr_dyn_undefined(), argc > 1 ? args[1] : scr_dyn_undefined());
+  ScrDyn *result = scr_dyn_new_promise(p); scr_promise_release(p); return result;
+}
+static ScrDyn *sf_fetch_function_value;
+static void sf_fetch_function_cleanup(void) {
+  ScrDyn *value = sf_fetch_function_value;
+  sf_fetch_function_value = NULL;
+  scr_dyn_release(value);
+}
+bool scr_fetch_web_is(const ScrDyn *value, const ScrStr *name) {
+  if (value->kind != SCR_DYN_HANDLE) return false;
+  if (sf_name(name->data, name->len, "Response")) return value->v.handle.tag == SCR_DYNH_FETCH_RESPONSE;
+  if (sf_name(name->data, name->len, "Request")) return value->v.handle.tag == SCR_DYNH_FETCH_REQUEST;
+  return sf_name(name->data, name->len, "Headers") && value->v.handle.tag == SCR_DYNH_FETCH_HEADERS;
+}
+
+bool scr_fetch_stream_is(const ScrDyn *value) {
+  return value && value->kind == SCR_DYN_HANDLE && value->v.handle.tag == SCR_DYNH_WEB_STREAM;
+}
+ScrDyn *scr_fetch_function(void) {
+  if (!sf_fetch_function_value) {
+    sf_fetch_function_value = scr_dyn_new_func(scr_closure_new(NULL, 0), sf_fetch_function_call, 1, "fetch", "fetch");
+    scr_atexit(sf_fetch_function_cleanup);
+  }
+  return scr_dyn_retain(sf_fetch_function_value);
+}
+
+static int sf_data_hex(unsigned char ch) {
+  if (ch >= '0' && ch <= '9') return ch - '0';
+  if (ch >= 'a' && ch <= 'f') return ch - 'a' + 10;
+  if (ch >= 'A' && ch <= 'F') return ch - 'A' + 10;
+  return -1;
+}
+
+static ScrDyn *sf_data_response(ScrStr *url) {
+  size_t end = url->len;
+  for (size_t i = 5; i < end; i++) if (url->data[i] == '#') { end = i; break; }
+  size_t comma = 5;
+  while (comma < end && url->data[comma] != ',') comma++;
+  if (comma == end) { sf_type_error("fetch failed"); return NULL; }
+  size_t meta_end = comma;
+  bool base64 = meta_end >= 12 && strncasecmp(url->data + meta_end - 7, ";base64", 7) == 0;
+  if (base64) meta_end -= 7;
+  ScrBytes *bytes = scr_bytes_new(SCR_BYTES_U8, (double)(end - comma - 1));
+  size_t n = 0;
+  for (size_t i = comma + 1; i < end; i++) {
+    int a, b;
+    if (url->data[i] == '%' && i + 2 < end && (a = sf_data_hex(url->data[i + 1])) >= 0 && (b = sf_data_hex(url->data[i + 2])) >= 0) {
+      bytes->data[n++] = (unsigned char)((a << 4) | b); i += 2;
+    } else bytes->data[n++] = (unsigned char)url->data[i];
+  }
+  bytes->len = n;
+  if (base64) {
+    ScrStr *encoded = scr_str_new((const char *)bytes->data, bytes->len);
+    ScrStr *encoding = scr_str_new("base64", 6);
+    ScrBytes *decoded = scr_bytes_from_str(encoded, encoding);
+    scr_str_release(encoded); scr_str_release(encoding); scr_bytes_release(bytes); bytes = decoded;
+  }
+  ScrDyn *body = scr_dyn_new_bytes(bytes); scr_bytes_release(bytes);
+  ScrStr *mime = meta_end == 5 ? scr_str_new("text/plain;charset=US-ASCII", 26) : scr_str_new(url->data + 5, meta_end - 5);
+  if (mime->len && mime->data[0] == ';') {
+    ScrJsonBuf b; scr_jb_init(&b); scr_jb_puts(&b, "text/plain"); for (size_t i = 0; i < mime->len; i++) scr_jb_putc(&b, mime->data[i]);
+    scr_str_release(mime); mime = scr_jb_finish(&b);
+  }
+  ScrDyn *headers = scr_dyn_new_obj(); scr_dyn_obj_set(headers, "content-type", 12, scr_dyn_new_str(mime)); scr_str_release(mime);
+  ScrDyn *init = scr_dyn_new_obj(); scr_dyn_obj_set(init, "headers", 7, headers);
+  ScrStr *ok = scr_str_new("OK", 2); scr_dyn_obj_set(init, "statusText", 10, scr_dyn_new_str(ok)); scr_str_release(ok);
+  ScrDyn *result = scr_fetch_response_new(body, init); scr_dyn_release(body); scr_dyn_release(init);
+  if (result) {
+    SfResponse *response = result->v.handle.ptr;
+    scr_str_release(response->url); response->url = scr_str_new(url->data, end);
+    response->headers->immutable = true;
+  }
+  return result;
+}
+
 ScrPromise *scr_fetch_static(ScrStr *url, ScrDyn *init) {
+  if (init && init->kind == SCR_DYN_TYPED_REF) {
+    ScrDyn *view = scr_dyn_typed_ref_materialize(init);
+    if (scr_exc_pending()) {
+      scr_dyn_release(view);
+      ScrPromise *promise = scr_promise_new();
+      scr_promise_reject_pending(promise);
+      return promise;
+    }
+    ScrPromise *result = scr_fetch_static(url, view);
+    scr_dyn_release(view);
+    return result;
+  }
   ScrPromise *promise = scr_promise_new();
   if (init && init->kind != SCR_DYN_OBJ &&
       init->kind != SCR_DYN_UNDEF && init->kind != SCR_DYN_NULL) {
@@ -5324,7 +5587,8 @@ ScrPromise *scr_fetch_static(ScrStr *url, ScrDyn *init) {
     return sf_reject_now(promise, "fetch failed");
   }
   bool https = sf_eq_ci(u->scheme, "https");
-  if (!https && !sf_eq_ci(u->scheme, "http")) {
+  bool data_url = sf_eq_ci(u->scheme, "data");
+  if (!https && !sf_eq_ci(u->scheme, "http") && !data_url) {
     scr_dyn_release(coerced_body);
     scr_arr_release(headers);
     scr_str_release(method);
@@ -5406,6 +5670,14 @@ ScrPromise *scr_fetch_static(ScrStr *url, ScrDyn *init) {
     return promise;
   }
 
+  if (data_url) {
+    ScrDyn *response = sf_data_response(url);
+    scr_dyn_release(coerced_body); scr_arr_release(headers); scr_str_release(method); scr_url_release(u);
+    if (response) { scr_promise_resolve_dyn(promise, response); }
+    else scr_promise_reject_pending(promise);
+    return promise;
+  }
+
   SfTransfer *t = calloc(1, sizeof *t);
   if (!t) sf_oom();
   t->rc = 1; /* registry */
@@ -5457,6 +5729,9 @@ static const ScrDynHandleOps sf_controller_ops = {
     "ReadableStreamDefaultController", &sf_stream_retain_v,
     &sf_stream_release_v, &sf_controller_invoke, &sf_controller_get,
     &sf_no_set, NULL};
+static const ScrDynHandleOps sf_request_ops = {
+    "Request", &sf_request_retain_v, &sf_request_release_v,
+    &sf_request_invoke, &sf_request_get, &sf_no_set, NULL};
 static const ScrDynHandleOps sf_response_ops = {
     "Response", &sf_response_retain_v, &sf_response_release_v,
     &sf_response_invoke, &sf_response_get, &sf_no_set, NULL};
@@ -5497,6 +5772,7 @@ void scr_fetch_install(void) {
   if (installed) return;
   installed = true;
   scr_tls_ca_install();
+  scr_global_fetch_install(scr_fetch_function);
   sf_proxy_snapshot();
   scr_net_install();
   scr_dyn_handle_install(SCR_DYNH_ABORT_SIGNAL, &sf_signal_ops);
@@ -5505,13 +5781,45 @@ void scr_fetch_install(void) {
   scr_dyn_handle_install(SCR_DYNH_WEB_STREAM, &sf_stream_ops);
   scr_dyn_handle_install(SCR_DYNH_WEB_READER, &sf_reader_ops);
   scr_dyn_handle_install(SCR_DYNH_WEB_CONTROLLER, &sf_controller_ops);
+  scr_dyn_handle_install(SCR_DYNH_FETCH_REQUEST, &sf_request_ops);
   scr_dyn_handle_install(SCR_DYNH_FETCH_RESPONSE, &sf_response_ops);
   scr_dyn_handle_install(SCR_DYNH_FETCH_HEADERS, &sf_headers_ops);
   scr_dyn_handle_install(SCR_DYNH_EVENT, &sf_event_ops);
   scr_atexit(sf_teardown);
 }
 
-#else
+#else /* SCR_FETCH_SIGNAL_ONLY */
+
+static bool sf_no_set(void *ptr, const char *key, size_t len, const ScrDyn *value) {
+  (void)ptr; (void)key; (void)len; (void)value;
+  return false;
+}
+static const ScrDynHandleOps sf_signal_ops = {
+  "AbortSignal", &sf_signal_retain_v, &sf_signal_release_v,
+  &sf_signal_invoke, &sf_signal_get, &sf_signal_set, NULL };
+static const ScrDynHandleOps sf_abort_controller_ops = {
+  "AbortController", &sf_signal_retain_v, &sf_signal_release_v,
+  &sf_abort_controller_invoke, &sf_abort_controller_get, &sf_no_set, NULL };
+static const ScrDynHandleOps sf_event_ops = {
+  "Event", &sf_event_retain_v, &sf_event_release_v,
+  &sf_event_invoke, &sf_event_get, &sf_event_set, NULL };
+static void sf_signal_teardown(void) {
+  while (sf_callback_signals) sf_signal_drop_callbacks(sf_callback_signals);
+  while (sf_reason_signals) sf_signal_drop_reason(sf_reason_signals);
+}
+static void sf_signal_install(void) {
+  static bool installed;
+  if (installed) return;
+  installed = true;
+  scr_dyn_handle_install(SCR_DYNH_ABORT_SIGNAL, &sf_signal_ops);
+  scr_dyn_handle_install(SCR_DYNH_ABORT_CONTROLLER, &sf_abort_controller_ops);
+  scr_dyn_handle_install(SCR_DYNH_EVENT, &sf_event_ops);
+  scr_atexit(sf_signal_teardown);
+}
+
+#endif /* SCR_FETCH_SIGNAL_ONLY */
+
+#else /* SCR_DYNAMIC */
 
 #include "scr_runtime.h"
 #include "scr_url_internal.h"

package/dist/lib/runtime-sources/src/scr_file_handle.c

@@ -476,6 +476,37 @@ ScrPromise *scr_file_handle_close_promise(ScrFileHandle *h) {
   return scr_promise_settled_void();
 }
 
+ScrPromise *scr_file_handle_sync_promise(ScrFileHandle *h) {
+  if (scr_file_handle_require_open(h)) scr_fs_fsync((double)h->fd);
+  return scr_promise_settled_void();
+}
+
+ScrPromise *scr_file_handle_datasync_promise(ScrFileHandle *h) {
+  if (scr_file_handle_require_open(h)) scr_fs_fdatasync((double)h->fd);
+  return scr_promise_settled_void();
+}
+
+ScrPromise *scr_file_handle_truncate_promise(ScrFileHandle *h, double length) {
+  if (scr_file_handle_require_open(h)) scr_fs_ftruncate((double)h->fd, length);
+  return scr_promise_settled_void();
+}
+
+ScrPromise *scr_file_handle_chmod_promise(ScrFileHandle *h, double mode) {
+  if (scr_file_handle_require_open(h) && scr_file_handle_mode_valid(mode))
+    scr_fs_fchmod((double)h->fd, mode);
+  return scr_promise_settled_void();
+}
+
+double scr_file_handle_readv(ScrFileHandle *h, ScrArr *buffers, double position) {
+  if (!scr_file_handle_require_open(h)) return 0;
+  return scr_fs_readv_sync((double)h->fd, buffers, position);
+}
+
+double scr_file_handle_writev(ScrFileHandle *h, ScrArr *buffers, double position) {
+  if (!scr_file_handle_require_open(h)) return 0;
+  return scr_fs_writev_sync((double)h->fd, buffers, position);
+}
+
 ScrPromise *scr_file_handle_read_file_promise(ScrFileHandle *h,
                                               ScrStr *encoding) {
   (void)encoding;

package/dist/lib/runtime-sources/src/scr_http.c

@@ -5567,6 +5567,8 @@ static ScrDyn *scr_http_dynh_agent_invoke(void *h, ScrDyn *self, const char *met
   }
   if (strcmp(method, "getName") == 0) {
     const ScrDyn *opts = argc > 0 ? args[0] : scr_dyn_undefined();
+    ScrDyn *view = opts->kind == SCR_DYN_TYPED_REF ? scr_dyn_typed_ref_materialize(opts) : NULL;
+    if (view != NULL) opts = view;
     ScrStr *host = scr_http_dynh_opt_str(opts, "host");
     ScrStr *port = scr_http_dynh_opt_str(opts, "port");
     ScrStr *laddr = scr_http_dynh_opt_str(opts, "localAddress");
@@ -5587,6 +5589,7 @@ static ScrDyn *scr_http_dynh_agent_invoke(void *h, ScrDyn *self, const char *met
     scr_str_release(port);
     scr_str_release(laddr);
     scr_str_release(spath);
+    scr_dyn_release(view);
     ScrDyn *d = scr_dyn_new_str(name);
     scr_str_release(name);
     return d;