@trpc/server 11.0.0-alpha-tmp-subscription-connection-state.489 → 11.0.0-alpha-tmp-12-06-react.665

package/dist/unstable-core-do-not-import/stream/jsonl.js

@@ -1,233 +1,334 @@
 'use strict';
 
-var TRPCError = require('../error/TRPCError.js');
+var unpromise = require('../../vendor/unpromise/unpromise.js');
 var utils = require('../utils.js');
+var asyncIterable = require('./utils/asyncIterable.js');
 var createDeferred = require('./utils/createDeferred.js');
-var createReadableStream = require('./utils/createReadableStream.js');
+var disposable = require('./utils/disposable.js');
+var readableStreamFrom = require('./utils/readableStreamFrom.js');
 
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _ts_add_disposable_resource(env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() {
+            try {
+                inner.call(this);
+            } catch (e) {
+                return Promise.reject(e);
+            }
+        };
+        env.stack.push({
+            value: value,
+            dispose: dispose,
+            async: async
+        });
+    } else if (async) {
+        env.stack.push({
+            async: true
+        });
+    }
+    return value;
+}
+function _ts_dispose_resources(env) {
+    var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+        var e = new Error(message);
+        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+    return (_ts_dispose_resources = function _ts_dispose_resources(env) {
+        function fail(e) {
+            env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while(r = env.stack.pop()){
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+                            fail(e);
+                            return next();
+                        });
+                    } else s |= 1;
+                } catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    })(env);
+}
+// ---------- types
 // ---------- types
 const CHUNK_VALUE_TYPE_PROMISE = 0;
 const CHUNK_VALUE_TYPE_ASYNC_ITERABLE = 1;
 const PROMISE_STATUS_FULFILLED = 0;
 const PROMISE_STATUS_REJECTED = 1;
 const ASYNC_ITERABLE_STATUS_RETURN = 0;
-const ASYNC_ITERABLE_STATUS_VALUE = 1;
+const ASYNC_ITERABLE_STATUS_YIELD = 1;
 const ASYNC_ITERABLE_STATUS_ERROR = 2;
 function isPromise(value) {
     return (utils.isObject(value) || utils.isFunction(value)) && typeof value?.['then'] === 'function' && typeof value?.['catch'] === 'function';
 }
 class MaxDepthError extends Error {
     constructor(path){
-        super('Max depth reached at path: ' + path.join('.'));
-        this.path = path;
+        super('Max depth reached at path: ' + path.join('.')), _define_property(this, "path", void 0), this.path = path;
     }
 }
