@lingxia/rong 0.0.1

package/dist/stream.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Stream module type definitions
+ * Corresponds to: modules/rong_stream
+ *
+ * Rong runtime provides the Web Streams API, which is a standard for handling
+ * streaming data in JavaScript. These APIs are globally available.
+ *
+ * ## Available Stream Types
+ *
+ * ### ReadableStream<T>
+ * Represents a readable stream of data.
+ *
+ * Usage:
+ * ```typescript
+ * // From file
+ * const file = await Rong.open('/path/to/file.txt', { read: true });
+ * const readable = file.readable;
+ *
+ * // Read from stream
+ * const reader = readable.getReader();
+ * while (true) {
+ *   const { done, value } = await reader.read();
+ *   if (done) break;
+ *   console.log('Received:', value);
+ * }
+ * ```
+ *
+ * ### WritableStream<T>
+ * Represents a writable stream of data.
+ *
+ * Usage:
+ * ```typescript
+ * // To file
+ * const file = await Rong.open('/path/to/output.txt', { write: true, create: true });
+ * const writable = file.writable;
+ *
+ * // Write to stream
+ * const writer = writable.getWriter();
+ * await writer.write(new TextEncoder().encode('Hello World'));
+ * await writer.close();
+ * ```
+ *
+ * ### TransformStream<I, O>
+ * Represents a transform stream for processing data.
+ *
+ * Usage:
+ * ```typescript
+ * // Pipe with transformation
+ * await readable
+ *   .pipeThrough(new TransformStream({
+ *     transform(chunk, controller) {
+ *       // Process chunk
+ *       controller.enqueue(processedChunk);
+ *     }
+ *   }))
+ *   .pipeTo(writable);
+ * ```
+ *
+ * ## Common Use Cases
+ *
+ * ### Pipe streams
+ * ```typescript
+ * // Pipe stdin to stdout
+ * await process.stdin.pipeTo(process.stdout);
+ *
+ * // Pipe file to file
+ * const source = await Rong.open('/source.txt', { read: true });
+ * const dest = await Rong.open('/dest.txt', { write: true, create: true });
+ * await source.readable.pipeTo(dest.writable);
+ * ```
+ *
+ * ### Process data in chunks
+ * ```typescript
+ * const file = await Rong.open('/large-file.txt', { read: true });
+ * const reader = file.readable.getReader();
+ *
+ * let totalBytes = 0;
+ * while (true) {
+ *   const { done, value } = await reader.read();
+ *   if (done) break;
+ *   totalBytes += value.byteLength;
+ *   // Process chunk...
+ * }
+ * console.log(`Processed ${totalBytes} bytes`);
+ * ```
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Streams_API
+ */
+export {};
+//# sourceMappingURL=stream.d.ts.map

package/dist/stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../src/stream.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuFG;AAUH,OAAO,EAAE,CAAC"}

package/dist/stream.js

