Merge branch 'main' into vaish/restart-from-step

Author: vaishnav-mk

build/deps/gen/deps.MODULE.bazel

@@ -27,10 +27,10 @@ bazel_dep(name = "brotli", version = "1.2.0.bcr.1")
 # capnp-cpp
 http.archive(
     name = "capnp-cpp",
-    sha256 = "448986f71b544270896a5d4feb306827072a7c1a05156358c33e8218fe79c59b",
-    strip_prefix = "capnproto-capnproto-d0e9605/c++",
+    sha256 = "3b0cb96441f2d72dab755e87b2ab8969fdfa096d62b5eb6f4bedd271d391967a",
+    strip_prefix = "capnproto-capnproto-59a195f/c++",
     type = "tgz",
-    url = "https://github.com/capnproto/capnproto/tarball/d0e9605b288ac4d8b86ee3201a23c43c017a6b61",
+    url = "https://github.com/capnproto/capnproto/tarball/59a195f011f259484acc71255bab8e1b67ef54d3",
 )
 use_repo(http, "capnp-cpp")
 
@@ -136,10 +136,10 @@ bazel_dep(name = "tcmalloc", version = "0.0.0-20250927-12f2552")
 # workerd-cxx
 http.archive(
     name = "workerd-cxx",
-    sha256 = "81e21ec4318e31bf33101bbda567b891c7643b604675121726f1ecdcb76b9e20",
-    strip_prefix = "cloudflare-workerd-cxx-8467078",
+    sha256 = "ee0867e96d70a37e2bb596f60051665ba828ad5f9237fe752811bb18f4f9fe07",
+    strip_prefix = "cloudflare-workerd-cxx-acbc654",
     type = "tgz",
-    url = "https://github.com/cloudflare/workerd-cxx/tarball/8467078a6607ff93fe0b26cc92aa17ffa57bf83a",
+    url = "https://github.com/cloudflare/workerd-cxx/tarball/acbc6548b09d50f20ac8fdcf252e802b8cbfc054",
 )
 use_repo(http, "workerd-cxx")
 

src/workerd/api/basics.c++

@@ -625,8 +625,8 @@ class AbortTriggerRpcServer final: public rpc::AbortTrigger::Server {
 AbortSignal::AbortSignal(kj::Maybe<kj::Exception> exception,
     jsg::Optional<jsg::JsRef<jsg::JsValue>> maybeReason,
     Flag flag)
-    : canceler(
-          IoContext::current().addObject(kj::refcounted<RefcountedCanceler>(kj::cp(exception)))),
+    : canceler(IoContext::current().addObject(kj::refcounted<RefcountedCanceler>(
+          exception.map([](const kj::Exception& e) { return e.clone(); })))),
       flag(flag),
       reason(kj::mv(maybeReason)) {}
 
@@ -675,14 +675,14 @@ jsg::JsValue AbortSignal::getReason(jsg::Lock& js) {
 }
 
 kj::Exception AbortSignal::abortException(
-    jsg::Lock& js, jsg::Optional<kj::OneOf<kj::Exception, jsg::JsValue>> maybeReason) {
+    jsg::Lock& js, const jsg::Optional<kj::OneOf<kj::Exception, jsg::JsValue>>& maybeReason) {
   KJ_IF_SOME(reason, maybeReason) {
     KJ_SWITCH_ONEOF(reason) {
       KJ_CASE_ONEOF(reason, jsg::JsValue) {
         return js.exceptionToKj(reason);
       }
       KJ_CASE_ONEOF(reason, kj::Exception) {
-        return kj::cp(reason);
+        return reason.clone();
       }
     }
   }
@@ -695,7 +695,7 @@ jsg::Ref<AbortSignal> AbortSignal::abort(jsg::Lock& js, jsg::Optional<jsg::JsVal
   KJ_IF_SOME(reason, maybeReason) {
     return js.alloc<AbortSignal>(kj::mv(exception), reason.addRef(js));
   }
-  return js.alloc<AbortSignal>(kj::cp(exception), js.exceptionToJsValue(kj::mv(exception)));
+  return js.alloc<AbortSignal>(exception.clone(), js.exceptionToJsValue(kj::mv(exception)));
 }
 
 void AbortSignal::throwIfAborted(jsg::Lock& js) {
@@ -808,7 +808,7 @@ void AbortSignal::triggerAbort(
       }
     }
   } else {
-    reason = js.exceptionToJsValue(kj::cp(exception));
+    reason = js.exceptionToJsValue(exception.clone());
   }
 
   canceler->cancel(kj::mv(exception));
@@ -981,7 +981,7 @@ kj::Maybe<jsg::JsValue> AbortSignal::deserializePendingReason(jsg::Lock& js) {
       }
 
       KJ_CASE_ONEOF(exception, kj::Exception) {
-        return kj::some(js.exceptionToJsValue(kj::cp(exception)).getHandle(js));
+        return kj::some(js.exceptionToJsValue(exception.clone()).getHandle(js));
       }
     }
   }

