command-stream 0.8.2 → 0.9.0

package/js/tests/builtin-commands.test.mjs

@@ -0,0 +1,387 @@
+import { test, expect, describe, beforeEach, afterEach } from 'bun:test';
+import { isWindows } from './test-helper.mjs'; // Automatically sets up beforeEach/afterEach cleanup
+import { $, register, unregister, enableVirtualCommands } from '../src/$.mjs';
+import { trace } from '../src/$.utils.mjs';
+import { rmSync, existsSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+// Test directory for safe file operations
+const TEST_DIR = 'test-builtin-commands';
+
+beforeEach(() => {
+  // Enable virtual commands for these tests
+  enableVirtualCommands();
+
+  // Create clean test directory
+  if (existsSync(TEST_DIR)) {
+    rmSync(TEST_DIR, { recursive: true, force: true });
+  }
+  mkdirSync(TEST_DIR);
+});
+
+afterEach(() => {
+  // Clean up test directory
+  if (existsSync(TEST_DIR)) {
+    rmSync(TEST_DIR, { recursive: true, force: true });
+  }
+});
+
+describe('Built-in Commands (Bun.$ compatible)', () => {
+  describe('File Reading Commands', () => {
+    test('cat should read file contents', async () => {
+      const testFile = join(TEST_DIR, 'test.txt');
+      writeFileSync(testFile, 'Hello World\nLine 2\n');
+
+      const result = await $`cat ${testFile}`;
+      expect(result.code).toBe(0);
+      expect(result.stdout).toBe('Hello World\nLine 2\n');
+    });
+
+    test('cat should read from stdin when no files provided', async () => {
+      const result = await $`echo "input" | cat`;
+      expect(result.code).toBe(0);
+      expect(result.stdout).toBe('input\n');
+    });
+
+    test('cat should handle non-existent files', async () => {
+      const result = await $`cat nonexistent.txt`;
+      expect(result.code).toBe(1);
+      expect(result.stderr).toContain('No such file or directory');
+    });
+  });
+
+  describe('Directory Listing Commands', () => {
+    test('ls should list directory contents', async () => {
+      writeFileSync(join(TEST_DIR, 'file1.txt'), 'content');
+      writeFileSync(join(TEST_DIR, 'file2.txt'), 'content');
+      mkdirSync(join(TEST_DIR, 'subdir'));
+
+      const result = await $`ls ${TEST_DIR}`;
+      expect(result.code).toBe(0);
+      expect(result.stdout).toContain('file1.txt');
+      expect(result.stdout).toContain('file2.txt');
+      expect(result.stdout).toContain('subdir');
+    });
+
+    test('ls should support -a flag for hidden files', async () => {
+      writeFileSync(join(TEST_DIR, '.hidden'), 'content');
+      writeFileSync(join(TEST_DIR, 'visible.txt'), 'content');
+
+      const result = await $`ls -a ${TEST_DIR}`;
+      expect(result.code).toBe(0);
+      expect(result.stdout).toContain('.hidden');
+      expect(result.stdout).toContain('visible.txt');
+    });
+
+    test('ls should support -l flag for long format', async () => {
+      writeFileSync(join(TEST_DIR, 'test.txt'), 'content');
+
+      const result = await $`ls -l ${TEST_DIR}`;
+      expect(result.code).toBe(0);
+      expect(result.stdout).toContain('-rw-r--r--');
+      expect(result.stdout).toContain('test.txt');
+    });
+  });
+
+  describe('File Creation Commands', () => {
+    test('mkdir should create directories', async () => {
+      const result = await $`mkdir ${join(TEST_DIR, 'newdir')}`;
+      expect(result.code).toBe(0);
+      expect(existsSync(join(TEST_DIR, 'newdir'))).toBe(true);
+    });
+
+    test('mkdir -p should create parent directories', async () => {
+      const result = await $`mkdir -p ${join(TEST_DIR, 'parent', 'child')}`;
+      expect(result.code).toBe(0);
+      expect(existsSync(join(TEST_DIR, 'parent', 'child'))).toBe(true);
+    });
+
+    test('touch should create new files', async () => {
+      const testFile = join(TEST_DIR, 'touched.txt');
+      const result = await $`touch ${testFile}`;
+      expect(result.code).toBe(0);
+      expect(existsSync(testFile)).toBe(true);
+    });
+
+    test('touch should update existing file timestamps', async () => {
+      const testFile = join(TEST_DIR, 'existing.txt');
+      writeFileSync(testFile, 'content');
+      const oldStat = require('fs').statSync(testFile);
+
+      // Wait a bit to ensure timestamp difference
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      const result = await $`touch ${testFile}`;
+      expect(result.code).toBe(0);
+
+      const newStat = require('fs').statSync(testFile);
+      expect(newStat.mtime.getTime()).toBeGreaterThan(oldStat.mtime.getTime());
+    });
+  });
+
+  describe('File Removal Commands', () => {
+    test('rm should remove files', async () => {
+      const testFile = join(TEST_DIR, 'to-remove.txt');
+      writeFileSync(testFile, 'content');
+
+      const result = await $`rm ${testFile}`;
+      expect(result.code).toBe(0);
+      expect(existsSync(testFile)).toBe(false);
+    });
+
+    test('rm should fail on directories without -r', async () => {
+      const testDir = join(TEST_DIR, 'to-remove-dir');
+      mkdirSync(testDir);
+
+      const result = await $`rm ${testDir}`;
+      expect(result.code).toBe(1);
+      expect(result.stderr).toContain('Is a directory');
+      expect(existsSync(testDir)).toBe(true);
+    });
+
+    test('rm -r should remove directories recursively', async () => {
+      const testDir = join(TEST_DIR, 'to-remove-recursive');
+      mkdirSync(testDir);
+      writeFileSync(join(testDir, 'file.txt'), 'content');
+
+      const result = await $`rm -r ${testDir}`;
+      expect(result.code).toBe(0);
+      expect(existsSync(testDir)).toBe(false);
+    });
+
+    test('rm -f should suppress errors on non-existent files', async () => {
+      const result = await $`rm -f nonexistent.txt`;
+      expect(result.code).toBe(0);
+    });
+  });
+
+  describe('File Copy/Move Commands', () => {
+    test('cp should copy files', async () => {
+      const source = join(TEST_DIR, 'source.txt');
+      const dest = join(TEST_DIR, 'dest.txt');
+      writeFileSync(source, 'test content');
+
+      const result = await $`cp ${source} ${dest}`;
+      expect(result.code).toBe(0);
+      expect(existsSync(dest)).toBe(true);
+      expect(readFileSync(dest, 'utf8')).toBe('test content');
+    });
+
+    test('cp -r should copy directories recursively', async () => {
+      const sourceDir = join(TEST_DIR, 'source-dir');
+      const destDir = join(TEST_DIR, 'dest-dir');
+      mkdirSync(sourceDir);
+      writeFileSync(join(sourceDir, 'file.txt'), 'content');
+
+      const result = await $`cp -r ${sourceDir} ${destDir}`;
+      expect(result.code).toBe(0);
+      expect(existsSync(destDir)).toBe(true);
+      expect(existsSync(join(destDir, 'file.txt'))).toBe(true);
+    });
+
+    test('mv should move/rename files', async () => {
+      const source = join(TEST_DIR, 'source.txt');
+      const dest = join(TEST_DIR, 'dest.txt');
+      writeFileSync(source, 'test content');
+
+      const result = await $`mv ${source} ${dest}`;
+      expect(result.code).toBe(0);
+      expect(existsSync(source)).toBe(false);
+      expect(existsSync(dest)).toBe(true);
+      expect(readFileSync(dest, 'utf8')).toBe('test content');
+    });
+
+    test('mv should move files to directory', async () => {
+      const source = join(TEST_DIR, 'source.txt');
+      const destDir = join(TEST_DIR, 'dest-dir');
+      writeFileSync(source, 'test content');
+      mkdirSync(destDir);
+
+      const result = await $`mv ${source} ${destDir}`;
+      expect(result.code).toBe(0);
+      expect(existsSync(source)).toBe(false);
+      expect(existsSync(join(destDir, 'source.txt'))).toBe(true);
+    });
+  });
+
+  describe('Path Utility Commands', () => {
+    test('basename should extract filename', async () => {
+      const result = await $`basename /path/to/file.txt`;
+      expect(result.code).toBe(0);
+      expect(result.stdout.trim()).toBe('file.txt');
+    });
+
+    test('basename should remove suffix', async () => {
+      const result = await $`basename /path/to/file.txt .txt`;
+      expect(result.code).toBe(0);
+      expect(result.stdout.trim()).toBe('file');
+    });
+
+    test('dirname should extract directory path', async () => {
+      const result = await $`dirname /path/to/file.txt`;
+      expect(result.code).toBe(0);
+      expect(result.stdout.trim()).toBe('/path/to');
+    });
+  });
+
+  describe('Sequence Generation Commands', () => {
+    test('seq should generate number sequence', async () => {
+      const result = await $`seq 1 3`;
+      expect(result.code).toBe(0);
+      expect(result.stdout).toBe('1\n2\n3\n');
+    });
+
+    test('seq should handle single argument', async () => {
+      const result = await $`seq 3`;
+      expect(result.code).toBe(0);
+      expect(result.stdout).toBe('1\n2\n3\n');
+    });
+
+    test('seq should handle step argument', async () => {
+      const result = await $`seq 1 2 5`;
+      expect(result.code).toBe(0);
+      expect(result.stdout).toBe('1\n3\n5\n');
+    });
+  });
+
+  describe('Streaming Commands', () => {
+    test('yes should output repeatedly', async () => {
+      // Test with a limit to avoid infinite output
+      const chunks = [];
+      let count = 0;
+
+      for await (const chunk of $`yes hello`.stream()) {
+        chunks.push(chunk.data.toString());
+        count++;
+        if (count >= 3) {
+          break;
+        }
+      }
+
+      expect(chunks.length).toBe(3);
+      chunks.forEach((chunk) => {
+        expect(chunk).toBe('hello\n');
+      });
+    });
+
+    test('yes should default to "y"', async () => {
+      const chunks = [];
+      let count = 0;
+
+      for await (const chunk of $`yes`.stream()) {
+        chunks.push(chunk.data.toString());
+        count++;
+        if (count >= 2) {
+          break;
+        }
+      }
+
+      expect(chunks.length).toBe(2);
+      chunks.forEach((chunk) => {
+        expect(chunk).toBe('y\n');
+      });
+    });
+  });
+
+  describe('Command Location (which)', () => {
+    // Skip on Windows - uses Unix 'which sh' command
+    test.skipIf(isWindows)(
+      'which should find existing system commands',
+      async () => {
+        // Test with a command that should definitely exist on all systems
+        const result = await $`which sh`;
+        expect(result.code).toBe(0);
+        expect(result.stdout).toMatch(/\/.*sh/); // Should contain path to sh
+      }
+    );
+
+    test('which should find node/bun executable', async () => {
+      // Test with node or bun depending on the environment
+      const command = typeof Bun !== 'undefined' ? 'bun' : 'node';
+      const result = await $`which ${command}`;
+      expect(result.code).toBe(0);
+      expect(result.stdout).toMatch(new RegExp(`.*${command}`));
+    });
+
+    test('which should find homebrew-installed commands (if available)', async () => {
+      // Test with gh (GitHub CLI) which is commonly installed via homebrew
+      const result = await $`which gh`;
+
+      // Enable verbose mode to see debug info if this test fails
+      if (result.code !== 0) {
+        trace('BuiltinTest', 'DEBUG: which gh failed');
+        trace('BuiltinTest', () => `Exit code: ${result.code}`);
+        trace('BuiltinTest', () => `Stdout: ${JSON.stringify(result.stdout)}`);
+        trace('BuiltinTest', () => `Stderr: ${JSON.stringify(result.stderr)}`);
+        trace('BuiltinTest', () => `PATH: ${process.env.PATH}`);
+
+        // Try to find gh manually to confirm it exists
+        const manualCheck = await $`/usr/bin/which gh`.catch(() => ({
+          code: 1,
+          stdout: '',
+          stderr: 'manual which failed',
+        }));
+        trace(
+          'BuiltinTest',
+          () => `Manual /usr/bin/which result: ${manualCheck}`
+        );
+      }
+
+      // If gh is installed, it should return 0, otherwise skip this test
+      // Note: We can't guarantee gh is installed on all systems
+      if (result.code === 0) {
+        expect(result.stdout).toMatch(/.*gh/);
+      } else {
+        trace(
+          'BuiltinTest',
+          'Skipping gh test - command not found or which implementation bug'
+        );
+      }
+    });
+
+    test('which should return non-zero for non-existent commands', async () => {
+      const result = await $`which nonexistent-command-12345`;
+      expect(result.code).toBe(1);
+      expect(result.stderr).toContain('no nonexistent-command-12345 in PATH');
+    });
+
+    test('which should find built-in virtual commands', async () => {
+      const result = await $`which echo`;
+      expect(result.code).toBe(0);
+      expect(result.stdout).toContain('shell builtin');
+    });
+
+    test('which should handle missing arguments', async () => {
+      const result = await $`which`;
+      expect(result.code).toBe(1);
+      expect(result.stderr).toContain('missing operand');
+    });
+  });
+
+  describe('Error Handling', () => {
+    test('commands should return proper exit codes', async () => {
+      const success = await $`true`;
+      expect(success.code).toBe(0);
+
+      const failure = await $`false`;
+      expect(failure.code).toBe(1);
+    });
+
+    test('commands should provide helpful error messages', async () => {
+      const result = await $`cat nonexistent.txt`;
+      expect(result.code).toBe(1);
+      expect(result.stderr).toContain('cat:');
+      expect(result.stderr).toContain('nonexistent.txt');
+    });
+
+    test('commands should handle missing operands', async () => {
+      const mkdirResult = await $`mkdir`;
+      expect(mkdirResult.code).toBe(1);
+      expect(mkdirResult.stderr).toContain('missing operand');
+
+      const rmResult = await $`rm`;
+      expect(rmResult.code).toBe(1);
+      expect(rmResult.stderr).toContain('missing operand');
+    });
+  });
+});

package/js/tests/bun-shell-path-fix.test.mjs

@@ -0,0 +1,115 @@
+/**
+ * Tests for Bun runtime shell path issue fix
+ *
+ * This addresses GitHub issue #42: Bun runtime shell path issues
+ * The issue was that string interpolation in template literals was incorrectly quoting
+ * complete command strings, causing shell commands to fail execution.
+ */
+
+import { test, expect, describe } from 'bun:test';
+import { $ } from '../src/$.mjs';
+
+// Test both Bun and Node.js runtimes
+const isBun = typeof globalThis.Bun !== 'undefined';
+const runtime = isBun ? 'Bun' : 'Node.js';
+
+// Platform detection - Some tests use Unix-specific paths and commands
+const isWindows = process.platform === 'win32';
+
+// Skip on Windows - tests reference /bin/sh and Unix paths
+describe.skipIf(isWindows)(`String interpolation fix for ${runtime}`, () => {
+  test('Template literal without interpolation should work', async () => {
+    const result = await $`echo hello`;
+    expect(result.stdout.toString().trim()).toBe('hello');
+  });
+
+  test('String interpolation with complete command should work', async () => {
+    const cmd = 'echo hello';
+    const result = await $`${cmd}`;
+    expect(result.stdout.toString().trim()).toBe('hello');
+  });
+
+  test('String interpolation with command and args should work', async () => {
+    const cmd = 'echo "hello world"';
+    const result = await $`${cmd}`;
+    expect(result.stdout.toString().trim()).toBe('hello world');
+  });
+
+  test('Mixed template literal with interpolation should work', async () => {
+    const arg = 'hello';
+    const result = await $`echo ${arg}`;
+    expect(result.stdout.toString().trim()).toBe('hello');
+  });
+
+  test('Complex shell commands via interpolation should work', async () => {
+    const cmd = 'echo hello | wc -w';
+    const result = await $`${cmd}`;
+    expect(result.stdout.toString().trim()).toBe('1');
+  });
+
+  test('Shell operators in interpolated commands should work', async () => {
+    const cmd = 'test -f /bin/sh && echo "sh exists"';
+    const result = await $`${cmd}`;
+    expect(result.stdout.toString().trim()).toBe('sh exists');
+  });
+
+  test('Commands with special characters should work', async () => {
+    const cmd = 'echo "test $HOME" | head -1';
+    const result = await $`${cmd}`;
+    expect(result.stdout.toString()).toContain('test ');
+  });
+
+  test('Multiple argument interpolation should still quote properly', async () => {
+    const arg1 = 'hello';
+    const arg2 = 'world with spaces';
+    const result = await $`echo ${arg1} ${arg2}`;
+    expect(result.stdout.toString().trim()).toBe('hello world with spaces');
+  });
+
+  test('Empty command string should not cause issues', async () => {
+    const cmd = '';
+    // This should not fail catastrophically
+    try {
+      await $`${cmd}`;
+    } catch (error) {
+      // It's expected to fail, but not with our quoting issue
+      expect(error.message).not.toContain('not found');
+    }
+  });
+
+  test('Command with unsafe characters should be handled correctly', async () => {
+    // This tests that we don't break security when fixing the quoting issue
+    const unsafeCmd = 'echo "safe"; echo "also safe"';
+    const result = await $`${unsafeCmd}`;
+    const lines = result.stdout.toString().trim().split('\n');
+    expect(lines).toContain('safe');
+    expect(lines).toContain('also safe');
+  });
+});
+
+// Additional runtime-specific tests
+// Skip on Windows - uses 'pwd' which outputs Unix-style paths with '/'
+if (isBun) {
+  describe.skipIf(isWindows)('Bun-specific shell path tests', () => {
+    test('Bun.spawn compatibility is maintained', async () => {
+      const result = await $`pwd`;
+      expect(result.stdout.toString().trim()).toContain('/');
+    });
+
+    test('Bun runtime detection works correctly', async () => {
+      // This is more of a meta-test to ensure our runtime detection is correct
+      expect(typeof globalThis.Bun).toBe('object');
+    });
+  });
+} else {
+  describe.skipIf(isWindows)('Node.js-specific shell path tests', () => {
+    test('Node.js child_process compatibility is maintained', async () => {
+      const result = await $`pwd`;
+      expect(result.stdout.toString().trim()).toContain('/');
+    });
+
+    test('Node.js runtime detection works correctly', async () => {
+      expect(typeof process.version).toBe('string');
+    });
+  });
+}

package/js/tests/bun.features.test.mjs

@@ -0,0 +1,189 @@
+import { test, expect, describe } from 'bun:test';
+import './test-helper.mjs'; // Automatically sets up beforeEach/afterEach cleanup
+
+describe('Bun.$ Feature Validation', () => {
+  describe('Runtime Support', () => {
+    test('should only work in Bun runtime', () => {
+      expect(typeof Bun).toBe('object');
+      expect(typeof Bun.$).toBe('function');
+    }, 30000);
+
+    test('should be Bun-specific (conceptual test)', () => {
+      // Bun.$ is Bun-specific and won't work in Node.js
+      // This test documents the Bun-only limitation
+      // Since we're running in Bun, we just validate it exists
+      expect(typeof Bun.$).toBe('function');
+      // In Node.js environment, Bun would be undefined
+    }, 30000);
+  });
+
+  describe('Template Literals', () => {
+    test('should support $`cmd` syntax', async () => {
+      const result = await Bun.$`echo "bun template literal test"`;
+      expect(result.exitCode).toBe(0);
+      expect(result.text().trim()).toBe('bun template literal test');
+    }, 30000);
+
+    test('should support variable interpolation', async () => {
+      const message = 'bun interpolation test';
+      const result = await Bun.$`echo ${message}`;
+      expect(result.text().trim()).toContain('bun interpolation test');
+    }, 30000);
+  });
+
+  describe('Real-time Streaming', () => {
+    test('should NOT provide live streaming (buffers only)', async () => {
+      // Bun.$ buffers output and returns it all at once
+      // This test documents the buffering behavior
+      const result = await Bun.$`echo "bun buffered test"`;
+
+      // Result is returned as complete buffer, not streamed
+      expect(typeof result.text).toBe('function');
+      expect(result.text().trim()).toBe('bun buffered test');
+
+      // No streaming interface available
+      expect(result.stream).toBeUndefined();
+      expect(typeof result[Symbol.asyncIterator]).toBe('undefined');
+    });
+  });
+
+  describe('Async Iteration', () => {
+    test('should NOT support for await iteration', async () => {
+      const result = await Bun.$`echo "no async iteration"`;
+
+      // Bun.$ result is not async iterable
+      expect(typeof result[Symbol.asyncIterator]).toBe('undefined');
+      expect(result.stream).toBeUndefined();
+    });
+  });
+
+  describe('EventEmitter Pattern', () => {
+    test('should NOT support .on() events', async () => {
+      const result = await Bun.$`echo "no events"`;
+
+      // Bun.$ result doesn't have EventEmitter interface
+      expect(typeof result.on).toBe('undefined');
+      expect(typeof result.emit).toBe('undefined');
+      expect(typeof result.addEventListener).toBe('undefined');
+    });
+  });
+
+  describe('Mixed Patterns', () => {
+    test('should NOT support events + await (only await)', async () => {
+      // Bun.$ only supports await pattern, no events
+      const result = await Bun.$`echo "await only"`;
+
+      expect(result.text().trim()).toBe('await only');
+      expect(typeof result.on).toBe('undefined');
+    });
+  });
+
+  describe('Shell Injection Protection', () => {
+    test('should have built-in injection protection', async () => {
+      const dangerous = "'; rm -rf /; echo 'hacked";
+      const result = await Bun.$`echo ${dangerous}`;
+
+      expect(result.text().trim()).toBe(dangerous);
+      expect(result.exitCode).toBe(0);
+    });
+  });
+
+  describe('Cross-platform Support', () => {
+    test('should work cross-platform', async () => {
+      const result = await Bun.$`echo "cross-platform"`;
+      expect(result.exitCode).toBe(0);
+      expect(result.text().trim()).toBe('cross-platform');
+    });
+  });
+
+  describe('Performance', () => {
+    test('should be very fast (built-in to Bun)', async () => {
+      const startTime = Date.now();
+      const result = await Bun.$`echo "performance test"`;
+      const endTime = Date.now();
+
+      expect(result.exitCode).toBe(0);
+      // Windows shell spawning is slower, allow more time
+      const maxTime = process.platform === 'win32' ? 500 : 100;
+      expect(endTime - startTime).toBeLessThan(maxTime); // Should be very fast
+    });
+  });
+
+  describe('Memory Efficiency', () => {
+    test('should buffer in memory (not streaming)', async () => {
+      // Bun.$ buffers output in memory
+      const result = await Bun.$`echo "memory buffering"`;
+
+      // All output is available immediately as buffer
+      expect(result.text().trim()).toBe('memory buffering');
+      expect(typeof result.text()).toBe('string');
+      expect(result.stdout).toBeDefined();
+    });
+  });
+
+  describe('Error Handling', () => {
+    test('should throw exception on error by default', async () => {
+      try {
+        await Bun.$`exit 42`;
+        expect(true).toBe(false); // Should not reach here
+      } catch (error) {
+        expect(error).toBeDefined();
+        expect(error.exitCode).toBe(42);
+      }
+    });
+
+    test('should support nothrow option', async () => {
+      const result = await Bun.$`exit 42`.nothrow();
+      expect(result.exitCode).toBe(42);
+    });
+  });
+
+  describe('Stdin Support', () => {
+    test('should support pipe operations', async () => {
+      // Bun.$ supports sophisticated pipe operations
+      const result = await Bun.$`echo "pipe test"`.text();
+      expect(result.trim()).toBe('pipe test');
+    });
+
+    test('should support input through echo/pipe (conceptual)', async () => {
+      // Bun.$ supports pipe operations differently
+      // const result = await Bun.$`echo ${input} | cat`;
+      const input = 'stdin input test';
+      const result = await Bun.$`echo ${input}`;
+      expect(result.text().trim()).toBe(input);
+    });
+  });
+
+  describe('Built-in Commands', () => {
+    test('should have built-in echo command', async () => {
+      // Bun.$ implements some commands natively for performance
+      const result = await Bun.$`echo "built-in echo"`;
+      expect(result.exitCode).toBe(0);
+      expect(result.text().trim()).toBe('built-in echo');
+    });
+
+    test('should have built-in cd and other commands', async () => {
+      // Bun.$ has built-in implementations of common commands
+      // This test validates that built-ins are available
+      const result = await Bun.$`pwd`;
+      expect(result.exitCode).toBe(0);
+      expect(result.text().trim().length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Bundle Size', () => {
+    test('should have 0KB bundle size (built into Bun)', () => {
+      // Bun.$ is built into the Bun runtime, no additional bundle size
+      expect(typeof Bun.$).toBe('function');
+      // This is a conceptual test - Bun.$ adds 0 bytes to bundle
+    });
+  });
+
+  describe('TypeScript Support', () => {
+    test('should have built-in TypeScript support', () => {
+      // Bun has native TypeScript support including for Bun.$
+      expect(typeof Bun.$).toBe('function');
+      // In a TypeScript file, Bun.$ would have full type definitions
+    });
+  });
+});