@@ -0,0 +1,90 @@
+"use strict";
+/**
+ * Stream module type definitions
+ * Corresponds to: modules/rong_stream
+ *
+ * Rong runtime provides the Web Streams API, which is a standard for handling
+ * streaming data in JavaScript. These APIs are globally available.
+ *
+ * ## Available Stream Types
+ *
+ * ### ReadableStream<T>
+ * Represents a readable stream of data.
+ *
+ * Usage:
+ * ```typescript
+ * // From file
+ * const file = await Rong.open('/path/to/file.txt', { read: true });
+ * const readable = file.readable;
+ *
+ * // Read from stream
+ * const reader = readable.getReader();
+ * while (true) {
+ *   const { done, value } = await reader.read();
+ *   if (done) break;
+ *   console.log('Received:', value);
+ * }
+ * ```
+ *
+ * ### WritableStream<T>
+ * Represents a writable stream of data.
+ *
+ * Usage:
+ * ```typescript
+ * // To file
+ * const file = await Rong.open('/path/to/output.txt', { write: true, create: true });
+ * const writable = file.writable;
+ *
+ * // Write to stream
+ * const writer = writable.getWriter();
+ * await writer.write(new TextEncoder().encode('Hello World'));
+ * await writer.close();
+ * ```
+ *
+ * ### TransformStream<I, O>
+ * Represents a transform stream for processing data.
+ *
+ * Usage:
+ * ```typescript
+ * // Pipe with transformation
+ * await readable
+ *   .pipeThrough(new TransformStream({
+ *     transform(chunk, controller) {
+ *       // Process chunk
+ *       controller.enqueue(processedChunk);
+ *     }
+ *   }))
+ *   .pipeTo(writable);
+ * ```
+ *
+ * ## Common Use Cases
+ *
+ * ### Pipe streams
+ * ```typescript
+ * // Pipe stdin to stdout
+ * await process.stdin.pipeTo(process.stdout);
+ *
+ * // Pipe file to file
+ * const source = await Rong.open('/source.txt', { read: true });
+ * const dest = await Rong.open('/dest.txt', { write: true, create: true });
+ * await source.readable.pipeTo(dest.writable);
+ * ```
+ *
+ * ### Process data in chunks
+ * ```typescript
+ * const file = await Rong.open('/large-file.txt', { read: true });
+ * const reader = file.readable.getReader();
+ *
+ * let totalBytes = 0;
+ * while (true) {
+ *   const { done, value } = await reader.read();
+ *   if (done) break;
+ *   totalBytes += value.byteLength;
+ *   // Process chunk...
+ * }
+ * console.log(`Processed ${totalBytes} bytes`);
+ * ```
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Streams_API
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/timer.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Timer module type definitions
+ * Corresponds to: modules/rong_timer
+ */
+export type TimerCallback = () => void;
+export type TimerId = number;
+export interface TimersNamespace {
+    /**
+     * Promise-based timeout that resolves with a timestamp (ms since epoch).
+     */
+    setTimeout(delay?: number): Promise<number>;
+    /**
+     * Promise-based immediate that resolves with a timestamp (ms since epoch).
+     */
+    setImmediate(): Promise<number>;
+    /**
+     * Async iterator that yields timestamps (ms since epoch) on each interval tick.
+     */
+    setInterval(delay?: number): AsyncIterableIterator<number>;
+}
+declare global {
+    /**
+     * Set a timer that executes a callback once after a delay
+     * @param callback - Function to execute
+     * @param delay - Delay in milliseconds (default: 0)
+     * @returns Timer ID that can be used with clearTimeout
+     */
+    function setTimeout(callback: TimerCallback, delay?: number): TimerId;
+    /**
+     * Clear a timer set with setTimeout
+     * @param id - Timer ID returned by setTimeout
+     */
+    function clearTimeout(id: TimerId): void;
+    /**
+     * Set a timer that executes a callback repeatedly with a delay between executions
+     * @param callback - Function to execute
+     * @param delay - Delay in milliseconds between executions (default: 0)
+     * @returns Timer ID that can be used with clearInterval
+     */
+    function setInterval(callback: TimerCallback, delay?: number): TimerId;
+    /**
+     * Clear a timer set with setInterval
+     * @param id - Timer ID returned by setInterval
+     */
+    function clearInterval(id: TimerId): void;
+    /**
+     * Promise-based timer namespace
+     */
+    const timers: TimersNamespace;
+}
+export {};
+//# sourceMappingURL=timer.d.ts.map

package/dist/timer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timer.d.ts","sourceRoot":"","sources":["../src/timer.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC;AACvC,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC;AAE7B,MAAM,WAAW,eAAe;IAC9B;;OAEG;IACH,UAAU,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAE5C;;OAEG;IACH,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IAEhC;;OAEG;IACH,WAAW,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,qBAAqB,CAAC,MAAM,CAAC,CAAC;CAC5D;AAED,OAAO,CAAC,MAAM,CAAC;IACb;;;;;OAKG;IACH,SAAS,UAAU,CAAC,QAAQ,EAAE,aAAa,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAEtE;;;OAGG;IACH,SAAS,YAAY,CAAC,EAAE,EAAE,OAAO,GAAG,IAAI,CAAC;IAEzC;;;;;OAKG;IACH,SAAS,WAAW,CAAC,QAAQ,EAAE,aAAa,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAEvE;;;OAGG;IACH,SAAS,aAAa,CAAC,EAAE,EAAE,OAAO,GAAG,IAAI,CAAC;IAE1C;;OAEG;IACH,MAAM,MAAM,EAAE,eAAe,CAAC;CAC/B;AAED,OAAO,EAAE,CAAC"}

package/dist/timer.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Timer module type definitions
+ * Corresponds to: modules/rong_timer
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/url.d.ts

