openai 7.5.0 → 7.6.0

package/lib/EventStream.mjs

@@ -1,6 +1,340 @@
-var _EventStream_instances, _EventStream_connectedPromise, _EventStream_resolveConnectedPromise, _EventStream_rejectConnectedPromise, _EventStream_endPromise, _EventStream_resolveEndPromise, _EventStream_rejectEndPromise, _EventStream_listeners, _EventStream_abortListeners, _EventStream_ended, _EventStream_errored, _EventStream_aborted, _EventStream_catchingPromiseCreated, _EventStream_removeAbortListeners, _EventStream_handleError;
+var _EventStream_instances, _EventStream_connectedPromise, _EventStream_resolveConnectedPromise, _EventStream_rejectConnectedPromise, _EventStream_endPromise, _EventStream_resolveEndPromise, _EventStream_rejectEndPromise, _EventStream_listeners, _EventStream_abortListeners, _EventStream_emittedListenerRegistrations, _EventStream_pendingListenerCleanup, _EventStream_pendingBufferedEventChecks, _EventStream_listenerDispatchDepth, _EventStream_ended, _EventStream_errored, _EventStream_aborted, _EventStream_catchingPromiseCreated, _EventStream_removeAbortListeners, _EventStream_onceForEmitted, _EventStream_removeEmittedListener, _EventStream_cleanupEmittedListeners, _EventStream_handleError;
 import { __classPrivateFieldGet, __classPrivateFieldSet } from "../internal/tslib.mjs";
