@trpc/server 11.0.0-rc.645 → 11.0.0-rc.648

package/dist/unstable-core-do-not-import/stream/utils/asyncIterable.mjs

@@ -1,12 +1,91 @@
 import { Unpromise } from '../../../vendor/unpromise/unpromise.mjs';
-import { disposablePromiseTimerResult, timerResource } from './timerResource.mjs';
+import { makeAsyncResource } from './disposable.mjs';
+import { timerResource, disposablePromiseTimerResult } from './timerResource.mjs';
 
+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);
+}
+function iteratorResource(iterable) {
+    const iterator = iterable[Symbol.asyncIterator]();
+    return makeAsyncResource(iterator, async ()=>{
+        await iterator.return?.();
+    });
+}
 /**
  * Derives a new {@link AsyncGenerator} based on {@link iterable}, that automatically stops after the specified duration.
  */ async function* withMaxDuration(iterable, opts) {
-    const iterator = iterable[Symbol.asyncIterator]();
-    const timer = timerResource(opts.maxDurationMs);
+    const env = {
+        stack: [],
+        error: void 0,
+        hasError: false
+    };
     try {
+        const iterator = _ts_add_disposable_resource(env, iteratorResource(iterable), true);
+        ;
+        const timer = _ts_add_disposable_resource(env, timerResource(opts.maxDurationMs), false);
+        ;
         const timerPromise = timer.start();
         // declaration outside the loop for garbage collection reasons
         let result;
@@ -27,10 +106,12 @@ import { disposablePromiseTimerResult, timerResource } from './timerResource.mjs
             // free up reference for garbage collection
             result = null;
         }
+    } catch (e) {
+        env.error = e;
+        env.hasError = true;
     } finally{
-        // dispose timer
-        // Shouldn't be needed, but build breaks with `using` keyword
-        timer[Symbol.dispose]();
+        const result = _ts_dispose_resources(env);
+        if (result) await result;
     }
 }
 /**
@@ -38,11 +119,18 @@ import { disposablePromiseTimerResult, timerResource } from './timerResource.mjs
  * {@link count} values. Then, a grace period of {@link gracePeriodMs} is started in which further
  * values may still come through. After this period, the generator stops.
  */ async function* takeWithGrace(iterable, opts) {
-    const iterator = iterable[Symbol.asyncIterator]();
-    // declaration outside the loop for garbage collection reasons
-    let result;
-    const timer = timerResource(opts.gracePeriodMs);
+    const env = {
+        stack: [],
+        error: void 0,
+        hasError: false
+    };
     try {
+        const iterator = _ts_add_disposable_resource(env, iteratorResource(iterable), true);
+        ;
+        // declaration outside the loop for garbage collection reasons
+        let result;
+        const timer = _ts_add_disposable_resource(env, timerResource(opts.gracePeriodMs), false);
+        ;
         let count = opts.count;
         let timerPromise = new Promise(()=>{
         // never resolves
@@ -67,9 +155,13 @@ import { disposablePromiseTimerResult, timerResource } from './timerResource.mjs
             // free up reference for garbage collection
             result = null;
         }
+    } catch (e) {
+        env.error = e;
+        env.hasError = true;
     } finally{
-        timer[Symbol.dispose]();
+        const result = _ts_dispose_resources(env);
+        if (result) await result;
     }
 }
 
-export { takeWithGrace, withMaxDuration };
+export { iteratorResource, takeWithGrace, withMaxDuration };

package/dist/unstable-core-do-not-import/stream/utils/disposable.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Takes a value and a dispose function and returns a new object that implements the Disposable interface.
+ * The returned object is the original value augmented with a Symbol.dispose method.
+ * @param thing The value to make disposable
+ * @param dispose Function to call when disposing the resource
+ * @returns The original value with Symbol.dispose method added
+ */
+export declare function makeResource<T>(thing: T, dispose: () => void): T & Disposable;
+/**
+ * Takes a value and an async dispose function and returns a new object that implements the AsyncDisposable interface.
+ * The returned object is the original value augmented with a Symbol.asyncDispose method.
+ * @param thing The value to make async disposable
+ * @param dispose Async function to call when disposing the resource
+ * @returns The original value with Symbol.asyncDispose method added
+ */
+export declare function makeAsyncResource<T>(thing: T, dispose: () => Promise<void>): T & AsyncDisposable;
+//# sourceMappingURL=disposable.d.ts.map

package/dist/unstable-core-do-not-import/stream/utils/disposable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disposable.d.ts","sourceRoot":"","sources":["../../../../src/unstable-core-do-not-import/stream/utils/disposable.ts"],"names":[],"mappings":"AAQA;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,MAAM,IAAI,GAAG,CAAC,GAAG,UAAU,CAY7E;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EACjC,KAAK,EAAE,CAAC,EACR,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAC3B,CAAC,GAAG,eAAe,CAYrB"}

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

@@ -0,0 +1,44 @@
+'use strict';
+
+// @ts-expect-error - polyfilling symbol
+// eslint-disable-next-line no-restricted-syntax
+var _Symbol, // @ts-expect-error - polyfilling symbol
+// eslint-disable-next-line no-restricted-syntax
+_Symbol1;
+(_Symbol = Symbol).dispose ?? (_Symbol.dispose = Symbol());
+(_Symbol1 = Symbol).asyncDispose ?? (_Symbol1.asyncDispose = Symbol());
+/**
+ * Takes a value and a dispose function and returns a new object that implements the Disposable interface.
+ * The returned object is the original value augmented with a Symbol.dispose method.
+ * @param thing The value to make disposable
+ * @param dispose Function to call when disposing the resource
+ * @returns The original value with Symbol.dispose method added
+ */ function makeResource(thing, dispose) {
+    const it = thing;
+    // eslint-disable-next-line no-restricted-syntax
+    if (it[Symbol.dispose]) {
+        throw new Error('Symbol.dispose already exists');
+    }
+    // eslint-disable-next-line no-restricted-syntax
+    it[Symbol.dispose] = dispose;
+    return it;
+}
+/**
+ * Takes a value and an async dispose function and returns a new object that implements the AsyncDisposable interface.
+ * The returned object is the original value augmented with a Symbol.asyncDispose method.
+ * @param thing The value to make async disposable
+ * @param dispose Async function to call when disposing the resource
+ * @returns The original value with Symbol.asyncDispose method added
+ */ function makeAsyncResource(thing, dispose) {
+    const it = thing;
+    // eslint-disable-next-line no-restricted-syntax
+    if (it[Symbol.asyncDispose]) {
+        throw new Error('Symbol.asyncDispose already exists');
+    }
+    // eslint-disable-next-line no-restricted-syntax
+    it[Symbol.asyncDispose] = dispose;
+    return it;
+}
+
+exports.makeAsyncResource = makeAsyncResource;
+exports.makeResource = makeResource;

package/dist/unstable-core-do-not-import/stream/utils/disposable.mjs

@@ -0,0 +1,41 @@
+// @ts-expect-error - polyfilling symbol
+// eslint-disable-next-line no-restricted-syntax
+var _Symbol, // @ts-expect-error - polyfilling symbol
+// eslint-disable-next-line no-restricted-syntax
+_Symbol1;
+(_Symbol = Symbol).dispose ?? (_Symbol.dispose = Symbol());
+(_Symbol1 = Symbol).asyncDispose ?? (_Symbol1.asyncDispose = Symbol());
+/**
+ * Takes a value and a dispose function and returns a new object that implements the Disposable interface.
+ * The returned object is the original value augmented with a Symbol.dispose method.
+ * @param thing The value to make disposable
+ * @param dispose Function to call when disposing the resource
+ * @returns The original value with Symbol.dispose method added
+ */ function makeResource(thing, dispose) {
+    const it = thing;
+    // eslint-disable-next-line no-restricted-syntax
+    if (it[Symbol.dispose]) {
+        throw new Error('Symbol.dispose already exists');
+    }
+    // eslint-disable-next-line no-restricted-syntax
+    it[Symbol.dispose] = dispose;
+    return it;
+}
+/**
+ * Takes a value and an async dispose function and returns a new object that implements the AsyncDisposable interface.
+ * The returned object is the original value augmented with a Symbol.asyncDispose method.
+ * @param thing The value to make async disposable
+ * @param dispose Async function to call when disposing the resource
+ * @returns The original value with Symbol.asyncDispose method added
+ */ function makeAsyncResource(thing, dispose) {
+    const it = thing;
+    // eslint-disable-next-line no-restricted-syntax
+    if (it[Symbol.asyncDispose]) {
+        throw new Error('Symbol.asyncDispose already exists');
+    }
+    // eslint-disable-next-line no-restricted-syntax
+    it[Symbol.asyncDispose] = dispose;
+    return it;
+}
+
+export { makeAsyncResource, makeResource };

package/dist/unstable-core-do-not-import/stream/utils/timerResource.d.ts

@@ -1,6 +1,5 @@
 export declare const disposablePromiseTimerResult: unique symbol;
 export declare function timerResource(ms: number): {
     start(): Promise<typeof disposablePromiseTimerResult>;
-    [Symbol.dispose]: () => void;
-};
+} & Disposable;
 //# sourceMappingURL=timerResource.d.ts.map