@@ -0,0 +1,75 @@
+/**
+ * URL module type definitions
+ * Corresponds to: modules/rong_url
+ */
+export interface URLSearchParams {
+    /** Append a parameter */
+    append(name: string, value: string): void;
+    /** Delete all parameters with the given name */
+    delete(name: string): void;
+    /** Get the first value for a parameter */
+    get(name: string): string | null;
+    /** Get all values for a parameter */
+    getAll(name: string): string[];
+    /** Check if a parameter exists */
+    has(name: string): boolean;
+    /** Set a parameter value (replaces existing) */
+    set(name: string, value: string): void;
+    /** Sort parameters by name */
+    sort(): void;
+    /** Get all parameter entries */
+    entries(): Array<[string, string]>;
+    /** Get all parameter names */
+    keys(): string[];
+    /** Get all parameter values */
+    values(): string[];
+    /** Iterate over parameters */
+    forEach(callback: (value: string, key: string) => void, thisArg?: any): void;
+    /** Convert to query string */
+    toString(): string;
+    /** Number of parameters */
+    readonly size: number;
+}
+export interface URLSearchParamsConstructor {
+    new (): URLSearchParams;
+    new (init: string): URLSearchParams;
+    new (init: Array<[string, string]>): URLSearchParams;
+    new (init: Record<string, string>): URLSearchParams;
+    prototype: URLSearchParams;
+}
+export interface URL {
+    /** Fragment identifier (e.g., "#section") */
+    hash: string;
+    /** Hostname with port (e.g., "example.com:8080") */
+    host: string;
+    /** Hostname only (e.g., "example.com") */
+    hostname: string;
+    /** Full URL string */
+    href: string;
+    /** Protocol + host (e.g., "https://example.com") */
+    readonly origin: string;
+    /** Password component */
+    password: string;
+    /** Path component (e.g., "/path/to/resource") */
+    pathname: string;
+    /** Port number as string */
+    port: string;
+    /** Protocol scheme (e.g., "https:") */
+    protocol: string;
+    /** Query string (e.g., "?key=value") */
+    search: string;
+    /** Username component */
+    username: string;
+    /** URL search parameters interface */
+    readonly searchParams: URLSearchParams;
+    /** Convert to string */
+    toString(): string;
+    /** Convert to JSON */
+    toJSON(): string;
+}
+export interface URLConstructor {
+    new (url: string, base?: string): URL;
+    prototype: URL;
+}
+export {};
+//# sourceMappingURL=url.d.ts.map

package/dist/url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.d.ts","sourceRoot":"","sources":["../src/url.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,eAAe;IAC9B,yBAAyB;IACzB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAE1C,gDAAgD;IAChD,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAE3B,0CAA0C;IAC1C,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IAEjC,qCAAqC;IACrC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAE/B,kCAAkC;IAClC,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAE3B,gDAAgD;IAChD,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAEvC,8BAA8B;IAC9B,IAAI,IAAI,IAAI,CAAC;IAEb,gCAAgC;IAChC,OAAO,IAAI,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAEnC,8BAA8B;IAC9B,IAAI,IAAI,MAAM,EAAE,CAAC;IAEjB,+BAA+B;IAC/B,MAAM,IAAI,MAAM,EAAE,CAAC;IAEnB,8BAA8B;IAC9B,OAAO,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,IAAI,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,IAAI,CAAC;IAE7E,8BAA8B;IAC9B,QAAQ,IAAI,MAAM,CAAC;IAEnB,2BAA2B;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,0BAA0B;IACzC,QAAO,eAAe,CAAC;IACvB,KAAI,IAAI,EAAE,MAAM,GAAG,eAAe,CAAC;IACnC,KAAI,IAAI,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,eAAe,CAAC;IACpD,KAAI,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,eAAe,CAAC;IACnD,SAAS,EAAE,eAAe,CAAC;CAC5B;AAED,MAAM,WAAW,GAAG;IAClB,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAC;IAEb,oDAAoD;IACpD,IAAI,EAAE,MAAM,CAAC;IAEb,0CAA0C;IAC1C,QAAQ,EAAE,MAAM,CAAC;IAEjB,sBAAsB;IACtB,IAAI,EAAE,MAAM,CAAC;IAEb,oDAAoD;IACpD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAExB,yBAAyB;IACzB,QAAQ,EAAE,MAAM,CAAC;IAEjB,iDAAiD;IACjD,QAAQ,EAAE,MAAM,CAAC;IAEjB,4BAA4B;IAC5B,IAAI,EAAE,MAAM,CAAC;IAEb,uCAAuC;IACvC,QAAQ,EAAE,MAAM,CAAC;IAEjB,wCAAwC;IACxC,MAAM,EAAE,MAAM,CAAC;IAEf,yBAAyB;IACzB,QAAQ,EAAE,MAAM,CAAC;IAEjB,sCAAsC;IACtC,QAAQ,CAAC,YAAY,EAAE,eAAe,CAAC;IAEvC,wBAAwB;IACxB,QAAQ,IAAI,MAAM,CAAC;IAEnB,sBAAsB;IACtB,MAAM,IAAI,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,cAAc;IAC7B,KAAI,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,GAAG,CAAC;IACrC,SAAS,EAAE,GAAG,CAAC;CAChB;AAID,OAAO,EAAE,CAAC"}

