tywrap 0.5.1 → 0.6.1

package/src/runtime/{safe-codec.ts → bridge-codec.ts}

@@ -1,5 +1,5 @@
 /**
- * SafeCodec - Unified validation and serialization for JS<->Python boundary crossing.
+ * BridgeCodec - Unified validation and serialization for JS<->Python boundary crossing.
  *
  * Provides safe encoding/decoding with configurable guardrails for:
  * - Special float rejection (NaN, Infinity)
@@ -18,7 +18,7 @@ import { PROTOCOL_ID } from './transport.js';
 // ═══════════════════════════════════════════════════════════════════════════
 
 /**
- * Configuration options for SafeCodec behavior.
+ * Configuration options for BridgeCodec behavior.
  */
 export interface CodecOptions {
   /** Reject NaN/Infinity in arguments. Default: true */
@@ -48,7 +48,7 @@ interface NormalizedPythonError {
   traceback?: string;
 }
 
-interface ProtocolEnvelope {
+interface RpcResponse {
   id: number;
   protocol?: string;
   result?: unknown;
@@ -167,10 +167,10 @@ function isPythonErrorResponse(value: unknown): value is PythonErrorResponse {
 }
 
 /**
- * Type guard for protocol response envelope.
- * Envelopes must include a numeric id.
+ * Type guard for the RPC response wrapper ({ id, result | error }).
+ * Responses must include a numeric id.
  */
-function isProtocolEnvelope(value: unknown): value is ProtocolEnvelope {
+function isRpcResponse(value: unknown): value is RpcResponse {
   if (value === null || typeof value !== 'object') {
     return false;
   }
@@ -233,7 +233,7 @@ function summarizePayloadForError(payload: string): string {
 
 /**
  * Validate the protocol version in a response.
- * Only validates when the response looks like a protocol envelope (has 'id' field).
+ * Only validates when the response looks like an RPC response (has 'id' field).
  * Throws if protocol is present but doesn't match expected version.
  * Allows missing protocol for backwards compatibility.
  */
@@ -242,7 +242,7 @@ function validateProtocolVersion(value: unknown): void {
     return;
   }
   const obj = value as Record<string, unknown>;
-  // Only validate protocol on protocol envelopes (responses with 'id' field)
+  // Only validate protocol on RPC responses (responses with 'id' field)
   // This avoids false positives on user data that happens to contain 'protocol' key
   if (!('id' in obj)) {
     return;
@@ -293,16 +293,16 @@ function findSpecialFloatPath(
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
-// SAFE CODEC CLASS
+// BRIDGE CODEC CLASS
 // ═══════════════════════════════════════════════════════════════════════════
 
 /**
- * SafeCodec provides unified validation and serialization for JS<->Python
+ * BridgeCodec provides unified validation and serialization for JS<->Python
  * boundary crossing with configurable guardrails.
  *
  * @example
  * ```typescript
- * const codec = new SafeCodec({ rejectSpecialFloats: true });
+ * const codec = new BridgeCodec({ rejectSpecialFloats: true });
  *
  * // Encoding a request
  * const payload = codec.encodeRequest({ data: [1, 2, 3] });
@@ -314,7 +314,7 @@ function findSpecialFloatPath(
  * const dataframe = await codec.decodeResponseAsync<ArrowTable>(arrowPayload);
  * ```
  */
-export class SafeCodec {
+export class BridgeCodec {
   private readonly rejectSpecialFloats: boolean;
   private readonly rejectNonStringKeys: boolean;
   private readonly maxPayloadBytes: number;
@@ -332,7 +332,7 @@ export class SafeCodec {
   }
 
   private assertValidBase64(b64: string): void {
-    if (!SafeCodec.base64Pattern.test(b64)) {
+    if (!BridgeCodec.base64Pattern.test(b64)) {
       throw new BridgeCodecError('Invalid base64 in bytes envelope', {
         codecPhase: 'decode',
         valueType: 'bytes',
@@ -368,8 +368,8 @@ export class SafeCodec {
    * JSON.parse reviver that decodes bytes envelopes.
    *
    * Supported shapes:
-   * - { "__tywrap_bytes__": true, "b64": "..." } (JS SafeCodec.encodeRequest; also allowed in responses)
-   * - { "__type__": "bytes", "encoding": "base64", "data": "..." } (Python SafeCodec default encoder)
+   * - { "__tywrap_bytes__": true, "b64": "..." } (JS BridgeCodec.encodeRequest; also allowed in responses)
+   * - { "__type__": "bytes", "encoding": "base64", "data": "..." } (Python BridgeCodec default encoder)
    */
   private reviveValue(_key: string, value: unknown): unknown {
     if (value === null || typeof value !== 'object' || Array.isArray(value)) {
@@ -410,20 +410,74 @@ export class SafeCodec {
     return bridgeError;
   }
 
-  private extractResultFromResponseEnvelope(parsed: unknown): unknown {
-    if (isProtocolEnvelope(parsed)) {
-      const envelope = parsed;
-      const hasResult = hasOwnKey(envelope, 'result');
-      const hasError = hasOwnKey(envelope, 'error');
+  /**
+   * Shared prelude for both decode paths: size guard, JSON parse (with bytes
+   * revival), protocol-version validation, and RPC-envelope unwrapping.
+   *
+   * Behavior-preserving extraction of the common head of decodeResponse and
+   * decodeResponseAsync; the only divergence between the two is what they do
+   * with the returned result (sync returns it as-is, async applies Arrow
+   * decoding) and so that divergence stays in the callers.
+   */
+  private parseResponseResult(payload: string): unknown {
+    // Check payload size first
+    const payloadBytes = new TextEncoder().encode(payload).length;
+    if (payloadBytes > this.maxPayloadBytes) {
+      throw new BridgeCodecError(
+        `Response payload size ${payloadBytes} bytes exceeds maximum ${this.maxPayloadBytes} bytes`,
+        { codecPhase: 'decode', valueType: 'payload' }
+      );
+    }
+
+    // Parse JSON
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(payload, this.reviveValueBound);
+    } catch (err) {
+      if (err instanceof BridgeCodecError || err instanceof BridgeProtocolError) {
+        throw err;
+      }
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      throw new BridgeCodecError(
+        `JSON parse failed: ${errorMessage}. Payload snippet: ${summarizePayloadForError(payload)}`,
+        { codecPhase: 'decode', valueType: 'json' }
+      );
+    }
+
+    // Validate protocol version (if present)
+    validateProtocolVersion(parsed);
+
+    return this.extractResultFromRpcResponse(parsed);
+  }
+
+  /**
+   * Post-decode guard: reject non-finite numbers (NaN/Infinity) when enabled.
+   * Shared by both decode paths.
+   */
+  private assertNoSpecialFloats(value: unknown): void {
+    if (this.rejectSpecialFloats && containsSpecialFloat(value)) {
+      const floatPath = findSpecialFloatPath(value);
+      throw new BridgeCodecError(
+        `Response contains non-finite number (NaN or Infinity) at ${floatPath}`,
+        { codecPhase: 'decode', valueType: 'number' }
+      );
+    }
+  }
+
+  private extractResultFromRpcResponse(parsed: unknown): unknown {
+    if (isRpcResponse(parsed)) {
+      const response = parsed;
+      const hasResult = hasOwnKey(response, 'result');
+      const hasError = hasOwnKey(response, 'error');
 
       if (hasResult && hasError) {
         throw new BridgeProtocolError('Protocol response cannot include both "result" and "error"');
       }
 
       if (hasError) {
-        const normalizedError = normalizeErrorPayload(envelope.error);
+        const normalizedError = normalizeErrorPayload(response.error);
         if (!normalizedError) {
-          const details = describeInvalidErrorPayload(envelope.error);
+          const details = describeInvalidErrorPayload(response.error);
           throw new BridgeProtocolError(`Invalid response "error" payload: ${details}`);
         }
         throw this.toBridgeExecutionError(normalizedError);
@@ -433,7 +487,7 @@ export class SafeCodec {
         throw new BridgeProtocolError('Protocol response missing "result" or "error" field');
       }
 
-      return envelope.result;
+      return response.result;
     }
 
     if (isPythonErrorResponse(parsed)) {
@@ -522,47 +576,14 @@ export class SafeCodec {
    * @param payload - The JSON string received from Python
    * @returns Decoded and validated result
    * @throws BridgeCodecError if payload is invalid or decoding fails
-   * @throws BridgeProtocolError if protocol envelope is invalid
+   * @throws BridgeProtocolError if the RPC response is invalid
    * @throws BridgeExecutionError if response contains a Python error
    */
   decodeResponse<T>(payload: string): T {
-    // Check payload size first
-    const payloadBytes = new TextEncoder().encode(payload).length;
-    if (payloadBytes > this.maxPayloadBytes) {
-      throw new BridgeCodecError(
-        `Response payload size ${payloadBytes} bytes exceeds maximum ${this.maxPayloadBytes} bytes`,
-        { codecPhase: 'decode', valueType: 'payload' }
-      );
-    }
-
-    // Parse JSON
-    let parsed: unknown;
-    try {
-      parsed = JSON.parse(payload, this.reviveValueBound);
-    } catch (err) {
-      if (err instanceof BridgeCodecError || err instanceof BridgeProtocolError) {
-        throw err;
-      }
-      const errorMessage = err instanceof Error ? err.message : String(err);
-      throw new BridgeCodecError(
-        `JSON parse failed: ${errorMessage}. Payload snippet: ${summarizePayloadForError(payload)}`,
-        { codecPhase: 'decode', valueType: 'json' }
-      );
-    }
-
-    // Validate protocol version (if present)
-    validateProtocolVersion(parsed);
-
-    const result = this.extractResultFromResponseEnvelope(parsed);
+    const result = this.parseResponseResult(payload);
 
     // Post-decode validation for special floats if enabled
-    if (this.rejectSpecialFloats && containsSpecialFloat(result)) {
-      const floatPath = findSpecialFloatPath(result);
-      throw new BridgeCodecError(
-        `Response contains non-finite number (NaN or Infinity) at ${floatPath}`,
-        { codecPhase: 'decode', valueType: 'number' }
-      );
-    }
+    this.assertNoSpecialFloats(result);
 
     return result as T;
   }
@@ -574,38 +595,11 @@ export class SafeCodec {
    * @param payload - The JSON string received from Python
    * @returns Decoded and validated result with Arrow decoding applied
    * @throws BridgeCodecError if payload is invalid or decoding fails
-   * @throws BridgeProtocolError if protocol envelope is invalid
+   * @throws BridgeProtocolError if the RPC response is invalid
    * @throws BridgeExecutionError if response contains a Python error
    */
   async decodeResponseAsync<T>(payload: string): Promise<T> {
-    // Check payload size first
-    const payloadBytes = new TextEncoder().encode(payload).length;
-    if (payloadBytes > this.maxPayloadBytes) {
-      throw new BridgeCodecError(
-        `Response payload size ${payloadBytes} bytes exceeds maximum ${this.maxPayloadBytes} bytes`,
-        { codecPhase: 'decode', valueType: 'payload' }
-      );
-    }
-
-    // Parse JSON
-    let parsed: unknown;
-    try {
-      parsed = JSON.parse(payload, this.reviveValueBound);
-    } catch (err) {
-      if (err instanceof BridgeCodecError || err instanceof BridgeProtocolError) {
-        throw err;
-      }
-      const errorMessage = err instanceof Error ? err.message : String(err);
-      throw new BridgeCodecError(
-        `JSON parse failed: ${errorMessage}. Payload snippet: ${summarizePayloadForError(payload)}`,
-        { codecPhase: 'decode', valueType: 'json' }
-      );
-    }
-
-    // Validate protocol version (if present)
-    validateProtocolVersion(parsed);
-
-    const result = this.extractResultFromResponseEnvelope(parsed);
+    const result = this.parseResponseResult(payload);
 
     // Apply Arrow decoding to the result
     let decoded: unknown;
@@ -621,13 +615,7 @@ export class SafeCodec {
 
     // Post-decode validation for special floats if enabled
     // Note: Arrow decoders can introduce NaN/Infinity from binary representations.
-    if (this.rejectSpecialFloats && containsSpecialFloat(decoded)) {
-      const floatPath = findSpecialFloatPath(decoded);
-      throw new BridgeCodecError(
-        `Response contains non-finite number (NaN or Infinity) at ${floatPath}`,
-        { codecPhase: 'decode', valueType: 'number' }
-      );
-    }
+    this.assertNoSpecialFloats(decoded);
 
     return decoded as T;
   }

package/src/runtime/{http-io.ts → http-transport.ts}

@@ -20,9 +20,9 @@ import type { Transport } from './transport.js';
 // =============================================================================
 
 /**
- * Configuration options for HttpIO transport.
+ * Configuration options for the HttpTransport.
  */
-export interface HttpIOOptions {
+export interface HttpTransportOptions {
   /** Base URL for the Python server (e.g., 'http://localhost:8000') */
   baseURL: string;
 
@@ -52,7 +52,7 @@ export interface HttpIOOptions {
  *
  * @example
  * ```typescript
- * const transport = new HttpIO({ baseURL: 'http://localhost:8000' });
+ * const transport = new HttpTransport({ baseURL: 'http://localhost:8000' });
  * await transport.init(); // No-op but follows Transport contract
  *
  * const response = await transport.send(
@@ -63,13 +63,13 @@ export interface HttpIOOptions {
  * await transport.dispose(); // Marks as disposed
  * ```
  */
-export class HttpIO implements Transport {
+export class HttpTransport implements Transport {
   private readonly baseURL: string;
   private readonly headers: Record<string, string>;
   private readonly defaultTimeoutMs: number;
   private _isDisposed = false;
 
-  constructor(options: HttpIOOptions) {
+  constructor(options: HttpTransportOptions) {
     // Normalize URL - remove trailing slash
     this.baseURL = options.baseURL.replace(/\/$/, '');
     this.headers = {

package/src/runtime/http.ts

@@ -2,7 +2,7 @@
  * HTTP runtime bridge.
  *
  * HttpBridge is a thin facade: it extends DisposableBase (lifecycle/resources)
- * and implements PythonRuntime by HOLDING an RpcClient over an HttpIO transport
+ * and implements PythonRuntime by HOLDING an RpcClient over an HttpTransport
  * for stateless HTTP POST-based communication with a Python server.
  *
  * @see https://github.com/bbopen/tywrap/issues/149
@@ -13,8 +13,8 @@ import { autoRegisterArrowDecoder } from '../utils/codec.js';
 
 import { DisposableBase } from './bounded-context.js';
 import { RpcClient, type GetBridgeInfoOptions } from './rpc-client.js';
-import { HttpIO } from './http-io.js';
-import type { CodecOptions } from './safe-codec.js';
+import { HttpTransport } from './http-transport.js';
+import type { CodecOptions } from './bridge-codec.js';
 
 // =============================================================================
 // OPTIONS
@@ -51,7 +51,7 @@ export interface HttpBridgeOptions {
  * Features:
  * - Stateless HTTP POST communication
  * - Timeout handling via AbortController
- * - Full SafeCodec validation (NaN/Infinity rejection, key validation)
+ * - Full BridgeCodec validation (NaN/Infinity rejection, key validation)
  * - Automatic Arrow decoding for DataFrames/ndarrays
  *
  * @example
@@ -76,7 +76,7 @@ export class HttpBridge extends DisposableBase implements PythonRuntime {
   constructor(options: HttpBridgeOptions) {
     super();
 
-    const transport = new HttpIO({
+    const transport = new HttpTransport({
       baseURL: options.baseURL,
       headers: options.headers,
       defaultTimeoutMs: options.timeoutMs,

package/src/runtime/index.ts

@@ -1,9 +1,31 @@
 /**
- * Runtime bridge registry for generated wrappers.
+ * tywrap/runtime entrypoint.
+ *
+ * Exposes the runtime bridge registry used by generated wrappers, plus the
+ * lower-level boundary primitives (codec + transport contract) for consumers
+ * building custom bridges. These were previously re-exported from the package
+ * root; they now live here so the root surface stays small.
  */
 
 import type { RuntimeExecution } from '../types/index.js';
 
+// BridgeCodec — validation and serialization for the JS<->Python boundary
+export { BridgeCodec, type CodecOptions } from './bridge-codec.js';
+
+// Transport contract — abstract I/O channel interface and guards
+export type {
+  Transport,
+  TransportOptions,
+  ProtocolMessage,
+  ProtocolResponse,
+} from './transport.js';
+export {
+  PROTOCOL_ID,
+  isTransport,
+  isProtocolMessage,
+  isProtocolResponse,
+} from './transport.js';
+
 let runtimeBridge: RuntimeExecution | null = null;
 
 export function setRuntimeBridge(bridge: RuntimeExecution): void {

package/src/runtime/node.ts

@@ -2,7 +2,7 @@
  * Node.js runtime bridge.
  *
  * NodeBridge is a thin facade: it extends DisposableBase (lifecycle/resources)
- * and implements PythonRuntime by HOLDING an RpcClient. It uses ProcessIO
+ * and implements PythonRuntime by HOLDING an RpcClient. It uses SubprocessTransport
  * transports with optional pooling for concurrent Python execution.
  *
  * @see https://github.com/bbopen/tywrap/issues/149
@@ -22,10 +22,10 @@ import { globalCache } from '../utils/cache.js';
 import { DisposableBase } from './bounded-context.js';
 import { RpcClient, type GetBridgeInfoOptions } from './rpc-client.js';
 import { BridgeCodecError, BridgeExecutionError, BridgeProtocolError } from './errors.js';
-import { ProcessIO } from './process-io.js';
+import { SubprocessTransport } from './subprocess-transport.js';
 import { PooledTransport } from './pooled-transport.js';
-import type { CodecOptions } from './safe-codec.js';
-import type { PooledWorker } from './worker-pool.js';
+import type { CodecOptions } from './bridge-codec.js';
+import type { TransportLease } from './transport-pool.js';
 
 // =============================================================================
 // OPTIONS
@@ -84,12 +84,12 @@ export interface NodeBridgeOptions {
   // ===========================================================================
 
   /**
-   * @deprecated No longer used. Pool idle time is managed by WorkerPool.
+   * @deprecated No longer used. Pool idle time is managed by TransportPool.
    */
   maxIdleTime?: number;
 
   /**
-   * @deprecated No longer used. Process restart is managed by ProcessIO.
+   * @deprecated No longer used. Process restart is managed by SubprocessTransport.
    */
   maxRequestsPerProcess?: number;
 
@@ -99,7 +99,7 @@ export interface NodeBridgeOptions {
   enableJsonFallback?: boolean;
 
   /**
-   * @deprecated Use ProcessIO options instead.
+   * @deprecated Use SubprocessTransport options instead.
    */
   maxLineLength?: number;
 }
@@ -277,7 +277,7 @@ function normalizeWarmupCommands(commands: NodeBridgeOptions['warmupCommands']):
  * Features:
  * - Single or multi-process execution via process pooling
  * - Virtual environment support
- * - Full SafeCodec validation (NaN/Infinity rejection, key validation)
+ * - Full BridgeCodec validation (NaN/Infinity rejection, key validation)
  * - Automatic Arrow decoding for DataFrames/ndarrays
  * - Optional result caching for pure functions
  * - Process warmup commands
@@ -343,7 +343,7 @@ export class NodeBridge extends DisposableBase implements PythonRuntime {
       codec: options.codec,
       warmupCommands,
     };
-    // Build environment for ProcessIO
+    // Build environment for SubprocessTransport
     const processEnv = buildProcessEnv(resolvedOptions);
 
     // Why a late-bound holder: PooledTransport copies onWorkerReady eagerly at
@@ -360,10 +360,10 @@ export class NodeBridge extends DisposableBase implements PythonRuntime {
       resolvedOptions.timeoutMs
     );
 
-    // Create pooled transport with ProcessIO workers
+    // Create pooled transport with SubprocessTransport workers
     const transport = new PooledTransport({
-      createTransport: (): ProcessIO =>
-        new ProcessIO({
+      createTransport: (): SubprocessTransport =>
+        new SubprocessTransport({
           pythonPath: resolvedOptions.pythonPath,
           bridgeScript: resolvedOptions.scriptPath,
           env: processEnv,
@@ -676,8 +676,8 @@ function createWorkerReadyCallback(
   rpcHolder: { rpc?: RpcClient },
   warmupCommands: WarmupCommand[],
   timeoutMs: number
-): (worker: PooledWorker) => Promise<void> {
-  return async (worker: PooledWorker) => {
+): (worker: TransportLease) => Promise<void> {
+  return async (worker: TransportLease) => {
     const rpc = rpcHolder.rpc;
     if (!rpc) {
       throw new BridgeExecutionError('Worker warmup attempted before RpcClient was wired');
@@ -721,7 +721,7 @@ function createWorkerReadyCallback(
 // =============================================================================
 
 /**
- * Build environment variables for ProcessIO.
+ * Build environment variables for SubprocessTransport.
  */
 function buildProcessEnv(options: ResolvedOptions): Record<string, string> {
   const allowedPrefixes = ['TYWRAP_'];

package/src/runtime/pooled-transport.ts

@@ -1,8 +1,8 @@
 /**
- * PooledTransport - Transport adapter that wraps WorkerPool for multi-process support.
+ * PooledTransport - Transport adapter that wraps TransportPool for multi-process support.
  *
- * This transport implements the Transport interface by delegating to a WorkerPool
- * of ProcessIO transports. Each send() acquires a worker, sends the message,
+ * This transport implements the Transport interface by delegating to a TransportPool
+ * of SubprocessTransport transports. Each send() acquires a worker, sends the message,
  * and releases the worker back to the pool.
  *
  * @see https://github.com/bbopen/tywrap/issues/149
@@ -11,7 +11,7 @@
 import { DisposableBase } from './bounded-context.js';
 import { BridgeDisposedError, BridgeExecutionError } from './errors.js';
 import type { Transport } from './transport.js';
-import { WorkerPool, type PooledWorker } from './worker-pool.js';
+import { TransportPool, type TransportLease } from './transport-pool.js';
 
 // =============================================================================
 // TYPES
@@ -40,12 +40,12 @@ export interface PooledTransportOptions {
    * Callback invoked after each worker is created and initialized.
    * Use this for per-worker warmup (e.g., importing modules, running setup).
    */
-  onWorkerReady?: (worker: PooledWorker) => Promise<void>;
+  onWorkerReady?: (worker: TransportLease) => Promise<void>;
 
   /**
    * Optional callback used only for background replacement workers.
    */
-  onReplacementWorkerReady?: (worker: PooledWorker) => Promise<void>;
+  onReplacementWorkerReady?: (worker: TransportLease) => Promise<void>;
 }
 
 // =============================================================================
@@ -53,10 +53,10 @@ export interface PooledTransportOptions {
 // =============================================================================
 
 /**
- * Transport adapter that wraps WorkerPool for multi-process message handling.
+ * Transport adapter that wraps TransportPool for multi-process message handling.
  *
  * PooledTransport presents a single Transport interface while internally
- * distributing requests across multiple worker transports (typically ProcessIO).
+ * distributing requests across multiple worker transports (typically SubprocessTransport).
  *
  * Features:
  * - Lazy worker creation (transports created on demand)
@@ -67,7 +67,7 @@ export interface PooledTransportOptions {
  * @example
  * ```typescript
  * const transport = new PooledTransport({
- *   createTransport: () => new ProcessIO({
+ *   createTransport: () => new SubprocessTransport({
  *     bridgeScript: '/path/to/bridge.py',
  *   }),
  *   maxWorkers: 4,
@@ -87,10 +87,10 @@ export class PooledTransport extends DisposableBase implements Transport {
     Required<PooledTransportOptions>,
     'onWorkerReady' | 'onReplacementWorkerReady'
   > & {
-    onWorkerReady?: (worker: PooledWorker) => Promise<void>;
-    onReplacementWorkerReady?: (worker: PooledWorker) => Promise<void>;
+    onWorkerReady?: (worker: TransportLease) => Promise<void>;
+    onReplacementWorkerReady?: (worker: TransportLease) => Promise<void>;
   };
-  private pool?: WorkerPool;
+  private pool?: TransportPool;
 
   /**
    * Create a new PooledTransport.
@@ -122,11 +122,11 @@ export class PooledTransport extends DisposableBase implements Transport {
   /**
    * Initialize the pooled transport.
    *
-   * Creates and initializes the internal WorkerPool.
+   * Creates and initializes the internal TransportPool.
    * If minWorkers > 0, workers are pre-spawned during init.
    */
   protected async doInit(): Promise<void> {
-    this.pool = new WorkerPool({
+    this.pool = new TransportPool({
       createTransport: this.poolOptions.createTransport,
       maxWorkers: this.poolOptions.maxWorkers,
       minWorkers: this.poolOptions.minWorkers,
@@ -142,7 +142,7 @@ export class PooledTransport extends DisposableBase implements Transport {
   /**
    * Dispose the pooled transport.
    *
-   * Disposes the internal WorkerPool, which disposes all workers.
+   * Disposes the internal TransportPool, which disposes all workers.
    */
   protected async doDispose(): Promise<void> {
     if (this.pool) {