package/dist/unstable-core-do-not-import/stream/utils/timerResource.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"timerResource.d.ts","sourceRoot":"","sources":["../../../../src/unstable-core-do-not-import/stream/utils/timerResource.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,4BAA4B,eAAW,CAAC;AACrD,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM;;;EAsBvC"}
+{"version":3,"file":"timerResource.d.ts","sourceRoot":"","sources":["../../../../src/unstable-core-do-not-import/stream/utils/timerResource.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,4BAA4B,eAAW,CAAC;AAErD,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM;;eAwBvC"}

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

@@ -1,12 +1,11 @@
 'use strict';
 
-// @ts-expect-error polyfill
-var _Symbol;
-(_Symbol = Symbol).dispose ?? (_Symbol.dispose = Symbol());
+var disposable = require('./disposable.js');
+
 const disposablePromiseTimerResult = Symbol();
 function timerResource(ms) {
     let timer = null;
-    return {
+    return disposable.makeResource({
         start () {
             if (timer) {
                 throw new Error('Timer already started');
@@ -15,13 +14,12 @@ function timerResource(ms) {
                 timer = setTimeout(()=>resolve(disposablePromiseTimerResult), ms);
             });
             return promise;
-        },
-        [Symbol.dispose]: ()=>{
-            if (timer) {
-                clearTimeout(timer);
-            }
         }
-    };
+    }, ()=>{
+        if (timer) {
+            clearTimeout(timer);
+        }
+    });
 }
 
 exports.disposablePromiseTimerResult = disposablePromiseTimerResult;

package/dist/unstable-core-do-not-import/stream/utils/timerResource.mjs

@@ -1,10 +1,9 @@
-// @ts-expect-error polyfill
-var _Symbol;
-(_Symbol = Symbol).dispose ?? (_Symbol.dispose = Symbol());
+import { makeResource } from './disposable.mjs';
+
 const disposablePromiseTimerResult = Symbol();
 function timerResource(ms) {
     let timer = null;
-    return {
+    return makeResource({
         start () {
             if (timer) {
                 throw new Error('Timer already started');
@@ -13,13 +12,12 @@ function timerResource(ms) {
                 timer = setTimeout(()=>resolve(disposablePromiseTimerResult), ms);
             });
             return promise;
-        },
-        [Symbol.dispose]: ()=>{
-            if (timer) {
-                clearTimeout(timer);
-            }
         }
-    };
+    }, ()=>{
+        if (timer) {
+            clearTimeout(timer);
+        }
+    });
 }
 
 export { disposablePromiseTimerResult, timerResource };

package/dist/unstable-core-do-not-import/stream/utils/withPing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"withPing.d.ts","sourceRoot":"","sources":["../../../../src/unstable-core-do-not-import/stream/utils/withPing.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,QAAQ,eAAiB,CAAC;AAEvC;;;GAGG;AACH,wBAAuB,QAAQ,CAAC,MAAM,EACpC,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,EAC/B,cAAc,EAAE,MAAM,GACrB,cAAc,CAAC,MAAM,GAAG,OAAO,QAAQ,CAAC,CAmC1C"}
+{"version":3,"file":"withPing.d.ts","sourceRoot":"","sources":["../../../../src/unstable-core-do-not-import/stream/utils/withPing.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,QAAQ,eAAiB,CAAC;AAEvC;;;GAGG;AACH,wBAAuB,QAAQ,CAAC,MAAM,EACpC,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,EAC/B,cAAc,EAAE,MAAM,GACrB,cAAc,CAAC,MAAM,GAAG,OAAO,QAAQ,CAAC,CAiC1C"}

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

@@ -1,39 +1,128 @@
 'use strict';
 
 var unpromise = require('../../../vendor/unpromise/unpromise.js');
+var asyncIterable = require('./asyncIterable.js');
 var timerResource = require('./timerResource.js');
 
+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);
+}
 const PING_SYM = Symbol('ping');
 /**
  * Derives a new {@link AsyncGenerator} based of {@link iterable}, that yields {@link PING_SYM}
  * whenever no value has been yielded for {@link pingIntervalMs}.
  */ async function* withPing(iterable, pingIntervalMs) {
-    const iterator = iterable[Symbol.asyncIterator]();
-    // declaration outside the loop for garbage collection reasons
-    let result;
-    let nextPromise = iterator.next();
-    while(true){
-        const pingPromise = timerResource.timerResource(pingIntervalMs);
-        try {
-            result = await unpromise.Unpromise.race([
-                nextPromise,
-                pingPromise.start()
-            ]);
-            if (result === timerResource.disposablePromiseTimerResult) {
-                // cancelled
-                yield PING_SYM;
-                continue;
-            }
-            if (result.done) {
-                return result.value;
+    const env = {
+        stack: [],
+        error: void 0,
+        hasError: false
+    };
+    try {
+        const iterator = _ts_add_disposable_resource(env, asyncIterable.iteratorResource(iterable), true);
+        ;
+        // declaration outside the loop for garbage collection reasons
+        let result;
+        let nextPromise = iterator.next();
+        while(true){
+            const env = {
+                stack: [],
+                error: void 0,
+                hasError: false
+            };
+            try {
+                const pingPromise = _ts_add_disposable_resource(env, timerResource.timerResource(pingIntervalMs), false);
+                ;
+                result = await unpromise.Unpromise.race([
+                    nextPromise,
+                    pingPromise.start()
+                ]);
+                if (result === timerResource.disposablePromiseTimerResult) {
+                    // cancelled
+                    yield PING_SYM;
+                    continue;
+                }
+                if (result.done) {
+                    return result.value;
+                }
+                nextPromise = iterator.next();
+                yield result.value;
+                // free up reference for garbage collection
+                result = null;
+            } catch (e) {
+                env.error = e;
+                env.hasError = true;
+            } finally{
+                _ts_dispose_resources(env);
             }
-            nextPromise = iterator.next();
-            yield result.value;
-            // free up reference for garbage collection
-            result = null;
-        } finally{
-            pingPromise[Symbol.dispose]();
         }
+    } catch (e) {
+        env.error = e;
+        env.hasError = true;
+    } finally{
+        const result = _ts_dispose_resources(env);
+        if (result) await result;
     }
 }
 

package/dist/unstable-core-do-not-import/stream/utils/withPing.mjs

@@ -1,37 +1,126 @@
 import { Unpromise } from '../../../vendor/unpromise/unpromise.mjs';
-import { disposablePromiseTimerResult, timerResource } from './timerResource.mjs';
+import { iteratorResource } from './asyncIterable.mjs';
+import { timerResource, disposablePromiseTimerResult } from './timerResource.mjs';
 
+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);
+}
 const PING_SYM = Symbol('ping');
 /**
  * Derives a new {@link AsyncGenerator} based of {@link iterable}, that yields {@link PING_SYM}
  * whenever no value has been yielded for {@link pingIntervalMs}.
  */ async function* withPing(iterable, pingIntervalMs) {
-    const iterator = iterable[Symbol.asyncIterator]();
-    // declaration outside the loop for garbage collection reasons
-    let result;
-    let nextPromise = iterator.next();
-    while(true){
-        const pingPromise = timerResource(pingIntervalMs);
-        try {
-            result = await Unpromise.race([
-                nextPromise,
-                pingPromise.start()
-            ]);
-            if (result === disposablePromiseTimerResult) {
-                // cancelled
-                yield PING_SYM;
-                continue;
-            }
-            if (result.done) {
-                return result.value;
+    const env = {
+        stack: [],
+        error: void 0,
+        hasError: false
+    };
+    try {
+        const iterator = _ts_add_disposable_resource(env, iteratorResource(iterable), true);
+        ;
+        // declaration outside the loop for garbage collection reasons
+        let result;
+        let nextPromise = iterator.next();
+        while(true){
+            const env = {
+                stack: [],
+                error: void 0,
+                hasError: false
+            };
+            try {
+                const pingPromise = _ts_add_disposable_resource(env, timerResource(pingIntervalMs), false);
+                ;
+                result = await Unpromise.race([
+                    nextPromise,
+                    pingPromise.start()
+                ]);
+                if (result === disposablePromiseTimerResult) {
+                    // cancelled
+                    yield PING_SYM;
+                    continue;
+                }
+                if (result.done) {
+                    return result.value;
+                }
+                nextPromise = iterator.next();
+                yield result.value;
+                // free up reference for garbage collection
+                result = null;
+            } catch (e) {
+                env.error = e;
+                env.hasError = true;
+            } finally{
+                _ts_dispose_resources(env);
             }
-            nextPromise = iterator.next();
-            yield result.value;
-            // free up reference for garbage collection
-            result = null;
-        } finally{
-            pingPromise[Symbol.dispose]();
         }
+    } catch (e) {
+        env.error = e;
+        env.hasError = true;
+    } finally{
+        const result = _ts_dispose_resources(env);
+        if (result) await result;
     }
 }
 

package/dist/unstable-core-do-not-import/transformer.d.ts

@@ -63,7 +63,7 @@ export declare const defaultTransformer: CombinedDataTransformer;
 /**
  * Takes a unserialized `TRPCResponse` and serializes it with the router's transformers
  **/
-export declare function transformTRPCResponse<TResponse extends TRPCResponse | TRPCResponse[] | TRPCResponseMessage | TRPCResponseMessage[]>(config: RootConfig<AnyRootTypes>, itemOrItems: TResponse): import("./rpc").TRPCErrorResponse<import("./rpc").TRPCErrorShape<object>> | import("./rpc").TRPCSuccessResponse<unknown> | ({
+export declare function transformTRPCResponse<TResponse extends TRPCResponse | TRPCResponse[] | TRPCResponseMessage | TRPCResponseMessage[]>(config: RootConfig<AnyRootTypes>, itemOrItems: TResponse): import("./rpc").TRPCSuccessResponse<unknown> | import("./rpc").TRPCErrorResponse<import("./rpc").TRPCErrorShape<object>> | ({
     id: import("./rpc").JSONRPC2.RequestId;
 } & TRPCResultMessage<unknown>) | (TRPCResponse | TRPCResponseMessage)[];
 /** @internal */

package/dist/unstable-core-do-not-import.d.ts

@@ -36,6 +36,7 @@ export * from './unstable-core-do-not-import/stream/sse.types';
 export * from './unstable-core-do-not-import/stream/sse';
 export * from './unstable-core-do-not-import/stream/tracked';
 export * from './unstable-core-do-not-import/stream/utils/createDeferred';
+export * from './unstable-core-do-not-import/stream/utils/disposable';
 export * from './unstable-core-do-not-import/transformer';
 export * from './unstable-core-do-not-import/types';
 export * from './unstable-core-do-not-import/utils';