wip direct streams

1 files changed, 397 insertions, 48 deletions

diff --git a/src/javascript/jsc/generate-jssink.js b/src/javascript/jsc/generate-jssink.js
index ba1bbf7ab..de5c5ec02 100644
--- a/src/javascript/jsc/generate-jssink.js
+++ b/src/javascript/jsc/generate-jssink.js
@@ -1,16 +1,26 @@
-const classes = ["ArrayBufferSink"];
-
+const classes = [ "ArrayBufferSink" ];
+
+function names(name) {
+  return {
+    constructor : `JS${name}Constructor`,
+    className : `JS${name}`,
+    controller : `JSReadable${name}Controller`,
+    controllerName : `Readable${name}Controller`,
+    prototypeName : `JS${name}Prototype`,
+    controllerPrototypeName : `JSReadable${name}ControllerPrototype`,
+  };
+}
 function header() {
-  function classTemplate(idName) {
-    const name = `JS${idName}`;
-    const constructor = `${name}Constructor`;
-    const constructorName = `JS${name}Constructor`;
+  function classTemplate(name) {
+    const {constructor, className, controller} = names(name);
 
-    return `class ${constructor} final : public JSC::InternalFunction {                                                                                                     
+    return `class ${
+        constructor} final : public JSC::InternalFunction {                                                                                                     
         public:                                                                                                                                                                     
             using Base = JSC::InternalFunction;                                                                                                                                     
-            static ${constructor}* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSC::JSObject* prototype); 
-            static constexpr SinkID Sink = SinkID::${idName};
+            static ${
+        constructor}* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSC::JSObject* prototype); 
+            static constexpr SinkID Sink = SinkID::${name};
                                                                                                                                                                                     
             static constexpr unsigned StructureFlags = Base::StructureFlags;                                                                                                        
             static constexpr bool needsDestruction = false;                                                                                                                         
@@ -20,7 +30,8 @@ function header() {
             {                                                                                                                                                                       
                 if constexpr (mode == JSC::SubspaceAccess::Concurrently)                                                                                                            
                     return nullptr;                                                                                                                                                 
-                return WebCore::subspaceForImpl<${constructor}, WebCore::UseCustomHeapCellType::No>(                                                                    
+                return WebCore::subspaceForImpl<${
+        constructor}, WebCore::UseCustomHeapCellType::No>(                                                                    
                     vm,                                                                                                                                                             
                     [](auto& spaces) { return spaces.m_clientSubspaceForJSSinkConstructor.get(); },                                                                                 
                     [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForJSSinkConstructor = WTFMove(space); },                                                               
@@ -39,7 +50,8 @@ function header() {
             static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
                                                                                                                                                                
         private:                                                                                                                                                                    
-            ${constructor}(JSC::VM& vm, JSC::Structure* structure, JSC::NativeFunction nativeFunction)                                                                  
+            ${
+        constructor}(JSC::VM& vm, JSC::Structure* structure, JSC::NativeFunction nativeFunction)                                                                  
                 : Base(vm, structure, nativeFunction, nativeFunction)                                                                                                               
                                                                                                                                                                                     
             {                                                                                                                                                                       
@@ -48,18 +60,22 @@ function header() {
             void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSC::JSObject* prototype);                                                     
         };                                                                                                                                                                          
                                                                                                                                                                                     
-        class ${name} final : public JSC::JSDestructibleObject {                                                                                                              
+        class ${
+        className} final : public JSC::JSDestructibleObject {                                                                                                              
         public:                                                                                                                                                                     
             using Base = JSC::JSDestructibleObject;                                                                                                                                 
-            static ${name}* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* sinkPtr);       
-            static constexpr SinkID Sink = SinkID::${idName};                                          
+            static ${
+        className}* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* sinkPtr);       
+            static constexpr SinkID Sink = SinkID::${
+        name};                                          
                                                                                                                                                                                     
             DECLARE_EXPORT_INFO;                                                                                                                                                    
             template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)                                                                
             {                                                                                                                                                                       
                 if constexpr (mode == JSC::SubspaceAccess::Concurrently)                                                                                                            
                     return nullptr;                                                                                                                                                 
-                return WebCore::subspaceForImpl<${name}, WebCore::UseCustomHeapCellType::No>(                                                                                 
+                return WebCore::subspaceForImpl<${
+        className}, WebCore::UseCustomHeapCellType::No>(                                                                                 
                     vm,                                                                                                                                                             
                     [](auto& spaces) { return spaces.m_clientSubspaceForJSSink.get(); },                                                                                            
                     [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForJSSink = WTFMove(space); },                                                                          
@@ -73,15 +89,21 @@ function header() {
                 return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());                                                 
             }                                                                                                                                                                       
                                                                                                                                                                                     
-            ~${name}();                                                                                                                                                       
+            ~${
+        className}();                                                                                                                                                       
                                                                                                                                                                                     
             void* wrapped() const { return m_sinkPtr; }                                                                                                                             
-                                                                                                                                                                                    
+
+            void detach() {
+                m_sinkPtr = nullptr;
+            }                       
+
             static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);                                                                                                                   
                                                                                                                                                                                     
             void* m_sinkPtr;
                                                                                                                                                                                     
-            ${name}(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)                                                                                                    
+            ${
+        className}(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)                                                                                                    
                 : Base(vm, structure)                                                                                                                                               
             {                                                                                                                                                                       
                 m_sinkPtr = sinkPtr;                                                                                                                                                
@@ -89,7 +111,68 @@ function header() {
                                                                                                                                                                                     
             void finishCreation(JSC::VM&);                                                                                                                                          
         };
-JSC_DECLARE_CUSTOM_GETTER(function${idName}__getter);        
+
+        class ${
+        controller} final : public JSC::JSDestructibleObject {                                                                                                              
+            public:                                                                                                                                                                     
+                using Base = JSC::JSDestructibleObject;                                                                                                                                 
+                static ${
+        controller}* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* sinkPtr);       
+                static constexpr SinkID Sink = SinkID::${
+        name};                                          
+                                                                                                                                                                                        
+                DECLARE_EXPORT_INFO;                                                                                                                                                    
+                template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)                                                                
+                {                                                                                                                                                                       
+                    if constexpr (mode == JSC::SubspaceAccess::Concurrently)                                                                                                            
+                        return nullptr;                                                                                                                                                 
+                    return WebCore::subspaceForImpl<${
+        controller}, WebCore::UseCustomHeapCellType::No>(                                                                                 
+                        vm,                                                                                                                                                             
+                        [](auto& spaces) { return spaces.m_clientSubspaceForJSSinkController.get(); },                                                                                            
+                        [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForJSSinkController = WTFMove(space); },                                                                          
+                        [](auto& spaces) { return spaces.m_subspaceForJSSinkController.get(); },                                                                                                  
+                        [](auto& spaces, auto&& space) { spaces.m_subspaceForJSSinkController = WTFMove(space); });                                                                               
+                }                                                                                                                                                                       
+                                                                                                                                                                                        
+                static void destroy(JSC::JSCell*);                                                                                                                                      
+                static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)                                                          
+                {                                                                                                                                                                       
+                    return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());                                                 
+                }                                                                                                                                                                       
+                                                                                                                                                                                        
+                ~${
+        controller}();                                                                                                                                                       
+
+
+                void* wrapped() const { return m_sinkPtr; }    
+                void detach() {
+                    m_sinkPtr = nullptr;
+                }
+
+                void start(JSC::JSGlobalObject *globalObject, JSC::JSValue readableStream, JSC::JSFunction *onPull, JSC::JSFunction *onClose);
+                DECLARE_VISIT_CHILDREN;
+                                                                                                                                                                                        
+                static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);                                                                                                                   
+                                                                                                                                                                                        
+                void* m_sinkPtr;
+                mutable WriteBarrier<JSC::JSFunction> m_onPull;
+                mutable WriteBarrier<JSC::JSFunction> m_onClose;
+                JSC::Weak<Unknown> m_weakReadableStream;
+                                                                                                                                                                                        
+                ${
+        controller}(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)                                                                                                    
+                    : Base(vm, structure)                                                                                                                                               
+                {                                                                                                                                                                       
+                    m_sinkPtr = sinkPtr;                                                                                                                                                
+                }                                                                                                                                                                       
+                                                                                                                                                                                        
+                void finishCreation(JSC::VM&);                                                                                                                                          
+            };
+
+JSC_DECLARE_CUSTOM_GETTER(function${name}__getter);
+
+
 
         `;
   }
@@ -111,9 +194,12 @@ extern "C" bool JSSink_isSink(JSC::JSGlobalObject*, JSC::EncodedJSValue);
 
 namespace WebCore {
 using namespace JSC;
+
+JSC_DECLARE_HOST_FUNCTION(functionStartDirectStream);
 `;
 
-  const bottom = `JSObject* createJSSinkPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, WebCore::SinkID sinkID);
+  const bottom =
+      `JSObject* createJSSinkPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, WebCore::SinkID sinkID);
 
 } // namespace WebCore
 `;
@@ -181,18 +267,150 @@ namespace WebCore {
 using namespace JSC;
 
 
+
+
+JSC_DEFINE_HOST_FUNCTION(functionStartDirectStream, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame *callFrame))
+{
+    
+    auto& vm = lexicalGlobalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+
+    JSC::JSValue readableStream = callFrame->argument(0);
+    JSC::JSValue onPull = callFrame->argument(1);
+    JSC::JSValue onClose = callFrame->argument(2);
+    if (!readableStream.isObject()) {
+        scope.throwException(callFrame, JSC::createTypeError(callFrame, "Expected ReadableStream"_s))
+        return JSC::JSValue::encode(JSC::jsUndefined());
+    }
+
+    if (!onPull.isObject() || !onPull.isCallable()) {
+        onPull = JSC::jsUndefined();
+    }
+
+    if (!onClose.isObject() || !onClose.isCallable()) {
+        onClose = JSC::jsUndefined();
+    }
+
 `;
   var templ = head;
 
+  var isFirst = true;
+  for (let name of classes) {
+    const {
+      className,
+      controller,
+      prototypeName,
+      controllerPrototypeName,
+      constructor,
+    } = names(name);
+
+    templ += `
+
+    ${isFirst ? "" : "else"} if (${controller}* ${
+        name}Controller = JSC::jsDynamicCast<${
+        controller}*>(callFrame->thisValue())) {
+        if (${name}Controller->wrapped() == nullptr) {
+            scope.throwException(callFrame, JSC::createTypeError(callFrame, "Controller is already closed"_s));
+            return JSC::JSValue::encode(JSC::jsUndefined());
+        }
+
+        ${name}Controller->start(globalObject, readableStream, onPull, onClose);
+    }
+}
+`;
+    isFirst = false;
+  }
+
+  templ += `
+    else {
+        scope.throwException(callFrame, JSC::createTypeError(callFrame, "Unknown direct controller. This is a bug in Bun."_s));
+        return JSC::JSValue::encode(JSC::jsUndefined());
+    }
+
+    RELEASE_AND_RETURN(scope, JSC::JSValue::encode(JSC::jsUndefined()));
+}
+`;
+
   for (let name of classes) {
+    const {
+      className,
+      controller,
+      prototypeName,
+      controllerName,
+      controllerPrototypeName,
+      constructor,
+    } = names(name);
+
     templ += `
-JSC_DEFINE_CUSTOM_GETTER(function${name}__getter, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::EncodedJSValue thisValue, JSC::PropertyName))
+JSC_DEFINE_CUSTOM_GETTER(function${
+        name}__getter, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::EncodedJSValue thisValue, JSC::PropertyName))
 {
     auto& vm = lexicalGlobalObject->vm();
     Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
 
     return JSC::JSValue::encode(globalObject->${name}());
 }
+
+
+JSC_DECLARE_HOST_FUNCTION(${controller}__close);
+JSC_DEFINE_HOST_FUNCTION(${
+        controller}__close, (JSC::JSGlobalObject * lexicalGlobalObject, JSC::CallFrame *callFrame))
+{
+    
+    auto& vm = lexicalGlobalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    ${controller}* controller = JSC::jsDynamicCast<${
+        controller}*>(callFrame->thisValue());
+    if (!${controller}) {
+        scope.throwException(callFrame, JSC::createTypeError(callFrame, "Expected ${
+        controller}"_s));
+        return JSC::JSValue::encode(JSC::jsUndefined());
+    }
+
+    void *ptr = controller->wrapped();
+    if (ptr == nullptr) {
+        scope.throwException(callFrame, JSC::createTypeError(callFrame, "Controller is already closed"_s));
+        return JSC::JSValue::encode(JSC::jsUndefined());
+    }
+
+    controller->detach();
+    ${name}__close(ptr, callFrame->argument(0));
+    return JSC::JSValue::encode(JSC::jsUndefined());
+}
+
+
+
+
+static const HashTableValue JS${name}PrototypeTableValues[]
+    = {
+          { "close"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(${
+        name}__close), (intptr_t)(0) } },
+          { "drain"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(${
+        name}__drain), (intptr_t)(1) } },
+          { "end"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(${
+        name}__end), (intptr_t)(0) } },
+          { "start"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(${
+        name}__start), (intptr_t)(1) } },
+          { "write"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(${
+        name}__write), (intptr_t)(1) } },
+      };
+
+static const HashTableValue ${controllerPrototypeName}TableValues[]
+      = {
+            { "close"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(${
+        controller}__close), (intptr_t)(0) } },
+            { "drain"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(${
+        name}__drain), (intptr_t)(1) } },
+            { "end"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(${
+        name}__end), (intptr_t)(0) } },
+            { "start"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(function${
+        controller}__start), (intptr_t)(1) } },
+            { "write"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t) static_cast<RawNativeFunction>(${
+        name}__write), (intptr_t)(1) } },
+        };
+
 `;
   }
 
@@ -206,10 +424,14 @@ ${(await Bun.file(import.meta.dir + "/bindings/JSSink+custom.h").text()).trim()}
 `;
 
   for (let name of classes) {
-    const constructorName = `JS${name}Constructor`;
-    const className = `JS${name}`;
-    const prototypeName = `JS${name}Prototype`;
-
+    const {
+      className,
+      controller,
+      prototypeName,
+      controllerPrototypeName,
+      constructor,
+      controllerName,
+    } = names(name);
     templ += `
 #pragma mark - ${name}
 
@@ -217,9 +439,11 @@ class ${prototypeName} final : public JSC::JSNonFinalObject {
 public:
     using Base = JSC::JSNonFinalObject;
 
-    static ${prototypeName}* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+    static ${
+        prototypeName}* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
     {
-        ${prototypeName}* ptr = new (NotNull, JSC::allocateCell<${prototypeName}>(vm)) ${prototypeName}(vm, globalObject, structure);
+        ${prototypeName}* ptr = new (NotNull, JSC::allocateCell<${
+        prototypeName}>(vm)) ${prototypeName}(vm, globalObject, structure);
         ptr->finishCreation(vm, globalObject);
         return ptr;
     }
@@ -245,11 +469,23 @@ private:
 };
 STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(${prototypeName}, ${prototypeName}::Base);
 
+const ClassInfo ${prototypeName}::s_info = { "${
+        name}"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(${
+        prototypeName}) };
+const ClassInfo ${className}::s_info = { "${
+        name}"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(${
+        className}) };
+const ClassInfo ${constructor}::s_info = { "${
+        name}"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(${
+        constructor}) };
 
 
-const ClassInfo ${prototypeName}::s_info = { "${name}"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(${prototypeName}) };
-const ClassInfo ${className}::s_info = { "${name}"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(${className}) };
-const ClassInfo ${constructorName}::s_info = { "${name}"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(${constructorName}) };
+const ClassInfo ${controllerPrototypeName}::s_info = { "${
+        controllerName}"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(${
+        controllerPrototypeName}) };
+const ClassInfo ${controller}::s_info = { "${
+        controllerName}"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(${
+        controller}) };
 
 ${className}::~${className}()
 {
@@ -259,37 +495,59 @@ ${className}::~${className}()
 }
 
 
