tywrap 0.6.0 → 0.6.1

package/src/runtime/rpc-client.ts

@@ -281,26 +281,7 @@ export class RpcClient extends DisposableBase {
     message: Omit<ProtocolMessage, 'id' | 'protocol'>,
     options?: ExecuteOptions<T>
   ): Promise<T> {
-    const fullMessage: ProtocolMessage = {
-      ...message,
-      id: this.generateId(),
-      protocol: PROTOCOL_ID,
-    };
-
-    return this.execute(async () => {
-      // 1. Encode request (validates args)
-      const encoded = this.codec.encodeRequest(fullMessage);
-
-      // 2. Send via transport
-      const responseStr = await this.transport.send(
-        encoded,
-        options?.timeoutMs ?? this.defaultTimeoutMs,
-        options?.signal
-      );
-
-      // 3. Decode response (validates result)
-      return this.codec.decodeResponse<T>(responseStr);
-    }, options);
+    return this.sendVia(message, options, responseStr => this.codec.decodeResponse<T>(responseStr));
   }
 
   /**
@@ -321,11 +302,27 @@ export class RpcClient extends DisposableBase {
     message: Omit<ProtocolMessage, 'id' | 'protocol'>,
     options?: ExecuteOptions<T>
   ): Promise<T> {
-    const fullMessage: ProtocolMessage = {
-      ...message,
-      id: this.generateId(),
-      protocol: PROTOCOL_ID,
-    };
+    return this.sendVia(message, options, responseStr =>
+      this.codec.decodeResponseAsync<T>(responseStr)
+    );
+  }
+
+  /**
+   * Shared body for sendMessage/sendMessageAsync: stamp the frame, run the
+   * encode -> transport.send -> decode pipeline inside this.execute() (which
+   * supplies auto-init, timeout/retry/abort), where the only difference between
+   * the sync and Arrow-aware paths is the supplied `decode` step.
+   *
+   * Behavior-preserving extraction of the two twins; ordering, the
+   * `options?.timeoutMs ?? this.defaultTimeoutMs` fallback, and the
+   * `this.execute(..., options)` wrapping are unchanged.
+   */
+  private async sendVia<T>(
+    message: Omit<ProtocolMessage, 'id' | 'protocol'>,
+    options: ExecuteOptions<T> | undefined,
+    decode: (responseStr: string) => T | Promise<T>
+  ): Promise<T> {
+    const fullMessage = this.stampMessage(message);
 
     return this.execute(async () => {
       // 1. Encode request (validates args)
@@ -338,8 +335,8 @@ export class RpcClient extends DisposableBase {
         options?.signal
       );
 
-      // 3. Decode response with Arrow support
-      return this.codec.decodeResponseAsync<T>(responseStr);
+      // 3. Decode response (sync or Arrow-aware, per caller)
+      return decode(responseStr);
     }, options);
   }
 
@@ -364,11 +361,7 @@ export class RpcClient extends DisposableBase {
     message: Omit<ProtocolMessage, 'id' | 'protocol'>,
     opts?: { timeoutMs?: number; signal?: AbortSignal }
   ): Promise<T> {
-    const fullMessage: ProtocolMessage = {
-      ...message,
-      id: this.generateId(),
-      protocol: PROTOCOL_ID,
-    };
+    const fullMessage = this.stampMessage(message);
     const encoded = this.codec.encodeRequest(fullMessage);
     const responseStr = await transport.send(
       encoded,
@@ -378,6 +371,20 @@ export class RpcClient extends DisposableBase {
     return this.codec.decodeResponseAsync<T>(responseStr);
   }
 
+  /**
+   * Stamp a partial message into a full wire frame: assign the next request id
+   * and the protocol marker. The single id counter + protocol stamping live
+   * here so every send path (sendMessage/sendMessageAsync/sendOn) is correlated
+   * identically.
+   */
+  private stampMessage(message: Omit<ProtocolMessage, 'id' | 'protocol'>): ProtocolMessage {
+    return {
+      ...message,
+      id: this.generateId(),
+      protocol: PROTOCOL_ID,
+    };
+  }
+
   /**
    * Generate a unique request ID.
    *

package/src/runtime/subprocess-transport.ts

@@ -14,6 +14,7 @@
  */
 
 import { spawn, type ChildProcess } from 'child_process';
+import type { Writable } from 'stream';
 import { DisposableBase } from './bounded-context.js';
 import { BridgeDisposedError, BridgeProtocolError, BridgeTimeoutError } from './errors.js';
 import { TimedOutRequestTracker } from './timed-out-request-tracker.js';
@@ -764,6 +765,67 @@ export class SubprocessTransport extends DisposableBase implements Transport {
     });
   }
 
