diff --git a/examples/advanced-typescript-features.ts b/examples/advanced-typescript-features.ts
new file mode 100644
index 0000000..e0e263e
--- /dev/null
+++ b/examples/advanced-typescript-features.ts
@@ -0,0 +1,318 @@
+/**
+ * Advanced TypeScript Features for command-stream
+ * Demonstrates unique type features that competitors don't have
+ */
+
+import { 
+  ProcessRunner,
+  CommandResult,
+  register,
+  VirtualCommandHandler,
+  StreamingOptions,
+  PipelineStep,
+  Pipeline
+} from '../index';
+
+// Advanced type definitions for unique features
+type VirtualCommandRegistry = Map<string, VirtualCommandHandler>;
+type StreamTransform<T, U> = (input: T) => U | Promise<U>;
+type EventMap = Record<string, any[]>;
+
+// Example 1: Type-safe virtual command registration with advanced generics
+interface TypedVirtualCommand<TArgs extends readonly unknown[], TReturn> {
+  name: string;
+  description?: string;
+  handler: (...args: TArgs) => Promise<TReturn> | TReturn;
+}
+
+// Register a math virtual command with full type safety
+const mathCommand: TypedVirtualCommand<[number, string, number], CommandResult> = {
+  name: 'math',
+  description: 'Perform mathematical operations',
+  handler: async (a: number, op: string, b: number): Promise<CommandResult> => {
+    let result: number;
+    switch (op) {
+      case '+': result = a + b; break;
+      case '-': result = a - b; break;
+      case '*': result = a * b; break;
+      case '/': result = a / b; break;
+      default: throw new Error(`Unknown operation: ${op}`);
+    }
+    
+    return {
+      code: 0,
+      stdout: result.toString(),
+      stderr: '',
+      stdin: '',
+      async text() { return this.stdout; }
+    };
+  }
+};
+
+// Example 2: Advanced streaming with generic type transformations
+interface StreamProcessor<TInput, TOutput> {
+  transform: StreamTransform<TInput, TOutput>;
+  filter?: (item: TInput) => boolean | Promise<boolean>;
+  batch?: number;
+}
+
+async function advancedStreamProcessing<T, U>(
+  runner: ProcessRunner,
+  processor: StreamProcessor<T, U>
+): Promise<U[]> {
+  const results: U[] = [];
+  let batch: T[] = [];
+  
+  for await (const chunk of runner.stream()) {
+    const item = chunk as unknown as T;
+    
+    // Apply filter if provided
+    if (processor.filter && !(await processor.filter(item))) {
+      continue;
+    }
+    
+    // Handle batching
+    if (processor.batch) {
+      batch.push(item);
+      if (batch.length >= processor.batch) {
+        const transformed = await Promise.all(
+          batch.map(processor.transform)
+        );
+        results.push(...transformed);
+        batch = [];
+      }
+    } else {
+      const transformed = await processor.transform(item);
+      results.push(transformed);
+    }
+  }
+  
+  // Process remaining batch
+  if (batch.length > 0) {
+    const transformed = await Promise.all(
+      batch.map(processor.transform)
+    );
+    results.push(...transformed);
+  }
+  
+  return results;
+}
+
+// Example 3: Type-safe pipeline builder with inference
+class TypeSafePipeline<TInput, TOutput> {
+  private steps: PipelineStep<any, any>[] = [];
+  
+  constructor(private initialType: new() => TInput) {}
+  
+  pipe<TNext>(
+    step: PipelineStep<TOutput, TNext>
+  ): TypeSafePipeline<TInput, TNext> {
+    this.steps.push(step);
+    return this as any;
+  }
+  
+  map<TNext>(
+    transform: (input: TOutput) => TNext | Promise<TNext>
+  ): TypeSafePipeline<TInput, TNext> {
+    this.steps.push(async (input: TOutput) => transform(input));
+    return this as any;
+  }
+  
+  filter(
+    predicate: (input: TOutput) => boolean | Promise<boolean>
+  ): TypeSafePipeline<TInput, TOutput> {
+    this.steps.push(async function* (input: AsyncIterable<TOutput>) {
+      for await (const item of input) {
+        if (await predicate(item)) {
+          yield item;
+        }
+      }
+    });
+    return this;
+  }
+  
+  async execute(input: TInput): Promise<TOutput> {
+    let current: any = input;
+    for (const step of this.steps) {
+      current = await step(current);
+    }
+    return current;
+  }
+}
+
+// Example 4: Advanced event system with discriminated unions
+type CommandEvent = 
+  | { type: 'start'; timestamp: Date; command: string }
+  | { type: 'data'; chunk: Buffer; size: number }
+  | { type: 'line'; content: string; lineNumber: number }
+  | { type: 'end'; result: CommandResult; duration: number }
+  | { type: 'error'; error: Error; context: string };
+
+interface TypedEventEmitter<TEvents extends EventMap> {
+  on<K extends keyof TEvents>(
+    event: K,
+    listener: (...args: TEvents[K]) => void
+  ): this;
+  
+  emit<K extends keyof TEvents>(
+    event: K,
+    ...args: TEvents[K]
+  ): boolean;
+}
+
+// Example 5: Conditional type system for command validation
+type ValidCommand<T> = T extends `${string}${infer Rest}` 
+  ? Rest extends ` ${string}` | ''
+    ? T 
+    : never
+  : never;
+
+type SafeCommand = ValidCommand<'echo hello'> | ValidCommand<'ls -la'> | ValidCommand<'pwd'>;
+
+// Example 6: Advanced streaming interface with backpressure
+interface BackpressureStream<T> {
+  readonly readable: boolean;
+  readonly highWaterMark: number;
+  readonly objectMode: boolean;
+  
+  read(size?: number): T | null;
+  on(event: 'readable', listener: () => void): this;
+  on(event: 'end', listener: () => void): this;
+  on(event: 'error', listener: (err: Error) => void): this;
+  
+  [Symbol.asyncIterator](): AsyncIterableIterator<T>;
+}
+
+// Example 7: Sophisticated error handling with typed error contexts
+class CommandError extends Error {
+  constructor(
+    message: string,
+    public readonly code: number,
+    public readonly command: string,
+    public readonly stderr: string,
+    public readonly context: 'execution' | 'streaming' | 'virtual-command'
+  ) {
+    super(message);
+    this.name = 'CommandError';
+  }
+}
+
+interface ErrorRecoveryStrategy<T> {
+  retries: number;
+  backoff: (attempt: number) => number;
+  fallback?: () => Promise<T>;
+  shouldRetry: (error: Error) => boolean;
+}
+
+async function executeWithRecovery<T>(
+  operation: () => Promise<T>,
+  strategy: ErrorRecoveryStrategy<T>
+): Promise<T> {
+  let lastError: Error;
+  
+  for (let attempt = 0; attempt <= strategy.retries; attempt++) {
+    try {
+      return await operation();
+    } catch (error) {
+      lastError = error as Error;
+      
+      if (!strategy.shouldRetry(error as Error) || attempt === strategy.retries) {
+        break;
+      }
+      
+      const delay = strategy.backoff(attempt);
+      await new Promise(resolve => setTimeout(resolve, delay));
+    }
+  }
+  
+  if (strategy.fallback) {
+    return strategy.fallback();
+  }
+  
+  throw lastError!;
+}
+
+// Example 8: Real-world usage combining all features
+export async function demonstrateAdvancedFeatures(): Promise<void> {
+  // Register the typed math command
+  register('math', mathCommand.handler);
+  
+  // Create a type-safe pipeline for log processing
+  const logPipeline = new TypeSafePipeline(Buffer)
+    .map((buffer: Buffer) => buffer.toString())
+    .filter((line: string) => line.includes('ERROR'))
+    .map((line: string) => ({
+      timestamp: new Date(),
+      level: 'ERROR',
+      message: line.trim()
+    }));
+  
+  // Use advanced streaming with error recovery
+  const strategy: ErrorRecoveryStrategy<CommandResult> = {
+    retries: 3,
+    backoff: (attempt) => Math.pow(2, attempt) * 1000,
+    shouldRetry: (error) => error.message.includes('temporary'),
+    fallback: async () => ({
+      code: -1,
+      stdout: '',
+      stderr: 'Operation failed after retries',
+      stdin: '',
+      async text() { return this.stderr; }
+    })
+  };
+  
+  try {
+    // Execute commands with full type safety and error handling
+    const result = await executeWithRecovery(
+      async () => {
+        const mathResult = await import('../index').then(({ $ }) => $`math 10 + 5`);
+        return mathResult;
+      },
+      strategy
+    );
+    
+    console.log(`Math result: ${result.stdout}`);
+    
+  } catch (error) {
+    if (error instanceof CommandError) {
+      console.error(`Command failed in ${error.context}: ${error.message}`);
+    }
+  }
+}
+
+// Example 9: Template literal types for command validation
+type CommandTemplate<T extends string> = T extends `${infer Command} ${infer Args}`
+  ? { command: Command; args: Args }
+  : { command: T; args: '' };
+
+function parseCommand<T extends string>(cmd: T): CommandTemplate<T> {
+  const parts = cmd.split(' ', 2);
+  return {
+    command: parts[0],
+    args: parts.slice(1).join(' ')
+  } as CommandTemplate<T>;
+}
+
+// Example 10: Advanced type guards and narrowing
+function isStreamableResult(result: any): result is AsyncIterable<Buffer> {
+  return result && typeof result[Symbol.asyncIterator] === 'function';
+}
+
+function isCommandResult(result: any): result is CommandResult {
+  return result && 
+    typeof result.code === 'number' &&
+    typeof result.stdout === 'string' &&
+    typeof result.stderr === 'string';
+}
+
+// Export the demonstration
+export { 
+  mathCommand,
+  advancedStreamProcessing,
+  TypeSafePipeline,
+  CommandError,
+  executeWithRecovery,
+  parseCommand,
+  isStreamableResult,
+  isCommandResult
+};
\ No newline at end of file
diff --git a/examples/test-typescript-definitions.mjs b/examples/test-typescript-definitions.mjs
new file mode 100644
index 0000000..e8d07af
--- /dev/null
+++ b/examples/test-typescript-definitions.mjs
@@ -0,0 +1,213 @@
+/**
+ * Test TypeScript definitions for command-stream
+ * This file tests that our TypeScript definitions work correctly at runtime
+ */
+
+import $ from '../src/$.mjs';
+
+// Test basic command execution
+async function testBasicCommands() {
+  console.log('Testing basic command execution...');
+  
+  try {
+    const result = await $`echo "Hello TypeScript!"`;
+    console.log(`✅ Basic command: ${result.stdout.trim()}`);
+    console.log(`   Exit code: ${result.code}`);
+    console.log(`   Has text() method: ${typeof result.text === 'function'}`);
+    
+    if (typeof result.text === 'function') {
+      const textResult = await result.text();
+      console.log(`   text() result: ${textResult.trim()}`);
+    } else {
+      console.log(`   ⚠️  text() method not implemented yet, using stdout directly`);
+    }
+  } catch (error) {
+    console.error('❌ Basic command failed:', error.message);
+  }
+}
+
+// Test command with options
+async function testCommandWithOptions() {
+  console.log('\nTesting command with options...');
+  
+  try {
+    const quietCmd = $({ mirror: false, capture: true });
+    const result = await quietCmd`pwd`;
+    console.log(`✅ Command with options: ${result.stdout.trim()}`);
+  } catch (error) {
+    console.error('❌ Command with options failed:', error.message);
+  }
+}
+
+// Test streaming functionality
+async function testStreaming() {
+  console.log('\nTesting streaming functionality...');
+  
+  try {
+    const cmd = $`echo -e "line1\\nline2\\nline3"`;
+    let chunkCount = 0;
+    
+    for await (const chunk of cmd.stream()) {
+      chunkCount++;
+      console.log(`✅ Received chunk ${chunkCount}: ${chunk ? chunk.length : 'undefined'} bytes`);
+      if (chunkCount > 5) break; // Prevent infinite loop
+    }
+    
+    console.log(`✅ Streaming completed with ${chunkCount} chunks`);
+    
+    // Note: lines() method is not implemented yet, but would work like this:
+    // const lineCmd = $`echo -e "line1\\nline2\\nline3"`;
+    // for await (const line of lineCmd.lines()) {
+    //   console.log(`Line: ${line}`);
+    // }
+  } catch (error) {
+    console.error('❌ Streaming failed:', error.message);
+  }
+}
+
+// Test event handling
+async function testEventHandling() {
+  console.log('\nTesting event handling...');
+  
+  return new Promise((resolve, reject) => {
+    const cmd = $`echo "Event test"`;
+    let dataReceived = false;
+    let endReceived = false;
+    
+    cmd.on('data', (chunk) => {
+      dataReceived = true;
+      console.log(`✅ Data event: ${chunk ? chunk.length : 'undefined'} bytes`);
+    });
+    
+    cmd.on('end', (result) => {
+      endReceived = true;
+      console.log(`✅ End event: code ${result.code}, stdout: "${result.stdout.trim()}"`);
+      
+      if (dataReceived && endReceived) {
+        resolve();
+      } else {
+        reject(new Error('Not all events received'));
+      }
+    });
+    
+    cmd.on('error', (error) => {
+      console.error('❌ Error event:', error.message);
+      reject(error);
+    });
+    
+    // Trigger execution
+    cmd.start();
+  });
+}
+
+// Test virtual commands
+async function testVirtualCommands() {
+  console.log('\nTesting virtual commands...');
+  
+  try {
+    // Test built-in virtual command
+    const result = await $`echo "Virtual command test"`;
+    console.log(`✅ Virtual echo command: ${result.stdout.trim()}`);
+    
+    // Test pwd virtual command
+    const pwdResult = await $`pwd`;
+    console.log(`✅ Virtual pwd command: ${pwdResult.stdout.trim()}`);
+  } catch (error) {
+    console.error('❌ Virtual commands failed:', error.message);
+  }
+}
+
+// Test stream access
+async function testStreamAccess() {
+  console.log('\nTesting stream access...');
+  
+  try {
+    const cmd = $`echo "Stream access test"`;
+    
+    // Access streams before starting
+    console.log(`✅ stdout initially: ${cmd.stdout === null ? 'null' : 'available'}`);
+    console.log(`✅ stderr initially: ${cmd.stderr === null ? 'null' : 'available'}`);
+    console.log(`✅ stdin initially: ${cmd.stdin === null ? 'null' : 'available'}`);
+    
+    // Execute and get result
+    const result = await cmd;
+    console.log(`✅ Stream access result: ${result.stdout.trim()}`);
+  } catch (error) {
+    console.error('❌ Stream access failed:', error.message);
+  }
+}
+
+// Test error handling
+async function testErrorHandling() {
+  console.log('\nTesting error handling...');
+  
+  try {
+    // This should fail
+    const result = await $`nonexistent-command-12345`;
+    // If we get here, the command didn't fail as expected
+    if (result.code !== 0) {
+      console.log(`✅ Error handling works: command failed with code ${result.code}`);
+    } else {
+      console.error('❌ Expected error but command succeeded');
+    }
+  } catch (error) {
+    console.log(`✅ Error handling works: ${error.message}`);
+  }
+}
+
+// Test interpolation
+async function testInterpolation() {
+  console.log('\nTesting variable interpolation...');
+  
+  try {
+    const name = "TypeScript";
+    const result = await $`echo "Hello, ${name}!"`;
+    console.log(`✅ Interpolation: ${result.stdout.trim()}`);
+    
+    const command = "echo";
+    const message = "Variable interpolation works";
+    const result2 = await $`${command} "${message}"`;
+    console.log(`✅ Command interpolation: ${result2.stdout.trim()}`);
+  } catch (error) {
+    console.error('❌ Interpolation failed:', error.message);
+  }
+}
+
+// Main test runner
+async function runAllTests() {
+  console.log('🚀 Running TypeScript definitions tests for command-stream...\n');
+  
+  try {
+    await testBasicCommands();
+    await testCommandWithOptions();
+    await testStreaming();
+    await testEventHandling();
+    await testVirtualCommands();
+    await testStreamAccess();
+    await testErrorHandling();
+    await testInterpolation();
+    
+    console.log('\n✅ All TypeScript definition tests passed!');
+    console.log('🎉 TypeScript support is working correctly!');
+  } catch (error) {
+    console.error('\n❌ Tests failed:', error.message);
+    process.exit(1);
+  }
+}
+
+// Run tests if this file is executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  runAllTests().catch(console.error);
+}
+
+export {
+  testBasicCommands,
+  testCommandWithOptions,
+  testStreaming,
+  testEventHandling,
+  testVirtualCommands,
+  testStreamAccess,
+  testErrorHandling,
+  testInterpolation,
+  runAllTests
+};
\ No newline at end of file
diff --git a/examples/typescript-examples.ts b/examples/typescript-examples.ts
new file mode 100644
index 0000000..07409dc
--- /dev/null
+++ b/examples/typescript-examples.ts
@@ -0,0 +1,277 @@
+/**
+ * TypeScript Examples for command-stream
+ * Demonstrates full type safety and IDE autocomplete support
+ */
+
+import $, { 
+  ProcessRunner, 
+  CommandResult, 
+  register, 
+  create, 
+  quote, 
+  raw,
+  configureAnsi 
+} from '../index';
+
+// Example 1: Basic command execution with full typing
+async function basicCommands(): Promise<void> {
+  // Tagged template usage - returns ProcessRunner
+  const result: CommandResult = await $`echo "Hello, TypeScript!"`;
+  console.log(`Exit code: ${result.code}`); // number
+  console.log(`Output: ${result.stdout}`);  // string
+  
+  // Command with interpolation - values are properly typed
+  const name = "TypeScript";
+  const greeting: CommandResult = await $`echo "Hello, ${name}!"`;
+  console.log(await greeting.text()); // string
+}
+
+// Example 2: Options-based configuration with type safety
+async function configuredCommands(): Promise<void> {
+  // Using $ with options - returns a new tagged template function
+  const quietCmd = $({ mirror: false, capture: true });
+  const result: CommandResult = await quietCmd`pwd`;
+  
+  // Custom default options
+  const customCmd = create({ 
+    cwd: '/tmp', 
+    env: { NODE_ENV: 'test' },
+    interactive: false 
+  });
+  await customCmd`ls -la`;
+}
+
+// Example 3: Streaming with generic types
+async function streamingExamples(): Promise<void> {
+  const cmd: ProcessRunner = $`find . -name "*.ts"`;
+  
+  // Stream as buffers
+  for await (const chunk of cmd.stream()) {
+    // chunk is typed as Buffer
+    console.log(`Received ${chunk.length} bytes`);
+  }
+  
+  // Stream as lines
+  const lineCmd: ProcessRunner = $`cat package.json`;
+  for await (const line of lineCmd.lines()) {
+    // line is typed as string
+    console.log(`Line: ${line}`);
+  }
+}
+
+// Example 4: Event-based processing with typed events
+function eventDrivenProcessing(): void {
+  const cmd: ProcessRunner = $`tail -f /var/log/system.log`;
+  
+  // Typed event listeners
+  cmd.on('data', (chunk: Buffer) => {
+    console.log(`Data: ${chunk.toString()}`);
+  });
+  
+  cmd.on('end', (result: CommandResult) => {
+    console.log(`Finished with code: ${result.code}`);
+  });
+  
+  cmd.on('error', (error: Error) => {
+    console.error(`Error: ${error.message}`);
+  });
+}
+
+// Example 5: Virtual commands with type safety
+async function virtualCommandsExample(): Promise<void> {
+  // Register a typed virtual command
+  register('greet', async (args: string[]): Promise<CommandResult> => {
+    const name = args[0] || 'World';
+    return {
+      code: 0,
+      stdout: `Hello, ${name}!`,
+      stderr: '',
+      stdin: '',
+      async text() { return this.stdout; }
+    };
+  });
+  
+  // Use the virtual command
+  const result: CommandResult = await $`greet TypeScript`;
+  console.log(result.stdout); // "Hello, TypeScript!"
+}
+
+// Example 6: Advanced streaming transformations
+async function advancedStreaming(): Promise<void> {
+  const cmd: ProcessRunner = $`ls -la`;
+  
+  // Custom stream transformation with types
+  const stream = cmd.stream({
+    transform: (chunk: Buffer): string => chunk.toString().toUpperCase(),
+    encoding: 'utf8'
+  });
+  
+  for await (const transformedChunk of stream) {
+    // transformedChunk is typed as string due to transform
+    console.log(`Transformed: ${transformedChunk}`);
+  }
+}
+
+// Example 7: Pipeline composition (conceptual - shows intended API)
+async function pipelineExample(): Promise<void> {
+  // Type-safe pipeline composition
+  const result = await $`cat data.json`
+    .then(r => r.stdout)
+    .then(JSON.parse)
+    .then((data: any[]) => data.filter(item => item.active))
+    .then(filtered => JSON.stringify(filtered, null, 2));
+  
+  console.log(result);
+}
+
+// Example 8: Error handling with proper types
+async function errorHandling(): Promise<void> {
+  try {
+    const result: CommandResult = await $`nonexistent-command`;
+    console.log(result.stdout);
+  } catch (error: unknown) {
+    if (error instanceof Error) {
+      console.error(`Command failed: ${error.message}`);
+    }
+  }
+}
+
+// Example 9: Working with process streams directly
+async function processStreams(): Promise<void> {
+  const cmd: ProcessRunner = $`grep -n "error" /var/log/system.log`;
+  
+  // Access typed streams
+  const stdout = cmd.stdout; // Readable | null
+  const stderr = cmd.stderr; // Readable | null
+  const stdin = cmd.stdin;   // Writable | null
+  
+  if (stdout) {
+    stdout.on('data', (chunk: Buffer) => {
+      console.log(`Found error: ${chunk.toString()}`);
+    });
+  }
+}
+
+// Example 10: Utility functions with proper typing
+function utilityExamples(): void {
+  // Quote function with type safety
+  const userInput = "file with spaces.txt";
+  const quotedInput: string = quote(userInput);
+  console.log(quotedInput); // 'file with spaces.txt'
+  
+  // Raw function for unescaped values
+  const rawCommand = raw("echo hello | wc -w");
+  console.log(`${rawCommand}`); // echo hello | wc -w
+}
+
+// Example 11: Configuration and ANSI handling
+function configurationExample(): void {
+  // Configure ANSI processing with typed options
+  configureAnsi({
+    enabled: true,
+    colors: true,
+    styles: false
+  });
+  
+  // Global configuration
+  import('./index').then(({ set, unset }) => {
+    set('verbose'); // Enable verbose logging
+    unset('mirror'); // Disable output mirroring
+  });
+}
+
+// Example 12: Advanced async iteration patterns
+async function asyncIterationPatterns(): Promise<void> {
+  const cmd: ProcessRunner = $`ping -c 5 google.com`;
+  
+  // Collect all chunks
+  const chunks: Buffer[] = [];
+  for await (const chunk of cmd.stream()) {
+    chunks.push(chunk);
+  }
+  
+  // Process line by line with proper typing
+  const lines: string[] = [];
+  for await (const line of cmd.lines()) {
+    lines.push(line);
+  }
+  
+  console.log(`Collected ${chunks.length} chunks and ${lines.length} lines`);
+}
+
+// Example 13: Combining multiple commands with type safety
+async function multipleCommands(): Promise<void> {
+  // Sequential execution
+  const ls: CommandResult = await $`ls`;
+  const wc: CommandResult = await $`echo ${ls.stdout} | wc -l`;
+  
+  console.log(`Directory has ${wc.stdout.trim()} items`);
+  
+  // Parallel execution with proper typing
+  const [date, uptime]: [CommandResult, CommandResult] = await Promise.all([
+    $`date`,
+    $`uptime`
+  ]);
+  
+  console.log(`Current time: ${date.stdout.trim()}`);
+  console.log(`System uptime: ${uptime.stdout.trim()}`);
+}
+
+// Example 14: Type-safe environment and working directory
+async function environmentExample(): Promise<void> {
+  // Custom environment with full typing
+  const envCmd = $({ 
+    env: { 
+      NODE_ENV: 'production',
+      DEBUG: 'command-stream:*' 
+    },
+    cwd: process.cwd()
+  });
+  
+  const result: CommandResult = await envCmd`node --version`;
+  console.log(`Node version: ${result.stdout.trim()}`);
+}
+
+// Export all examples for demonstration
+export {
+  basicCommands,
+  configuredCommands,
+  streamingExamples,
+  eventDrivenProcessing,
+  virtualCommandsExample,
+  advancedStreaming,
+  pipelineExample,
+  errorHandling,
+  processStreams,
+  utilityExamples,
+  configurationExample,
+  asyncIterationPatterns,
+  multipleCommands,
+  environmentExample
+};
+
+// Main demonstration function
+export async function runAllExamples(): Promise<void> {
+  console.log('Running TypeScript examples for command-stream...');
+  
+  try {
+    await basicCommands();
+    await configuredCommands();
+    await streamingExamples();
+    eventDrivenProcessing();
+    await virtualCommandsExample();
+    await advancedStreaming();
+    await pipelineExample();
+    await errorHandling();
+    await processStreams();
+    utilityExamples();
+    configurationExample();
+    await asyncIterationPatterns();
+    await multipleCommands();
+    await environmentExample();
+    
+    console.log('All examples completed successfully!');
+  } catch (error) {
+    console.error('Error running examples:', error);
+  }
+}
\ No newline at end of file
diff --git a/index.d.ts b/index.d.ts
new file mode 100644
index 0000000..177fd80
--- /dev/null
+++ b/index.d.ts
@@ -0,0 +1,220 @@
+/**
+ * TypeScript definitions for command-stream
+ * Modern $ shell utility library with streaming, async iteration, and EventEmitter support
+ */
+
+import { Readable, Writable } from 'stream';
+import { ChildProcess } from 'child_process';
+
+// Base interfaces
+export interface CommandResult {
+  /** Exit code of the command */
+  code: number;
+  /** Standard output as string */
+  stdout: string;
+  /** Standard error as string */
+  stderr: string;
+  /** Standard input that was provided */
+  stdin: string;
+  /** Get stdout as text (async method) */
+  text(): Promise<string>;
+}
+
+export interface ProcessOptions {
+  /** Mirror output to console (default: true) */
+  mirror?: boolean;
+  /** Capture output for result (default: true) */
+  capture?: boolean;
+  /** Standard input handling */
+  stdin?: 'inherit' | 'pipe' | string | Buffer;
+  /** Working directory */
+  cwd?: string;
+  /** Environment variables */
+  env?: Record<string, string>;
+  /** Enable interactive TTY forwarding */
+  interactive?: boolean;
+  /** Enable shell operator parsing (default: true) */
+  shellOperators?: boolean;
+}
+
+export interface StreamOptions {
+  /** Standard input handling */
+  stdin?: 'inherit' | 'pipe';
+  /** Standard output handling */
+  stdout?: 'inherit' | 'pipe';
+  /** Standard error handling */
+  stderr?: 'inherit' | 'pipe';
+}
+
+// Event types for StreamEmitter
+export interface StreamEvents {
+  data: [Buffer];
+  end: [CommandResult];
+  error: [Error];
+  close: [number];
+}
+
+// Virtual command handler type
+export type VirtualCommandHandler = (args: string[], options: ProcessOptions) => Promise<CommandResult> | CommandResult | AsyncIterable<Buffer>;
+
+// Stream interfaces
+export interface ProcessStreams {
+  readonly stdin: Writable | null;
+  readonly stdout: Readable | null;
+  readonly stderr: Readable | null;
+}
+
+// Core ProcessRunner class with proper typing
+export declare class ProcessRunner {
+  constructor(spec: { mode: string; command: string }, options?: ProcessOptions);
+  
+  // Stream properties
+  readonly stdout: Readable | null;
+  readonly stderr: Readable | null;
+  readonly stdin: Writable | null;
+  
+  // New streaming interfaces
+  readonly streams: ProcessStreams;
+  
+  // EventEmitter-like interface
+  on<K extends keyof StreamEvents>(event: K, listener: (...args: StreamEvents[K]) => void): this;
+  once<K extends keyof StreamEvents>(event: K, listener: (...args: StreamEvents[K]) => void): this;
+  emit<K extends keyof StreamEvents>(event: K, ...args: StreamEvents[K]): boolean;
+  off<K extends keyof StreamEvents>(event: K, listener: (...args: StreamEvents[K]) => void): this;
+  
+  // Core methods
+  start(options?: { mode?: 'async' | 'sync' } & StreamOptions): this;
+  cancel(signal?: NodeJS.Signals): void;
+  
+  // Async iteration support
+  stream(): AsyncIterable<Buffer>;
+  
+  // Promise interface
+  then<TResult1 = CommandResult, TResult2 = never>(
+    onfulfilled?: ((value: CommandResult) => TResult1 | PromiseLike<TResult1>) | null,
+    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null
+  ): Promise<TResult1 | TResult2>;
+  
+  catch<TResult = never>(
+    onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null
+  ): Promise<CommandResult | TResult>;
+  
+  finally(onfinally?: (() => void) | null): Promise<CommandResult>;
+}
+
+// Main $ function interfaces
+export interface $Function {
+  // Tagged template usage: $`command`
+  (strings: TemplateStringsArray, ...values: any[]): ProcessRunner;
+  
+  // Options usage: $({ option: value })`command`
+  (options: ProcessOptions): (strings: TemplateStringsArray, ...values: any[]) => ProcessRunner;
+}
+
+// Shell execution functions
+export declare function sh(command: string, options?: ProcessOptions): ProcessRunner;
+export declare function exec(command: string, options?: ProcessOptions): ProcessRunner;
+export declare function run(command: string, options?: ProcessOptions): ProcessRunner;
+
+// Factory function
+export declare function create(defaultOptions?: ProcessOptions): $Function;
+
+// Utility functions
+export declare function quote(value: any): string;
+export declare function raw(value: any): { [Symbol.toPrimitive](): string };
+
+// Global state management
+export declare function set(option: string): void;
+export declare function unset(option: string): void;
+export declare function resetGlobalState(): void;
+export declare function forceCleanupAll(): void;
+
+// Virtual commands system with type safety
+export declare function register<TArgs extends readonly string[] = string[]>(
+  name: string, 
+  handler: VirtualCommandHandler
+): void;
+
+export declare function unregister(name: string): boolean;
+export declare function listCommands(): string[];
+export declare function enableVirtualCommands(): void;
+export declare function disableVirtualCommands(): void;
+
+// ANSI utilities
+export interface AnsiConfig {
+  enabled?: boolean;
+  colors?: boolean;
+  styles?: boolean;
+}
+
+export declare const AnsiUtils: {
+  strip(text: string): string;
+  hasAnsi(text: string): boolean;
+};
+
+export declare function configureAnsi(options?: AnsiConfig): void;
+export declare function getAnsiConfig(): Required<AnsiConfig>;
+export declare function processOutput(data: string | Buffer, options?: AnsiConfig): string;
+
+// Shell detection and utilities
+export declare const shell: {
+  cmd: string;
+  args: string[];
+};
+
+// Main exports
+export declare const $: $Function;
+export default $;
+
+// Type-safe pipeline definitions
+export type PipelineStep<T = any> = ProcessRunner | ((input: T) => ProcessRunner);
+export type Pipeline<T = any> = PipelineStep<T>[];
+
+// Generic streaming support
+export interface StreamingOptions<T = Buffer> {
+  transform?: (chunk: Buffer) => T;
+  encoding?: BufferEncoding;
+}
+
+// Enhanced ProcessRunner with generics for streaming
+declare module './src/$.mjs' {
+  interface ProcessRunner {
+    stream<T = Buffer>(options?: StreamingOptions<T>): AsyncIterable<T>;
+  }
+}
+
+// Template expression type for advanced usage
+export type TemplateExpression = string | number | boolean | null | undefined | Buffer | 
+  { toString(): string } | { [Symbol.toPrimitive](hint: 'string'): string };
+
+// Virtual command registration with better typing
+export interface TypedVirtualCommand<TArgs extends readonly unknown[] = unknown[]> {
+  name: string;
+  handler: (...args: TArgs) => Promise<CommandResult> | CommandResult | AsyncIterable<Buffer>;
+}
+
+export declare function registerTyped<TArgs extends readonly unknown[]>(
+  command: TypedVirtualCommand<TArgs>
+): void;
+
+// Event type definitions for full IDE support
+export type CommandEventMap = {
+  'data': Buffer;
+  'stdout': Buffer;
+  'stderr': Buffer;
+  'end': CommandResult;
+  'error': Error;
+  'close': number;
+  'start': void;
+  'cancel': NodeJS.Signals;
+};
+
+// Extend ProcessRunner with properly typed events
+declare module './src/$.mjs' {
+  interface ProcessRunner {
+    on<K extends keyof CommandEventMap>(event: K, listener: (data: CommandEventMap[K]) => void): this;
+    once<K extends keyof CommandEventMap>(event: K, listener: (data: CommandEventMap[K]) => void): this;
+    emit<K extends keyof CommandEventMap>(event: K, data: CommandEventMap[K]): boolean;
+    off<K extends keyof CommandEventMap>(event: K, listener: (data: CommandEventMap[K]) => void): this;
+  }
+}
\ No newline at end of file
diff --git a/package.json b/package.json
index 6723c5b..71848c2 100644
--- a/package.json
+++ b/package.json
@@ -1,12 +1,16 @@
 {
   "name": "command-stream",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "description": "Modern $ shell utility library with streaming, async iteration, and EventEmitter support, optimized for Bun runtime",
   "type": "module",
   "main": "src/$.mjs",
   "exports": {
-    ".": "./src/$.mjs"
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./src/$.mjs"
+    }
   },