+${controller}::~${controller}()
+{
+    if (m_sinkPtr) {
+        ${name}__finalize(m_sinkPtr);
+    }
+}
+
+
 `;
 
     templ += `
 
-${constructorName}* ${constructorName}::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSObject* prototype)
+${constructor}* ${
+        constructor}::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSObject* prototype)
 {
-    ${constructorName}* ptr = new (NotNull, JSC::allocateCell<${constructorName}>(vm)) ${constructorName}(vm, structure, ${name}__construct);
+    ${constructor}* ptr = new (NotNull, JSC::allocateCell<${
+        constructor}>(vm)) ${constructor}(vm, structure, ${name}__construct);
     ptr->finishCreation(vm, globalObject, prototype);
     return ptr;
 }
 
-${className}* ${className}::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* sinkPtr)
+${className}* ${
+        className}::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* sinkPtr)
+{
+    ${className}* ptr = new (NotNull, JSC::allocateCell<${className}>(vm)) ${
+        className}(vm, structure, sinkPtr);
+    ptr->finishCreation(vm);
+    return ptr;
+}
+
+${controller}* ${
+        controller}::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* sinkPtr)
 {
-    ${className}* ptr = new (NotNull, JSC::allocateCell<${className}>(vm)) ${className}(vm, structure, sinkPtr);
+    ${controller}* ptr = new (NotNull, JSC::allocateCell<${controller}>(vm)) ${
+        controller}(vm, structure, sinkPtr);
     ptr->finishCreation(vm);
     return ptr;
 }
 