-import { APIUserAbortError, OpenAIError } from "../error.mjs";
+import { APIConnectionError, APIConnectionTimeoutError, APIError, APIUserAbortError, AuthenticationError, BadRequestError, ConflictError, ContentFilterFinishReasonError, InternalServerError, InvalidWebhookSignatureError, LengthFinishReasonError, NotFoundError, OAuthError, OpenAIError, PermissionDeniedError, RateLimitError, SubjectTokenProviderError, UnprocessableEntityError, } from "../error.mjs";
+const MAX_BUFFERED_ITERATOR_EVENTS = 4096;
+const MAX_BUFFERED_ITERATOR_BYTES = 8 * 1024 * 1024;
+// Typed-array own-key enumeration materializes every dense index before custom keys.
+const MAX_INSPECTABLE_TYPED_ARRAY_ELEMENTS = 4096;
+// Structured JSON may nest 128 levels before stream-event wrappers are added.
+const MAX_BUFFERED_EVENT_DEPTH = 256;
+const bufferedJSONStringify = JSON.stringify;
+const bufferedJSONParse = JSON.parse;
+const sdkOwnedBufferedEventArguments = new WeakSet();
+const typedArrayBufferGetter = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Uint8Array.prototype), 'buffer')?.get;
+const typedArrayLengthGetter = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Uint8Array.prototype), 'length')?.get;
+const dataViewBufferGetter = Object.getOwnPropertyDescriptor(DataView.prototype, 'buffer')?.get;
+const symbolDescriptionGetter = Object.getOwnPropertyDescriptor(Symbol.prototype, 'description')?.get;
+const dateTimestampGetter = Date.prototype.getTime;
+const arrayBufferByteLengthGetter = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, 'byteLength')?.get;
+const sharedArrayBufferByteLengthGetter = typeof SharedArrayBuffer === 'function'
+    ? Object.getOwnPropertyDescriptor(SharedArrayBuffer.prototype, 'byteLength')?.get
+    : undefined;
+// V8 uses the same trusted lazy-stack accessor pair for native Error instances.
+const errorStackDescriptor = Object.getOwnPropertyDescriptor(new Error('native stack descriptor'), 'stack');
+const functionToString = Function.prototype.toString;
+const objectToString = Object.prototype.toString;
+const errorBrandDescriptor = Object.getOwnPropertyDescriptor(Error, 'isError');
+const nativeErrorBrand = errorBrandDescriptor && 'value' in errorBrandDescriptor && typeof errorBrandDescriptor.value === 'function'
+    ? errorBrandDescriptor.value
+    : undefined;
+const nativeErrorConstructorSource = functionToString.call(Error);
+const nativeDateConstructorSource = functionToString.call(Date);
+const nativeFunctionConstructorSource = functionToString.call(Function);
+const trustedIntrinsicPrototypes = new Set([
+    APIConnectionError.prototype,
+    APIConnectionTimeoutError.prototype,
+    APIError.prototype,
+    OpenAIError.prototype,
+    APIUserAbortError.prototype,
+    AuthenticationError.prototype,
+    BadRequestError.prototype,
+    ConflictError.prototype,
+    ContentFilterFinishReasonError.prototype,
+    InternalServerError.prototype,
+    InvalidWebhookSignatureError.prototype,
+    LengthFinishReasonError.prototype,
+    NotFoundError.prototype,
+    OAuthError.prototype,
+    PermissionDeniedError.prototype,
+    RateLimitError.prototype,
+    SubjectTokenProviderError.prototype,
+    UnprocessableEntityError.prototype,
+]);
+const trustedNativeConstructorSources = new Set();
+const canonicalIntrinsicDescriptors = new Map();
+const foreignErrorStackDescriptors = new WeakMap();
+function captureNativeProxyDetector() {
+    if (typeof process === 'undefined') {
+        return undefined;
+    }
+    try {
+        const loader = Object.getOwnPropertyDescriptor(process, 'getBuiltinModule');
+        if (!loader || !('value' in loader) || typeof loader.value !== 'function') {
+            return undefined;
+        }
+        const util = Reflect.apply(loader.value, process, ['node:util']);
+        if (typeof util !== 'object' || util === null) {
+            return undefined;
+        }
+        const types = Object.getOwnPropertyDescriptor(util, 'types');
+        if (!types || !('value' in types) || typeof types.value !== 'object' || types.value === null) {
+            return undefined;
+        }
+        const detector = Object.getOwnPropertyDescriptor(types.value, 'isProxy');
+        if (!detector || !('value' in detector) || typeof detector.value !== 'function') {
+            return undefined;
+        }
+        return detector.value;
+    }
+    catch {
+        return undefined;
+    }
+}
+// Transparent proxies have no portable ECMAScript brand. Newer Node runtimes
+// expose one without adding a Node-only import to browser-compatible bundles.
+const nativeProxyDetector = captureNativeProxyDetector();
+function rememberTrustedIntrinsic(constructor) {
+    if (typeof constructor !== 'function') {
+        return;
+    }
+    const prototypeDescriptor = Object.getOwnPropertyDescriptor(constructor, 'prototype');
+    if (!prototypeDescriptor ||
+        !('value' in prototypeDescriptor) ||
+        (typeof prototypeDescriptor.value !== 'object' && typeof prototypeDescriptor.value !== 'function')) {
+        return;
+    }
+    trustedIntrinsicPrototypes.add(prototypeDescriptor.value);
+    const source = functionToString.call(constructor);
+    if (/^function [A-Za-z_$][\w$]*\(\) \{ \[native code\] \}$/u.test(source) &&
+        prototypeDescriptor.configurable === false &&
+        prototypeDescriptor.writable === false) {
+        trustedNativeConstructorSources.add(source);
+        const descriptors = new Map();
+        for (const key of Reflect.ownKeys(prototypeDescriptor.value)) {
+            const descriptor = Object.getOwnPropertyDescriptor(prototypeDescriptor.value, key);
+            if (descriptor) {
+                descriptors.set(key, descriptor);
+            }
+        }
+        canonicalIntrinsicDescriptors.set(source, descriptors);
+    }
+}
+for (const constructor of [
+    Object,
+    Function,
+    Array,
+    Date,
+    Map,
+    Set,
+    ArrayBuffer,
+    DataView,
+    Error,
+    EvalError,
+    RangeError,
+    ReferenceError,
+    SyntaxError,
+    TypeError,
+    URIError,
+    Uint8Array,
+    Uint8ClampedArray,
+    Uint16Array,
+    Uint32Array,
+    Int8Array,
+    Int16Array,
+    Int32Array,
+    Float32Array,
+    Float64Array,
+]) {
+    rememberTrustedIntrinsic(constructor);
+}
+for (const name of [
+    'SharedArrayBuffer',
+    'AggregateError',
+    'Float16Array',
+    'BigInt64Array',
+    'BigUint64Array',
+    'Blob',
+    'File',
+    'Headers',
+]) {
+    const descriptor = Object.getOwnPropertyDescriptor(globalThis, name);
+    if (descriptor && 'value' in descriptor) {
+        rememberTrustedIntrinsic(descriptor.value);
+    }
+}
+const typedArrayConstructorDescriptor = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Uint8Array.prototype), 'constructor');
+if (typedArrayConstructorDescriptor && 'value' in typedArrayConstructorDescriptor) {
+    rememberTrustedIntrinsic(typedArrayConstructorDescriptor.value);
+}
+if (typeof Buffer === 'function') {
+    rememberTrustedIntrinsic(Buffer);
+}
+const blobInternalHandlePrototype = (() => {
+    if (typeof Blob !== 'function') {
+        return undefined;
+    }
+    try {
+        const blob = new Blob([]);
+        for (const key of Object.getOwnPropertySymbols(blob)) {
+            const descriptor = Object.getOwnPropertyDescriptor(blob, key);
+            if (descriptor && 'value' in descriptor && typeof descriptor.value === 'object' && descriptor.value) {
+                return Object.getPrototypeOf(descriptor.value);
+            }
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+})();
+const mapEntries = Map.prototype.entries;
+const setValues = Set.prototype.values;
+const headersEntriesDescriptor = typeof Headers === 'function' ? Object.getOwnPropertyDescriptor(Headers.prototype, 'entries') : undefined;
+const headersEntries = headersEntriesDescriptor &&
+    'value' in headersEntriesDescriptor &&
+    typeof headersEntriesDescriptor.value === 'function'
+    ? headersEntriesDescriptor.value
+    : undefined;
+const retainedStorageBrands = new Set([
+    'ArrayBuffer',
+    'SharedArrayBuffer',
+    'Blob',
+    'File',
+    'Map',
+    'Date',
+    'Set',
+    'Headers',
+]);
+function getTrustedForeignIntrinsic(prototype) {
+    const descriptor = Object.getOwnPropertyDescriptor(prototype, 'constructor');
+    if (!descriptor || !('value' in descriptor) || typeof descriptor.value !== 'function') {
+        return undefined;
+    }
+    const constructor = descriptor.value;
+    const source = functionToString.call(constructor);
+    const descriptors = canonicalIntrinsicDescriptors.get(source);
+    if (!trustedNativeConstructorSources.has(source) || !descriptors) {
+        return undefined;
+    }
+    const constructorPrototype = Object.getOwnPropertyDescriptor(constructor, 'prototype');
+    if (!constructorPrototype ||
+        !('value' in constructorPrototype) ||
+        constructorPrototype.value !== prototype ||
+        constructorPrototype.configurable !== false ||
+        constructorPrototype.writable !== false) {
+        return undefined;
+    }
+    return { constructor, descriptors, functionPrototype: Object.getPrototypeOf(constructor) };
+}
+function isTrustedIntrinsicPrototype(prototype) {
+    return trustedIntrinsicPrototypes.has(prototype) || getTrustedForeignIntrinsic(prototype) !== undefined;
+}
+function isCanonicalIntrinsicFunction(value, canonical, functionPrototype) {
+    if (canonical === undefined) {
+        return value === undefined;
+    }
+    if (typeof value !== 'function' || typeof canonical !== 'function') {
+        return false;
+    }
+    const source = functionToString.call(canonical);
+    if (functionToString.call(value) !== source) {
+        return false;
+    }
+    const actualFunctionPrototype = Object.getPrototypeOf(value);
+    if (actualFunctionPrototype === functionPrototype) {
+        return true;
+    }
+    if (!/^function [A-Za-z_$][\w$]*\(\) \{ \[native code\] \}$/u.test(source)) {
+        return false;
+    }
+    const intrinsic = getTrustedForeignIntrinsic(actualFunctionPrototype);
+    return (intrinsic !== undefined &&
+        functionToString.call(intrinsic.constructor) === nativeFunctionConstructorSource);
+}
+function isCanonicalIntrinsicDescriptor(descriptor, canonical, functionPrototype) {
+    if (!canonical ||
+        descriptor.configurable !== canonical.configurable ||
+        descriptor.enumerable !== canonical.enumerable ||
+        'value' in descriptor !== 'value' in canonical) {
+        return false;
+    }
+    if ('value' in descriptor && 'value' in canonical) {
+        if (descriptor.writable !== canonical.writable) {
+            return false;
+        }
+        if (typeof canonical.value === 'function') {
+            return isCanonicalIntrinsicFunction(descriptor.value, canonical.value, functionPrototype);
+        }
+        if (canonical.value !== null && typeof canonical.value === 'object') {
+            return false;
+        }
+        return Object.is(descriptor.value, canonical.value);
+    }
+    return (isCanonicalIntrinsicFunction(descriptor.get, canonical.get, functionPrototype) &&
+        isCanonicalIntrinsicFunction(descriptor.set, canonical.set, functionPrototype));
+}
+function hasNativeErrorBrand(current) {
+    if (nativeErrorBrand) {
+        return nativeErrorBrand.call(Error, current);
+    }
+    let prototype = current;
+    for (let depth = 0; prototype !== null && depth < MAX_BUFFERED_EVENT_DEPTH; depth += 1) {
+        if (Object.getOwnPropertyDescriptor(prototype, Symbol.toStringTag)) {
+            return false;
+        }
+        prototype = Object.getPrototypeOf(prototype);
+    }
+    return prototype === null && objectToString.call(current) === '[object Error]';
+}
+function getVerifiedForeignErrorConstructor(current, stackDescriptor) {
+    if (typeof stackDescriptor.get !== 'function' || typeof stackDescriptor.set !== 'function') {
+        return undefined;
+    }
+    let prototype = Object.getPrototypeOf(current);
+    for (let depth = 0; prototype !== null && depth < MAX_BUFFERED_EVENT_DEPTH; depth += 1) {
+        const descriptor = Object.getOwnPropertyDescriptor(prototype, 'constructor');
+        if (descriptor && 'value' in descriptor && typeof descriptor.value === 'function') {
+            const constructor = descriptor.value;
+            if (functionToString.call(constructor) === nativeErrorConstructorSource &&
+                isTrustedIntrinsicPrototype(prototype)) {
+                const functionPrototype = Object.getPrototypeOf(constructor);
+                if (Object.getPrototypeOf(stackDescriptor.get) === functionPrototype &&
+                    Object.getPrototypeOf(stackDescriptor.set) === functionPrototype) {
+                    return { constructor, prototype };
+                }
+                return undefined;
+            }
+        }
+        prototype = Object.getPrototypeOf(prototype);
+    }
+    return undefined;
+}
+function isTrustedNativeErrorStack(current, descriptor) {
+    if (!hasNativeErrorBrand(current)) {
+        return false;
+    }
+    if (errorStackDescriptor &&
+        !('value' in errorStackDescriptor) &&
+        typeof errorStackDescriptor.get === 'function' &&
+        Object.prototype.isPrototypeOf.call(Error.prototype, current) &&
+        descriptor.get === errorStackDescriptor.get &&
+        descriptor.set === errorStackDescriptor.set) {
+        return true;
+    }
+    const verified = getVerifiedForeignErrorConstructor(current, descriptor);
+    if (!verified) {
+        return false;
+    }
+    let canonicalDescriptor = foreignErrorStackDescriptors.get(verified.prototype);
+    if (!canonicalDescriptor) {
+        const canonical = Reflect.construct(verified.constructor, []);
+        if (typeof canonical !== 'object' ||
+            canonical === null ||
+            !hasNativeErrorBrand(canonical) ||
+            Object.getPrototypeOf(canonical) !== verified.prototype) {
+            return false;
+        }
+        canonicalDescriptor = Object.getOwnPropertyDescriptor(canonical, 'stack');
+        if (!canonicalDescriptor ||
+            'value' in canonicalDescriptor ||
+            typeof canonicalDescriptor.get !== 'function' ||
+            typeof canonicalDescriptor.set !== 'function') {
+            return false;
+        }
+        foreignErrorStackDescriptors.set(verified.prototype, canonicalDescriptor);
+    }
+    return descriptor.get === canonicalDescriptor.get && descriptor.set === canonicalDescriptor.set;
+}
 function createEventQueue() {
     let entries = [];
     let head = 0;
@@ -34,6 +368,605 @@ function createEventQueue() {
         },
     };
 }
+function getRetainedStorageBrand(current) {
+    let prototype = Object.getPrototypeOf(current);
+    for (let depth = 0; prototype !== null && depth < MAX_BUFFERED_EVENT_DEPTH; depth += 1) {
+        if (prototype === Date.prototype) {
+            return 'Date';
+        }
+        if (!trustedIntrinsicPrototypes.has(prototype)) {
+            const constructor = Object.getOwnPropertyDescriptor(prototype, 'constructor');
+            if (constructor &&
+                'value' in constructor &&
+                typeof constructor.value === 'function' &&
+                functionToString.call(constructor.value) === nativeDateConstructorSource &&
+                getTrustedForeignIntrinsic(prototype)) {
+                return 'Date';
+            }
+        }
+        const descriptor = Object.getOwnPropertyDescriptor(prototype, Symbol.toStringTag);
+        if (descriptor &&
+            'value' in descriptor &&
+            typeof descriptor.value === 'string' &&
+            retainedStorageBrands.has(descriptor.value)) {
+            return descriptor.value;
+        }
+        prototype = Object.getPrototypeOf(prototype);
+    }
+    return undefined;
+}
+function estimateRetainedBufferBytes(current, visit, depth) {
+    if (ArrayBuffer.isView(current)) {
+        let buffer;
+        let kind = 'typed-array';
+        try {
+            buffer = typedArrayBufferGetter?.call(current);
+        }
+        catch {
+            kind = 'data-view';
+            buffer = dataViewBufferGetter?.call(current);
+        }
+        if (typeof buffer !== 'object' || buffer === null) {
+            return { bytes: Number.POSITIVE_INFINITY, kind };
+        }
+        // Even a one-byte cross-realm view retains its complete backing allocation.
+        visit(buffer, depth + 1);
+        return { bytes: 0, kind };
+    }
+    const brand = getRetainedStorageBrand(current);
+    if (!brand) {
+        return undefined;
+    }
+    let getter;
+    const kind = 'buffer';
+    switch (brand) {
+        case 'ArrayBuffer': {
+            getter = arrayBufferByteLengthGetter;
+            break;
+        }
+        case 'SharedArrayBuffer': {
+            getter = sharedArrayBufferByteLengthGetter;
+            break;
+        }
+        case 'Blob':
+        case 'File': {
+            // Blob slices can retain an arbitrarily larger native backing allocation,
+            // and neither browser nor Node exposes its extent or ownership. Detached
+            // queues must fail closed; waiting readers bypass retained-size inspection.
+            return { bytes: Number.POSITIVE_INFINITY, kind: 'blob' };
+        }
+        case 'Map': {
+            return { bytes: 0, kind: 'map' };
+        }
+        case 'Date': {
+            Reflect.apply(dateTimestampGetter, current, []);
+            return { bytes: 8, kind: 'date' };
+        }
+        case 'Set': {
+            return { bytes: 0, kind: 'set' };
+        }
+        case 'Headers': {
+            return { bytes: 0, kind: 'headers' };
+        }
+        default: {
+            return undefined;
+        }
+    }
+    const bytes = getter?.call(current);
+    return {
+        bytes: typeof bytes === 'number' && Number.isSafeInteger(bytes) && bytes >= 0
+            ? bytes
+            : Number.POSITIVE_INFINITY,
+        kind,
+    };
+}
+function visitHiddenEventValues(current, kind, visit) {
+    if (kind === 'map') {
+        for (const [key, entry] of mapEntries.call(current)) {
+            if (!visit(key, 8) || !visit(entry, 8)) {
+                return false;
+            }
+        }
+    }
+    if (kind === 'set') {
+        for (const entry of setValues.call(current)) {
+            if (!visit(entry, 8)) {
+                return false;
+            }
+        }
+    }
+    if (kind === 'headers') {
+        if (!headersEntries) {
+            return false;
+        }
+        for (const [name, value] of headersEntries.call(current)) {
+            if (!visit(name, 8) || !visit(value, 8)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+function getInspectableEventKeys(current, kind, availableBytes) {
+    if (Array.isArray(current)) {
+        const descriptor = Object.getOwnPropertyDescriptor(current, 'length');
+        const length = descriptor && 'value' in descriptor ? descriptor.value : undefined;
+        if (typeof length !== 'number' ||
+            !Number.isSafeInteger(length) ||
+            length < 0 ||
+            length > Math.floor(availableBytes / 16)) {
+            return undefined;
+        }
+    }
+    if (kind !== 'typed-array') {
+        return Reflect.ownKeys(current);
+    }
+    const length = typedArrayLengthGetter?.call(current);
+    if (typeof length !== 'number' ||
+        !Number.isSafeInteger(length) ||
+        length < 0 ||
+        length > MAX_INSPECTABLE_TYPED_ARRAY_ELEMENTS) {
+        return undefined;
+    }
+    return Reflect.ownKeys(current).filter((key) => {
+        if (typeof key !== 'string') {
+            return true;
+        }
+        const index = Number(key);
+        return !Number.isInteger(index) || index < 0 || index >= length || String(index) !== key;
+    });
+}
+function visitInspectableEventProperties(current, kind, depth, availableBytes, charge, visit) {
+    const keys = getInspectableEventKeys(current, kind, availableBytes());
+    if (keys === undefined) {
+        return false;
+    }
+    for (const key of keys) {
+        if (!charge(typeof key === 'string' ? key.length * 2 + 8 : 8)) {
+            return false;
+        }
+        if (typeof key === 'symbol') {
+            visit(key, depth + 1);
+        }
+        const descriptor = Object.getOwnPropertyDescriptor(current, key);
+        if (!descriptor) {
+            return false;
+        }
+        if (!('value' in descriptor)) {
+            if (key === 'stack' && isTrustedNativeErrorStack(current, descriptor)) {
+                continue;
+            }
+            return false;
+        }
+        visit(descriptor.value, depth + 1, kind === 'blob');
+    }
+    return true;
+}
+function visitRetainedEventPrototypes(current, depth, isBlobInternalHandle, visited, availableBytes, charge, visit, retainPrototype) {
+    let prototype = Object.getPrototypeOf(current);
+    for (let prototypeDepth = depth + 1; prototype !== null; prototypeDepth += 1) {
+        if (prototypeDepth >= MAX_BUFFERED_EVENT_DEPTH) {
+            return false;
+        }
+        if (trustedIntrinsicPrototypes.has(prototype) ||
+            (isBlobInternalHandle && prototype === blobInternalHandlePrototype)) {
+            return true;
+        }
+        if (visited.has(prototype)) {
+            visit(prototype, prototypeDepth);
+            return availableBytes() >= 0;
+        }
+        visited.add(prototype);
+        const retainedPrototype = prototype;
+        const retained = retainPrototype(retainedPrototype, () => {
+            if (!charge(16)) {
+                return false;
+            }
+            const intrinsic = getTrustedForeignIntrinsic(retainedPrototype);
+            if (!intrinsic) {
+                return visitInspectableEventProperties(retainedPrototype, undefined, prototypeDepth, availableBytes, charge, visit);
+            }
+            for (const key of Reflect.ownKeys(retainedPrototype)) {
+                const descriptor = Object.getOwnPropertyDescriptor(retainedPrototype, key);
+                if (!descriptor) {
+                    return false;
+                }
+                if (isCanonicalIntrinsicDescriptor(descriptor, intrinsic.descriptors.get(key), intrinsic.functionPrototype)) {
+                    continue;
+                }
+                if (!charge(typeof key === 'string' ? key.length * 2 + 8 : 8) || !('value' in descriptor)) {
+                    return false;
+                }
+                if (typeof key === 'symbol') {
+                    visit(key, prototypeDepth + 1);
+                }
+                visit(descriptor.value, prototypeDepth + 1);
+            }
+            return availableBytes() >= 0;
+        });
+        if (!retained) {
+            return false;
+        }
+        prototype = Object.getPrototypeOf(retainedPrototype);
+    }
+    return true;
+}
+const BUFFERED_LEDGER_ENTRY_BYTES = 32;
+const BUFFERED_LEDGER_NODE_BYTES = 32;
+const BUFFERED_LEDGER_EDGE_BYTES = 8;
+const BUFFERED_LEDGER_OWNER_BYTES = 16;
+const MAX_BUFFERED_LEDGER_RECONCILIATION_WORK = 128 * 1024;
+function inspectBufferedEventGraph(value, remainingBytes) {
+    let bytes = 0;
+    let scalarBytes = 0;
+    const visited = new WeakSet();
+    const visitedSymbols = new Set();
+    const roots = new Set();
+    const nodes = new Map();
+    let activeNode;
+    const availableBytes = () => remainingBytes - bytes;
+    const charge = (amount) => {
+        if (!Number.isSafeInteger(amount) || amount < 0) {
+            bytes = remainingBytes + 1;
+            return false;
+        }
+        bytes += amount;
+        if (activeNode) {
+            activeNode.bytes += amount;
+        }
+        else {
+            scalarBytes += amount;
+        }
+        return bytes <= remainingBytes;
+    };
+    const addIdentity = (identity) => {
+        if (activeNode) {
+            activeNode.edges.add(identity);
+        }
+        else {
+            roots.add(identity);
+        }
+    };
+    const retainIdentity = (identity, inspect) => {
+        addIdentity(identity);
+        const node = { bytes: 0, edges: new Set() };
+        nodes.set(identity, node);
+        const previous = activeNode;
+        activeNode = node;
+        try {
+            return inspect();
+        }
+        finally {
+            activeNode = previous;
+        }
+    };
+    const visitSymbol = (current) => {
+        if (visitedSymbols.has(current)) {
+            addIdentity(current);
+            charge(8);
+            return;
+        }
+        visitedSymbols.add(current);
+        if (!retainIdentity(current, () => {
+            if (!symbolDescriptionGetter) {
+                return false;
+            }
+            const description = Reflect.apply(symbolDescriptionGetter, current, []);
+            return charge(8 + (description?.length ?? 0) * 2);
+        })) {
+            bytes = remainingBytes + 1;
+        }
+    };
+    const visit = (current, depth, isBlobInternalHandle = false) => {
+        if (bytes > remainingBytes) {
+            return;
+        }
+        if (typeof current === 'string') {
+            charge(current.length * 2);
+            return;
+        }
+        if (typeof current === 'symbol') {
+            visitSymbol(current);
+            return;
+        }
+        if (typeof current === 'function') {
+            bytes = remainingBytes + 1;
+            return;
+        }
+        if (current === null || typeof current !== 'object') {
+            charge(8);
+            return;
+        }
+        if (nativeProxyDetector?.(current)) {
+            bytes = remainingBytes + 1;
+            return;
+        }
+        if (depth >= MAX_BUFFERED_EVENT_DEPTH) {
+            bytes = remainingBytes + 1;
+            return;
+        }
+        if (visited.has(current)) {
+            addIdentity(current);
+            charge(8);
+            return;
+        }
+        visited.add(current);
+        if (!retainIdentity(current, () => {
+            if (!charge(16)) {
+                return false;
+            }
+            const retainedStorage = estimateRetainedBufferBytes(current, visit, depth);
+            if (!visitRetainedEventPrototypes(current, depth, isBlobInternalHandle, visited, availableBytes, charge, visit, retainIdentity)) {
+                return false;
+            }
+            if (retainedStorage !== undefined && !charge(retainedStorage.bytes)) {
+                return false;
+            }
+            if (!visitHiddenEventValues(current, retainedStorage?.kind, (hiddenValue, overhead) => {
+                if (!charge(overhead)) {
+                    return false;
+                }
+                visit(hiddenValue, depth + 1);
+                return bytes <= remainingBytes;
+            })) {
+                return false;
+            }
+            return visitInspectableEventProperties(current, retainedStorage?.kind, depth, availableBytes, charge, visit);
+        })) {
+            bytes = remainingBytes + 1;
+        }
+    };
+    try {
+        visit(value, 0);
+    }
+    catch {
+        return undefined;
+    }
+    return bytes <= remainingBytes ? { scalarBytes, roots, nodes } : undefined;
+}
+function areBufferedRetainedEdgesEqual(first, second) {
+    if (first.size !== second.size) {
+        return false;
+    }
+    for (const identity of first) {
+        if (!second.has(identity)) {
+            return false;
+        }
+    }
+    return true;
+}
+function getBufferedLedgerNodeBytes(node, owners) {
+    return (node.bytes +
+        BUFFERED_LEDGER_NODE_BYTES +
+        node.edges.size * BUFFERED_LEDGER_EDGE_BYTES +
+        owners * BUFFERED_LEDGER_OWNER_BYTES);
+}
+function getBufferedLedgerEntryBytes(entry) {
+    return BUFFERED_LEDGER_ENTRY_BYTES + entry.scalarBytes + entry.roots.size * BUFFERED_LEDGER_EDGE_BYTES;
+}
+function collectBufferedLedgerIdentities(roots, candidate, records, work) {
+    const identities = new Set();
+    const pending = [...roots];
+    while (pending.length) {
+        work.remaining -= 1;
+        if (work.remaining < 0) {
+            return undefined;
+        }
+        const identity = pending.pop();
+        if (identities.has(identity)) {
+            continue;
+        }
+        const node = candidate.get(identity) ?? records.get(identity);
+        if (!node) {
+            return undefined;
+        }
+        identities.add(identity);
+        for (const edge of node.edges) {
+            pending.push(edge);
+        }
+    }
+    return identities;
+}
+function getBufferedLedgerChange(identity, graph, records, changes, node) {
+    const existing = changes.get(identity);
+    if (existing) {
+        if (node) {
+            existing.node = node;
+        }
+        return existing;
+    }
+    const current = node ?? graph.nodes.get(identity) ?? records.get(identity);
+    if (!current) {
+        return undefined;
+    }
+    const update = { node: current, ownerDelta: 0 };
+    changes.set(identity, update);
+    return update;
+}
+function findBufferedLedgerAffectedOwners(entry, graph, records, changes, work) {
+    const affected = new Set([entry]);
+    for (const [identity, node] of graph.nodes) {
+        work.remaining -= 1;
+        if (work.remaining < 0) {
+            return undefined;
+        }
+        const previous = records.get(identity);
+        if (!previous) {
+            continue;
+        }
+        const changedEdges = !areBufferedRetainedEdgesEqual(previous.edges, node.edges);
+        if (previous.bytes !== node.bytes || changedEdges) {
+            getBufferedLedgerChange(identity, graph, records, changes, node);
+        }
+        if (!changedEdges) {
+            continue;
+        }
+        for (const owner of previous.owners) {
+            work.remaining -= 1;
+            if (work.remaining < 0) {
+                return undefined;
+            }
+            affected.add(owner);
+        }
+    }
+    return affected;
+}
+function updateBufferedLedgerMembershipChanges(owner, next, graph, records, changes, work) {
+    for (const identity of owner.identities) {
+        work.remaining -= 1;
+        if (work.remaining < 0) {
+            return false;
+        }
+        if (!next.has(identity)) {
+            const update = getBufferedLedgerChange(identity, graph, records, changes);
+            if (!update) {
+                return false;
+            }
+            update.ownerDelta -= 1;
+        }
+    }
+    for (const identity of next) {
+        work.remaining -= 1;
+        if (work.remaining < 0) {
+            return false;
+        }
+        if (!owner.identities.has(identity)) {
+            const update = getBufferedLedgerChange(identity, graph, records, changes);
+            if (!update) {
+                return false;
+            }
+            update.ownerDelta += 1;
+        }
+    }
+    return true;
+}
+function collectBufferedLedgerMemberships(entry, graph, affected, records, changes, work) {
+    const memberships = new Map();
+    for (const owner of affected) {
+        const roots = owner === entry ? graph.roots : owner.roots;
+        const next = collectBufferedLedgerIdentities(roots, graph.nodes, records, work);
+        if (!next || !updateBufferedLedgerMembershipChanges(owner, next, graph, records, changes, work)) {
+            return undefined;
+        }
+        memberships.set(owner, next);
+    }
+    return memberships;
+}
+function projectBufferedLedgerBytes(currentBytes, entry, graph, isNew, changes, records) {
+    let projected = currentBytes - (isNew ? 0 : getBufferedLedgerEntryBytes(entry)) + getBufferedLedgerEntryBytes(graph);
+    for (const [identity, update] of changes) {
+        const previous = records.get(identity);
+        const owners = (previous?.owners.size ?? 0) + update.ownerDelta;
+        if (owners < 0) {
+            return undefined;
+        }
+        if (previous) {
+            projected -= getBufferedLedgerNodeBytes(previous, previous.owners.size);
+        }
+        if (owners) {
+            projected += getBufferedLedgerNodeBytes(update.node, owners);
+        }
+    }
+    return Number.isSafeInteger(projected) && projected >= 0 && projected <= MAX_BUFFERED_ITERATOR_BYTES
+        ? projected
+        : undefined;
+}
+function applyBufferedLedgerChanges(records, changes, memberships) {
+    for (const [identity, update] of changes) {
+        const previous = records.get(identity);
+        const owners = (previous?.owners.size ?? 0) + update.ownerDelta;
+        if (!owners) {
+            continue;
+        }
+        if (previous) {
+            previous.bytes = update.node.bytes;
+            previous.edges = update.node.edges;
+        }
+        else {
+            records.set(identity, {
+                bytes: update.node.bytes,
+                edges: update.node.edges,
+                owners: new Set(),
+            });
+        }
+    }
+    for (const [owner, next] of memberships) {
+        for (const identity of owner.identities) {
+            if (!next.has(identity)) {
+                records.get(identity)?.owners.delete(owner);
+            }
+        }
+        for (const identity of next) {
+            if (!owner.identities.has(identity)) {
+                records.get(identity).owners.add(owner);
+            }
+        }
+        owner.identities = next;
+    }
+    for (const identity of changes.keys()) {
+        if (records.get(identity)?.owners.size === 0) {
+            records.delete(identity);
+        }
+    }
+}
+/**
+ * Account for queue-owned identities once while charging bounded ownership and
+ * edge metadata. Shared topology changes are reconciled for every queued owner.
+ */
+function createBufferedEventLedger() {
+    const records = new Map();
+    let bytes = 0;
+    const reconcile = (entry, graph, isNew) => {
+        const work = { remaining: MAX_BUFFERED_LEDGER_RECONCILIATION_WORK };
+        const changes = new Map();
+        const affected = findBufferedLedgerAffectedOwners(entry, graph, records, changes, work);
+        if (!affected) {
+            return false;
+        }
+        const memberships = collectBufferedLedgerMemberships(entry, graph, affected, records, changes, work);
+        if (!memberships) {
+            return false;
+        }
+        const projectedBytes = projectBufferedLedgerBytes(bytes, entry, graph, isNew, changes, records);
+        if (projectedBytes === undefined) {
+            return false;
+        }
+        applyBufferedLedgerChanges(records, changes, memberships);
+        entry.scalarBytes = graph.scalarBytes;
+        entry.roots = graph.roots;
+        bytes = projectedBytes;
+        return true;
+    };
+    const release = (entry) => {
+        bytes -= getBufferedLedgerEntryBytes(entry);
+        for (const identity of entry.identities) {
+            const record = records.get(identity);
+            if (!record?.owners.delete(entry)) {
+                continue;
+            }
+            bytes -= BUFFERED_LEDGER_OWNER_BYTES;
+            if (record.owners.size === 0) {
+                bytes -= getBufferedLedgerNodeBytes(record, 0);
+                records.delete(identity);
+            }
+        }
+        entry.identities.clear();
+    };
+    return {
+        retain(graph) {
+            const entry = { scalarBytes: 0, roots: new Set(), identities: new Set() };
+            return reconcile(entry, graph, true) ? entry : undefined;
+        },
+        refresh(entry, graph) {
+            return reconcile(entry, graph, false);
+        },
+        release,
+        clear() {
+            records.clear();
+            bytes = 0;
+        },
+    };
+}
 /** An abortable event stream with typed listeners, asynchronous iteration, and lifecycle state. */
 export class EventStream {
     /** Creates an unstarted stream with independent connection and completion lifecycle promises. */
@@ -51,6 +984,10 @@ export class EventStream {
         // oxlint-enable class-methods-use-this
         _EventStream_listeners.set(this, Object.create(null));
         _EventStream_abortListeners.set(this, []);
+        _EventStream_emittedListenerRegistrations.set(this, new WeakMap());
+        _EventStream_pendingListenerCleanup.set(this, new Set());
+        _EventStream_pendingBufferedEventChecks.set(this, new Set());
+        _EventStream_listenerDispatchDepth.set(this, 0);
         _EventStream_ended.set(this, false);
         _EventStream_errored.set(this, false);
         _EventStream_aborted.set(this, false);
@@ -159,7 +1096,14 @@ export class EventStream {
         if (!listeners) {
             return this;
         }
-        const index = listeners.findIndex((l) => l.listener === listener);
+        const emittedRegistration = __classPrivateFieldGet(this, _EventStream_emittedListenerRegistrations, "f").get(listener);
+        if (emittedRegistration?.event === event &&
+            !emittedRegistration.registration.removed &&
+            !emittedRegistration.registration.detached) {
+            __classPrivateFieldGet(this, _EventStream_instances, "m", _EventStream_removeEmittedListener).call(this, event, emittedRegistration.registration);
+            return this;
+        }
+        const index = listeners.findIndex((l) => !l.removed && l.listener === listener);
         if (index !== -1) {
             listeners.splice(index, 1);
         }
@@ -203,9 +1147,9 @@ export class EventStream {
                 resolve((values.length > 1 ? values : values[0]));
             };
             if (event !== 'error') {
-                this.once('error', onError);
+                __classPrivateFieldGet(this, _EventStream_instances, "m", _EventStream_onceForEmitted).call(this, 'error', onError);
             }
-            this.once(event, onEvent);
+            __classPrivateFieldGet(this, _EventStream_instances, "m", _EventStream_onceForEmitted).call(this, event, onEvent);
         });
     }
     /**
@@ -222,7 +1166,15 @@ export class EventStream {
      */
     events(event) {
         return this._createIterator((push) => {
-            const onEvent = (...args) => push(args);
+            const onEvent = (...args) => {
+                sdkOwnedBufferedEventArguments.add(args);
+                try {
+                    push(args);
+                }
+                finally {
+                    sdkOwnedBufferedEventArguments.delete(args);
+                }
+            };
             this.on(event, onEvent);
             return () => this.off(event, onEvent);
         }, {
@@ -240,10 +1192,16 @@ export class EventStream {
      * here: the iterator ends when the stream ends, listeners are removed on
      * end/return, and a terminal error is retained until buffered values have
      * drained so it is surfaced even when no reader was waiting when it fired.
+     * Detached consumers have bounded event and byte queues; exceeding either
+     * limit fails the stream and aborts its underlying request. Detached queues
+     * also reject accessor-backed payloads because getter closures cannot be
+     * safely sized without executing untrusted code.
      */
     _createIterator(attach, { rejectOnError = true, rejectOnAbort = true, onReturn, } = {}) {
         const pushQueue = createEventQueue();
+        const bufferedEventSizes = createEventQueue();
         const readQueue = createEventQueue();
+        const bufferedLedger = createBufferedEventLedger();
         let ended = this.ended;
         let failure;
         let failureDelivered = false;
@@ -271,6 +1229,39 @@ export class EventStream {
                 this.off('abort', onFailure);
             }
         };
+        const deactivateBufferedEvent = (entry) => {
+            entry.active = false;
+            if (entry.check) {
+                __classPrivateFieldGet(this, _EventStream_pendingBufferedEventChecks, "f").delete(entry.check);
+                entry.check = undefined;
+            }
+        };
+        const failBufferedEvents = (discardRetained = false) => {
+            if (discardRetained) {
+                while (bufferedEventSizes.length) {
+                    deactivateBufferedEvent(bufferedEventSizes.dequeue());
+                }
+                pushQueue.clear();
+                bufferedLedger.clear();
+            }
+            const error = new OpenAIError(`Event stream iterator buffer limit exceeded (${MAX_BUFFERED_ITERATOR_EVENTS} events or ${MAX_BUFFERED_ITERATOR_BYTES} bytes); consume events as they arrive.`);
+            try {
+                __classPrivateFieldGet(this, _EventStream_instances, "m", _EventStream_handleError).call(this, error);
+            }
+            finally {
+                this.controller.abort();
+            }
+            return error;
+        };
+        const revalidateBufferedEvent = (value, entry) => {
+            if (!entry.active || __classPrivateFieldGet(this, _EventStream_ended, "f")) {
+                return;
+            }
+            const graph = inspectBufferedEventGraph(value, MAX_BUFFERED_ITERATOR_BYTES);
+            if (!graph || !bufferedLedger.refresh(entry.retention, graph)) {
+                failBufferedEvents(true);
+            }
+        };
         const push = (value) => {
             if (ended) {
                 return;
@@ -280,7 +1271,34 @@ export class EventStream {
                 reader.resolve({ value, done: false });
             }
             else {
+                if (pushQueue.length >= MAX_BUFFERED_ITERATOR_EVENTS) {
+                    failBufferedEvents();
+                    return;
+                }
+                const graph = inspectBufferedEventGraph(value, MAX_BUFFERED_ITERATOR_BYTES);
+                const retention = graph && bufferedLedger.retain(graph);
+                if (!retention) {
+                    failBufferedEvents();
+                    return;
+                }
+                if (typeof value === 'object' && value !== null && sdkOwnedBufferedEventArguments.has(value)) {
+                    const argumentsTuple = value;
+                    for (let index = 0; index < argumentsTuple.length; index += 1) {
+                        const argument = argumentsTuple[index];
+                        if (typeof argument === 'string') {
+                            argumentsTuple[index] = bufferedJSONParse(bufferedJSONStringify(argument));
+                        }
+                    }
+                }
+                const entry = { retention, active: true, check: undefined };
                 pushQueue.enqueue(value);
+                bufferedEventSizes.enqueue(entry);
+                const check = () => {
+                    entry.check = undefined;
+                    revalidateBufferedEvent(value, entry);
+                };
+                entry.check = check;
+                __classPrivateFieldGet(this, _EventStream_pendingBufferedEventChecks, "f").add(check);
             }
         };
         const onFailure = (error) => {
@@ -310,7 +1328,17 @@ export class EventStream {
         return {
             next: () => {
                 if (pushQueue.length) {
-                    return Promise.resolve({ value: pushQueue.dequeue(), done: false });
+                    const value = pushQueue.dequeue();
+                    const entry = bufferedEventSizes.dequeue();
+                    deactivateBufferedEvent(entry);
+                    const graph = inspectBufferedEventGraph(value, MAX_BUFFERED_ITERATOR_BYTES);
+                    if (!graph || !bufferedLedger.refresh(entry.retention, graph)) {
+                        const error = failBufferedEvents(true);
+                        failureDelivered = true;
+                        return Promise.reject(error);
+                    }
+                    bufferedLedger.release(entry.retention);
+                    return Promise.resolve({ value, done: false });
                 }
                 if (failure && !failureDelivered) {
                     failureDelivered = true;
@@ -325,7 +1353,11 @@ export class EventStream {
             },
             return: () => {
                 ended = true;
+                while (bufferedEventSizes.length) {
+                    deactivateBufferedEvent(bufferedEventSizes.dequeue());
+                }
                 pushQueue.clear();
+                bufferedLedger.clear();
                 cleanup();
                 finishReaders();
                 if (onReturn) {
@@ -350,7 +1382,7 @@ export class EventStream {
     }
     /** Returns whether an event currently has one or more registered listeners. */
     _hasListeners(event) {
-        return Boolean(__classPrivateFieldGet(this, _EventStream_listeners, "f")[event]?.length);
+        return Boolean(__classPrivateFieldGet(this, _EventStream_listeners, "f")[event]?.some((listener) => !listener.removed));
     }
     /** Dispatches a stream event and performs the associated lifecycle transitions. */
     _emit(event, ...args) {
@@ -365,9 +1397,31 @@ export class EventStream {
         }
         const listeners = __classPrivateFieldGet(this, _EventStream_listeners, "f")[event];
         if (listeners) {
-            __classPrivateFieldGet(this, _EventStream_listeners, "f")[event] = listeners.filter((l) => !l.once);
-            for (const { listener } of listeners) {
-                listener(...args);
+            __classPrivateFieldGet(this, _EventStream_listeners, "f")[event] = listeners.filter((listener) => {
+                if (listener.once) {
+                    listener.detached = true;
+                }
+                return !listener.once && !listener.removed;
+            });
+            __classPrivateFieldSet(this, _EventStream_listenerDispatchDepth, __classPrivateFieldGet(this, _EventStream_listenerDispatchDepth, "f") + 1, "f");
+            try {
+                for (const registration of listeners) {
+                    if (!registration.removed) {
+                        registration.listener(...args);
+                    }
+                }
+            }
+            finally {
+                __classPrivateFieldSet(this, _EventStream_listenerDispatchDepth, __classPrivateFieldGet(this, _EventStream_listenerDispatchDepth, "f") - 1, "f");
+                if (__classPrivateFieldGet(this, _EventStream_listenerDispatchDepth, "f") === 0) {
+                    __classPrivateFieldGet(this, _EventStream_instances, "m", _EventStream_cleanupEmittedListeners).call(this);
+                    for (const check of __classPrivateFieldGet(this, _EventStream_pendingBufferedEventChecks, "f")) {
+                        __classPrivateFieldGet(this, _EventStream_pendingBufferedEventChecks, "f").delete(check);
+                        if (!__classPrivateFieldGet(this, _EventStream_ended, "f")) {
+                            check();
+                        }
+                    }
+                }
             }
         }
         if (event === 'abort') {
@@ -402,10 +1456,41 @@ export class EventStream {
         // Hook for subclasses.
     }
 }
-_EventStream_connectedPromise = new WeakMap(), _EventStream_resolveConnectedPromise = new WeakMap(), _EventStream_rejectConnectedPromise = new WeakMap(), _EventStream_endPromise = new WeakMap(), _EventStream_resolveEndPromise = new WeakMap(), _EventStream_rejectEndPromise = new WeakMap(), _EventStream_listeners = new WeakMap(), _EventStream_abortListeners = new WeakMap(), _EventStream_ended = new WeakMap(), _EventStream_errored = new WeakMap(), _EventStream_aborted = new WeakMap(), _EventStream_catchingPromiseCreated = new WeakMap(), _EventStream_instances = new WeakSet(), _EventStream_removeAbortListeners = function _EventStream_removeAbortListeners() {
+_EventStream_connectedPromise = new WeakMap(), _EventStream_resolveConnectedPromise = new WeakMap(), _EventStream_rejectConnectedPromise = new WeakMap(), _EventStream_endPromise = new WeakMap(), _EventStream_resolveEndPromise = new WeakMap(), _EventStream_rejectEndPromise = new WeakMap(), _EventStream_listeners = new WeakMap(), _EventStream_abortListeners = new WeakMap(), _EventStream_emittedListenerRegistrations = new WeakMap(), _EventStream_pendingListenerCleanup = new WeakMap(), _EventStream_pendingBufferedEventChecks = new WeakMap(), _EventStream_listenerDispatchDepth = new WeakMap(), _EventStream_ended = new WeakMap(), _EventStream_errored = new WeakMap(), _EventStream_aborted = new WeakMap(), _EventStream_catchingPromiseCreated = new WeakMap(), _EventStream_instances = new WeakSet(), _EventStream_removeAbortListeners = function _EventStream_removeAbortListeners() {
     for (const { signal, listener } of __classPrivateFieldGet(this, _EventStream_abortListeners, "f").splice(0)) {
         signal.removeEventListener('abort', listener);
     }
+}, _EventStream_onceForEmitted = function _EventStream_onceForEmitted(event, listener) {
+    const previousListeners = __classPrivateFieldGet(this, _EventStream_listeners, "f")[event];
+    const previousLength = previousListeners?.length ?? 0;
+    this.once(event, listener);
+    const listeners = __classPrivateFieldGet(this, _EventStream_listeners, "f")[event];
+    const [registration] = listeners?.slice(-1) ?? [];
+    if ((previousListeners === undefined || listeners === previousListeners) &&
+        listeners?.length === previousLength + 1 &&
+        registration?.listener === listener &&
+        registration.once) {
+        __classPrivateFieldGet(this, _EventStream_emittedListenerRegistrations, "f").set(listener, { event, registration });
+    }
+}, _EventStream_removeEmittedListener = function _EventStream_removeEmittedListener(event, registration) {
+    if (registration.removed) {
+        return;
+    }
+    registration.removed = true;
+    __classPrivateFieldGet(this, _EventStream_emittedListenerRegistrations, "f").delete(registration.listener);
+    __classPrivateFieldGet(this, _EventStream_pendingListenerCleanup, "f").add(event);
+    if (__classPrivateFieldGet(this, _EventStream_listenerDispatchDepth, "f") === 0) {
+        __classPrivateFieldGet(this, _EventStream_instances, "m", _EventStream_cleanupEmittedListeners).call(this);
+    }
+}, _EventStream_cleanupEmittedListeners = function _EventStream_cleanupEmittedListeners() {
+    for (const event of __classPrivateFieldGet(this, _EventStream_pendingListenerCleanup, "f")) {
+        const eventType = event;
+        const listeners = __classPrivateFieldGet(this, _EventStream_listeners, "f")[eventType];
+        if (listeners) {
+            __classPrivateFieldGet(this, _EventStream_listeners, "f")[eventType] = listeners.filter((listener) => !listener.removed);
+        }
+    }
+    __classPrivateFieldGet(this, _EventStream_pendingListenerCleanup, "f").clear();
 }, _EventStream_handleError = function _EventStream_handleError(error) {
     __classPrivateFieldSet(this, _EventStream_errored, true, "f");
     if (error instanceof Error && error.name === 'AbortError') {