+  /**
+   * Reject and clear every entry currently in the write queue.
+   * Clears each entry's timeout before rejecting so no late timer fires.
+   */
+  private rejectAllQueuedWrites(error: Error): void {
+    for (const q of this.writeQueue) {
+      this.clearQueuedWriteTimeout(q);
+      q.reject(error);
+    }
+    this.writeQueue.length = 0;
+  }
+
+  /**
+   * Process a single dequeued write entry: enforce the fallback queue timeout,
+   * then attempt the stdin write. The returned status tells {@link flushWriteQueue}
+   * how to proceed:
+   * - `'continue'`: entry settled (written or timed out); process the next entry.
+   * - `'backpressure'`: write accepted but stream is full; pause until the next drain.
+   * - `'error'`: synchronous write failure; the caller must reject the remaining queue.
+   *
+   * The entry's own timeout must already be cleared by the caller before this runs.
+   */
+  private processQueuedWrite(
+    queued: QueuedWrite,
+    stdin: Writable,
+    now: number
+  ): 'continue' | 'backpressure' | 'error' {
+    // Check for write queue timeout (fallback check, timer should have handled this)
+    if (now - queued.queuedAt > this.writeQueueTimeoutMs) {
+      queued.reject(
+        new BridgeTimeoutError(
+          `Write queue timeout: entry waited ${now - queued.queuedAt}ms (limit: ${this.writeQueueTimeoutMs}ms)`
+        )
+      );
+      return 'continue';
+    }
+
+    try {
+      const canWrite = stdin.write(queued.data);
+
+      if (canWrite) {
+        queued.resolve();
+        return 'continue';
+      }
+
+      // Backpressure - this write has been accepted by stream buffer.
+      // Pause further queued writes until the next "drain" event.
+      queued.resolve();
+      this.draining = true;
+      return 'backpressure';
+    } catch (err) {
+      // Synchronous write error (e.g., EPIPE) - reject this entry; caller rejects the rest.
+      const errorMessage = err instanceof Error ? err.message : 'unknown';
+      const error = new BridgeProtocolError(this.withStderrTail(`Write error: ${errorMessage}`));
+      queued.reject(error);
+      this.rejectAllQueuedWrites(error);
+      this.markForRestart();
+      return 'error';
+    }
+  }
+
   /**
    * Flush queued writes when backpressure clears.
    */
