openai 7.4.0 → 7.6.0

package/lib/EventStream.mjs

@@ -1,18 +1,993 @@
-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;
+    return {
+        get length() {
+            return entries.length - head;
+        },
+        enqueue(value) {
+            entries.push(value);
+        },
+        dequeue() {
+            if (head === entries.length) {
+                return undefined;
+            }
+            const value = entries[head];
+            entries[head] = undefined;
+            head += 1;
+            if (head === entries.length) {
+                entries = [];
+                head = 0;
+            }
+            else if (head >= 1024 && head * 2 >= entries.length) {
+                entries = entries.slice(head);
+                head = 0;
+            }
+            return value;
+        },
+        clear() {
+            entries = [];
+            head = 0;
+        },
+    };
+}
+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. */
     constructor() {
         _EventStream_instances.add(this);
+        /** Controls the underlying request; aborting this controller cancels the stream. */
         this.controller = new AbortController();
         _EventStream_connectedPromise.set(this, void 0);
-        _EventStream_resolveConnectedPromise.set(this, () => { });
-        _EventStream_rejectConnectedPromise.set(this, () => { });
+        // oxlint-disable class-methods-use-this -- Deferred promise resolvers are intentionally per-instance mutable callbacks.
+        _EventStream_resolveConnectedPromise.set(this, () => undefined);
+        _EventStream_rejectConnectedPromise.set(this, () => undefined);
         _EventStream_endPromise.set(this, void 0);
-        _EventStream_resolveEndPromise.set(this, () => { });
-        _EventStream_rejectEndPromise.set(this, () => { });
-        _EventStream_listeners.set(this, {});
+        _EventStream_resolveEndPromise.set(this, () => undefined);
+        _EventStream_rejectEndPromise.set(this, () => undefined);
+        // 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);
@@ -29,16 +1004,24 @@ export class EventStream {
         // we will manually cause an unhandled rejection error later
         // if the user hasn't registered any error listener or called
         // any promise-returning method.
-        __classPrivateFieldGet(this, _EventStream_connectedPromise, "f").catch(() => { });
-        __classPrivateFieldGet(this, _EventStream_endPromise, "f").catch(() => { });
+        __classPrivateFieldGet(this, _EventStream_connectedPromise, "f").catch(() => undefined);
+        __classPrivateFieldGet(this, _EventStream_endPromise, "f").catch(() => undefined);
     }
     _run(executor) {
         // Unfortunately if we call `executor()` immediately we get runtime errors about
         // references to `this` before the `super()` constructor call returns.
         setTimeout(() => {
+            let failed = false;
             Promise.resolve()
                 .then(executor)
+                .catch((error) => {
+                failed = true;
+                __classPrivateFieldGet(this, _EventStream_instances, "m", _EventStream_handleError).call(this, error);
+            })
                 .then(() => {
+                if (failed) {
+                    return;
+                }
                 try {
                     this._emitFinal();
                 }
@@ -47,30 +1030,39 @@ export class EventStream {
                     return;
                 }
                 this._emit('end');
-            }, __classPrivateFieldGet(this, _EventStream_instances, "m", _EventStream_handleError).bind(this));
+            });
         }, 0);
     }
     _connected() {
-        if (this.ended)
+        if (this.ended) {
             return;
+        }
         __classPrivateFieldGet(this, _EventStream_resolveConnectedPromise, "f").call(this);
         this._emit('connect');
     }
+    /** Whether the stream has finished successfully, failed, or been aborted. */
     get ended() {
         return __classPrivateFieldGet(this, _EventStream_ended, "f");
     }
+    /** Whether an error or user cancellation has been observed. */
     get errored() {
         return __classPrivateFieldGet(this, _EventStream_errored, "f");
     }
+    /** Whether the stream ended because its request was cancelled. */
     get aborted() {
         return __classPrivateFieldGet(this, _EventStream_aborted, "f");
     }
