tywrap 0.5.1 → 0.6.0

package/src/index.ts

@@ -3,70 +3,20 @@
  *
  * @description Build-time code generation system that makes Python libraries
  * feel native in TypeScript with zero runtime overhead
+ *
+ * This is the package root. It intentionally exposes only the stable,
+ * consumer-facing surface. Runtime plumbing (codec, transport, bridge
+ * implementations, disposables, validators) lives behind the subpath
+ * entrypoints: `tywrap/runtime`, `tywrap/node`, `tywrap/pyodide`, `tywrap/http`.
  */
 
 import { tywrap } from './tywrap.js';
 
+// Configuration
 export type { TywrapConfig, ResolvedTywrapConfig } from './config/index.js';
 export { defineConfig, resolveConfig } from './config/index.js';
-// DisposableBase - lifecycle/resource base for cross-boundary components
-export {
-  DisposableBase,
-  type ContextState,
-  type ExecuteOptions,
-} from './runtime/bounded-context.js';
-// RpcClient - the single correlated-RPC client (codec + transport), held by bridges
-export { RpcClient, type RpcClientOptions } from './runtime/rpc-client.js';
-// SafeCodec - validation and serialization for JS<->Python boundary
-export { SafeCodec, type CodecOptions } from './runtime/safe-codec.js';
-// Transport - abstract I/O channel interface
-export type {
-  Transport,
-  TransportOptions,
-  ProtocolMessage,
-  ProtocolResponse,
-} from './runtime/transport.js';
-export {
-  PROTOCOL_ID,
-  isTransport,
-  isProtocolMessage,
-  isProtocolResponse,
-} from './runtime/transport.js';
-// Transport implementations
-export { ProcessIO, type ProcessIOOptions } from './runtime/process-io.js';
-export { HttpIO, type HttpIOOptions } from './runtime/http-io.js';
-export { PyodideIO, type PyodideIOOptions } from './runtime/pyodide-io.js';
-// WorkerPool - concurrent transport management
-export { WorkerPool, type WorkerPoolOptions, type PooledWorker } from './runtime/worker-pool.js';
-// PooledTransport - Transport adapter that wraps WorkerPool
-export { PooledTransport, type PooledTransportOptions } from './runtime/pooled-transport.js';
-export type { Disposable } from './runtime/disposable.js';
-export { isDisposable, safeDispose, disposeAll } from './runtime/disposable.js';
-export {
-  ValidationError,
-  isFiniteNumber,
-  isPositiveNumber,
-  isNonNegativeNumber,
-  isNonEmptyString,
-  isPlainObject,
-  assertFiniteNumber,
-  assertPositive,
-  assertNonNegative,
-  assertString,
-  assertNonEmptyString,
-  assertArray,
-  assertObject,
-  containsSpecialFloat,
-  assertNoSpecialFloats,
-  sanitizeForFilename,
-  containsPathTraversal,
-} from './runtime/validators.js';
-
-/**
- * @deprecated Use DisposableBase instead. RuntimeBridge will be removed in the next major version.
- */
-export { RuntimeBridge } from './runtime/base.js';
 
+// Bridge error hierarchy
 export {
   BridgeError,
   BridgeCodecError,
@@ -75,12 +25,6 @@ export {
   BridgeDisposedError,
   BridgeExecutionError,
 } from './runtime/errors.js';
-export { getRuntimeBridge, setRuntimeBridge, clearRuntimeBridge } from './runtime/index.js';
-
-// Runtime-specific exports (Bridge facades that HOLD an RpcClient)
-export { NodeBridge, type NodeBridgeOptions } from './runtime/node.js';
-export { PyodideBridge, type PyodideBridgeOptions } from './runtime/pyodide.js';
-export { HttpBridge, type HttpBridgeOptions } from './runtime/http.js';
 
 // Core types
 export type {
@@ -138,6 +82,8 @@ export type { GenerateFailure, GenerateResult, GenerateRunOptions } from './tywr
 
 // Runtime detection utilities
 export { detectRuntime, isNodejs, isDeno, isBun, isBrowser } from './utils/runtime.js';
+
+// Arrow/codec public helpers
 export {
   decodeValue,
   decodeValueAsync,
@@ -146,11 +92,8 @@ export {
   clearArrowDecoder,
 } from './utils/codec.js';
 
-// Version info
-export const VERSION = '0.3.0';
+// Version info — single-sourced from package.json via scripts/generate-version.mjs
+export { VERSION } from './version.js';
 
-/**
- * Quick setup function for getting started
- */
 // Default export for convenience
 export default tywrap;

package/src/runtime/bounded-context.ts

@@ -6,8 +6,8 @@
  * ownership tracking. It carries ZERO RPC methods by design — the
  * cross-boundary RPC contract (call/instantiate/callMethod/disposeInstance)
  * is PythonRuntime, implemented only by the bridge facades, never by a base
- * class or a transport. This separation is what keeps transports (ProcessIO,
- * PooledTransport, WorkerPool, PyodideIO) and RpcClient from having to stub
+ * class or a transport. This separation is what keeps transports (SubprocessTransport,
+ * PooledTransport, TransportPool, PyodideTransport) and RpcClient from having to stub
  * RPC methods they do not implement.
  *
  * Reused by RpcClient and all transports.

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,20 @@ 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');
+  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 +433,7 @@ export class SafeCodec {
         throw new BridgeProtocolError('Protocol response missing "result" or "error" field');
       }
 
-      return envelope.result;
+      return response.result;
     }
 
     if (isPythonErrorResponse(parsed)) {
@@ -522,7 +522,7 @@ 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 {
@@ -553,7 +553,7 @@ export class SafeCodec {
     // Validate protocol version (if present)
     validateProtocolVersion(parsed);
 
-    const result = this.extractResultFromResponseEnvelope(parsed);
+    const result = this.extractResultFromRpcResponse(parsed);
 
     // Post-decode validation for special floats if enabled
     if (this.rejectSpecialFloats && containsSpecialFloat(result)) {
@@ -574,7 +574,7 @@ 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> {
@@ -605,7 +605,7 @@ export class SafeCodec {
     // Validate protocol version (if present)
     validateProtocolVersion(parsed);
 
-    const result = this.extractResultFromResponseEnvelope(parsed);
+    const result = this.extractResultFromRpcResponse(parsed);
 
     // Apply Arrow decoding to the result
     let decoded: unknown;

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) {