refactor(core): replace class #private with WeakMap to avoid brand-check crashes

- Replace JS private fields with module-scoped WeakMaps on hot paths:
  - core/api-promise.ts (APIPromise ↔ client)
  - core/pagination.ts (AbstractPage ↔ client)
  - core/streaming.ts (Stream ↔ client; tee preserves client)
  - client.ts (replace #encoder with private field; private baseURLOverridden)
- Add minimal inline rationale comments; no issue links in code.
- Remove temporary repros under tests/temp/.
- No public API changes.

Author: SkinnnyJay

src/client.ts

@@ -329,7 +329,9 @@ export class OpenAI {
   fetchOptions: MergedRequestInit | undefined;
 
   private fetch: Fetch;
-  #encoder: Opts.RequestEncoder;
+  // Use a normal private field instead of JS #private to avoid
+  // brand-check crashes when methods are invoked across copies.
+  private encoder: Opts.RequestEncoder;
   protected idempotencyHeader?: string;
   protected _options: ClientOptions;
 
@@ -391,7 +393,7 @@ export class OpenAI {
     this.fetchOptions = options.fetchOptions;
     this.maxRetries = options.maxRetries ?? 2;
     this.fetch = options.fetch ?? Shims.getDefaultFetch();
-    this.#encoder = Opts.FallbackEncoder;
+    this.encoder = Opts.FallbackEncoder;
 
     this._options = options;
 
@@ -426,7 +428,7 @@ export class OpenAI {
   /**
    * Check whether the base URL is set to its default.
    */
-  #baseURLOverridden(): boolean {
+  private baseURLOverridden(): boolean {
     return this.baseURL !== 'https://api.openai.com/v1';
   }
 
@@ -493,7 +495,7 @@ export class OpenAI {
     query: Record<string, unknown> | null | undefined,
     defaultBaseURL?: string | undefined,
   ): string {
-    const baseURL = (!this.#baseURLOverridden() && defaultBaseURL) || this.baseURL;
+    const baseURL = (!this.baseURLOverridden() && defaultBaseURL) || this.baseURL;
     const url =
       isAbsoluteURL(path) ?
         new URL(path)
@@ -959,7 +961,7 @@ export class OpenAI {
     ) {
       return { bodyHeaders: undefined, body: Shims.ReadableStreamFrom(body as AsyncIterable<Uint8Array>) };
     } else {
-      return this.#encoder({ body, headers });
+      return this.encoder({ body, headers });
     }
   }
 

src/core/api-promise.ts

@@ -1,6 +1,7 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 import { type OpenAI } from '../client';
+import { OpenAIError } from './error';
 
 import { type PromiseOrValue } from '../internal/types';
 import {
@@ -14,9 +15,12 @@ import {
  * A subclass of `Promise` providing additional helper methods
  * for interacting with the SDK.
  */
+// Associate instance with client via a module WeakMap to avoid
+// JS private-field brand checks across bundles/copies.
+const apiPromiseClient = /* @__PURE__ */ new WeakMap<object, OpenAI>();
+
 export class APIPromise<T> extends Promise<WithRequestID<T>> {
   private parsedPromise: Promise<WithRequestID<T>> | undefined;
-  #client: OpenAI;
 
   constructor(
     client: OpenAI,
@@ -32,11 +36,13 @@ export class APIPromise<T> extends Promise<WithRequestID<T>> {
       // to parse the response
       resolve(null as any);
     });
-    this.#client = client;
+    apiPromiseClient.set(this, client);
   }
 
   _thenUnwrap<U>(transform: (data: T, props: APIResponseProps) => U): APIPromise<U> {
-    return new APIPromise(this.#client, this.responsePromise, async (client, props) =>
+    const client = apiPromiseClient.get(this);
+    if (!client) throw new OpenAIError('Illegal invocation of APIPromise method');
+    return new APIPromise(client, this.responsePromise, async (client, props) =>
       addRequestID(transform(await this.parseResponse(client, props), props), props.response),
     );
   }
@@ -75,8 +81,10 @@ export class APIPromise<T> extends Promise<WithRequestID<T>> {
 
   private parse(): Promise<WithRequestID<T>> {
     if (!this.parsedPromise) {
+      const client = apiPromiseClient.get(this);
+      if (!client) throw new OpenAIError('Illegal invocation of APIPromise method');
       this.parsedPromise = this.responsePromise.then((data) =>
-        this.parseResponse(this.#client, data),
+        this.parseResponse(client, data),
       ) as any as Promise<WithRequestID<T>>;
     }
     return this.parsedPromise;

src/core/pagination.ts

@@ -10,15 +10,18 @@ import { maybeObj } from '../internal/utils/values';
 
 export type PageRequestOptions = Pick<FinalRequestOptions, 'query' | 'headers' | 'body' | 'path' | 'method'>;
 
+// Associate pages with their client via a module WeakMap to avoid
+// JS private-field brand checks across bundles/copies.
+const pageClient = /* @__PURE__ */ new WeakMap<object, OpenAI>();
+
 export abstract class AbstractPage<Item> implements AsyncIterable<Item> {
-  #client: OpenAI;
   protected options: FinalRequestOptions;
 
   protected response: Response;
   protected body: unknown;
 
   constructor(client: OpenAI, response: Response, body: unknown, options: FinalRequestOptions) {
-    this.#client = client;
+    pageClient.set(this, client);
     this.options = options;
     this.response = response;
     this.body = body;
@@ -42,7 +45,9 @@ export abstract class AbstractPage<Item> implements AsyncIterable<Item> {
       );
     }
 
-    return await this.#client.requestAPIList(this.constructor as any, nextOptions);
+    const client = pageClient.get(this);
+    if (!client) throw new OpenAIError('Illegal invocation of Page method');
+    return await client.requestAPIList(this.constructor as any, nextOptions);
   }
 
   async *iterPages(): AsyncGenerator<this> {

src/core/streaming.ts

@@ -18,17 +18,20 @@ export type ServerSentEvent = {
   raw: string[];
 };
 
+// Associate Stream instances with their client via a module WeakMap to avoid
+// JS private-field brand checks across bundles/copies.
+const streamClient = /* @__PURE__ */ new WeakMap<object, OpenAI | undefined>();
+
 export class Stream<Item> implements AsyncIterable<Item> {
   controller: AbortController;
-  #client: OpenAI | undefined;
 
   constructor(
     private iterator: () => AsyncIterator<Item>,
     controller: AbortController,
     client?: OpenAI,
   ) {
     this.controller = controller;
-    this.#client = client;
+    streamClient.set(this, client);
   }
 
   static fromSSEResponse<Item>(
@@ -75,8 +78,8 @@ export class Stream<Item> implements AsyncIterable<Item> {
             try {
               data = JSON.parse(sse.data);
             } catch (e) {
-              console.error(`Could not parse message into JSON:`, sse.data);
-              console.error(`From chunk:`, sse.raw);
+              logger.error(`Could not parse message into JSON:`, sse.data);
+              logger.error(`From chunk:`, sse.raw);
               throw e;
             }
             // TODO: Is this where the error should be thrown?
@@ -177,9 +180,10 @@ export class Stream<Item> implements AsyncIterable<Item> {
       };
     };
 
+    const client = streamClient.get(this);
     return [
-      new Stream(() => teeIterator(left), this.controller, this.#client),
-      new Stream(() => teeIterator(right), this.controller, this.#client),
+      new Stream(() => teeIterator(left), this.controller, client),
+      new Stream(() => teeIterator(right), this.controller, client),
     ];
   }