mcollina/skills

The Node.js child process implementation operates across three distinct layers:

1. JavaScript Layer (lib/child_process.js): Provides the high-level API including spawn(), fork(), exec(), and execFile().
2. Internal JS (lib/internal/child_process.js): Manages the ChildProcess class, channel setup, and synchronous spawning.
3. C++ Bindings (src/process_wrap.cc): Interfaces with the OS via the ProcessWrap class to handle Spawn() and Kill() operations.
4. libuv: The underlying abstraction layer that handles actual process spawning (uv_spawn), killing (uv_process_kill), and standard I/O pipes (uv_pipe_t).

JavaScript Layer (lib/child_process.js)
├── spawn()
├── fork()
├── exec()
└── execFile()
        │
        ▼
Internal JS (lib/internal/child_process.js)
├── ChildProcess class
├── setupChannel()
└── spawnSync
        │
        ▼
C++ Bindings (src/process_wrap.cc)
├── ProcessWrap
├── Spawn(), Kill()
        │
        ▼
libuv
├── uv_spawn()
├── uv_process_kill()
└── uv_pipe_t (for stdio)

You can use the infer keyword within a template literal type to extract specific parts of a string type.

Remove Prefix

To remove a specific prefix, use infer to capture the remainder of the string:

type RemoveMaps<T> = T extends `maps:${infer Rest}` ? Rest : T;

type Test1 = RemoveMaps<"maps:longitude">; // "longitude"

Remove Suffix

To remove a suffix, capture the prefix before the suffix:

type RemovePostSuffix<T> = T extends `${infer Prefix}:post` ? Prefix : T;

type Test = RemovePostSuffix<"attribute:post">; // "attribute"

Split on Delimiter

You can recursively split a string into a tuple based on a delimiter:

type Split<S extends string, D extends string> =
  S extends `${infer Head}${D}${infer Tail}`
    ? [Head, ...Split<Tail, D>]
    : S extends ""
    ? []
    : [S];

type Parts = Split<"a-b-c", "-">; // ["a", "b", "c"]

The lifecycle of a write operation follows this path:

1. JS: stream.write(chunk) is called.
2. JS: stream._write(chunk, encoding, callback) is invoked (user implementation).
3. C++: WriteString() or WriteBuffer() is called.
4. C++: DoWrite() triggers uv_write().
5. libuv: The write request is queued.
6. libuv: write_cb is triggered upon completion.
7. C++: WriteWrap::OnDone() is called.
8. JS: afterWrite() triggers the user's callback().
9. JS: The 'drain' event is emitted if the buffer was previously full.

1. JavaScript: stream.write(chunk)
   ↓
2. JavaScript: _write(chunk, encoding, callback) [user implements]
   ↓
3. C++: WriteString() or WriteBuffer()
   ↓
4. C++: DoWrite() → uv_write()
   ↓
5. libuv: Queue write request
   ↓
6. libuv: write_cb when complete
   ↓
7. C++: WriteWrap::OnDone()
   ↓
8. JavaScript: afterWrite() → callback()
   ↓
9. JavaScript: 'drain' event if buffer was full

Type stripping works by removing type annotations without transforming code. To ensure compatibility, your TypeScript code must follow these constraints:

1. Use Type-Only Imports

Always use the type keyword for imports that only involve types. This prevents runtime errors during stripping.

2. No Enums

Enums require code transformation. Instead, use a const object with a corresponding type.

3. No Namespaces

Namespaces require transformation. Use standard ES modules (export) instead.

4. No Constructor Parameter Properties

Avoid using access modifiers (e.g., public, private) directly in constructor parameters. Use explicit property declarations and assignments instead.

5. No Legacy Decorators

Use the TC39 (stage 3) decorator syntax. Compatibility for decorators depends on your specific Node.js version.

// GOOD - type-only import
import type { User, Config } from './types.ts';
import { createUser, type User } from './user.ts';

// GOOD - const object instead of enum
const Status = {
  Active: 'active',
  Inactive: 'inactive',
} as const;
type Status = (typeof Status)[keyof typeof Status];

// GOOD - explicit property declaration instead of parameter properties
class User {
  name: string;
  private age: number;

  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }
}