package/dist/url.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * URL module type definitions
+ * Corresponds to: modules/rong_url
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@lingxia/rong",
+  "version": "0.0.1",
+  "description": "TypeScript type definitions for Rong JavaScript runtime",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "rong",
+    "types",
+    "typescript",
+    "runtime"
+  ],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "files": [
+    "dist",
+    "src"
+  ]
+}

package/src/abort.ts

@@ -0,0 +1,50 @@
+/**
+ * Abort module type definitions
+ * Corresponds to: modules/rong_abort
+ */
+
+import { EventTarget } from './event';
+
+export interface AbortSignal extends EventTarget {
+  /** Whether the signal has been aborted */
+  readonly aborted: boolean;
+
+  /** Reason for abort (if any) */
+  readonly reason: any;
+
+  /** Abort event handler */
+  onabort: ((event: Event) => void) | null;
+
+  /** If the signal has been aborted, throw the abort reason */
+  throwIfAborted(): void;
+}
+
+export interface AbortSignalConstructor {
+  prototype: AbortSignal;
+
+  /** Returns an AbortSignal that is aborted when any of the given signals are aborted */
+  any(signals: AbortSignal[]): AbortSignal;
+
+  /** Returns an AbortSignal that is already aborted */
+  abort(reason?: any): AbortSignal;
+
+  /** Returns an AbortSignal that will abort after the specified milliseconds */
+  timeout(milliseconds: number): AbortSignal;
+}
+
+export interface AbortController {
+  /** The AbortSignal associated with this controller */
+  readonly signal: AbortSignal;
+
+  /** Abort the associated signal */
+  abort(reason?: any): void;
+}
+
+export interface AbortControllerConstructor {
+  new(): AbortController;
+  prototype: AbortController;
+}
+
+// Note: AbortSignal and AbortController are provided by the global environment
+// These type definitions are for reference and extend the standard Web API
+export {};

package/src/assert.ts

@@ -0,0 +1,51 @@
+/**
+ * Assert module type definitions
+ * Corresponds to: modules/rong_assert
+ */
+
+export type AssertionErrorMessage = string | Error;
+
+export interface AssertFunction {
+  /**
+   * Assert that a value is truthy
+   * @param value - Value to check
+   * @param message - Optional error message
+   * @throws Error if value is falsy
+   */
+  (value: any, message?: AssertionErrorMessage): asserts value;
+
+  /**
+   * Assert that a value is truthy (alias)
+   * @param value - Value to check
+   * @param message - Optional error message
+   * @throws Error if value is falsy
+   */
+  ok(value: any, message?: AssertionErrorMessage): asserts value;
+
+  /**
+   * Assert that two values are equal
+   * @param left - Left value
+   * @param right - Right value
+   * @param message - Optional error message
+   * @throws Error if values are not equal
+   */
+  equal(left: any, right: any, message?: AssertionErrorMessage): void;
+
+  /**
+   * Force assertion failure
+   * @param message - Error message
+   * @throws Error always
+   */
+  fail(message?: AssertionErrorMessage): never;
+
+  /**
+   * Assert that a function does not throw
+   * @param fn - Function to execute
+   * @param message - Optional error message
+   * @throws Error if function throws
+   */
+  doesNotThrow(fn: () => void, message?: AssertionErrorMessage): void;
+}
+
+// Note: assert is declared as a global in global.d.ts
+export {};

package/src/buffer.ts

