Update QuickJS: faster context creation and faster dbuf

Update couchjs.c to use the new intrinsics return value and check their
initialization.

* Faster context creation and exception checks in JS_NewContext
bellard/quickjs@42eb279

* Faster and safer dbuf functions
bellard/quickjs@0d4cd2d

* Fixed argument evaluation order in Date constructor and Date.UTC()
bellard/quickjs@7fb994c

* Stricter year parsing in Date
bellard/quickjs@2161640

Author: nickva

src/couch_quickjs/c_src/couchjs.c

@@ -86,14 +86,20 @@ static CmdType parse_command(char* str, size_t len) {
   return CMD_VIEW;
 }
 
-static void add_cx_methods(JSContext* cx) {
+// Return true if initializations succeed and false if any fails. Failure
+// will shortcut the sequence and will return early. The only thing to do
+// then is to free the context and return early
+//
+static bool add_cx_methods(JSContext* cx) {
   //TODO: configure some features with env vars of command line switches
-  JS_AddIntrinsicBaseObjects(cx);
-  JS_AddIntrinsicEval(cx);
-  JS_AddIntrinsicJSON(cx);
-  JS_AddIntrinsicRegExp(cx);
-  JS_AddIntrinsicMapSet(cx);
-  JS_AddIntrinsicDate(cx);
+  return ! (
+      JS_AddIntrinsicBaseObjects(cx) ||
+      JS_AddIntrinsicEval(cx) ||
+      JS_AddIntrinsicJSON(cx) ||
+      JS_AddIntrinsicRegExp(cx) ||
+      JS_AddIntrinsicMapSet(cx) ||
+      JS_AddIntrinsicDate(cx)
+  );
 }
 
 // Creates a new JSContext with only the provided sandbox function
@@ -104,7 +110,12 @@ static JSContext* make_sandbox(JSContext* cx, JSValue sbox) {
    if(!cx1) {
      return NULL;
    }
-   add_cx_methods(cx1);
+
+   if(!add_cx_methods(cx1)) {
+       JS_FreeContext(cx1);
+       return NULL;
+   }
+
    JSValue global = JS_GetGlobalObject(cx1);
 
    int i;

src/couch_quickjs/patches/01-spidermonkey-185-mode.patch

@@ -1,6 +1,6 @@
---- quickjs-master/quickjs.c	2025-10-08 08:16:51
-+++ quickjs/quickjs.c	2025-10-08 17:43:48
-@@ -30951,10 +30951,24 @@
+--- quickjs-master/quickjs.c	2025-10-13 08:51:37
++++ quickjs/quickjs.c	2025-10-15 21:57:44
+@@ -30997,10 +30997,24 @@
      if (s->token.val == TOK_FUNCTION ||
          (token_is_pseudo_keyword(s, JS_ATOM_async) &&
           peek_token(s, TRUE) == TOK_FUNCTION)) {

src/couch_quickjs/patches/02-test262-errors.patch

@@ -1,11 +1,11 @@
---- quickjs-master/test262_errors.txt	2025-10-08 08:16:51
-+++ quickjs/test262_errors.txt	2025-10-08 17:43:48
-@@ -6,6 +6,8 @@
- test262/test/annexB/language/expressions/assignmenttargettype/callexpression.js:33: SyntaxError: invalid assignment left-hand side
+--- quickjs-master/test262_errors.txt	2025-10-13 08:51:37
++++ quickjs/test262_errors.txt	2025-10-15 22:00:27
+@@ -7,6 +7,8 @@
  test262/test/annexB/language/expressions/assignmenttargettype/cover-callexpression-and-asyncarrowhead.js:20: SyntaxError: invalid assignment left-hand side
  test262/test/language/identifier-resolution/assign-to-global-undefined.js:20: strict mode: expected error
+ test262/test/language/module-code/top-level-await/rejection-order.js:20: TypeError: $DONE() not called
 +test262/test/language/statements/expression/S12.4_A1.js:15: unexpected error type: Test262: This statement should not be evaluated.
 +test262/test/language/statements/expression/S12.4_A1.js:15: strict mode: unexpected error type: Test262: This statement should not be evaluated.
- test262/test/staging/sm/Date/UTC-convert-all-arguments.js:13: Test262Error: index 1: expected 42, got Error: didn't throw Expected SameValue(«Error: didn't throw», «42») to be true
- test262/test/staging/sm/Date/UTC-convert-all-arguments.js:13: strict mode: Test262Error: index 1: expected 42, got Error: didn't throw Expected SameValue(«Error: didn't throw», «42») to be true
- test262/test/staging/sm/Date/constructor-convert-all-arguments.js:13: Test262Error: index undefined: expected 42, got Error: didn't throw Expected SameValue(«Error: didn't throw», «42») to be true
+ test262/test/staging/sm/Function/arguments-parameter-shadowing.js:14: Test262Error: Expected SameValue(«true», «false») to be true
+ test262/test/staging/sm/Function/constructor-binding.js:11: Test262Error: Expected SameValue(«"function"», «"undefined"») to be true
+ test262/test/staging/sm/Function/constructor-binding.js:11: strict mode: Test262Error: Expected SameValue(«"function"», «"undefined"») to be true

