fix: Pass ctx.props to default handlers

Author: tewaro

src/workerd/api/global-scope.h

@@ -382,6 +382,32 @@ struct ExportedHandler {
   jsg::Optional<jsg::Ref<ExecutionContext>> getCtx() {
     return ctx.map([&](jsg::Ref<ExecutionContext>& p) { return p.addRef(); });
   }
+
+ private:
+  template <typename T>
+  static jsg::LenientOptional<T> mapAddRef(jsg::Lock& js, jsg::LenientOptional<T>& function) {
+    return function.map([&](T& a) { return a.addRef(js); });
+  }
+
+ public:
+  ExportedHandler clone(jsg::Lock& js) {
+    return ExportedHandler{
+      .fetch{mapAddRef(js, fetch)},
+      .tail{mapAddRef(js, tail)},
+      .trace{mapAddRef(js, trace)},
+      .tailStream{mapAddRef(js, tailStream)},
+      .scheduled{mapAddRef(js, scheduled)},
+      .alarm{mapAddRef(js, alarm)},
+      .test{mapAddRef(js, test)},
+      .webSocketMessage{mapAddRef(js, webSocketMessage)},
+      .webSocketClose{mapAddRef(js, webSocketClose)},
+      .webSocketError{mapAddRef(js, webSocketError)},
+      .self{js.v8Isolate, v8::Object::New(js.v8Isolate)},
+      .env{env.addRef(js)},
+      .ctx{getCtx()},
+      .missingSuperclass = missingSuperclass,
+    };
+  }
 };
 
 // An approximation of Node.js setImmediate `Immediate` object.

src/workerd/io/compatibility-date.capnp

@@ -692,4 +692,10 @@ struct CompatibilityFlags @0x8f8c1b68151b6cef {
       $experimental
       $neededByFl;
   # Enables cache settings specified request in fetch api cf object to override cache rules. (only for user owned or grey-clouded sites)
+
+  uniqueCtxPerInvocation @73: Bool
+      $compatEnableFlag("unique_ctx_per_invocation")
+      $compatDisableFlag("nonclass_entrypoint_reuses_ctx_accros_invocations")
+      $compatEnableDate("2025-02-24");
+  # Creates a unique ExportedHandler for each call to `export default` allows a unique ctx per invocation
 }

src/workerd/io/worker.c++

@@ -1665,11 +1665,9 @@ Worker::Worker(kj::Own<const Script> scriptParam,
                     KJ_SWITCH_ONEOF(handler.value) {
                       KJ_CASE_ONEOF(obj, api::ExportedHandler) {
                         obj.env = lock.v8Ref(bindingsScope.As<v8::Value>());
-                        // TODO(cleanup): Unfortunately, for non-class-based handlers, we have
-                        //   always created only a single `ctx` object and reused it for all
-                        //   requests. This is weird and obviously wrong but changing it probably
-                        //   requires a compat flag. Until then, connection properties will not be
-                        //   available for non-class handlers.
+                        // Historically, non-class-based handlers reused the same ctx object for all requests.
+                        // This was an accident, but some Workers depend on it.
+                        // Newer worker with the unique_ctx_per_invocation will allocate a new ctx for every request.
                         obj.ctx = jsg::alloc<api::ExecutionContext>(lock);
 
                         impl->namedHandlers.insert(kj::mv(handler.name), kj::mv(obj));
@@ -1971,6 +1969,12 @@ kj::Maybe<kj::Own<api::ExportedHandler>> Worker::Lock::getExportedHandler(
 
   kj::StringPtr n = name.orDefault("default"_kj);
   KJ_IF_SOME(h, worker.impl->namedHandlers.find(n)) {
+    jsg::Lock& js = *this;
+    if (FeatureFlags::get(js).getUniqueCtxPerInvocation()) {
+      api::ExportedHandler constructedHandler = h.clone(js);
+      constructedHandler.ctx = jsg::alloc<api::ExecutionContext>(js, props.toJs(js));
+      return kj::heap(kj::mv(constructedHandler));
+    }
     return fakeOwn(h);
   } else KJ_IF_SOME(cls, worker.impl->statelessClasses.find(n)) {
     jsg::Lock& js = *this;