src/workerd/api/basics.h

@@ -693,7 +693,7 @@ class AbortSignal final: public EventTarget {
   kj::Maybe<jsg::JsRef<jsg::JsValue>> onAbortHandler;
 
   static kj::Exception abortException(
-      jsg::Lock& js, jsg::Optional<kj::OneOf<kj::Exception, jsg::JsValue>> reason);
+      jsg::Lock& js, const jsg::Optional<kj::OneOf<kj::Exception, jsg::JsValue>>& reason);
 
   void visitForGc(jsg::GcVisitor& visitor);
 

src/workerd/api/html-rewriter.c++

@@ -505,7 +505,7 @@ kj::Promise<void> Rewriter::end() {
 
 void Rewriter::abort(kj::Exception reason) {
   // End the rewriter and forward the error to the wrapped output stream.
-  maybeException = kj::cp(reason);
+  maybeException = reason.clone();
 
   inner->abort(kj::mv(reason));
 }
@@ -530,8 +530,8 @@ kj::Promise<void> Rewriter::flushWrite() {
   }
 
   KJ_IF_SOME(exception, maybeException) {
-    inner->abort(kj::cp(exception));
-    kj::throwFatalException(kj::cp(exception));
+    inner->abort(exception.clone());
+    kj::throwFatalException(exception.clone());
   }
 }
 template <typename T, typename CType>

src/workerd/api/hyperdrive.c++

@@ -37,7 +37,7 @@ jsg::Ref<Socket> Hyperdrive::connect(jsg::Lock& js) {
     return kj::mv(stream);
   }, [&f = *paf.fulfiller](kj::Exception e) {
     KJ_LOG(WARNING, "failed to connect to local database", e);
-    f.fulfill(kj::cp(e));
+    f.fulfill(e.clone());
     return kj::mv(e);
   }).attach(kj::mv(paf.fulfiller)));
 

src/workerd/api/queue.c++