@@ -0,0 +1,60 @@
+/**
+ * Buffer module type definitions (Blob and File)
+ * Corresponds to: modules/rong_buffer
+ */
+
+export type BlobPart = Blob | ArrayBuffer | ArrayBufferView | string;
+
+export interface BlobOptions {
+  /** MIME type of the blob */
+  type?: string;
+  /** Line ending normalization: "transparent" (default) or "native" */
+  endings?: 'transparent' | 'native';
+}
+
+export interface Blob {
+  /** Blob size in bytes */
+  readonly size: number;
+
+  /** MIME type of the blob */
+  readonly type: string;
+
+  /** Create a slice of the blob */
+  slice(start?: number, end?: number, contentType?: string): Blob;
+
+  /** Get blob contents as ArrayBuffer */
+  arrayBuffer(): Promise<ArrayBuffer>;
+
+  /** Get blob contents as text */
+  text(): Promise<string>;
+
+  /** Get blob contents as Uint8Array */
+  bytes(): Promise<Uint8Array>;
+}
+
+export interface BlobConstructor {
+  new(blobParts?: BlobPart[], options?: BlobOptions): Blob;
+  prototype: Blob;
+}
+
+export interface FileOptions extends BlobOptions {
+  /** Last modified timestamp (milliseconds since epoch) */
+  lastModified?: number;
+}
+
+export interface File extends Blob {
+  /** File name */
+  readonly name: string;
+
+  /** Last modified timestamp (milliseconds since epoch) */
+  readonly lastModified: number;
+}
+
+export interface FileConstructor {
+  new(fileBits: BlobPart[], fileName: string, options?: FileOptions): File;
+  prototype: File;
+}
+
+// Note: Blob and File are provided by the global environment
+// These type definitions are for reference and extend the standard Web API
+export {};

package/src/child_process.ts

@@ -0,0 +1,116 @@
+/**
+ * Child Process module type definitions
+ * Corresponds to: modules/rong_child_process
+ */
+
+import type { EventEmitter } from './event';
+
+export interface SpawnOptions {
+  /** Current working directory */
+  cwd?: string;
+  /** Environment variables */
+  env?: Record<string, string>;
+  /** Use shell to execute command */
+  shell?: boolean;
+  /** Timeout in milliseconds */
+  timeout?: number;
+}
+
+export interface ExecOptions {
+  /** Current working directory */
+  cwd?: string;
+  /** Environment variables */
+  env?: Record<string, string>;
+  /** Timeout in milliseconds */
+  timeout?: number;
+}
+
+export interface ExecResult {
+  /** Exit code (null if not yet exited) */
+  code: number | null;
+  /** Standard output */
+  stdout: string;
+  /** Standard error */
+  stderr: string;
+}
+
+export interface ChildProcess extends EventEmitter {
+  /** Process ID (null if process failed to spawn) */
+  readonly pid: number | null;
+
+  /** Exit code (available after process exits) */
+  readonly exitCode: number | null;
+
+  /** Standard input stream (if configured as 'piped') */
+  readonly stdin: WritableStream<Uint8Array> | null;
+
+  /** Standard output stream (if configured as 'piped') */
+  readonly stdout: ReadableStream<Uint8Array> | null;
+
+  /** Standard error stream (if configured as 'piped') */
+  readonly stderr: ReadableStream<Uint8Array> | null;
+
+  /**
+   * Wait for process to exit
+   * @returns Exit code (null if terminated by signal)
+   */
+  wait(): Promise<number | null>;
+
+  /**
+   * Kill the process with a signal
+   * @param signal - Signal name (e.g., 'SIGTERM', 'SIGKILL') or number
+   * @returns true if signal was sent successfully
+   */
+  kill(signal?: string): boolean;
+
+  // Event emitter methods (Node.js style)
+  on(event: 'exit', listener: (code: number | null) => void): this;
+  once(event: 'exit', listener: (code: number | null) => void): this;
+  off(event: 'exit', listener: (code: number | null) => void): this;
+}
+
+export interface ChildProcessModule {
+  /**
+   * Spawn a child process
+   * @param command - Command to execute
+   * @param args - Command arguments (optional)
+   * @param options - Spawn options
+   *
+   * @example
+   * ```typescript
+   * const child = child_process.spawn('ls', ['-la'], { cwd: '/tmp' });
+   * const code = await child.wait();
+   * ```
+   */
+  spawn(command: string, args?: string[], options?: SpawnOptions): ChildProcess;
+
+  /**
+   * Execute a shell command and capture output
+   * @param command - Shell command to execute
+   * @param options - Execution options
+   *
+   * @example
+   * ```typescript
+   * const result = await child_process.exec('echo "Hello"', { timeout: 5000 });
+   * console.log(result.stdout);
+   * ```
+   */
+  exec(command: string, options?: ExecOptions): Promise<ExecResult>;
+
+  /**
+   * Execute a file directly without shell
+   * @param file - File path to execute
+   * @param args - Command arguments
+   * @param options - Execution options
+   *
+   * @example
+   * ```typescript
+   * const result = await child_process.execFile('/usr/bin/node', ['--version']);
+   * console.log(result.stdout);
+   * ```
+   */
+  execFile(file: string, args?: string[], options?: ExecOptions): Promise<ExecResult>;
+}
+
+// Note: ChildProcess module is mounted as globalThis.child_process
+export {};