openai 7.16.0 → 7.18.0

package/src/client.ts

@@ -739,6 +739,21 @@ export class OpenAI {
     return this._options.defaultQuery;
   }
 
+  /** @internal Client request headers for each new WebSocket handshake. */
+  _buildWebSocketHeaders(authHeaders: Record<string, string>): Record<string, string> {
+    return Object.fromEntries(
+      buildHeaders([
+        {
+          'User-Agent': this.getUserAgent(),
+          'OpenAI-Organization': this.organization,
+          'OpenAI-Project': this.project,
+        },
+        authHeaders,
+        this._options.defaultHeaders,
+      ]).values,
+    );
+  }
+
   protected validateHeaders(
     { values, nulls }: NullableHeaders,
     schemes: { bearerAuth?: boolean; adminAPIKeyAuth?: boolean } = {
@@ -856,6 +871,10 @@ export class OpenAI {
     return Errors.APIError.generate(status, normalizedError, message, headers);
   }
 
+  _hasApiKeyProvider(): boolean {
+    return typeof this._options.apiKey === 'function';
+  }
+
   /**
    * Resolves a function-based API key and retains the resolved value on this client.
    * Returns whether a provider was invoked. Internal callers can capture this
@@ -1108,6 +1127,8 @@ export class OpenAI {
           props.options,
           retriesRemaining,
           props.retryOfRequestLogID ?? props.requestLogID,
+          undefined,
+          props.requestSignal,
         );
         Object.assign(props, next);
       } finally {
@@ -1318,7 +1339,13 @@ export class OpenAI {
             message: x509Authentication ? 'X.509 workload identity API connection failed.' : response.message,
           }),
         );
-        return this.retryRequest(options, retriesRemaining, retryOfRequestLogID ?? requestLogID);
+        return this.retryRequest(
+          options,
+          retriesRemaining,
+          retryOfRequestLogID ?? requestLogID,
+          undefined,
+          req.signal,
+        );
       }
       const terminalMessage = hasStreamingBody
         ? 'error; streaming body cannot be retried'
@@ -1442,6 +1469,7 @@ export class OpenAI {
           retriesRemaining,
           retryOfRequestLogID ?? requestLogID,
           response.headers,
+          req.signal,
         );
       }
 
@@ -1497,7 +1525,15 @@ export class OpenAI {
       helperMethod: options.__metadata?.['helperMethod'],
       ...(continueRequest ? { continueRequest } : {}),
     });
-    return { response, options, controller, requestLogID, retryOfRequestLogID, startTime };
+    return {
+      response,
+      options,
+      controller,
+      requestSignal: req.signal,
+      requestLogID,
+      retryOfRequestLogID,
+      startTime,
+    };
   }
 
   getAPIList<Item, PageClass extends Pagination.AbstractPage<Item> = Pagination.AbstractPage<Item>>(
@@ -1638,6 +1674,7 @@ export class OpenAI {
     retriesRemaining: number,
     requestLogID: string,
     responseHeaders?: Headers | undefined,
+    requestSignal: AbortSignal | null | undefined = options.signal,
   ): Promise<APIResponseProps> {
     let timeoutMillis: number | undefined;
 
@@ -1685,7 +1722,17 @@ export class OpenAI {
     if (x509Authentication) {
       await x509Authentication.waitForRetry(timeoutMillis, x509Authentication.effectiveSignal());
     } else {
-      await sleep(timeoutMillis);
+      const retrySignals =
+        requestSignal === options.signal ? [requestSignal] : [requestSignal, options.signal];
+      try {
+        await sleep(timeoutMillis, ...retrySignals);
+      } catch (error) {
+        const abortedSignal = retrySignals.find((signal) => signal?.aborted);
+        if (abortedSignal) {
+          throw this._makeUserAbortError(abortedSignal);
+        }
+        throw error;
+      }
     }
 
     return this.makeRequest(options, retriesRemaining - 1, requestLogID);

package/src/core/EventEmitter.ts

@@ -54,12 +54,14 @@ export class EventEmitter<EventTypes extends Record<string, (...args: any) => an
       return this;
     }
 
+    // SAFETY: Listener functions are object identities used as WeakMap keys; registration and removal use the same function instance.
     const emittedRegistration = this.#emittedListenerRegistrations.get(listener as object);
     if (
       emittedRegistration?.event === event &&
       !emittedRegistration.registration.removed &&
       !emittedRegistration.registration.detached
     ) {
+      // SAFETY: The stored registration event was compared with this event above, preserving the event/listener type correlation.
       this.#removeEmittedListener(
         event,
         emittedRegistration.registration as EventListeners<EventTypes, Event>[number],
@@ -101,6 +103,7 @@ export class EventEmitter<EventTypes extends Record<string, (...args: any) => an
       registration?.listener === listener &&
       registration.once
     ) {
+      // SAFETY: Listener functions are object identities used as WeakMap keys; registration and removal use the same function instance.
       this.#emittedListenerRegistrations.set(listener as object, { event, registration });
     }
   }
@@ -114,6 +117,7 @@ export class EventEmitter<EventTypes extends Record<string, (...args: any) => an
     }
 
     registration.removed = true;
+    // SAFETY: Listener functions are object identities used as WeakMap keys; registration and removal use the same function instance.
     this.#emittedListenerRegistrations.delete(registration.listener as object);
     this.#pendingListenerCleanup.add(event);
     if (this.#listenerDispatchDepth === 0) {
@@ -123,9 +127,11 @@ export class EventEmitter<EventTypes extends Record<string, (...args: any) => an
 
   #cleanupEmittedListeners(): void {
     for (const event of this.#pendingListenerCleanup) {
+      // SAFETY: Pending cleanup keys are added only from registered EventTypes events; the key retains its event-map membership.
       const eventType = event as keyof EventTypes;
       const listeners = this.#listeners[eventType];
       if (listeners) {
+        // SAFETY: Filtering only removes registrations from the same event bucket and preserves the listener signatures for that event.
         this.#listeners[eventType] = listeners.filter((listener) => !listener.removed) as any;
       }
     }
@@ -150,21 +156,27 @@ export class EventEmitter<EventTypes extends Record<string, (...args: any) => an
   ): Promise<EmittedEventResult<EventParameters<EventTypes, Event>>> {
     return new Promise((resolve, reject) => {
       const listeners = {
+        // oxlint-disable-next-line anti-slop/no-unknown-parameters -- Failures and rejection reasons can be arbitrary JavaScript values; preserve them until inspection or forwarding.
         onError: (error: unknown) => {
+          // SAFETY: This callback is paired with the same event when registered and removed; its variadic body forwards the event tuple or captured error.
           this.off(event, listeners.onEvent as any);
           reject(error);
         },
         onEvent: (...values: unknown[]) => {
           if (event !== 'error') {
+            // SAFETY: This callback is paired with the same event when registered and removed; its variadic body forwards the event tuple or captured error.
             this.off('error', listeners.onError as any);
           }
+          // SAFETY: The emitted API returns the sole argument or the full tuple according to its existing EventTypes-dependent result contract.
           resolve((values.length > 1 ? values : values[0]) as any);
         },
       };
 
       if (event !== 'error') {
+        // SAFETY: This callback is paired with the same event when registered and removed; its variadic body forwards the event tuple or captured error.
         this.#onceForEmitted('error', listeners.onError as any);
       }
+      // SAFETY: This callback is paired with the same event when registered and removed; its variadic body forwards the event tuple or captured error.
       this.#onceForEmitted(event, listeners.onEvent as any);
     });
   }
@@ -176,6 +188,7 @@ export class EventEmitter<EventTypes extends Record<string, (...args: any) => an
   ) {
     const listeners: EventListeners<EventTypes, Event> | undefined = this.#listeners[event];
     if (listeners) {
+      // SAFETY: Filtering only removes registrations from the same event bucket and preserves the listener signatures for that event.
       this.#listeners[event] = listeners.filter((listener) => {
         if (listener.once) {
           listener.detached = true;
@@ -186,10 +199,12 @@ export class EventEmitter<EventTypes extends Record<string, (...args: any) => an
       let firstListenerError: unknown;
       this.#listenerDispatchDepth += 1;
       try {
+        // SAFETY: The listener bucket and argument tuple come from the same EventTypes key; this bridges TypeScript generic indexed-access correlation.
         for (const registration of listeners as any) {
           if (!registration.removed) {
             try {
               const { listener } = registration;
+              // SAFETY: The listener bucket and argument tuple come from the same EventTypes key; this bridges TypeScript generic indexed-access correlation.
               listener(...(args as any));
             } catch (error) {
               if (!listenerThrew) {

package/src/core/streaming.ts

@@ -139,7 +139,7 @@ export class Stream<Item> implements AsyncIterable<Item> {
             let data;
 
             try {
-              data = JSON.parse(sse.data) as any;
+              data = JSON.parse(sse.data);
             } catch {
               logger.error(`Could not parse message into JSON:`);
               logger.error(`From chunk:`);
@@ -164,6 +164,7 @@ export class Stream<Item> implements AsyncIterable<Item> {
               logger.error(`From chunk:`);
               throw new SyntaxError('Error reading response: malformed server-sent event JSON.');
             }
+            // SAFETY: Named SSE events use the public stream's event/data envelope; Item is the caller-selected API event contract.
             yield { event: sse.event, data } as any;
           }
         }
@@ -264,6 +265,7 @@ export class Stream<Item> implements AsyncIterable<Item> {
           if (line) {
             let data: Item;
             try {
+              // SAFETY: Item is the caller's NDJSON response contract; JSON syntax is parsed here without a per-resource runtime schema.
               data = JSON.parse(line) as Item;
             } catch (error) {
               if (error instanceof SyntaxError) {
@@ -352,10 +354,13 @@ export class Stream<Item> implements AsyncIterable<Item> {
    * which can be turned back into a Stream with `Stream.fromReadableStream()`.
    * Canceling a response-backed readable aborts its request. Canceling a tee
    * branch discards its buffered events and leaves sibling consumers running.
+   * Read or serialization failures also release the iterator without replacing the original error.
    */
   toReadableStream(): ReadableStream {
     const { controller } = this;
     let iter: AsyncIterator<Item>;
+    let cancellation: Promise<void> | undefined;
+    const cancel = () => (cancellation ??= this.#cancelIterator(iter, controller));
 
     return makeReadableStream({
       start: async () => {
@@ -373,9 +378,12 @@ export class Stream<Item> implements AsyncIterable<Item> {
           ctrl.enqueue(bytes);
         } catch (err) {
           ctrl.error(err);
+          // An errored readable never invokes its cancel hook. Release the source ourselves,
+          // without letting failed or stalled cleanup replace the read/serialization error.
+          void cancel().catch(() => undefined);
         }
       },
-      cancel: () => this.#cancelIterator(iter, controller),
+      cancel,
     });
   }
 
@@ -385,6 +393,7 @@ export class Stream<Item> implements AsyncIterable<Item> {
       if (!this.#isTeeBranch) {
         controller.abort();
       }
+      // oxlint-disable-next-line anti-slop/no-reflect-apply -- Invoke the captured iterator method with its receiver even if a caller-supplied function shadows call.
       await Reflect.apply(returnMethod, iterator, []);
     }
   }
@@ -524,6 +533,7 @@ export async function* _iterSSEMessages(
 ): AsyncGenerator<ServerSentEvent, void, unknown> {
   if (!response.body) {
     controller.abort();
+    // SAFETY: navigator is optional across SDK runtimes; this compatibility branch checks its presence before identifying React Native.
     if (
       (globalThis as any).navigator !== undefined &&
       (globalThis as any).navigator.product === 'ReactNative'
@@ -569,6 +579,15 @@ export async function* _iterSSEMessages(
         yield sse;
       }
     }
+    // Servers sometimes omit the trailing blank line that normally
+    // terminates the last event. Flush any in-progress event exactly once.
+    if (signal.aborted) {
+      return;
+    }
+    const pending = sseDecoder.flush();
+    if (pending) {
+      yield pending;
+    }
   } catch (error) {
     failed = true;
     if (!signal.aborted || (!isAbortError(error) && error !== signal.reason)) {
@@ -699,6 +718,15 @@ class SSEDecoder {
 
     return null;
   }
+
+  /**
+   * Emits a pending event at EOF when the stream omitted the trailing blank
+   * line. Returns `null` when no event is in progress so a record that already
+   * ended with a blank line is not delivered twice.
+   */
+  flush(): ServerSentEvent | null {
+    return this.decode('');
+  }
 }
 
 function partition(str: string, delimiter: string): [string, string, string] {

package/src/helpers/audio.ts

@@ -47,11 +47,13 @@ async function nodejsPlayAudio(stream: NodeJS.ReadableStream | Response | File):
     try {
       let source: NodeJS.ReadableStream;
       if (isResponse(stream)) {
+        // SAFETY: Fetch implementations may expose a web or Node response body; the following pipe check selects the matching stream adapter.
         const body = stream.body as NodeReadableStream | NodeJS.ReadableStream | null;
         if (!body) {
           throw new Error('Cannot play audio from a response without a body');
         }
 
+        // SAFETY: The preceding branch handled Node pipe streams; the remaining response body follows the web ReadableStream contract consumed by fromWeb.
         source =
           'pipe' in body && typeof body.pipe === 'function'
             ? body

package/src/helpers/standard-schema.ts

@@ -1,3 +1,4 @@
+import { isObj } from '../internal/utils/values';
 import { OpenAIError } from '../error';
 import type { AutoParseableResponseFormat, AutoParseableTextFormat, AutoParseableTool } from '../lib/parser';
 import {
@@ -138,6 +139,7 @@ type StandardTextFormatProps = Omit<
 /** Function callback invoked with arguments validated by a Standard Schema implementation. */
 type StandardToolFunction<Parameters extends StandardSchemaLike> = (
   args: InferStandardOutput<Parameters>,
+  // oxlint-disable-next-line anti-slop/no-unknown-returns -- Public tool callbacks may return arbitrary application values; preserve the published callback contract.
 ) => unknown | Promise<unknown>;
 
 /** Model-facing function-tool settings and optional Standard Schema validation callback. */
@@ -198,10 +200,11 @@ const JSON_SCHEMA_TYPES = new Set(['string', 'number', 'integer', 'boolean', 'ob
 type JSONPrimitive = string | number | boolean | null;
 
 function getSchemaTypes(schema: unknown): Set<string> | undefined {
-  if (!schema || typeof schema !== 'object' || Array.isArray(schema)) {
+  if (!isObj(schema)) {
     return undefined;
   }
 
+  // SAFETY: The preceding guard excludes null, primitives, and arrays; property values remain unknown until their individual schema checks.
   const type = (schema as Record<string, unknown>)['type'];
   if (type === undefined) {
     return getLiteralSchemaTypes(schema);
@@ -227,10 +230,11 @@ function isJSONPrimitive(value: unknown): value is JSONPrimitive {
 }
 
 function getLiteralValues(schema: unknown): JSONPrimitive[] | undefined {
-  if (!schema || typeof schema !== 'object' || Array.isArray(schema)) {
+  if (!isObj(schema)) {
     return undefined;
   }
 
+  // SAFETY: The preceding guard excludes null, primitives, and arrays; property values remain unknown until their individual schema checks.
   const record = schema as Record<string, unknown>;
   if ('const' in record && isJSONPrimitive(record['const'])) {
     return [record['const']];
@@ -286,19 +290,17 @@ function haveDisjointObjectDiscriminator(left: unknown, right: unknown, root: JS
     return false;
   }
 
+  // SAFETY: The preceding guard excludes null, primitives, and arrays; property values remain unknown until their individual schema checks.
   const leftRecord = left as Record<string, unknown>;
+  // SAFETY: The preceding guard excludes null, primitives, and arrays; property values remain unknown until their individual schema checks.
   const rightRecord = right as Record<string, unknown>;
   const leftProperties = leftRecord['properties'];
   const rightProperties = rightRecord['properties'];
   const leftRequired = leftRecord['required'];
   const rightRequired = rightRecord['required'];
   if (
-    !leftProperties ||
-    typeof leftProperties !== 'object' ||
-    Array.isArray(leftProperties) ||
-    !rightProperties ||
-    typeof rightProperties !== 'object' ||
-    Array.isArray(rightProperties) ||
+    !isObj(leftProperties) ||
+    !isObj(rightProperties) ||
     !Array.isArray(leftRequired) ||
     !Array.isArray(rightRequired)
   ) {
@@ -306,6 +308,7 @@ function haveDisjointObjectDiscriminator(left: unknown, right: unknown, root: JS
   }
 
   for (const property of leftRequired) {
+    // SAFETY: Both properties maps were checked as non-null non-array objects; the selected values remain untrusted inputs to reference resolution.
     if (
       typeof property === 'string' &&
       rightRequired.includes(property) &&
@@ -328,14 +331,13 @@ function getClosedObjectPropertySet(
     return undefined;
   }
 
+  // SAFETY: The preceding guard excludes null, primitives, and arrays; property values remain unknown until their individual schema checks.
   const record = schema as Record<string, unknown>;
   const properties = record['properties'];
   const required = record['required'];
   if (
     record['additionalProperties'] !== false ||
-    !properties ||
-    typeof properties !== 'object' ||
-    Array.isArray(properties) ||
+    !isObj(properties) ||
     !Array.isArray(required) ||
     required.some((property) => typeof property !== 'string')
   ) {
@@ -343,6 +345,7 @@ function getClosedObjectPropertySet(
   }
 
   const propertySet = new Set(Object.keys(properties));
+  // SAFETY: The preceding every check proved each required-property name is a string.
   const requiredProperties = required as string[];
   // A required undeclared property makes a closed branch unsatisfiable, but
   // the strictifier rejects that shape rather than representing it. Keep this
@@ -355,9 +358,9 @@ function getClosedObjectPropertySet(
 }
 
 function haveDisjointClosedObjectPropertySets(left: unknown, right: unknown): boolean {
-  const leftShape = getClosedObjectPropertySet(left);
-  const rightShape = getClosedObjectPropertySet(right);
-  if (!leftShape || !rightShape) {
+  const leftPropertySet = getClosedObjectPropertySet(left);
+  const rightPropertySet = getClosedObjectPropertySet(right);
+  if (!leftPropertySet || !rightPropertySet) {
     return false;
   }
 
@@ -366,8 +369,8 @@ function haveDisjointClosedObjectPropertySets(left: unknown, right: unknown): bo
   // an additional property. This proves oneOf exclusivity without widening
   // overlapping closed shapes.
   return (
-    leftShape.required.some((property) => !rightShape.properties.has(property)) ||
-    rightShape.required.some((property) => !leftShape.properties.has(property))
+    leftPropertySet.required.some((property) => !rightPropertySet.properties.has(property)) ||
+    rightPropertySet.required.some((property) => !leftPropertySet.properties.has(property))
   );
 }
 
@@ -395,17 +398,20 @@ function resolveLocalRefForExclusivity(
   schema: unknown,
   root: JSONSchema,
   seenRefs = new Set<string>(),
+  // oxlint-disable-next-line anti-slop/no-unknown-returns -- Resolving untrusted schema references may produce any value; callers perform the schema checks.
 ): unknown | undefined {
-  if (!schema || typeof schema !== 'object' || Array.isArray(schema)) {
+  if (!isObj(schema)) {
     return schema;
   }
 
+  // SAFETY: The preceding guard excludes null, primitives, and arrays; property values remain unknown until their individual schema checks.
   const record = schema as Record<string, unknown>;
   const ref = record['$ref'];
   if (ref !== undefined) {
     // Annotation keywords do not affect Draft 7 validation, so they are safe
     // to retain while proving the referenced branches are mutually exclusive.
     // Keep the proof conservative for every other sibling constraint.
+    // SAFETY: The helper only checks allowed sibling keys on this object; it does not assume that arbitrary property values form a valid schema.
     if (typeof ref !== 'string' || !hasOnlyRefAndAnnotations(record as JSONSchema)) {
       return undefined;
     }
@@ -425,6 +431,7 @@ function resolveLocalRefForExclusivity(
     if (!Array.isArray(record['allOf'])) {
       return undefined;
     }
+    // SAFETY: The allOf value was checked as an array; normalization performs the remaining branch-shape checks before proving exclusivity.
     const normalized = normalizeObjectAllOfForExclusivity(record as JSONSchema, root);
     if (normalized === undefined) {
       return undefined;
@@ -460,9 +467,10 @@ function normalizeStructuredOutputSchema(schema: JSONSchema): JSONSchema {
   const visitedSchemas = new Set<Record<string, unknown>>();
 
   const visitSchema = (value: unknown): void => {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    if (!isObj(value)) {
       return;
     }
+    // SAFETY: The preceding guard excludes null, primitives, and arrays; property values remain unknown until their individual schema checks.
     const record = value as Record<string, unknown>;
     if (visitedSchemas.has(record)) {
       return;
@@ -528,6 +536,7 @@ function parseStandardSchema<Schema extends StandardSchemaLike>(
 ): InferStandardOutput<Schema> {
   const parsed = parseResponseFormatContent({ type: 'json_schema', $parseRaw: undefined }, content);
   const { standard, validate } = getBinding();
+  // oxlint-disable-next-line anti-slop/no-reflect-apply -- A validator may shadow call; invoke the captured function with its original metadata receiver.
   const result = Reflect.apply(validate, standard, [parsed]);
 
   if (isPromiseLike(result)) {
@@ -541,6 +550,7 @@ function parseStandardSchema<Schema extends StandardSchemaLike>(
     throw new OpenAIError(`Standard Schema validation failed: ${formatStandardSchemaIssues(result.issues)}`);
   }
 
+  // SAFETY: The captured Standard Schema validator completed synchronously without issues, so its value follows that schema's inferred output contract.
   return result.value as InferStandardOutput<Schema>;
 }
 
@@ -548,6 +558,7 @@ function resolveStandardJSONSchema<Schema extends StandardSchemaLike>(
   getBinding: () => StandardSchemaBinding<Schema>,
   schemaOverride?: JSONSchema | Record<string, unknown> | undefined,
 ): Record<string, unknown> {
+  // SAFETY: The override or Standard Schema input converter supplies the schema; normalization and strict conversion below validate the supported structure.
   const schema = (schemaOverride ?? getBinding().standard.jsonSchema?.input({ target: 'draft-07' })) as
     | JSONSchema
     | undefined;
@@ -558,7 +569,8 @@ function resolveStandardJSONSchema<Schema extends StandardSchemaLike>(
     );
   }
 
-  return toStrictJsonSchema(normalizeStructuredOutputSchema(schema)) as unknown as Record<string, unknown>;
+  // SAFETY: Strict conversion returns an object schema here; the record view exposes its JSON keyword properties without narrowing their values.
+  return toStrictJsonSchema(normalizeStructuredOutputSchema(schema)) as Record<string, unknown>;
 }
 
 /**

package/src/helpers/zod-v3-strict-schema.ts

@@ -10,6 +10,7 @@ interface SchemaDefinition {
   typeName: string;
   checks?: readonly { kind: string; value?: unknown }[];
   coerce?: boolean;
+  // oxlint-disable-next-line anti-slop/no-shape-in-symbol-names -- Zod v3 defines this property name on object schemas.
   shape: () => Record<string, SchemaNode>;
   type: SchemaNode;
   innerType: SchemaNode;
@@ -32,6 +33,7 @@ interface SchemaChild {
   path: string;
 }
 
+// oxlint-disable-next-line anti-slop/no-known-value-widening -- Runtime Zod type names index this dictionary, including unsupported names outside the known entries.
 const simpleJSONDomains: Readonly<Record<string, JSONDomain['type']>> = {
   ZodString: 'string',
   ZodNumber: 'number',
@@ -109,6 +111,7 @@ function nativeEnumDomains(def: SchemaDefinition): JSONDomain[] {
   if (!definitionValues || Array.isArray(definitionValues)) {
     return [];
   }
+  // SAFETY: The preceding guard accepts a non-array object; its values remain unknown until individual definition checks.
   const object = definitionValues as Record<string, unknown>;
   const values = Object.keys(object)
     .filter((key) => {
@@ -429,12 +432,15 @@ export function assertSupportedZodV3Schema(
   definitions: Record<string, ZodV3Schema> | undefined,
 ): void {
   const visited = new Set<SchemaDefinition>();
-  visit(schema as unknown as SchemaNode, '$', visited);
+  // SAFETY: The public Zod v3 input is viewed through the validator's minimal schema-node contract; visit checks its definition and rejects unsupported kinds.
+  visit(schema as SchemaNode, '$', visited);
   for (const [name, definition] of Object.entries(definitions ?? {})) {
-    visit(definition as unknown as SchemaNode, `$.definitions.${name}`, visited);
+    // SAFETY: The public Zod v3 input is viewed through the validator's minimal schema-node contract; visit checks its definition and rejects unsupported kinds.
+    visit(definition as SchemaNode, `$.definitions.${name}`, visited);
   }
 }
 
+// oxlint-disable-next-line anti-slop/no-object-parameters -- Serialization validation must inspect any object, including arrays and foreign prototypes, without trusting fields.
 function assertNoJSONSerializationHook(value: object, path: string): void {
   for (let current: object | null = value; current !== null; current = Object.getPrototypeOf(current)) {
     const descriptor = Object.getOwnPropertyDescriptor(current, 'toJSON');