-function createBatchStreamProducer(opts) {
-    const { data  } = opts;
-    let counter = 0;
-    const placeholder = 0;
-    const stream = createReadableStream.createReadableStream();
-    const pending = new Set();
-    function maybeClose() {
-        if (pending.size === 0 && !stream.cancelled()) {
-            stream.controller.close();
-        }
-    }
-    function dehydratePromise(promise, path) {
-        //
-        const error = checkMaxDepth(path);
-        if (error) {
-            promise.catch(()=>{
-            // ignore
+async function* createBatchStreamProducer(opts) {
+    const env = {
+        stack: [],
+        error: void 0,
+        hasError: false
+    };
+    try {
+        const { data } = opts;
+        let counter = 0;
+        const placeholder = 0;
+        const queue = _ts_add_disposable_resource(env, disposable.makeAsyncResource(new Set(), async ()=>{
+            await Promise.all(Array.from(queue).map((it)=>it.iterator.return?.()));
+        }), true);
+        ;
+        function registerAsync(callback) {
+            const idx = counter++;
+            const iterator = callback(idx)[Symbol.asyncIterator]();
+            const nextPromise = iterator.next();
+            nextPromise.catch(()=>{
+            // prevent unhandled promise rejection
             });
-            promise = Promise.reject(error);
-        }
-        const idx = counter++;
-        pending.add(idx);
-        Promise.race([
-            promise,
-            stream.cancelledPromise
-        ]).then((it)=>{
-            if (it === null) {
-                return;
-            }
-            stream.controller.enqueue([
-                idx,
-                PROMISE_STATUS_FULFILLED,
-                dehydrate(it, path)
-            ]);
-        }).catch((cause)=>{
-            opts.onError?.({
-                error: cause,
-                path
+            queue.add({
+                iterator,
+                nextPromise
             });
-            stream.controller.enqueue([
-                idx,
-                PROMISE_STATUS_REJECTED,
-                opts.formatError?.({
-                    error: cause,
-                    path
-                })
-            ]);
-        }).finally(()=>{
-            pending.delete(idx);
-            maybeClose();
-        });
-        return idx;
-    }
-    function dehydrateAsyncIterable(iterable, path) {
-        const error = checkMaxDepth(path);
-        if (error) {
-            iterable = {
-                [Symbol.asyncIterator] () {
-                    throw error;
-                }
-            };
+            return idx;
         }
-        const idx = counter++;
-        pending.add(idx);
-        utils.run(async ()=>{
-            const iterator = iterable[Symbol.asyncIterator]();
-            while(true){
-                const next = await Promise.race([
-                    iterator.next().catch(TRPCError.getTRPCErrorFromUnknown),
-                    stream.cancelledPromise
-                ]);
-                if (next instanceof Error) {
+        function encodePromise(promise, path) {
+            return registerAsync(async function*(idx) {
+                const error = checkMaxDepth(path);
+                if (error) {
+                    // Catch any errors from the original promise to ensure they're reported
+                    promise.catch((cause)=>{
+                        opts.onError?.({
+                            error: cause,
+                            path
+                        });
+                    });
+                    // Replace the promise with a rejected one containing the max depth error
+                    promise = Promise.reject(error);
+                }
+                try {
+                    const next = await promise;
+                    return [
+                        idx,
+                        PROMISE_STATUS_FULFILLED,
+                        encode(next, path)
+                    ];
+                } catch (cause) {
                     opts.onError?.({
-                        error: next,
+                        error: cause,
                         path
                     });
-                    stream.controller.enqueue([
+                    return [
                         idx,
-                        ASYNC_ITERABLE_STATUS_ERROR,
+                        PROMISE_STATUS_REJECTED,
                         opts.formatError?.({
-                            error: next,
+                            error: cause,
                             path
                         })
-                    ]);
-                    return;
+                    ];
                 }
-                if (next === 'cancelled') {
-                    await iterator.return?.();
-                    break;
-                }
-                if (next.done) {
-                    stream.controller.enqueue([
-                        idx,
-                        ASYNC_ITERABLE_STATUS_RETURN,
-                        dehydrate(next.value, path)
-                    ]);
-                    break;
+            });
+        }
+        function encodeAsyncIterable(iterable, path) {
+            return registerAsync(async function*(idx) {
+                const env = {
+                    stack: [],
+                    error: void 0,
+                    hasError: false
+                };
+                try {
+                    const error = checkMaxDepth(path);
+                    if (error) {
+                        throw error;
+                    }
+                    const iterator = _ts_add_disposable_resource(env, asyncIterable.iteratorResource(iterable), true);
+                    ;
+                    try {
+                        while(true){
+                            const next = await iterator.next();
+                            if (next.done) {
+                                return [
+                                    idx,
+                                    ASYNC_ITERABLE_STATUS_RETURN,
+                                    encode(next.value, path)
+                                ];
+                            }
+                            yield [
+                                idx,
+                                ASYNC_ITERABLE_STATUS_YIELD,
+                                encode(next.value, path)
+                            ];
+                        }
+                    } catch (cause) {
+                        opts.onError?.({
+                            error: cause,
+                            path
+                        });
+                        return [
+                            idx,
+                            ASYNC_ITERABLE_STATUS_ERROR,
+                            opts.formatError?.({
+                                error: cause,
+                                path
+                            })
+                        ];
+                    }
+                } catch (e) {
+                    env.error = e;
+                    env.hasError = true;
+                } finally{
+                    const result = _ts_dispose_resources(env);
+                    if (result) await result;
                 }
-                stream.controller.enqueue([
-                    idx,
-                    ASYNC_ITERABLE_STATUS_VALUE,
-                    dehydrate(next.value, path)
-                ]);
-            }
-            pending.delete(idx);
-            maybeClose();
-        }).catch((cause)=>{
-            // this shouldn't happen, but node crashes if we don't catch it
-            opts.onError?.({
-                error: new Error('You found a bug - please report it on https://github.com/trpc/trpc', // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                // @ts-ignore https://github.com/tc39/proposal-error-cause
-                {
-                    cause
-                }),
-                path
             });
-        });
-        return idx;
-    }
-    function checkMaxDepth(path) {
-        if (opts.maxDepth && path.length > opts.maxDepth) {
-            return new MaxDepthError(path);
         }
-        return null;
-    }
-    function dehydrateChunk(value, path) {
-        if (isPromise(value)) {
-            return [
-                CHUNK_VALUE_TYPE_PROMISE,
-                dehydratePromise(value, path)
-            ];
+        function checkMaxDepth(path) {
+            if (opts.maxDepth && path.length > opts.maxDepth) {
+                return new MaxDepthError(path);
+            }
+            return null;
         }
-        if (utils.isAsyncIterable(value)) {
-            if (opts.maxDepth && path.length >= opts.maxDepth) {
-                throw new Error('Max depth reached');
+        function encodeAsync(value, path) {
+            if (isPromise(value)) {
+                return [
+                    CHUNK_VALUE_TYPE_PROMISE,
+                    encodePromise(value, path)
+                ];
             }
-            return [
-                CHUNK_VALUE_TYPE_ASYNC_ITERABLE,
-                dehydrateAsyncIterable(value, path)
-            ];
+            if (utils.isAsyncIterable(value)) {
+                if (opts.maxDepth && path.length >= opts.maxDepth) {
+                    throw new Error('Max depth reached');
+                }
+                return [
+                    CHUNK_VALUE_TYPE_ASYNC_ITERABLE,
+                    encodeAsyncIterable(value, path)
+                ];
+            }
+            return null;
         }
-        return null;
-    }
-    function dehydrate(value, path) {
-        const reg = dehydrateChunk(value, path);
-        if (reg) {
+        function encode(value, path) {
+            if (value === undefined) {
+                return [
+                    []
+                ];
+            }
+            if (!utils.isObject(value)) {
+                return [
+                    [
+                        value
+                    ]
+                ];
+            }
+            const reg = encodeAsync(value, path);
+            if (reg) {
+                return [
+                    [
+                        placeholder
+                    ],
+                    [
+                        null,
+                        ...reg
+                    ]
+                ];
+            }
+            const newObj = {};
+            const asyncValues = [];
+            for (const [key, item] of Object.entries(value)){
+                const transformed = encodeAsync(item, [
+                    ...path,
+                    key
+                ]);
+                if (!transformed) {
+                    newObj[key] = item;
+                    continue;
+                }
+                newObj[key] = placeholder;
+                asyncValues.push([
+                    key,
+                    ...transformed
+                ]);
+            }
             return [
                 [
-                    placeholder
+                    newObj
                 ],
-                [
-                    null,
-                    ...reg
-                ]
+                ...asyncValues
             ];
         }
-        if (!utils.isObject(value)) {
-            return [
-                [
-                    value
-                ]
-            ];
-        }
-        const newObj = {};
-        const asyncValues = [];
-        for (const [key, item] of Object.entries(value)){
-            const transformed = dehydrateChunk(item, [
-                ...path,
+        const newHead = {};
+        for (const [key, item] of Object.entries(data)){
+            newHead[key] = encode(item, [
                 key
             ]);
-            if (!transformed) {
-                newObj[key] = item;
-                continue;
+        }
+        yield newHead;
+        // Process all async iterables in parallel by racing their next values
+        while(queue.size > 0){
+            // Race all iterators to get the next value from any of them
+            const [entry, res] = await unpromise.Unpromise.race(Array.from(queue).map(async (it)=>[
+                    it,
+                    await it.nextPromise
+                ]));
+            yield res.value;
+            // Remove current iterator and re-add if not done
+            queue.delete(entry);
+            if (!res.done) {
+                entry.nextPromise = entry.iterator.next();
+                queue.add(entry);
             }
-            newObj[key] = placeholder;
-            asyncValues.push([
-                key,
-                ...transformed
-            ]);
         }
-        return [
-            [
-                newObj
-            ],
-            ...asyncValues
-        ];
+    } catch (e) {
+        env.error = e;
+        env.hasError = true;
+    } finally{
+        const result = _ts_dispose_resources(env);
+        if (result) await result;
     }
-    const newHead = {};
-    for (const [key, item] of Object.entries(data)){
-        newHead[key] = dehydrate(item, [
-            key
-        ]);
-    }
-    return [
-        newHead,
-        stream.readable
-    ];
 }
 /**
  * JSON Lines stream producer
  * @see https://jsonlines.org/
  */ function jsonlStreamProducer(opts) {
-    let [head, stream] = createBatchStreamProducer(opts);
-    const { serialize  } = opts;
+    let stream = readableStreamFrom.readableStreamFrom(createBatchStreamProducer(opts));
+    const { serialize } = opts;
     if (serialize) {
-        head = serialize(head);
         stream = stream.pipeThrough(new TransformStream({
             transform (chunk, controller) {
                 controller.enqueue(serialize(chunk));
@@ -235,9 +336,6 @@ function createBatchStreamProducer(opts) {
         }));
     }
     return stream.pipeThrough(new TransformStream({
-        start (controller) {
-            controller.enqueue(JSON.stringify(head) + '\n');
-        },
         transform (chunk, controller) {
             controller.enqueue(JSON.stringify(chunk) + '\n');
         }
@@ -254,24 +352,26 @@ class StreamInterruptedError extends Error {
 }
 class AsyncError extends Error {
     constructor(data){
-        super('Received error from server');
-        this.data = data;
+        super('Received error from server'), _define_property(this, "data", void 0), this.data = data;
     }
 }
 const nodeJsStreamToReaderEsque = (source)=>{
     return {
         getReader () {
-            const { readable , controller  } = createReadableStream.createReadableStream();
-            source.on('data', (chunk)=>{
-                controller.enqueue(chunk);
-            });
-            source.on('end', ()=>{
-                controller.close();
-            });
-            source.on('error', (error)=>{
-                controller.error(error);
+            const stream = new ReadableStream({
+                start (controller) {
+                    source.on('data', (chunk)=>{
+                        controller.enqueue(chunk);
+                    });
+                    source.on('end', ()=>{
+                        controller.close();
+                    });
+                    source.on('error', (error)=>{
+                        controller.error(error);
+                    });
+                }
             });
-            return readable.getReader();
+            return stream.getReader();
         }
     };
 };
@@ -280,7 +380,7 @@ function createLineAccumulator(from) {
     let lineAggregate = '';
     return new ReadableStream({
         async pull (controller) {
-            const { done , value  } = await reader.read();
+            const { done, value } = await reader.read();
             if (done) {
                 controller.close();
             } else {
@@ -317,11 +417,84 @@ function createConsumerStream(from) {
         }
     }));
 }
+/**
+ * Creates a handler for managing stream controllers and their lifecycle
+ */ function createStreamsManager(abortController) {
+    const controllerMap = new Map();
+    /**
+   * Checks if there are no pending controllers or deferred promises
+   */ function isEmpty() {
+        return Array.from(controllerMap.values()).every((c)=>c.closed);
+    }
+    /**
+   * Creates a stream controller
+   */ function createStreamController() {
+        let originalController;
+        const stream = new ReadableStream({
+            start (controller) {
+                originalController = controller;
+            }
+        });
+        const streamController = {
+            enqueue: (v)=>originalController.enqueue(v),
+            close: ()=>{
+                originalController.close();
+                // mark as closed and remove methods
+                Object.assign(streamController, {
+                    closed: true,
+                    close: ()=>{
+                    // noop
+                    },
+                    enqueue: ()=>{
+                    // noop
+                    },
+                    getReaderResource: null
+                });
+                if (isEmpty()) {
+                    abortController.abort();
+                }
+            },
+            closed: false,
+            getReaderResource: ()=>{
+                const reader = stream.getReader();
+                return disposable.makeResource(reader, ()=>{
+                    reader.releaseLock();
+                    streamController.close();
+                });
+            }
+        };
+        return streamController;
+    }
+    /**
+   * Gets or creates a stream controller
+   */ function getOrCreate(chunkId) {
+        let c = controllerMap.get(chunkId);
+        if (!c) {
+            c = createStreamController();
+            controllerMap.set(chunkId, c);
+        }
+        return c;
+    }
+    /**
+   * Cancels all pending controllers and rejects deferred promises
+   */ function cancelAll(reason) {
+        const error = new StreamInterruptedError(reason);
+        for (const controller of controllerMap.values()){
+            controller.enqueue(error);
+            controller.close();
+        }
+    }
+    return {
+        getOrCreate,
+        isEmpty,
+        cancelAll
+    };
+}
 /**
  * JSON Lines stream consumer
  * @see https://jsonlines.org/
  */ async function jsonlStreamConsumer(opts) {
-    const { deserialize =(v)=>v  } = opts;
+    const { deserialize = (v)=>v } = opts;
     let source = createConsumerStream(opts.from);
     if (deserialize) {
         source = source.pipeThrough(new TransformStream({
@@ -331,149 +504,105 @@ function createConsumerStream(from) {
         }));
     }
     let headDeferred = createDeferred.createDeferred();
-    const chunkDeferred = new Map();
-    const controllers = new Map();
-    const maybeAbort = ()=>{
-        if (chunkDeferred.size === 0 && Array.from(controllers.values()).every((it)=>it.returned)) {
-            // nothing is listening to the stream anymore
-            opts.abortController?.abort();
-        }
-    };
-    function hydrateChunkDefinition(value) {
+    const streamManager = createStreamsManager(opts.abortController);
+    function decodeChunkDefinition(value) {
         const [_path, type, chunkId] = value;
-        const { readable , controller  } = createReadableStream.createReadableStream();
-        const wrapper = {
-            controller,
-            returned: false
-        };
-        controllers.set(chunkId, wrapper);
-        // resolve chunk deferred if it exists
-        const deferred = chunkDeferred.get(chunkId);
-        if (deferred) {
-            deferred.resolve(wrapper);
-            chunkDeferred.delete(chunkId);
-        }
+        const controller = streamManager.getOrCreate(chunkId);
         switch(type){
             case CHUNK_VALUE_TYPE_PROMISE:
                 {
-                    return new Promise((resolve, reject)=>{
-                        // listen for next value in the stream
-                        const reader = readable.getReader();
-                        reader.read().then((it)=>{
-                            if (it.done) {
-                                reject(new Error('Promise chunk ended without value'));
-                                return;
-                            }
-                            if (it.value instanceof StreamInterruptedError) {
-                                reject(it.value);
-                                return;
+                    return utils.run(async ()=>{
+                        const env = {
+                            stack: [],
+                            error: void 0,
+                            hasError: false
+                        };
+                        try {
+                            const reader = _ts_add_disposable_resource(env, controller.getReaderResource(), false);
+                            ;
+                            const { value } = await reader.read();
+                            if (value instanceof StreamInterruptedError) {
+                                throw value;
                             }
-                            const value = it.value;
                             const [_chunkId, status, data] = value;
                             switch(status){
                                 case PROMISE_STATUS_FULFILLED:
-                                    resolve(hydrate(data));
-                                    break;
+                                    return decode(data);
                                 case PROMISE_STATUS_REJECTED:
-                                    reject(opts.formatError?.({
+                                    throw opts.formatError?.({
                                         error: data
-                                    }) ?? new AsyncError(data));
-                                    break;
+                                    }) ?? new AsyncError(data);
                             }
-                        }).catch(reject).finally(()=>{
-                            // reader.releaseLock();
-                            controllers.delete(chunkId);
-                            maybeAbort();
-                        });
+                        } catch (e) {
+                            env.error = e;
+                            env.hasError = true;
+                        } finally{
+                            _ts_dispose_resources(env);
+                        }
                     });
                 }
             case CHUNK_VALUE_TYPE_ASYNC_ITERABLE:
                 {
-                    return {
-                        [Symbol.asyncIterator]: ()=>{
-                            const reader = readable.getReader();
-                            const iterator = {
-                                next: async ()=>{
-                                    const { done , value  } = await reader.read();
-                                    if (value instanceof StreamInterruptedError) {
-                                        throw value;
-                                    }
-                                    if (done) {
-                                        controllers.delete(chunkId);
-                                        maybeAbort();
-                                        return {
-                                            done: true,
-                                            value: undefined
-                                        };
-                                    }
-                                    const [_chunkId, status, data] = value;
-                                    switch(status){
-                                        case ASYNC_ITERABLE_STATUS_VALUE:
-                                            return {
-                                                done: false,
-                                                value: hydrate(data)
-                                            };
-                                        case ASYNC_ITERABLE_STATUS_RETURN:
-                                            controllers.delete(chunkId);
-                                            maybeAbort();
-                                            return {
-                                                done: true,
-                                                value: hydrate(data)
-                                            };
-                                        case ASYNC_ITERABLE_STATUS_ERROR:
-                                            controllers.delete(chunkId);
-                                            maybeAbort();
-                                            throw opts.formatError?.({
-                                                error: data
-                                            }) ?? new AsyncError(data);
-                                    }
-                                },
-                                return: async ()=>{
-                                    wrapper.returned = true;
-                                    maybeAbort();
-                                    return {
-                                        done: true,
-                                        value: undefined
-                                    };
+                    return utils.run(async function*() {
+                        const env = {
+                            stack: [],
+                            error: void 0,
+                            hasError: false
+                        };
+                        try {
+                            const reader = _ts_add_disposable_resource(env, controller.getReaderResource(), false);
+                            ;
+                            while(true){
+                                const { value } = await reader.read();
+                                if (value instanceof StreamInterruptedError) {
+                                    throw value;
                                 }
-                            };
-                            return iterator;
+                                const [_chunkId, status, data] = value;
+                                switch(status){
+                                    case ASYNC_ITERABLE_STATUS_YIELD:
+                                        yield decode(data);
+                                        break;
+                                    case ASYNC_ITERABLE_STATUS_RETURN:
+                                        return decode(data);
+                                    case ASYNC_ITERABLE_STATUS_ERROR:
+                                        throw opts.formatError?.({
+                                            error: data
+                                        }) ?? new AsyncError(data);
+                                }
+                            }
+                        } catch (e) {
+                            env.error = e;
+                            env.hasError = true;
+                        } finally{
+                            _ts_dispose_resources(env);
                         }
-                    };
+                    });
                 }
         }
     }
-    function hydrate(value) {
+    function decode(value) {
         const [[data], ...asyncProps] = value;
-        for (const value1 of asyncProps){
-            const [key] = value1;
-            const hydrated = hydrateChunkDefinition(value1);
+        for (const value of asyncProps){
+            const [key] = value;
+            const decoded = decodeChunkDefinition(value);
             if (key === null) {
-                return hydrated;
+                return decoded;
             }
-            data[key] = hydrated;
+            data[key] = decoded;
         }
         return data;
     }
     const closeOrAbort = (reason)=>{
         const error = new StreamInterruptedError(reason);
         headDeferred?.reject(error);
-        for (const deferred of chunkDeferred.values()){
-            deferred.reject(error);
-        }
-        chunkDeferred.clear();
-        for (const { controller  } of controllers.values()){
-            controller.enqueue(error);
-            controller.close();
-        }
-        controllers.clear();
+        streamManager.cancelAll(error);
     };
     source.pipeTo(new WritableStream({
-        async write (chunkOrHead) {
+        write (chunkOrHead) {
             if (headDeferred) {
                 const head = chunkOrHead;
                 for (const [key, value] of Object.entries(chunkOrHead)){
-                    const parsed = hydrate(value);
+                    const parsed = decode(value);
                     head[key] = parsed;
                 }
                 headDeferred.resolve(head);
@@ -482,20 +611,14 @@ function createConsumerStream(from) {
             }
             const chunk = chunkOrHead;
             const [idx] = chunk;
-            let wrapper = controllers.get(idx);
-            if (!wrapper) {
-                let deferred = chunkDeferred.get(idx);
-                if (!deferred) {
-                    deferred = createDeferred.createDeferred();
-                    chunkDeferred.set(idx, deferred);
-                }
-                wrapper = await deferred.promise;
-            }
-            wrapper.controller.enqueue(chunk);
+            const controller = streamManager.getOrCreate(idx);
+            controller.enqueue(chunk);
         },
         close: closeOrAbort,
         abort: closeOrAbort
-    })).catch((error)=>{
+    }), {
+        signal: opts.abortController.signal
+    }).catch((error)=>{
         opts.onError?.({
             error
         });
@@ -503,9 +626,7 @@ function createConsumerStream(from) {
     });
     return [
         await headDeferred.promise,
-        {
-            controllers
-        }
+        streamManager
     ];
 }