@scriptc/runtime 0.0.21 → 0.0.23

package/src/scr_fetch_curl.c

@@ -360,14 +360,17 @@ static JSValue fx_host_start(JSContext *ctx, JSValueConst this_val, int argc,
   curl_easy_setopt(e, CURLOPT_ACCEPT_ENCODING, ""); /* gzip in, transparent out */
   curl_easy_setopt(e, CURLOPT_PROTOCOLS_STR, "http,https");
   curl_easy_setopt(e, CURLOPT_SUPPRESS_CONNECT_HEADERS, 1L);
-  /* Node parity: undici's global fetch IGNORES http_proxy/https_proxy/
-   * all_proxy environment variables unless NODE_USE_ENV_PROXY=1 opts in
-   * (Node 24's EnvHttpProxyAgent). libcurl's default is the opposite —
-   * honor them — so an empty CURLOPT_PROXY switches the env lookup off;
-   * with the opt-in set, libcurl's own env handling stands in for
-   * undici's agent (same variables, same no_proxy exclusions). */
-  const char *env_proxy = getenv("NODE_USE_ENV_PROXY");
-  if (env_proxy == NULL || strcmp(env_proxy, "1") != 0) {
+  /* Node's global opt-in and Vercel's request-local EnvProxyDispatcher both
+   * activate libcurl's environment proxy lookup. Otherwise explicitly turn
+   * it off, because libcurl enables proxy variables by default. */
+  JSValue envproxyv = JS_GetPropertyStr(ctx, req, "useEnvProxy");
+  bool use_env_proxy = JS_ToBool(ctx, envproxyv) > 0;
+  JS_FreeValue(ctx, envproxyv);
+  const char *global_env_proxy = getenv("NODE_USE_ENV_PROXY");
+  use_env_proxy = use_env_proxy ||
+                  (global_env_proxy != NULL &&
+                   strcmp(global_env_proxy, "1") == 0);
+  if (!use_env_proxy) {
     curl_easy_setopt(e, CURLOPT_PROXY, "");
   }
 
@@ -486,6 +489,15 @@ static const char fx_glue[] =
     "        url = String(input);\n"
     "      }\n"
     "      init = init === undefined || init === null ? {} : init;\n"
+    "      let useEnvProxy = g.process?.env?.NODE_USE_ENV_PROXY === '1';\n"
+    "      const initDispatcher = init.dispatcher;\n"
+    "      if (initDispatcher !== undefined) {\n"
+    "        const dispatcher = initDispatcher;\n"
+    "        const methods = ['dispatch', 'close', 'destroy', 'agents', 'getAgent', 'shouldProxy', 'parseNoProxy'];\n"
+    "        const known = dispatcher !== null && typeof dispatcher === 'object' && dispatcher.constructor?.name === 'EnvProxyDispatcher' && methods.every((member) => typeof dispatcher[member] === 'function');\n"
+    "        if (!known) throw new TypeError('unsupported RequestInit option: dispatcher');\n"
+    "        useEnvProxy = true;\n"
+    "      }\n"
     "      // An explicit init.signal overrides the Request's, null included.\n"
     "      if (init.signal !== undefined) {\n"
     "        if (init.signal !== null && !(init.signal instanceof g.AbortSignal)) {\n"
@@ -546,7 +558,7 @@ static const char fx_glue[] =
     "      const flat = [];\n"
     "      for (const pair of headers) { flat.push(pair[0], pair[1]); }\n"
     "      id = host.start(\n"
-    "        { url, method, headers: flat, body: body === null ? undefined : body },\n"
+    "        { url, method, headers: flat, body: body === null ? undefined : body, useEnvProxy },\n"
     "        {\n"
     "          onResponse(status, statusText, raw, finalUrl, redirected) {\n"
     "            resolved = true;\n"

package/src/scr_http.c

@@ -2608,6 +2608,19 @@ static bool scr_http_client_parse_head(ScrHttpConn *conn, size_t head_len) {
     return false;
   }
 
+  /*
+   * Informational responses do not settle the request. Node emits an
+   * `information` event for these and keeps parsing until the final
+   * response; this runtime has no information listener surface yet, so
+   * consume the head and continue. 101 is the upgrade case below.
+   */
+  if (status >= 100 && status < 200 && status != 101) {
+    memmove(conn->buf, conn->buf + head_len, conn->len - head_len);
+    conn->len -= head_len;
+    scr_http_req_release(res);
+    return true;
+  }
+
   /* framing: HEAD requests and 204/304 responses have NO body; chunked
    * wins over Content-Length; neither means EOF-delimited */
   bool chunked = false;

package/src/scr_inspect.c

@@ -849,6 +849,12 @@ ScrStr *scr_insp_dyn(ScrDyn *d, double recurse, double depth) {
       scr_throw_error(SCR_ERR_ERROR, ib_take(&out));
       return scr_str_new("", 0);
     }
+    case SCR_DYN_TYPED_REF: {
+      ScrDyn *materialized = scr_dyn_typed_ref_materialize(d);
+      ScrStr *out = scr_insp_dyn(materialized, recurse, depth);
+      scr_dyn_release(materialized);
+      return out;
+    }
     case SCR_DYN_PROMISE: {
       /* Node renders Promise { <pending> } / Promise { value } — the
        * settled-value rendering pulls in the whole inspector; fence

package/src/scr_island.c

@@ -1635,6 +1635,25 @@ ScrJsval *scr_jsval_call(ScrJsval *f, int argc, ScrJsval **argv) {
   return isl_cell_new(r);
 }
 
+/* Call an already-resolved computed member with its original receiver. The
+ * frontend performs GetValue before argument evaluation, then arrives here
+ * after the arguments are ready; keeping callee and receiver separate avoids
+ * a second getter read while preserving method `this`. */
+ScrJsval *scr_jsval_call_this(ScrJsval *f, ScrJsval *receiver, int argc,
+                              ScrJsval **argv) {
+  isl_entry();
+  JSValue stack_args[8];
+  JSValue *args = argc <= 8 ? stack_args : malloc((size_t)argc * sizeof(JSValue));
+  for (int i = 0; i < argc; i++) args[i] = argv[i]->v;
+  JSValue r = JS_Call(isl_ctx, f->v, receiver->v, argc, args);
+  if (args != stack_args) free(args);
+  if (JS_IsException(r)) {
+    isl_bridge_exception();
+    return NULL;
+  }
+  return isl_cell_new(r);
+}
+
 /* Spread application on an island callee (jsOp callSpread) — the prelude
  * helper's real `f(...pre, ...spread)`, so iterator protocols are the
  * engine's own and the guards front-run V8's exact spread-call TypeError