src/couch_quickjs/quickjs/Makefile

@@ -55,7 +55,7 @@ PREFIX?=/usr/local
 #CONFIG_UBSAN=y
 
 # TEST262 bootstrap config: commit id and shallow "since" parameter
-TEST262_COMMIT?=06dfddc4ebd21c39e1ce44f3e13b56b0dfda28e3
+TEST262_COMMIT?=42303c7c2bcf1c1edb9e5375c291c6fbc8a261ab
 TEST262_SINCE?=2025-09-01
 
 OBJDIR=.obj

src/couch_quickjs/quickjs/cutils.c

@@ -100,15 +100,20 @@ void dbuf_init(DynBuf *s)
     dbuf_init2(s, NULL, NULL);
 }
 
-/* return < 0 if error */
-int dbuf_realloc(DynBuf *s, size_t new_size)
+/* Try to allocate 'len' more bytes. return < 0 if error */
+int dbuf_claim(DynBuf *s, size_t len)
 {
-    size_t size;
+    size_t new_size, size;
     uint8_t *new_buf;
+    new_size = s->size + len;
+    if (new_size < len)
+        return -1; /* overflow case */
     if (new_size > s->allocated_size) {
         if (s->error)
             return -1;
-        size = s->allocated_size * 3 / 2;
+        size = s->allocated_size + (s->allocated_size / 2);
+        if (size < s->allocated_size)
+            return -1; /* overflow case */
         if (size > new_size)
             new_size = size;
         new_buf = s->realloc_func(s->opaque, s->buf, new_size);
@@ -122,22 +127,10 @@ int dbuf_realloc(DynBuf *s, size_t new_size)
     return 0;
 }
 
-int dbuf_write(DynBuf *s, size_t offset, const uint8_t *data, size_t len)
-{
-    size_t end;
-    end = offset + len;
-    if (dbuf_realloc(s, end))
-        return -1;
-    memcpy(s->buf + offset, data, len);
-    if (end > s->size)
-        s->size = end;
-    return 0;
-}
-
 int dbuf_put(DynBuf *s, const uint8_t *data, size_t len)
 {
-    if (unlikely((s->size + len) > s->allocated_size)) {
-        if (dbuf_realloc(s, s->size + len))
+    if (unlikely((s->allocated_size - s->size) < len)) {
+        if (dbuf_claim(s, len))
             return -1;
     }
     memcpy_no_ub(s->buf + s->size, data, len);
@@ -147,20 +140,35 @@ int dbuf_put(DynBuf *s, const uint8_t *data, size_t len)
 
 int dbuf_put_self(DynBuf *s, size_t offset, size_t len)
 {
-    if (unlikely((s->size + len) > s->allocated_size)) {
-        if (dbuf_realloc(s, s->size + len))
+    if (unlikely((s->allocated_size - s->size) < len)) {
+        if (dbuf_claim(s, len))
             return -1;
     }
     memcpy(s->buf + s->size, s->buf + offset, len);
     s->size += len;
     return 0;
 }
 
-int dbuf_putc(DynBuf *s, uint8_t c)
+int __dbuf_putc(DynBuf *s, uint8_t c)
 {
     return dbuf_put(s, &c, 1);
 }
 
+int __dbuf_put_u16(DynBuf *s, uint16_t val)
+{
+    return dbuf_put(s, (uint8_t *)&val, 2);
+}
+
+int __dbuf_put_u32(DynBuf *s, uint32_t val)
+{
+    return dbuf_put(s, (uint8_t *)&val, 4);
+}
+
+int __dbuf_put_u64(DynBuf *s, uint64_t val)
+{
+    return dbuf_put(s, (uint8_t *)&val, 8);
+}
+
 int dbuf_putstr(DynBuf *s, const char *str)
 {
     return dbuf_put(s, (const uint8_t *)str, strlen(str));
@@ -182,7 +190,7 @@ int __attribute__((format(printf, 2, 3))) dbuf_printf(DynBuf *s,
         /* fast case */
         return dbuf_put(s, (uint8_t *)buf, len);
     } else {
-        if (dbuf_realloc(s, s->size + len + 1))
+        if (dbuf_claim(s, len + 1))
             return -1;
         va_start(ap, fmt);
         vsnprintf((char *)(s->buf + s->size), s->allocated_size - s->size,

src/couch_quickjs/quickjs/cutils.h

@@ -264,24 +264,58 @@ typedef struct DynBuf {
 
 void dbuf_init(DynBuf *s);
 void dbuf_init2(DynBuf *s, void *opaque, DynBufReallocFunc *realloc_func);
-int dbuf_realloc(DynBuf *s, size_t new_size);
-int dbuf_write(DynBuf *s, size_t offset, const uint8_t *data, size_t len);
+int dbuf_claim(DynBuf *s, size_t len);
 int dbuf_put(DynBuf *s, const uint8_t *data, size_t len);
 int dbuf_put_self(DynBuf *s, size_t offset, size_t len);
-int dbuf_putc(DynBuf *s, uint8_t c);
 int dbuf_putstr(DynBuf *s, const char *str);
+int __dbuf_putc(DynBuf *s, uint8_t c);
+int __dbuf_put_u16(DynBuf *s, uint16_t val);
+int __dbuf_put_u32(DynBuf *s, uint32_t val);
+int __dbuf_put_u64(DynBuf *s, uint64_t val);
+
+static inline int dbuf_putc(DynBuf *s, uint8_t val)
+{
+    if (unlikely((s->allocated_size - s->size) < 1)) {
+        return __dbuf_putc(s, val);
+    } else {
+        s->buf[s->size++] = val;
+        return 0;
+    }
+}
+
 static inline int dbuf_put_u16(DynBuf *s, uint16_t val)
 {
-    return dbuf_put(s, (uint8_t *)&val, 2);
+    if (unlikely((s->allocated_size - s->size) < 2)) {
+        return __dbuf_put_u16(s, val);
+    } else {
+        put_u16(s->buf + s->size, val);
+        s->size += 2;
+        return 0;
+    }
 }
+
 static inline int dbuf_put_u32(DynBuf *s, uint32_t val)
 {
-    return dbuf_put(s, (uint8_t *)&val, 4);
+    if (unlikely((s->allocated_size - s->size) < 4)) {
+        return __dbuf_put_u32(s, val);
+    } else {
+        put_u32(s->buf + s->size, val);
+        s->size += 4;
+        return 0;
+    }
 }
+
 static inline int dbuf_put_u64(DynBuf *s, uint64_t val)
 {
-    return dbuf_put(s, (uint8_t *)&val, 8);
+    if (unlikely((s->allocated_size - s->size) < 8)) {
+        return __dbuf_put_u64(s, val);
+    } else {
+        put_u64(s->buf + s->size, val);
+        s->size += 8;
+        return 0;
+    }
 }
+
 int __attribute__((format(printf, 2, 3))) dbuf_printf(DynBuf *s,
                                                       const char *fmt, ...);
 void dbuf_free(DynBuf *s);

src/couch_quickjs/quickjs/libregexp.c

@@ -117,7 +117,7 @@ static inline int is_digit(int c) {
 /* insert 'len' bytes at position 'pos'. Return < 0 if error. */
 static int dbuf_insert(DynBuf *s, int pos, int len)
 {
-    if (dbuf_realloc(s, s->size + len))
+    if (dbuf_claim(s, len))
         return -1;
     memmove(s->buf + pos + len, s->buf + pos, s->size - pos);
     s->size += len;
@@ -2340,7 +2340,7 @@ static int re_parse_alternative(REParseState *s, BOOL is_backward_dir)
                speed is not really critical here) */
             end = s->byte_code.size;
             term_size = end - term_start;
-            if (dbuf_realloc(&s->byte_code, end + term_size))
+            if (dbuf_claim(&s->byte_code, term_size))
                 return -1;
             memmove(s->byte_code.buf + start + term_size,
                     s->byte_code.buf + start,

src/couch_quickjs/quickjs/libunicode.c

@@ -1179,7 +1179,7 @@ int unicode_normalize(uint32_t **pdst, const uint32_t *src, int src_len,
     is_compat = n_type >> 1;
 
     dbuf_init2(dbuf, opaque, realloc_func);
-    if (dbuf_realloc(dbuf, sizeof(int) * src_len))
+    if (dbuf_claim(dbuf, sizeof(int) * src_len))
         goto fail;
 
     /* common case: latin1 is unaffected by NFC */

src/couch_quickjs/quickjs/quickjs-atom.h

@@ -256,6 +256,7 @@ DEF(SyntaxError, "SyntaxError")
 DEF(TypeError, "TypeError")
 DEF(URIError, "URIError")
 DEF(InternalError, "InternalError")
+DEF(AggregateError, "AggregateError")
 /* private symbols */
 DEF(Private_brand, "<brand>")
 /* symbols */