@@ -771,13 +833,12 @@ export class SubprocessTransport extends DisposableBase implements Transport {
     const now = Date.now();
 
     while (this.writeQueue.length > 0 && !this.draining) {
-      if (!this.process?.stdin || this.processExited) {
+      const stdin = this.process?.stdin;
+      if (!stdin || this.processExited) {
         // Process died - reject all queued writes
-        for (const q of this.writeQueue) {
-          this.clearQueuedWriteTimeout(q);
-          q.reject(new BridgeProtocolError(this.withStderrTail('Process stdin not available')));
-        }
-        this.writeQueue.length = 0;
+        this.rejectAllQueuedWrites(
+          new BridgeProtocolError(this.withStderrTail('Process stdin not available'))
+        );
         this.markForRestart();
         return;
       }
@@ -790,39 +851,8 @@ export class SubprocessTransport extends DisposableBase implements Transport {
       // Clear the timeout since we're processing this entry now
       this.clearQueuedWriteTimeout(queued);
 
-      // Check for write queue timeout (fallback check, timer should have handled this)
-      if (now - queued.queuedAt > this.writeQueueTimeoutMs) {
-        queued.reject(
-          new BridgeTimeoutError(
-            `Write queue timeout: entry waited ${now - queued.queuedAt}ms (limit: ${this.writeQueueTimeoutMs}ms)`
-          )
-        );
-        continue; // Process next entry
-      }
-
-      try {
-        const canWrite = this.process.stdin.write(queued.data);
-
-        if (canWrite) {
-          queued.resolve();
-        } else {
-          // Backpressure - this write has been accepted by stream buffer.
-          // Pause further queued writes until the next "drain" event.
-          queued.resolve();
-          this.draining = true;
-          return;
-        }
-      } catch (err) {
-        // Synchronous write error (e.g., EPIPE) - reject this and all remaining writes
-        const errorMessage = err instanceof Error ? err.message : 'unknown';
-        const error = new BridgeProtocolError(this.withStderrTail(`Write error: ${errorMessage}`));
-        queued.reject(error);
-        for (const q of this.writeQueue) {
-          this.clearQueuedWriteTimeout(q);
-          q.reject(error);
-        }
-        this.writeQueue.length = 0;
-        this.markForRestart();
+      const status = this.processQueuedWrite(queued, stdin, now);
+      if (status === 'backpressure' || status === 'error') {
         return;
       }
     }

package/src/tywrap.ts

@@ -52,30 +52,6 @@ export async function tywrap(options: Partial<TywrapOptions> = {}): Promise<Tywr
   };
 }
 
-export default tywrap;
-
-/**
- * Append minimal tsd tests for a generated module (optional dev aid)
- */
-export async function emitTypeTestsForModule(
-  moduleName: string,
-  outDir = 'test-d/generated'
-): Promise<void> {
-  const { writeFile, mkdir } = await import('fs/promises');
-  const { join } = await import('path');
-  try {
-    await mkdir(outDir, { recursive: true });
-  } catch {}
-  const filePath = join(outDir, `${moduleName}.test-d.ts`);
-  const content = `import { expectType } from 'tsd';
-import * as mod from '../../generated/${moduleName}.generated.ts';
-
-// Opportunistic: ensure module namespace is an object
-expectType<Record<string, unknown>>(mod);
-`;
-  await writeFile(filePath, content, 'utf-8');
-}
-
 export interface GenerateRunOptions {
   /**
    * If true, do not write files; instead compare generated output to what's on disk.

package/src/utils/cache.ts

@@ -149,75 +149,73 @@ export class ArtifactCache {
     hash.update(prefix);
     hash.update('\0');
 
-    // Add inputs
+    // Add inputs. Each input contributes a type tag, an optional payload, and a
+    // boundary separator so that "1" vs 1 and ["a","bc"] vs ["ab","c"] never collide.
     for (const input of inputs) {
-      // Why: disambiguate types so "1" and 1 don't collide, and keep input boundaries so
-      // ["a", "bc"] doesn't collide with ["ab", "c"].
-      if (input === undefined) {
-        hash.update('undef:');
-        hash.update('\0');
-        continue;
+      const { tag, payload } = ArtifactCache.encodeKeyInput(input);
+      hash.update(tag);
+      if (payload !== undefined) {
+        hash.update(payload);
       }
-      if (input === null) {
-        hash.update('null:');
-        hash.update('\0');
-        continue;
-      }
-      if (typeof input === 'string') {
-        hash.update('str:');
-        hash.update(input);
-        hash.update('\0');
-        continue;
-      }
-      if (typeof input === 'number') {
-        hash.update('num:');
-        hash.update(String(input));
-        hash.update('\0');
-        continue;
-      }
-      if (typeof input === 'boolean') {
-        hash.update('bool:');
-        hash.update(input ? '1' : '0');
-        hash.update('\0');
-        continue;
-      }
-      if (typeof input === 'bigint') {
-        hash.update('bigint:');
-        hash.update(input.toString());
-        hash.update('\0');
-        continue;
-      }
-      if (Buffer.isBuffer(input)) {
-        hash.update('buf:');
-        hash.update(input);
-        hash.update('\0');
-        continue;
-      }
-
-      if (typeof input === 'symbol') {
-        hash.update('sym:');
-        hash.update(input.toString());
-        hash.update('\0');
-        continue;
-      }
-
-      hash.update('json:');
-      let json: string;
-      try {
-        json =
-          JSON.stringify(input, (_key, value) =>
-            typeof value === 'symbol' ? value.toString() : value
-          ) ?? 'undefined';
-      } catch {
-        json = String(input);
-      }
-      hash.update(json);
       hash.update('\0');
     }
 
     return hash.digest('hex').substring(0, 16); // Use first 16 chars for readability
   }
 
+  /**
+   * Encode a single key input as a type tag plus optional payload.
+   * Why: disambiguate types so "1" and 1 don't collide, and keep input boundaries so
+   * ["a", "bc"] doesn't collide with ["ab", "c"].
+   */
+  private static encodeKeyInput(input: unknown): {
+    tag: string;
+    payload?: string | Buffer;
+  } {
+    if (input === undefined) {
+      return { tag: 'undef:' };
+    }
+    if (input === null) {
+      return { tag: 'null:' };
+    }
+    if (typeof input === 'string') {
+      return { tag: 'str:', payload: input };
+    }
+    if (typeof input === 'number') {
+      return { tag: 'num:', payload: String(input) };
+    }
+    if (typeof input === 'boolean') {
+      return { tag: 'bool:', payload: input ? '1' : '0' };
+    }
+    if (typeof input === 'bigint') {
+      return { tag: 'bigint:', payload: input.toString() };
+    }
+    if (Buffer.isBuffer(input)) {
+      return { tag: 'buf:', payload: input };
+    }
+    if (typeof input === 'symbol') {
+      return { tag: 'sym:', payload: input.toString() };
+    }
+
+    return { tag: 'json:', payload: ArtifactCache.stringifyKeyInput(input) };
+  }
+
+  /**
+   * Stringify an arbitrary key input for hashing, normalizing symbols and
+   * falling back to String() when JSON serialization fails.
+   */
+  private static stringifyKeyInput(input: unknown): string {
+    try {
+      return (
+        JSON.stringify(input, (_key, value) =>
+          typeof value === 'symbol' ? value.toString() : value
+        ) ?? 'undefined'
+      );
+    } catch {
+      return String(input);
+    }
+  }
+
   /**
    * Get entry from cache with performance tracking
    */

package/src/utils/python.ts

@@ -44,30 +44,43 @@ export function getDefaultPythonPath(): string {
   return getPythonExecutableName();
 }
 
+/**
+ * Whether the configured pythonPath is the default interpreter (or unset),
+ * meaning a virtual environment lookup should take precedence.
+ */
+function usesDefaultPython(pythonPath: string | undefined): boolean {
+  return !pythonPath || pythonPath === 'python3' || pythonPath === 'python';
+}
+
+/**
+ * Resolve the Python executable inside a virtual environment, preferring the
+ * Node path module when available and falling back to cross-runtime pathUtils.
+ */
+async function resolveVenvPython(virtualEnv: string, cwd: string): Promise<string> {
+  const binDir = getVenvBinDir();
+  const exe = getVenvPythonExe();
+  const pathMod = await loadNodePathModule();
+
+  if (pathMod) {
+    const venvRoot = pathMod.resolve(cwd, virtualEnv);
+    return pathMod.join(venvRoot, binDir, exe);
+  }
+
+  const venvRoot = isAbsolutePath(virtualEnv)
+    ? pathUtils.join(virtualEnv)
+    : pathUtils.join(cwd, virtualEnv);
+  return pathUtils.join(venvRoot, binDir, exe);
+}
+
 export async function resolvePythonExecutable(options: PythonResolveOptions = {}): Promise<string> {
   const pythonPath = options.pythonPath?.trim();
   const virtualEnv = options.virtualEnv?.trim();
 
-  if (virtualEnv) {
-    const usesDefaultPython = !pythonPath || pythonPath === 'python3' || pythonPath === 'python';
-    if (usesDefaultPython) {
-      const cwd =
-        options.cwd ??
-        (typeof process !== 'undefined' && typeof process.cwd === 'function' ? process.cwd() : '.');
-      const binDir = getVenvBinDir();
-      const exe = getVenvPythonExe();
-      const pathMod = await loadNodePathModule();
-
-      if (pathMod) {
-        const venvRoot = pathMod.resolve(cwd, virtualEnv);
-        return pathMod.join(venvRoot, binDir, exe);
-      }
-
-      const venvRoot = isAbsolutePath(virtualEnv)
-        ? pathUtils.join(virtualEnv)
-        : pathUtils.join(cwd, virtualEnv);
-      return pathUtils.join(venvRoot, binDir, exe);
-    }
+  if (virtualEnv && usesDefaultPython(pythonPath)) {
+    const cwd =
+      options.cwd ??
+      (typeof process !== 'undefined' && typeof process.cwd === 'function' ? process.cwd() : '.');
+    return resolveVenvPython(virtualEnv, cwd);
   }
 
   if (pythonPath) {

package/src/utils/runtime.ts

@@ -229,26 +229,37 @@ async function loadPathModule(): Promise<PathModule | null> {
   return null;
 }
 
+/**
+ * Apply a single path segment to the accumulated normalized segments,
+ * resolving '..' and dropping '.'/empty segments in place.
+ */
+function applyPathSegment(normalized: string[], segment: string, isAbsolute: boolean): void {
+  if (segment === '.' || segment === '') {
+    return; // Skip current directory and empty segments
+  }
+
+  if (segment !== '..') {
+    normalized.push(segment);
+    return;
+  }
+
+  // '..' segment: go up one directory when possible.
+  if (normalized.length > 0 && normalized[normalized.length - 1] !== '..') {
+    normalized.pop();
+  } else if (!isAbsolute) {
+    normalized.push(segment); // Keep '..' if not absolute and at root
+  }
+}
+
 /**
  * Normalize path by stripping '.' and resolving '..' components
  */
 function normalizePath(path: string): string {
   const isAbsolute = path.startsWith('/');
-  const segments = path.split('/');
   const normalized: string[] = [];
 
-  for (const segment of segments) {
-    if (segment === '.' || segment === '') {
-      continue; // Skip current directory and empty segments
-    } else if (segment === '..') {
-      if (normalized.length > 0 && normalized[normalized.length - 1] !== '..') {
-        normalized.pop(); // Go up one directory
-      } else if (!isAbsolute) {
-        normalized.push(segment); // Keep '..' if not absolute and at root
-      }
-    } else {
-      normalized.push(segment);
-    }
+  for (const segment of path.split('/')) {
+    applyPathSegment(normalized, segment, isAbsolute);
   }
 
   const result = normalized.join('/');

package/src/version.ts

@@ -9,4 +9,4 @@
  * Regenerate with: node scripts/generate-version.mjs
  */
 
-export const VERSION: string = "0.6.0";
+export const VERSION: string = "0.6.1";