+    /**
+     * Cancels the underlying request; {@link done} and {@link events} observe cancellation.
+     * Promises returned by {@link emitted} for other events may remain pending.
+     */
     abort() {
         this.controller.abort();
     }
     _listenForAbort(signal) {
-        if (!signal || this.ended)
+        if (!signal || this.ended) {
             return;
+        }
         if (signal.aborted) {
             this.controller.abort();
             return;
@@ -84,10 +1076,11 @@ export class EventStream {
      * No checks are made to see if the listener has already been added. Multiple calls passing
      * the same combination of event and listener will result in the listener being added, and
      * called, multiple times.
-     * @returns this ChatCompletionStream, so that calls can be chained
+     * @returns This stream, so that listener registration calls can be chained.
      */
     on(event, listener) {
-        const listeners = __classPrivateFieldGet(this, _EventStream_listeners, "f")[event] || (__classPrivateFieldGet(this, _EventStream_listeners, "f")[event] = []);
+        var _a;
+        const listeners = ((_a = __classPrivateFieldGet(this, _EventStream_listeners, "f"))[event] || (_a[event] = []));
         listeners.push({ listener });
         return this;
     }
@@ -96,33 +1089,45 @@ export class EventStream {
      * off() will remove, at most, one instance of a listener from the listener array. If any single
      * listener has been added multiple times to the listener array for the specified event, then
      * off() must be called multiple times to remove each instance.
-     * @returns this ChatCompletionStream, so that calls can be chained
+     * @returns This stream, so that listener registration calls can be chained.
      */
     off(event, listener) {
         const listeners = __classPrivateFieldGet(this, _EventStream_listeners, "f")[event];
-        if (!listeners)
+        if (!listeners) {
+            return this;
+        }
+        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.listener === listener);
-        if (index >= 0)
+        }
+        const index = listeners.findIndex((l) => !l.removed && l.listener === listener);
+        if (index !== -1) {
             listeners.splice(index, 1);
+        }
         return this;
     }
     /**
      * Adds a one-time listener function for the event. The next time the event is triggered,
      * this listener is removed and then invoked.
-     * @returns this ChatCompletionStream, so that calls can be chained
+     * @returns This stream, so that listener registration calls can be chained.
      */
     once(event, listener) {
-        const listeners = __classPrivateFieldGet(this, _EventStream_listeners, "f")[event] || (__classPrivateFieldGet(this, _EventStream_listeners, "f")[event] = []);
+        var _a;
+        const listeners = ((_a = __classPrivateFieldGet(this, _EventStream_listeners, "f"))[event] || (_a[event] = []));
         listeners.push({ listener, once: true });
         return this;
     }
     /**
      * This is similar to `.once()`, but returns a Promise that resolves the next time
      * the event is triggered, instead of calling a listener callback.
-     * @returns a Promise that resolves the next time given event is triggered,
-     * or rejects if an error is emitted.  (If you request the 'error' event,
-     * returns a promise that resolves with the error).
+     * Events without arguments resolve to `undefined`, single-argument events resolve
+     * to that argument, and events with multiple arguments resolve to an argument tuple.
+     *
+     * @returns A promise for the next event, or a rejection if an error occurs first.
+     * Requesting the `error` event resolves with the emitted error instead.
      *
      * Example:
      *
@@ -131,9 +1136,20 @@ export class EventStream {
     emitted(event) {
         return new Promise((resolve, reject) => {
             __classPrivateFieldSet(this, _EventStream_catchingPromiseCreated, true, "f");
-            if (event !== 'error')
-                this.once('error', reject);
-            this.once(event, resolve);
+            const onError = (error) => {
+                this.off(event, onEvent);
+                reject(error);
+            };
+            const onEvent = (...values) => {
+                if (event !== 'error') {
+                    this.off('error', onError);
+                }
+                resolve((values.length > 1 ? values : values[0]));
+            };
+            if (event !== 'error') {
+                __classPrivateFieldGet(this, _EventStream_instances, "m", _EventStream_onceForEmitted).call(this, 'error', onError);
+            }
+            __classPrivateFieldGet(this, _EventStream_instances, "m", _EventStream_onceForEmitted).call(this, event, onEvent);
         });
     }
     /**
@@ -149,46 +1165,147 @@ export class EventStream {
      *   }
      */
     events(event) {
-        const pushQueue = [];
-        const readQueue = [];
+        return this._createIterator((push) => {
+            const onEvent = (...args) => {
+                sdkOwnedBufferedEventArguments.add(args);
+                try {
+                    push(args);
+                }
+                finally {
+                    sdkOwnedBufferedEventArguments.delete(args);
+                }
+            };
+            this.on(event, onEvent);
+            return () => this.off(event, onEvent);
+        }, {
+            // When iterating the 'error' or 'abort' event itself, yield it as a
+            // value instead of rejecting the iterator.
+            rejectOnError: event !== 'error',
+            rejectOnAbort: event !== 'abort',
+        });
+    }
+    /**
+     * Shared buffered async-iterator adapter over this stream's events.
+     *
+     * `attach` registers the producer listener(s) with the given `push` and
+     * returns a cleanup function that removes them. Termination is handled
+     * 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;
+        let detach = () => undefined;
         const doneResult = () => ({ value: undefined, done: true });
         const finishReaders = () => {
             while (readQueue.length) {
-                readQueue.shift().resolve(doneResult());
+                readQueue.dequeue().resolve(doneResult());
             }
         };
         const rejectReader = () => {
-            if (!failure || failureDelivered || !readQueue.length)
+            if (!failure || failureDelivered || !readQueue.length) {
                 return;
+            }
             failureDelivered = true;
-            readQueue.shift().reject(failure);
+            readQueue.dequeue().reject(failure);
         };
         const cleanup = () => {
-            this.off(event, onEvent);
+            detach();
             this.off('end', onEnd);
-            if (event !== 'error')
+            if (rejectOnError) {
                 this.off('error', onFailure);
-            if (event !== 'abort')
+            }
+            if (rejectOnAbort) {
                 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 onEvent = (...args) => {
-            if (ended)
+        const revalidateBufferedEvent = (value, entry) => {
+            if (!entry.active || __classPrivateFieldGet(this, _EventStream_ended, "f")) {
                 return;
-            const reader = readQueue.shift();
+            }
+            const graph = inspectBufferedEventGraph(value, MAX_BUFFERED_ITERATOR_BYTES);
+            if (!graph || !bufferedLedger.refresh(entry.retention, graph)) {
+                failBufferedEvents(true);
+            }
+        };
+        const push = (value) => {
+            if (ended) {
+                return;
+            }
+            const reader = readQueue.dequeue();
             if (reader) {
-                reader.resolve({ value: args, done: false });
+                reader.resolve({ value, done: false });
             }
             else {
-                pushQueue.push(args);
+                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) => {
             failure = error;
-            if (!pushQueue.length)
+            if (!pushQueue.length) {
                 rejectReader();
+            }
         };
         const onEnd = () => {
             ended = true;
@@ -199,33 +1316,58 @@ export class EventStream {
             }
         };
         if (!ended) {
-            this.on(event, onEvent);
+            detach = attach(push);
             this.on('end', onEnd);
-            if (event !== 'error')
+            if (rejectOnError) {
                 this.on('error', onFailure);
-            if (event !== 'abort')
+            }
+            if (rejectOnAbort) {
                 this.on('abort', onFailure);
+            }
         }
         return {
             next: () => {
-                const value = pushQueue.shift();
-                if (value)
+                if (pushQueue.length) {
+                    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;
                     return Promise.reject(failure);
                 }
-                if (ended)
+                if (ended) {
                     return Promise.resolve(doneResult());
+                }
                 return new Promise((resolve, reject) => {
-                    readQueue.push({ resolve, reject });
+                    readQueue.enqueue({ resolve, reject });
                 });
             },
             return: () => {
                 ended = true;
-                pushQueue.length = 0;
+                while (bufferedEventSizes.length) {
+                    deactivateBufferedEvent(bufferedEventSizes.dequeue());
+                }
+                pushQueue.clear();
+                bufferedLedger.clear();
                 cleanup();
                 finishReaders();
+                if (onReturn) {
+                    // The consumer explicitly ended iteration, so any failure the
+                    // onReturn callback triggers (e.g. aborting the stream) is
+                    // self-inflicted; mark the stream's terminal promise as handled so
+                    // it does not surface as an unhandled rejection.
+                    void this.done().catch(() => undefined);
+                    onReturn();
+                }
                 return Promise.resolve(doneResult());
             },
             [Symbol.asyncIterator]() {
@@ -233,10 +1375,16 @@ export class EventStream {
             },
         };
     }
+    /** Resolves when the stream ends successfully or rejects when it fails or is aborted. */
     async done() {
         __classPrivateFieldSet(this, _EventStream_catchingPromiseCreated, true, "f");
         await __classPrivateFieldGet(this, _EventStream_endPromise, "f");
     }
+    /** Returns whether an event currently has one or more registered listeners. */
+    _hasListeners(event) {
+        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) {
         // make sure we don't emit any events after end
         if (__classPrivateFieldGet(this, _EventStream_ended, "f")) {
@@ -249,8 +1397,32 @@ export class EventStream {
         }
         const listeners = __classPrivateFieldGet(this, _EventStream_listeners, "f")[event];
         if (listeners) {
-            __classPrivateFieldGet(this, _EventStream_listeners, "f")[event] = listeners.filter((l) => !l.once);
-            listeners.forEach(({ listener }) => 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') {
             const error = args[0];
@@ -279,12 +1451,46 @@ export class EventStream {
             this._emit('end');
         }
     }
-    _emitFinal() { }
+    // oxlint-disable-next-line class-methods-use-this -- Subclasses override this instance hook.
+    _emitFinal() {
+        // 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') {