-void ${constructorName}::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject, JSObject* prototype)
+void ${constructor}::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject, JSObject* prototype)
 {
     Base::finishCreation(vm);
     ASSERT(inherits(info()));
     initializeProperties(vm, globalObject, prototype);
 }
 
-JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES ${constructorName}::construct(JSC::JSGlobalObject* globalObject, JSC::CallFrame* callFrame) {
+JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES ${
+        constructor}::construct(JSC::JSGlobalObject* globalObject, JSC::CallFrame* callFrame) {
     return ${name}__construct(globalObject, callFrame);
 }
 
 
-void ${constructorName}::initializeProperties(VM& vm, JSC::JSGlobalObject* globalObject, JSObject* prototype)
+void ${constructor}::initializeProperties(VM& vm, JSC::JSGlobalObject* globalObject, JSObject* prototype)
 {
     putDirect(vm, vm.propertyNames->length, jsNumber(0), JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::DontEnum);
     JSString* nameString = jsNontrivialString(vm, "${name}"_s);
@@ -300,7 +558,16 @@ void ${constructorName}::initializeProperties(VM& vm, JSC::JSGlobalObject* globa
 void ${prototypeName}::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
 {
     Base::finishCreation(vm);
-    reifyStaticProperties(vm, ${className}::info(), ${className}PrototypeTableValues, *this);
+    reifyStaticProperties(vm, ${className}::info(), ${
+        className}PrototypeTableValues, *this);
+    JSC_TO_STRING_TAG_WITHOUT_TRANSITION();
+}
+
+void ${controllerPrototypeName}::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
+{
+    Base::finishCreation(vm);
+    reifyStaticProperties(vm, ${controller}::info(), ${
+        controller}PrototypeTableValues, *this);
     JSC_TO_STRING_TAG_WITHOUT_TRANSITION();
 }
 
@@ -310,6 +577,13 @@ void ${className}::finishCreation(VM& vm)
     ASSERT(inherits(info()));
 }
 
+void ${controller}::finishCreation(VM& vm)
+{
+    Base::finishCreation(vm);
+    ASSERT(inherits(info()));
+}
+
+
 void ${className}::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
 {
     auto* thisObject = jsCast<${className}*>(cell);
@@ -321,12 +595,44 @@ void ${className}::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
     Base::analyzeHeap(cell, analyzer);
 }
 
+void ${controller}::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
+{
+    auto* thisObject = jsCast<${controller}*>(cell);
+    if (void* wrapped = thisObject->wrapped()) {
+        analyzer.setWrappedObjectForCell(cell, wrapped);
+        // if (thisObject->scriptExecutionContext())
+        //     analyzer.setLabelForCell(cell, "url " + thisObject->scriptExecutionContext()->url().string());
+    }
+    Base::analyzeHeap(cell, analyzer);
+}
+
+
+template<typename Visitor>
+void ${controller}::visitChildrenImpl(JSCell* cell, Visitor& visitor)
+{
+    auto* thisObject = jsCast<${controller}*>(cell);
+    ASSERT_GC_OBJECT_INHERITS(thisObject, info());
+    Base::visitChildren(thisObject, visitor);
+    visitor.append(thisObject->m_onPull);
+    visitor.append(thisObject->m_onClose);
+    visitor.append(thisObject->m_weakReadableStream);
+}
+
+DEFINE_VISIT_CHILDREN(${controller});
+
+
 void ${className}::destroy(JSCell* cell)
 {
     static_cast<${className}*>(cell)->${className}::~${className}();
 }
 
 
+void ${controller}::destroy(JSCell* cell)
+{
+    static_cast<${controller}*>(cell)->${controller}::~${controller}();
+}
+
+
 `;
   }
 
@@ -338,7 +644,8 @@ void ${className}::destroy(JSCell* cell)
   for (let name of classes) {
     templ += `
     case ${name}:
-        return JS${name}Prototype::create(vm, globalObject, JS${name}Prototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
+        return JS${name}Prototype::create(vm, globalObject, JS${
+        name}Prototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
 `;
   }
   templ += `
@@ -350,31 +657,73 @@ default:
   templ += footer;
 
   for (let name of classes) {
+    const {
+      className,
+      controller,
+      prototypeName,
+      controllerPrototypeName,
+      constructor,
+    } = names(name);
+
     templ += `
-extern "C" JSC__JSValue ${name}__createObject(JSC__JSGlobalObject* arg0, void* sinkPtr)
+extern "C" JSC__JSValue ${
+        name}__createObject(JSC__JSGlobalObject* arg0, void* sinkPtr)
 {
     auto& vm = arg0->vm();
     Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(arg0);
     JSC::JSValue prototype = globalObject->${name}Prototype();
-    JSC::Structure* structure = WebCore::JS${name}::createStructure(vm, globalObject, prototype);
-    return JSC::JSValue::encode(WebCore::JS${name}::create(vm, globalObject, structure, sinkPtr));
+    JSC::Structure* structure = WebCore::JS${
+        name}::createStructure(vm, globalObject, prototype);
+    return JSC::JSValue::encode(WebCore::JS${
+        name}::create(vm, globalObject, structure, sinkPtr));
 }
 
-extern "C" void* ${name}__fromJS(JSC__JSGlobalObject* arg0, JSC__JSValue JSValue1)
+extern "C" void* ${
+        name}__fromJS(JSC__JSGlobalObject* arg0, JSC__JSValue JSValue1)
 {
     JSC::VM& vm = WebCore::getVM(arg0);
-    if (auto* sink = JSC::jsDynamicCast<WebCore::JS${name}*>(JSC::JSValue::decode(JSValue1)))
+    if (auto* sink = JSC::jsDynamicCast<WebCore::JS${
+        name}*>(JSC::JSValue::decode(JSValue1)))
         return sink->wrapped();
 
     return nullptr;
 }
+
+extern "C" JSC__JSValue ${
+        name}__assignToStream(JSC__JSGlobalObject* arg0, JSC__JSValue stream, void* sinkPtr, int32_t *bunNativeTag, void** bunNativePtr)
+{
+    auto& vm = arg0->vm();
+    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(arg0);
+    JSC::JSValue prototype = globalObject->${controllerPrototypeName}();
+    JSC::Structure* structure = WebCore::${
+        controller}::createStructure(vm, globalObject, prototype);
+    ${controller} *controller = WebCore::${
+        controller}::create(vm, globalObject, structure, sinkPtr);
+    auto &clientData = WebCore:;getClientData(vm);
+    JSC::JSObject *readableStream = JSC::JSValue::decode(stream).getObject();
+
+    if (readableStream->get(vm, clientData.builtinNames().bunNativeTag()).isUndefined()) {
+
+    }
+
+
+    JSC::JSObject *function = globalObject->getDirect(vm, clientData.builtinNames()->assignDirectStreamPrivateName()).getObject();
+    auto callData = JSC::getCallData(function);
+    MarkedArgumentBuffer arguments;
+    args.append(JSC::JSValue::encode(stream));
+    args.append(JSC::JSValue::encode(controller));
+
+    auto result = JSC::call(arg0, function, callData, jsUndefined(), arguments);
+    return JSC::JSValue::encode(result);
+}
+
+
+
 `;
     return templ;
   }
 }
 
 await Bun.write(import.meta.dir + "/bindings/JSSink.h", header());
-await Bun.write(
-  import.meta.dir + "/bindings/JSSink.cpp",
-  await implementation()
-);
+await Bun.write(import.meta.dir + "/bindings/JSSink.cpp",
+                await implementation());