fix(graalvm): correct name for queuing strategies

Signed-off-by: Dario Valdespino <dvaldespino00@gmail.com>

Author: darvld

packages/graalvm/src/main/kotlin/elide/runtime/gvm/internals/intrinsics/js/webstreams/ReadableByteStream.kt

@@ -44,7 +44,7 @@ internal class ReadableByteStream(
   /** Underlying source for this stream. */
   private val source: ReadableStreamSource,
   /** Queueing strategy used to manage backpressure. */
-  private val strategy: QueueingStrategy,
+  private val strategy: QueuingStrategy,
   override val executor: GuestExecutor
 ) : ReadableStreamBase() {
   /**
@@ -890,8 +890,8 @@ internal class ReadableByteStream(
       override fun cancel(reason: Any?): JsPromise<Unit> = cancelBranch(reason, forBranch2 = true)
     }
 
-    branch1.set(ReadableByteStream(source1, QueueingStrategy.DefaultReadStrategy, executor))
-    branch2.set(ReadableByteStream(source2, QueueingStrategy.DefaultReadStrategy, executor))
+    branch1.set(ReadableByteStream(source1, QueuingStrategy.DefaultReadStrategy, executor))
+    branch2.set(ReadableByteStream(source2, QueuingStrategy.DefaultReadStrategy, executor))
     reader.get().forwardReaderError()
 
     return arrayOf(branch1.get(), branch2.get())

packages/graalvm/src/main/kotlin/elide/runtime/gvm/internals/intrinsics/js/webstreams/ReadableDefaultStream.kt

@@ -24,7 +24,7 @@ import elide.runtime.intrinsics.js.JsPromise
 import elide.runtime.intrinsics.js.ReadableStream
 import elide.runtime.intrinsics.js.ReadableStream.ReadResult
 import elide.runtime.intrinsics.js.err.TypeError
-import elide.runtime.intrinsics.js.stream.QueueingStrategy
+import elide.runtime.intrinsics.js.stream.QueuingStrategy
 import elide.runtime.intrinsics.js.stream.ReadableStreamController
 import elide.runtime.intrinsics.js.stream.ReadableStreamReader
 import elide.runtime.intrinsics.js.stream.ReadableStreamSource
@@ -39,7 +39,7 @@ internal class ReadableDefaultStream(
   /** Underlying source for this stream. */
   private val source: ReadableStreamSource,
   /** Queueing strategy used to manage backpressure. */
-  private val strategy: QueueingStrategy,
+  private val strategy: QueuingStrategy,
   override val executor: GuestExecutor
 ) : ReadableStreamBase() {
   /** Simple chunk type allowing an arbitrary untyped value to be enqueued with a computed size. */
@@ -308,8 +308,8 @@ internal class ReadableDefaultStream(
       override fun cancel(reason: Any?): JsPromise<Unit> = cancel2(reason)
     }
 
-    branch1.set(ReadableDefaultStream(source1, QueueingStrategy.DefaultReadStrategy, executor))
-    branch2.set(ReadableDefaultStream(source2, QueueingStrategy.DefaultReadStrategy, executor))
+    branch1.set(ReadableDefaultStream(source1, QueuingStrategy.DefaultReadStrategy, executor))
+    branch2.set(ReadableDefaultStream(source2, QueuingStrategy.DefaultReadStrategy, executor))
 
     reader.closed.catch {
       branch1.get().error(it)

packages/graalvm/src/main/kotlin/elide/runtime/gvm/internals/intrinsics/js/webstreams/ReadableStreamIntrinsic.kt

@@ -19,18 +19,18 @@ import elide.runtime.gvm.internals.intrinsics.js.AbstractJsIntrinsic
 import elide.runtime.gvm.js.JsSymbol.JsSymbols.asPublicJsSymbol
 import elide.runtime.intrinsics.GuestIntrinsic
 import elide.runtime.intrinsics.js.ReadableStream
-import elide.runtime.intrinsics.js.stream.ByteLengthQueueingStrategy
-import elide.runtime.intrinsics.js.stream.CountQueueingStrategy
+import elide.runtime.intrinsics.js.stream.ByteLengthQueuingStrategy
+import elide.runtime.intrinsics.js.stream.CountQueuingStrategy
 import elide.runtime.intrinsics.js.stream.ReadableStreamBYOBReader
 import elide.runtime.intrinsics.js.stream.ReadableStreamDefaultReader
 
 /** Implementation of readable streams (via the Web Streams standard). */
-@Intrinsic(global = "ReadableStream") @Singleton internal class ReadableStreamIntrinsic : AbstractJsIntrinsic() {
+@Intrinsic(internal = false) @Singleton internal class ReadableStreamIntrinsic : AbstractJsIntrinsic() {
   @OptIn(DelicateElideApi::class)
   override fun install(bindings: GuestIntrinsic.MutableIntrinsicBindings) {
     bindings[READABLE_STREAM_SYMBOL.asPublicJsSymbol()] = ReadableStream
-    bindings[BYTE_LENGTH_STRATEGY_SYMBOL.asPublicJsSymbol()] = ByteLengthQueueingStrategy
-    bindings[COUNT_STRATEGY_SYMBOL.asPublicJsSymbol()] = CountQueueingStrategy
+    bindings[BYTE_LENGTH_STRATEGY_SYMBOL.asPublicJsSymbol()] = ByteLengthQueuingStrategy
+    bindings[COUNT_STRATEGY_SYMBOL.asPublicJsSymbol()] = CountQueuingStrategy
     bindings[DEFAULT_READER_SYMBOL.asPublicJsSymbol()] = ReadableStreamDefaultReader
     bindings[BYOB_READER_SYMBOL.asPublicJsSymbol()] = ReadableStreamBYOBReader
   }

packages/graalvm/src/main/kotlin/elide/runtime/gvm/internals/intrinsics/js/webstreams/TransformDefaultStream.kt

@@ -29,8 +29,8 @@ import elide.vm.annotations.Polyglot
 internal class TransformDefaultStream(
   val transformer: TransformStreamTransformer,
   executor: GuestExecutor,
-  writableStrategy: QueueingStrategy = QueueingStrategy.DefaultReadStrategy,
-  readableStrategy: QueueingStrategy = QueueingStrategy.DefaultReadStrategy,
+  writableStrategy: QueuingStrategy = QueuingStrategy.DefaultReadStrategy,
+  readableStrategy: QueuingStrategy = QueuingStrategy.DefaultReadStrategy,
 ) : TransformStream, ReadOnlyProxyObject {
   @JvmInline private value class DelegatingSource(private val stream: TransformDefaultStream) : ReadableStreamSource {
     override fun pull(controller: ReadableStreamController): JsPromise<Unit> {

packages/graalvm/src/main/kotlin/elide/runtime/gvm/internals/intrinsics/js/webstreams/TransformStreamIntrinsic.kt

@@ -22,7 +22,7 @@ import elide.runtime.intrinsics.js.TransformStream
 import elide.runtime.intrinsics.js.WritableStream
 
 /** Implementation of transform streams (via the Web Streams standard). */
-@Intrinsic(global = "TransformStream") @Singleton internal class TransformStreamIntrinsic : AbstractJsIntrinsic() {
+@Intrinsic(internal = false) @Singleton internal class TransformStreamIntrinsic : AbstractJsIntrinsic() {
   @OptIn(DelicateElideApi::class)
   override fun install(bindings: GuestIntrinsic.MutableIntrinsicBindings) {
     bindings[TRANSFORM_STREAM_SYMBOL.asPublicJsSymbol()] = TransformStream

packages/graalvm/src/main/kotlin/elide/runtime/gvm/internals/intrinsics/js/webstreams/WritableDefaultStream.kt

@@ -28,7 +28,7 @@ import elide.runtime.intrinsics.js.CompletableJsPromise
 import elide.runtime.intrinsics.js.JsPromise
 import elide.runtime.intrinsics.js.WritableStream
 import elide.runtime.intrinsics.js.err.TypeError
-import elide.runtime.intrinsics.js.stream.QueueingStrategy
+import elide.runtime.intrinsics.js.stream.QueuingStrategy
 import elide.runtime.intrinsics.js.stream.WritableStreamDefaultController
 import elide.runtime.intrinsics.js.stream.WritableStreamDefaultWriter
 import elide.runtime.intrinsics.js.stream.WritableStreamSink
@@ -42,7 +42,7 @@ internal class WritableDefaultStream(
   /** Underlying sink this stream writes to. */
   private val sink: WritableStreamSink,
   /** Queueing strategy used to control backpressure. */
-  private val strategy: QueueingStrategy = QueueingStrategy.DefaultWriteStrategy,
+  private val strategy: QueuingStrategy = QueuingStrategy.DefaultWriteStrategy,
 ) : WritableStream, ReadOnlyProxyObject {
   /** Inline wrapper for the stream providing the controller API by delegation. */
   @JvmInline private value class ControllerToken(

packages/graalvm/src/main/kotlin/elide/runtime/gvm/internals/intrinsics/js/webstreams/WritableStreamIntrinsic.kt

@@ -22,7 +22,7 @@ import elide.runtime.intrinsics.js.WritableStream
 import elide.runtime.intrinsics.js.stream.WritableStreamDefaultWriter
 
 /** Implementation of writable streams (via the Web Streams standard). */
-@Intrinsic(global = "WritableStream") @Singleton internal class WritableStreamIntrinsic : AbstractJsIntrinsic() {
+@Intrinsic(internal = false) @Singleton internal class WritableStreamIntrinsic : AbstractJsIntrinsic() {
   @OptIn(DelicateElideApi::class)
   override fun install(bindings: GuestIntrinsic.MutableIntrinsicBindings) {
     bindings[WRITABLE_STREAM_SYMBOL.asPublicJsSymbol()] = WritableStream

packages/graalvm/src/main/kotlin/elide/runtime/gvm/intrinsics/BuildTimeIntrinsicsResolver.kt

@@ -35,6 +35,8 @@ import elide.runtime.gvm.internals.intrinsics.js.fetch.FetchIntrinsic
 import elide.runtime.gvm.internals.intrinsics.js.url.URLIntrinsic
 import elide.runtime.gvm.internals.intrinsics.js.url.URLSearchParamsIntrinsic
 import elide.runtime.gvm.internals.intrinsics.js.webstreams.ReadableStreamIntrinsic
+import elide.runtime.gvm.internals.intrinsics.js.webstreams.TransformStreamIntrinsic
+import elide.runtime.gvm.internals.intrinsics.js.webstreams.WritableStreamIntrinsic
 import elide.runtime.gvm.internals.js.JsTimersIntrinsic
 import elide.runtime.gvm.internals.sqlite.ElideSqliteModule
 import elide.runtime.gvm.internals.testing.ElideTestingModule
@@ -143,7 +145,6 @@ import elide.runtime.plugins.env.EnvConfig
     @JvmStatic private val zlib = NodeZlibModule()
     @JvmStatic private val webCrypto = WebCryptoIntrinsic()
     @JvmStatic private val inspector = NodeInspectorModule()
-    @JvmStatic private val readableStream = ReadableStreamIntrinsic()
     @JvmStatic private val childProcess = NodeChildProcessModule(fs, execProvider)
     @JvmStatic private val queueMicrotaskCallable = QueueMicrotaskCallable(execProvider)
     @JvmStatic private val messageChannel = MessageChannelBuiltin()
@@ -155,6 +156,9 @@ import elide.runtime.plugins.env.EnvConfig
     @JvmStatic private val elideSqlite = ElideSqliteModule()
     @JvmStatic private val elideLlm = ElideLLMModule(execProvider)
     @JvmStatic private val elideBuiltin = ElideIntrinsic()
+    @JvmStatic private val readableStream = ReadableStreamIntrinsic()
+    @JvmStatic private val writableStream = WritableStreamIntrinsic()
+    @JvmStatic private val transformStream = TransformStreamIntrinsic()
 
     // All built-ins and intrinsics.
     @JvmStatic private val all = arrayOf(
@@ -198,6 +202,8 @@ import elide.runtime.plugins.env.EnvConfig
       webCrypto,
       inspector,
       readableStream,
+      writableStream,
+      transformStream,
       childProcess,
       queueMicrotaskCallable,
       messageChannel,

packages/graalvm/src/main/kotlin/elide/runtime/intrinsics/js/ReadableStream.kt

@@ -23,7 +23,6 @@ import java.nio.ByteBuffer
 import elide.annotations.API
 import elide.runtime.exec.GuestExecution
 import elide.runtime.gvm.internals.intrinsics.js.webstreams.*
-import elide.runtime.interop.ReadOnlyProxyObject
 import elide.runtime.intrinsics.js.ReadableStream.ReaderMode.BYOB
 import elide.runtime.intrinsics.js.ReadableStream.ReaderMode.Default
 import elide.runtime.intrinsics.js.stream.*
@@ -120,14 +119,14 @@ import elide.vm.annotations.Polyglot
    */
   public interface Factory<Impl> : ProxyInstantiable where Impl : ReadableStream {
     /**
-     * Constructor for a custom [ReadableStream], which implements the provided [source] and [queueingStrategy], if
+     * Constructor for a custom [ReadableStream], which implements the provided [source] and [queuingStrategy], if
      * provided.
      *
      * @param source Source for the [ReadableStream].
-     * @param queueingStrategy Optional [QueueingStrategy] for the [ReadableStream].
+     * @param queuingStrategy Optional [QueuingStrategy] for the [ReadableStream].
      * @return A new [ReadableStream] instance.
      */
-    @Polyglot public fun create(source: ReadableStreamSource, queueingStrategy: QueueingStrategy?): ReadableStream
+    @Polyglot public fun create(source: ReadableStreamSource, queuingStrategy: QueuingStrategy?): ReadableStream
 
     /**
      * Constructor for a custom [ReadableStream], which implements the provided [source].
@@ -185,25 +184,25 @@ import elide.vm.annotations.Polyglot
       return create(ReadableStreamAsyncIteratorSource(asyncIterable.iterator))
     }
 
-    override fun create(source: ReadableStreamSource, queueingStrategy: QueueingStrategy?): ReadableStream {
+    override fun create(source: ReadableStreamSource, queuingStrategy: QueuingStrategy?): ReadableStream {
       return when (source.type) {
         Type.Default -> ReadableDefaultStream(
           source,
-          queueingStrategy ?: QueueingStrategy.DefaultReadStrategy,
+          queuingStrategy ?: QueuingStrategy.DefaultReadStrategy,
           streamExecutor,
         )
 
         Type.BYOB -> ReadableByteStream(
           source,
-          queueingStrategy ?: QueueingStrategy.DefaultReadStrategy,
+          queuingStrategy ?: QueuingStrategy.DefaultReadStrategy,
           streamExecutor,
         )
       }
     }
 
     override fun newInstance(vararg arguments: Value?): Any {
       val source = arguments.getOrNull(0)?.let(::GuestReadableStreamSource) ?: ReadableStreamSource.Empty
-      val strategy = arguments.getOrNull(1)?.let(GuestQueueingStrategy::from) ?: QueueingStrategy.DefaultReadStrategy
+      val strategy = arguments.getOrNull(1)?.let(GuestQueuingStrategy::from) ?: QueuingStrategy.DefaultReadStrategy
 
       return create(source, strategy)
     }

packages/graalvm/src/main/kotlin/elide/runtime/intrinsics/js/TransformStream.kt

@@ -18,10 +18,9 @@ import org.graalvm.polyglot.proxy.ProxyObject
 import elide.annotations.API
 import elide.runtime.exec.GuestExecution
 import elide.runtime.gvm.internals.intrinsics.js.webstreams.TransformDefaultStream
-import elide.runtime.interop.ReadOnlyProxyObject
-import elide.runtime.intrinsics.js.stream.GuestQueueingStrategy
+import elide.runtime.intrinsics.js.stream.GuestQueuingStrategy
 import elide.runtime.intrinsics.js.stream.GuestTransformStreamTransformer
-import elide.runtime.intrinsics.js.stream.QueueingStrategy
+import elide.runtime.intrinsics.js.stream.QueuingStrategy
 import elide.runtime.intrinsics.js.stream.TransformStreamTransformer
 import elide.vm.annotations.Polyglot
 
@@ -44,8 +43,8 @@ import elide.vm.annotations.Polyglot
   public interface Factory<Impl> where Impl : TransformStream {
     public fun create(
       transformer: TransformStreamTransformer,
-      writableStrategy: QueueingStrategy? = null,
-      readableStrategy: QueueingStrategy? = null,
+      writableStrategy: QueuingStrategy? = null,
+      readableStrategy: QueuingStrategy? = null,
     ): Impl
   }
 
@@ -57,21 +56,21 @@ import elide.vm.annotations.Polyglot
 
     override fun create(
       transformer: TransformStreamTransformer,
-      writableStrategy: QueueingStrategy?,
-      readableStrategy: QueueingStrategy?
+      writableStrategy: QueuingStrategy?,
+      readableStrategy: QueuingStrategy?
     ): TransformStream {
       return TransformDefaultStream(
         transformer = transformer,
         executor = streamExecutor,
-        writableStrategy = writableStrategy ?: QueueingStrategy.DefaultWriteStrategy,
-        readableStrategy = readableStrategy ?: QueueingStrategy.DefaultReadStrategy,
+        writableStrategy = writableStrategy ?: QueuingStrategy.DefaultWriteStrategy,
+        readableStrategy = readableStrategy ?: QueuingStrategy.DefaultReadStrategy,
       )
     }
 
     override fun newInstance(vararg arguments: Value?): Any {
       val transformer = arguments.getOrNull(0)?.let(::GuestTransformStreamTransformer)
-      val writableStrategy = arguments.getOrNull(1)?.let(GuestQueueingStrategy::from)
-      val readableStrategy = arguments.getOrNull(2)?.let(GuestQueueingStrategy::from)
+      val writableStrategy = arguments.getOrNull(1)?.let(GuestQueuingStrategy::from)
+      val readableStrategy = arguments.getOrNull(2)?.let(GuestQueuingStrategy::from)
 
       return create(transformer ?: TransformStreamTransformer.Identity, writableStrategy, readableStrategy)
     }