@@ -774,7 +774,7 @@ StartQueueEventResponse startQueueEvent(EventTarget& globalEventTarget,
           t.setReturn(context.now());
         }
       }, [event = event.addRef()](kj::Exception&& e) mutable {
-        event->setCompletionStatus(QueueEvent::CompletedWithError{kj::cp(e)});
+        event->setCompletionStatus(QueueEvent::CompletedWithError{e.clone()});
         return kj::mv(e);
       });
       if (FeatureFlags::get(js).getQueueConsumerNoWaitForWaitUntil()) {

src/workerd/api/queue.h

@@ -354,10 +354,10 @@ class QueueEvent final: public ExtendableEvent {
   using CompletionStatus = kj::OneOf<Incomplete, CompletedSuccessfully, CompletedWithError>;
 
   void setCompletionStatus(CompletionStatus status) {
-    completionStatus = status;
+    completionStatus = kj::mv(status);
   }
 
-  CompletionStatus getCompletionStatus() const {
+  const CompletionStatus& getCompletionStatus() const {
     return completionStatus;
   }
 

src/workerd/api/sockets.c++

@@ -502,8 +502,8 @@ void Socket::handleProxyStatus(jsg::Lock& js, kj::Promise<kj::Maybe<kj::Exceptio
 }
 
 void Socket::handleProxyError(jsg::Lock& js, kj::Exception e) {
-  resolveFulfiller(js, kj::cp(e));
-  openedResolver.reject(js, kj::cp(e));
+  resolveFulfiller(js, e.clone());
+  openedResolver.reject(js, e.clone());
   readable->getController().cancel(js, kj::none).markAsHandled(js);
   writable->getController().abort(js, js.error(e.getDescription())).markAsHandled(js);
 }

src/workerd/api/sockets.h

@@ -226,7 +226,7 @@ class Socket: public jsg::Object {
 
   void resolveFulfiller(jsg::Lock& js, kj::Maybe<kj::Exception> maybeErr) {
     KJ_IF_SOME(err, maybeErr) {
-      closedResolver.reject(js, kj::cp(err));
+      closedResolver.reject(js, err.clone());
     } else {
       closedResolver.resolve(js);
     }

src/workerd/api/streams/compression.c++

@@ -320,11 +320,11 @@ class CompressionStreamBase: public kj::Refcounted,
       auto pending = kj::mv(pendingReads.front());
       pendingReads.pop_front();
       if (pending.promise->isWaiting()) {
-        pending.promise->reject(kj::cp(reason));
+        pending.promise->reject(reason.clone());
       }
     }
 
-    canceler.cancel(kj::cp(reason));
+    canceler.cancel(reason.clone());
     transitionToErrored(kj::mv(reason));
   }
 
@@ -374,7 +374,7 @@ class CompressionStreamBase: public kj::Refcounted,
       KJ_IF_SOME(exception, kj::runCatchingExceptions([this, flush, &result]() {
         result = context.pumpOnce(flush);
       })) {
-        cancelInternal(kj::cp(exception));
+        cancelInternal(exception.clone());
         kj::throwFatalException(kj::mv(exception));
       }
 
@@ -412,12 +412,12 @@ class CompressionStreamBase: public kj::Refcounted,
         // so we need to report an error here and error the stream.
         if (pending.filled > 0) {
           auto ex = JSG_KJ_EXCEPTION(FAILED, Error, "A partially fulfilled read was canceled.");
-          cancelInternal(kj::cp(ex));
+          cancelInternal(ex.clone());
           kj::throwFatalException(kj::mv(ex));
         }
 
         auto ex = JSG_KJ_EXCEPTION(FAILED, Error, "The pending read was canceled.");
-        cancelInternal(kj::cp(ex));
+        cancelInternal(ex.clone());
         kj::throwFatalException(kj::mv(ex));
       }
 
@@ -478,7 +478,7 @@ class CompressionStreamImpl final: public CompressionStreamBase<mode> {
  protected:
   void requireActive(kj::StringPtr errorMessage) override {
     KJ_IF_SOME(exception, state.tryGetErrorUnsafe()) {
-      kj::throwFatalException(kj::cp(exception));
+      kj::throwFatalException(exception.clone());
     }
     // isActive() returns true only if in Open state (the ActiveState)
     JSG_REQUIRE(state.isActive(), Error, errorMessage);
@@ -500,7 +500,7 @@ class CompressionStreamImpl final: public CompressionStreamBase<mode> {
 
   void throwIfException() override {
     KJ_IF_SOME(exception, state.tryGetErrorUnsafe()) {
-      kj::throwFatalException(kj::cp(exception));
+      kj::throwFatalException(exception.clone());
     }
   }