+  "types": "index.d.ts",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/link-foundation/command-stream.git"
@@ -34,7 +38,9 @@
     "eventemitter",
     "bun",
     "node",
-    "cross-runtime"
+    "cross-runtime",
+    "typescript",
+    "types"
   ],
   "author": "link-foundation",
   "license": "Unlicense",
@@ -44,6 +50,8 @@
   },
   "files": [
     "src/",
+    "index.d.ts",
+    "types/",
     "README.md",
     "LICENSE"
   ]
diff --git a/tsconfig.json b/tsconfig.json
new file mode 100644
index 0000000..198d78b
--- /dev/null
+++ b/tsconfig.json
@@ -0,0 +1,35 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Node",
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "strict": true,
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "./dist",
+    "rootDir": "./",
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "lib": ["ES2022", "DOM"],
+    "types": ["node"],
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "resolveJsonModule": true
+  },
+  "include": [
+    "src/**/*",
+    "examples/**/*",
+    "index.d.ts",
+    "types/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "tests/**/*"
+  ],
+  "ts-node": {
+    "esm": true
+  }
+}
\ No newline at end of file
diff --git a/types/pipelines.d.ts b/types/pipelines.d.ts
new file mode 100644
index 0000000..e6d95ef
--- /dev/null
+++ b/types/pipelines.d.ts
@@ -0,0 +1,225 @@
+/**
+ * TypeScript definitions for type-safe pipeline operations in command-stream
+ * Advanced pipeline composition with full type inference
+ */
+
+import { ProcessRunner, CommandResult, ProcessOptions } from '../index';
+
+// Pipeline step types with full type inference
+export type PipelineInput<T = Buffer> = T | AsyncIterable<T> | Promise<T>;
+export type PipelineOutput<T = Buffer> = ProcessRunner | AsyncIterable<T> | Promise<T>;
+
+export interface PipelineStep<TInput = any, TOutput = any> {
+  (input: PipelineInput<TInput>): PipelineOutput<TOutput>;
+}
+
+// Type-safe pipeline builder with inference
+export interface TypedPipeline<TInput = Buffer, TOutput = Buffer> {
+  /** Add a processing step to the pipeline */
+  pipe<TNext>(step: PipelineStep<TOutput, TNext>): TypedPipeline<TInput, TNext>;
+  
+  /** Add a command step to the pipeline */
+  command(cmd: string, options?: ProcessOptions): TypedPipeline<TInput, Buffer>;
+  
+  /** Add a transformation step */
+  transform<TNext>(
+    transform: (input: TOutput) => TNext | Promise<TNext>
+  ): TypedPipeline<TInput, TNext>;
+  
+  /** Add a filtering step */
+  filter(predicate: (input: TOutput) => boolean | Promise<boolean>): TypedPipeline<TInput, TOutput>;
+  
+  /** Add a mapping step */
+  map<TNext>(
+    mapper: (input: TOutput) => TNext | Promise<TNext>
+  ): TypedPipeline<TInput, TNext>;
+  
+  /** Execute the pipeline */
+  execute(input: PipelineInput<TInput>): Promise<TOutput>;
+  
+  /** Execute and collect results as array */
+  collect(input: PipelineInput<TInput>): Promise<TOutput[]>;
+  
+  /** Execute and get final result */
+  result(input: PipelineInput<TInput>): Promise<CommandResult>;
+}
+
+// Pipeline creation functions with full type safety
+export declare function pipeline<T = Buffer>(): TypedPipeline<T, T>;
+
+export declare function pipeline<TInput, TOutput>(
+  firstStep: PipelineStep<TInput, TOutput>
+): TypedPipeline<TInput, TOutput>;
+
+// Common pipeline patterns
+export interface CommonPipelines {
+  /** Text processing pipeline */
+  text(): TypedPipeline<string, string>;
+  
+  /** JSON processing pipeline */
+  json<T = any>(): TypedPipeline<T, T>;
+  
+  /** File processing pipeline */
+  files(): TypedPipeline<string, Buffer>;
+  
+  /** Line-by-line processing pipeline */
+  lines(): TypedPipeline<Buffer, string>;
+  
+  /** Byte processing pipeline */
+  bytes(): TypedPipeline<Buffer, Buffer>;
+}
+
+export declare const pipelines: CommonPipelines;
+
+// Pipeline composition utilities
+export declare function compose<A, B, C>(
+  f: PipelineStep<A, B>,
+  g: PipelineStep<B, C>
+): PipelineStep<A, C>;
+
+export declare function compose<A, B, C, D>(
+  f: PipelineStep<A, B>,
+  g: PipelineStep<B, C>,
+  h: PipelineStep<C, D>
+): PipelineStep<A, D>;
+
+// Overload for more compositions as needed
+export declare function compose<T>(...steps: PipelineStep<any, any>[]): PipelineStep<any, T>;
+
+// Parallel pipeline execution
+export interface ParallelPipeline<TInput = Buffer, TOutput = Buffer> {
+  /** Add a parallel branch */
+  branch<TBranch>(
+    step: PipelineStep<TInput, TBranch>
+  ): ParallelPipeline<TInput, TOutput | TBranch>;
+  
+  /** Execute all branches in parallel */
+  execute(input: PipelineInput<TInput>): Promise<TOutput[]>;
+  
+  /** Merge results from all branches */
+  merge<TMerged>(
+    merger: (results: TOutput[]) => TMerged | Promise<TMerged>
+  ): Promise<TMerged>;
+}
+
+export declare function parallel<T = Buffer>(): ParallelPipeline<T, never>;
+
+// Conditional pipeline execution
+export interface ConditionalPipeline<TInput = Buffer> {
+  /** Add a condition */
+  when<TOutput>(
+    condition: (input: TInput) => boolean | Promise<boolean>,
+    step: PipelineStep<TInput, TOutput>
+  ): ConditionalPipeline<TInput> & { then: TypedPipeline<TInput, TOutput> };
+  
+  /** Add an else branch */
+  otherwise<TOutput>(
+    step: PipelineStep<TInput, TOutput>
+  ): TypedPipeline<TInput, TOutput>;
+}
+
+export declare function conditional<T = Buffer>(): ConditionalPipeline<T>;
+
+// Pipeline error handling
+export interface ErrorHandlingPipeline<TInput = Buffer, TOutput = Buffer> 
+  extends TypedPipeline<TInput, TOutput> {
+  
+  /** Add error handling */
+  catch<TError = Error>(
+    handler: (error: TError, input: TInput) => TOutput | Promise<TOutput>
+  ): ErrorHandlingPipeline<TInput, TOutput>;
+  
+  /** Add retry logic */
+  retry(
+    attempts: number,
+    backoff?: (attempt: number) => number
+  ): ErrorHandlingPipeline<TInput, TOutput>;
+  
+  /** Add fallback value */
+  fallback(value: TOutput | (() => TOutput | Promise<TOutput>)): TypedPipeline<TInput, TOutput>;
+}
+
+export declare function resilient<TInput = Buffer, TOutput = Buffer>(
+  pipeline: TypedPipeline<TInput, TOutput>
+): ErrorHandlingPipeline<TInput, TOutput>;
+
+// Pipeline monitoring and debugging
+export interface PipelineMetrics {
+  stepCount: number;
+  totalDuration: number;
+  stepDurations: number[];
+  stepNames: string[];
+  inputSize?: number;
+  outputSize?: number;
+  throughput?: number;
+}
+
+export interface MonitoredPipeline<TInput = Buffer, TOutput = Buffer> 
+  extends TypedPipeline<TInput, TOutput> {
+  
+  /** Get execution metrics */
+  getMetrics(): PipelineMetrics;
+  
+  /** Add step timing */
+  timeStep(name: string): MonitoredPipeline<TInput, TOutput>;
+  
+  /** Add logging */
+  log(logger: (step: string, input: any, output: any, duration: number) => void): MonitoredPipeline<TInput, TOutput>;
+}
+
+export declare function monitored<TInput = Buffer, TOutput = Buffer>(
+  pipeline: TypedPipeline<TInput, TOutput>
+): MonitoredPipeline<TInput, TOutput>;
+
+// Common pipeline step factories
+export interface PipelineSteps {
+  /** Command execution step */
+  command(cmd: string, options?: ProcessOptions): PipelineStep<Buffer, Buffer>;
+  
+  /** Text transformation step */
+  textTransform(
+    transform: (text: string) => string | Promise<string>
+  ): PipelineStep<Buffer, Buffer>;
+  
+  /** JSON parsing step */
+  parseJson<T = any>(): PipelineStep<Buffer, T>;
+  
+  /** JSON stringifying step */
+  stringifyJson(): PipelineStep<any, Buffer>;
+  
+  /** File reading step */
+  readFile(path: string): PipelineStep<void, Buffer>;
+  
+  /** File writing step */
+  writeFile(path: string): PipelineStep<Buffer, void>;
+  
+  /** Buffer to string conversion */
+  toString(encoding?: BufferEncoding): PipelineStep<Buffer, string>;
+  
+  /** String to buffer conversion */
+  toBuffer(encoding?: BufferEncoding): PipelineStep<string, Buffer>;
+  
+  /** Array collection step */
+  collect<T>(): PipelineStep<AsyncIterable<T>, T[]>;
+  
+  /** Batching step */
+  batch<T>(size: number): PipelineStep<AsyncIterable<T>, AsyncIterable<T[]>>;
+  
+  /** Debouncing step */
+  debounce<T>(delay: number): PipelineStep<AsyncIterable<T>, AsyncIterable<T>>;
+  
+  /** Throttling step */
+  throttle<T>(rate: number): PipelineStep<AsyncIterable<T>, AsyncIterable<T>>;
+}
+
+export declare const steps: PipelineSteps;
+
+// Template literal type for command pipelines
+export type CommandTemplate = (strings: TemplateStringsArray, ...values: any[]) => ProcessRunner;
+
+export interface PipelineTemplate {
+  /** Template literal for type-safe command pipelines */
+  (strings: TemplateStringsArray, ...values: any[]): TypedPipeline<Buffer, Buffer>;
+}
+
+export declare const p: PipelineTemplate;
\ No newline at end of file
diff --git a/types/streaming.d.ts b/types/streaming.d.ts
new file mode 100644
index 0000000..7d2b76e
--- /dev/null
+++ b/types/streaming.d.ts
@@ -0,0 +1,162 @@
+/**
+ * TypeScript definitions for streaming functionality in command-stream
+ * Advanced streaming interfaces with full generic type support
+ */
+
+import { Readable, Writable, Transform } from 'stream';
+import { ProcessRunner, CommandResult } from '../index';
+
+// Generic streaming transformations
+export type StreamTransform<TInput = Buffer, TOutput = Buffer> = 
+  (chunk: TInput) => TOutput | Promise<TOutput>;
+
+export type StreamFilter<T = Buffer> = 
+  (chunk: T) => boolean | Promise<boolean>;
+
+export type StreamReducer<T = Buffer, TAcc = T> = 
+  (accumulator: TAcc, chunk: T) => TAcc | Promise<TAcc>;
+
+// Streaming options with generics
+export interface StreamingOptions<TInput = Buffer, TOutput = TInput> {
+  /** Transform each chunk */
+  transform?: StreamTransform<TInput, TOutput>;
+  /** Filter chunks */
+  filter?: StreamFilter<TInput>;
+  /** Encoding for string conversion */
+  encoding?: BufferEncoding;
+  /** Chunk size for reading */
+  highWaterMark?: number;
+  /** Object mode for non-buffer data */
+  objectMode?: boolean;
+}
+
+// Line-based streaming
+export interface LineStreamingOptions {
+  /** Line ending character(s) */
+  separator?: string | RegExp;
+  /** Skip empty lines */
+  skipEmpty?: boolean;
+  /** Trim whitespace from lines */
+  trim?: boolean;
+  /** Encoding for string conversion */
+  encoding?: BufferEncoding;
+}
+
+// Advanced streaming interfaces
+export interface EnhancedProcessRunner extends ProcessRunner {
+  // Generic streaming with transformations
+  stream<TOutput = Buffer>(options?: StreamingOptions<Buffer, TOutput>): AsyncIterable<TOutput>;
+  
+  // JSON streaming (for commands that output JSON)
+  json<T = any>(): AsyncIterable<T>;
+  
+  // Byte streaming with exact control
+  bytes(options?: { chunkSize?: number }): AsyncIterable<Buffer>;
+  
+  // Text streaming with encoding
+  text(encoding?: BufferEncoding): AsyncIterable<string>;
+  
+  // Stream operations
+  map<TOutput>(transform: StreamTransform<Buffer, TOutput>): AsyncIterable<TOutput>;
+  filter(predicate: StreamFilter<Buffer>): AsyncIterable<Buffer>;
+  reduce<TAcc>(reducer: StreamReducer<Buffer, TAcc>, initialValue: TAcc): Promise<TAcc>;
+  collect(): Promise<Buffer[]>;
+  collectText(encoding?: BufferEncoding): Promise<string>;
+  
+  // Pipeline operations
+  pipe<TTarget extends Writable>(destination: TTarget): TTarget;
+  pipeThrough<TTransform extends Transform>(transform: TTransform): TTransform;
+}
+
+// Stream composition types
+export type StreamPipeline<TInput = Buffer, TOutput = Buffer> = 
+  (input: AsyncIterable<TInput>) => AsyncIterable<TOutput>;
+
+export interface PipelineBuilder<T = Buffer> {
+  map<TOutput>(transform: StreamTransform<T, TOutput>): PipelineBuilder<TOutput>;
+  filter(predicate: StreamFilter<T>): PipelineBuilder<T>;
+  take(count: number): PipelineBuilder<T>;
+  skip(count: number): PipelineBuilder<T>;
+  batch(size: number): PipelineBuilder<T[]>;
+  build(): StreamPipeline<Buffer, T>;
+}
+
+// Stream utilities
+export declare function createPipeline<T = Buffer>(): PipelineBuilder<T>;
+
+export declare function streamToArray<T>(stream: AsyncIterable<T>): Promise<T[]>;
+
+export declare function streamToString(
+  stream: AsyncIterable<Buffer>, 
+  encoding?: BufferEncoding
+): Promise<string>;
+
+export declare function mergeStreams<T>(...streams: AsyncIterable<T>[]): AsyncIterable<T>;
+
+export declare function splitStream<T>(
+  stream: AsyncIterable<T>,
+  predicate: StreamFilter<T>
+): [AsyncIterable<T>, AsyncIterable<T>];
+
+// Real-time streaming events
+export interface StreamEventMap<T = Buffer> {
+  'chunk': T;
+  'line': string;
+  'json': any;
+  'error': Error;
+  'end': void;
+  'start': void;
+}
+
+export interface RealTimeStream<T = Buffer> {
+  on<K extends keyof StreamEventMap<T>>(
+    event: K, 
+    listener: (data: StreamEventMap<T>[K]) => void
+  ): this;
+  
+  off<K extends keyof StreamEventMap<T>>(
+    event: K, 
+    listener: (data: StreamEventMap<T>[K]) => void
+  ): this;
+  
+  once<K extends keyof StreamEventMap<T>>(
+    event: K, 
+    listener: (data: StreamEventMap<T>[K]) => void
+  ): this;
+}
+
+// Streaming process runner factory
+export declare function createStreamingRunner(
+  command: string,
+  options?: StreamingOptions
+): EnhancedProcessRunner;
+
+// Type guards
+export declare function isStreamableProcessRunner(
+  runner: ProcessRunner
+): runner is EnhancedProcessRunner;
+
+// Stream performance monitoring
+export interface StreamMetrics {
+  bytesProcessed: number;
+  chunksProcessed: number;
+  startTime: Date;
+  endTime?: Date;
+  duration?: number;
+  throughput?: number; // bytes per second
+}
+
+export declare function monitorStream<T>(
+  stream: AsyncIterable<T>
+): AsyncIterable<T> & { getMetrics(): StreamMetrics };
+
+// Advanced stream combinators
+export declare function race<T>(...streams: AsyncIterable<T>[]): AsyncIterable<T>;
+export declare function parallel<T>(
+  stream: AsyncIterable<T>,
+  concurrency?: number
+): AsyncIterable<T>;
+export declare function buffer<T>(
+  stream: AsyncIterable<T>,
+  size: number
+): AsyncIterable<T[]>;
\ No newline at end of file
diff --git a/types/virtual-commands.d.ts b/types/virtual-commands.d.ts
new file mode 100644
index 0000000..80fee3d
--- /dev/null
+++ b/types/virtual-commands.d.ts
@@ -0,0 +1,73 @@
+/**
+ * TypeScript definitions for virtual commands in command-stream
+ * Built-in command implementations with full type safety
+ */
+
+import { CommandResult, ProcessOptions } from '../index';
+
+// Built-in virtual commands with typed interfaces
+export interface BuiltinCommands {
+  // File system operations
+  cat: (files: string[]) => Promise<CommandResult>;
+  cp: (source: string, destination: string, options?: { recursive?: boolean }) => Promise<CommandResult>;
+  mv: (source: string, destination: string) => Promise<CommandResult>;
+  rm: (files: string[], options?: { recursive?: boolean; force?: boolean }) => Promise<CommandResult>;
+  ls: (paths?: string[], options?: { all?: boolean; long?: boolean }) => Promise<CommandResult>;
+  mkdir: (paths: string[], options?: { parents?: boolean; mode?: string }) => Promise<CommandResult>;
+  touch: (files: string[]) => Promise<CommandResult>;
+  pwd: () => Promise<CommandResult>;
+  cd: (path?: string) => Promise<CommandResult>;
+  
+  // Text processing
+  echo: (...args: string[]) => Promise<CommandResult>;
+  yes: (text?: string) => AsyncIterable<Buffer>;
+  seq: (start: number, end?: number, step?: number) => Promise<CommandResult>;
+  
+  // System utilities
+  basename: (path: string, suffix?: string) => Promise<CommandResult>;
+  dirname: (path: string) => Promise<CommandResult>;
+  env: (variables?: Record<string, string>) => Promise<CommandResult>;
+  which: (command: string) => Promise<CommandResult>;
+  test: (expression: string) => Promise<CommandResult>;
+  sleep: (seconds: number) => Promise<CommandResult>;
+  
+  // Control flow
+  true: () => Promise<CommandResult>;
+  false: () => Promise<CommandResult>;
+  exit: (code?: number) => Promise<CommandResult>;
+}
+
+// Type-safe virtual command registration
+export type VirtualCommandName = keyof BuiltinCommands;
+
+export interface VirtualCommandDefinition<TArgs extends readonly unknown[] = unknown[]> {
+  name: string;
+  description?: string;
+  usage?: string;
+  handler: (...args: TArgs) => Promise<CommandResult> | CommandResult | AsyncIterable<Buffer>;
+}
+
+// Enhanced registration with full typing
+export declare function registerVirtualCommand<TArgs extends readonly unknown[]>(
+  definition: VirtualCommandDefinition<TArgs>
+): void;
+
+// Command existence checking
+export declare function hasVirtualCommand(name: string): boolean;
+export declare function getVirtualCommand(name: string): VirtualCommandDefinition | undefined;
+
+// Bulk operations
+export declare function registerBuiltinCommands(): void;
+export declare function unregisterAllVirtualCommands(): void;
+
+// Command metadata
+export interface CommandMetadata {
+  name: string;
+  description: string;
+  usage: string;
+  category: 'filesystem' | 'text' | 'system' | 'control' | 'custom';
+  builtin: boolean;
+}
+
+export declare function getCommandMetadata(name: string): CommandMetadata | undefined;
+export declare function listCommandMetadata(): CommandMetadata[];
\ No newline at end of file