@stacksjs/defaults 0.70.207 → 0.70.208

package/ai/skills/stacks-validation/SKILL.md

@@ -0,0 +1,371 @@
+---
+name: stacks-validation
+description: Use when implementing validation in Stacks — type guards (isString, isNumber, isBoolean, isObject, isArray, isFunction, etc.), numeric checks (isPositive, isEven, isInteger), the schema builder for model attribute validation, or request validation. Covers @stacksjs/validation.
+license: MIT
+compatibility: Bun >= 1.3.0, TypeScript
+allowed-tools: Read Edit Write Bash Grep Glob
+---
+
+# Stacks Validation
+
+## Key Paths
+- Core package: `storage/framework/core/validation/src/`
+- Package: `@stacksjs/validation`
+
+## Architecture
+
+The `index.ts` re-exports from multiple sources:
+```typescript
+// Re-export everything from the validation library
+export * from '@stacksjs/ts-validation'
+
+// Local modules
+export * from './reporter'    // error reporting
+export * from './validator'   // model/custom validation
+export { schema } from './schema'  // schema builder instance
+
+// Type guard functions defined directly in index.ts
+export function isString(value: unknown): value is string
+export function isNumber(value: unknown): value is number
+export function isBoolean(value: unknown): value is boolean
+export function isObject(value: unknown): value is Record<string, unknown>
+export function isArray(value: unknown): value is unknown[]
+export function isFunction(value: unknown): value is Function
+export function isUndefined(value: unknown): value is undefined
+export function isNull(value: unknown): value is null
+export function isNullOrUndefined(value: unknown): value is null | undefined
+```
+
+Additional type guards are in `is.ts` (but not directly imported by index.ts -- available via separate import).
+
+## Type Guards (`index.ts`)
+
+Basic type guards with TypeScript type narrowing:
+
+```typescript
+import { isString, isNumber, isBoolean, isObject, isArray, isFunction } from '@stacksjs/validation'
+
+isString('hello')          // true   -- typeof value === 'string'
+isNumber(42)               // true   -- typeof value === 'number' && !Number.isNaN(value)
+isNumber(NaN)              // FALSE  -- NaN is explicitly excluded
+isBoolean(true)            // true   -- typeof value === 'boolean'
+isObject({})               // true   -- typeof === 'object' && !== null && !Array.isArray
+isObject([])               // FALSE  -- arrays are excluded
+isObject(null)             // FALSE  -- null is excluded
+isArray([])                // true   -- Array.isArray()
+isFunction(() => {})       // true   -- typeof value === 'function'
+isUndefined(undefined)     // true
+isNull(null)               // true
+isNullOrUndefined(null)    // true
+isNullOrUndefined(undefined) // true
+```
+
+## Extended Type Guards (`is.ts`)
+
+Additional guards using `getTypeName()` from `@stacksjs/types` and `toString()` from `@stacksjs/strings`:
+
+```typescript
+isDef(value)                // true if typeof value !== 'undefined'
+isMap(new Map())            // true  -- toString check '[object Map]'
+isSet(new Set())            // true  -- toString check '[object Set]'
+isPromise(Promise.resolve()) // true -- toString check '[object Promise]'
+isSymbol(Symbol())          // true
+isDate(new Date())          // true
+isRegExp(/test/)            // true
+isWindow(globalThis)        // true in browser -- toString check '[object Window]'
+isPrimitive(42)             // true (string, number, boolean, null, undefined, symbol)
+isPrimitive({})             // false
+
+// Environment detection
+isBrowser: boolean          // typeof window !== 'undefined'
+isServer: boolean           // typeof document === 'undefined'
+```
+
+## Numeric Checks (`is.ts`)
+
+```typescript
+isInteger(42)               // true   -- Number.isInteger()
+isInteger(42.0)             // true   -- 42.0 is an integer in JS
+isFloat(3.14)               // true   -- isNumber && !Number.isInteger
+isFloat(42)                 // false
+
+isPositive(5)               // true   -- > 0
+isNegative(-5)              // true   -- < 0
+isEven(4)                   // true   -- % 2 === 0
+isOdd(3)                    // true   -- % 2 !== 0
+
+// Classification functions (return string, not boolean)
+isEvenOrOdd(4)              // 'even'
+isEvenOrOdd(3)              // 'odd'
+isEvenOrOdd('not a number') // 'odd'  -- non-numbers default to 'odd'
+
+isPositiveOrNegative(5)     // 'positive'
+isPositiveOrNegative(-5)    // 'negative'
+isPositiveOrNegative('x')   // 'negative'  -- non-numbers default to 'negative'
+
+isIntegerOrFloat(42)        // 'integer'
+isIntegerOrFloat(3.14)      // 'float'
+isIntegerOrFloat('x')       // 'float'  -- non-numbers default to 'float'
+```
+
+## Schema Builder (`schema.ts`)
+
+The `schema` object is an instance of `ValidationInstance` from `@stacksjs/ts-validation`. It provides fluent validators for model attribute definitions.
+
+```typescript
+import { schema } from '@stacksjs/validation'
+```
+
+### Available Schema Types
+
+```typescript
+// String types
+schema.string()                    // StringValidatorType
+schema.string().minLength(2)       // chain: min length
+schema.string().maxLength(100)     // chain: max length
+schema.string().email()            // chain: must be email
+schema.string().url()              // chain: must be URL
+schema.string().matches(/pattern/) // chain: regex match
+schema.string().equals('exact')    // chain: exact match
+schema.string().alphanumeric()     // chain: alphanumeric only
+schema.string().alpha()            // chain: letters only
+schema.string().numeric()          // chain: numeric string
+schema.string().custom(fn, msg)    // chain: custom validator
+schema.text()                      // TextValidatorType (extends StringValidatorType)
+
+// Number types
+schema.number()                    // NumberValidatorType
+schema.number().min(0).max(100)    // chain: min/max
+schema.bigint()                    // BigintValidatorType
+schema.integer()                   // IntegerValidatorType
+schema.smallint()                  // SmallintValidatorType
+schema.float()                     // FloatValidatorType
+schema.double()                    // DoubleValidatorType
+schema.decimal()                   // DecimalValidatorType
+
+// Boolean
+schema.boolean()                   // BooleanValidatorType
+
+// Enum
+schema.enum(['draft', 'published', 'archived'])  // EnumValidatorType
+
+// Date/time types
+schema.date()                      // DateValidatorType
+schema.datetime()                  // DatetimeValidatorType
+schema.timestamp()                 // TimestampValidatorType
+schema.timestampTz()               // TimestampTzValidatorType (with timezone)
+schema.unix()                      // UnixValidatorType
+schema.time()                      // TimeValidatorType
+
+// Binary/blob
+schema.binary()                    // BinaryValidatorType
+schema.blob()                      // BlobValidatorType
+
+// JSON
+schema.json()                      // JsonValidatorType
+
+// Password
+schema.password()                  // PasswordValidatorType
+
+// Array
+schema.array<T>()                  // ArrayValidatorType<T>
+
+// Object
+schema.object<T>(shapeSchema?)     // ObjectValidatorType<T>
+
+// Custom
+schema.custom<T>(validationFn, message)  // CustomValidatorType<T>
+```
+
+### Model Attribute Usage
+
+Schema validators are used in `defineModel()` attribute validation:
+
+```typescript
+import { defineModel } from '@stacksjs/config'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  attributes: {
+    name: {
+      validation: {
+        rule: schema.string().minLength(2).maxLength(100),
+        message: {
+          minLength: 'Name must be at least 2 characters',
+          maxLength: 'Name cannot exceed 100 characters',
+        }
+      }
+    },
+
+    email: {
+      validation: {
+        rule: schema.string().email(),
+        message: {
+          email: 'Please provide a valid email address',
+        }
+      }
+    },
+
+    price: {
+      validation: {
+        rule: schema.number().min(1),
+        message: {
+          min: 'Price must be at least 1',
+        }
+      }
+    },
+
+    status: {
+      validation: {
+        rule: schema.enum(['active', 'inactive', 'archived']),
+        message: {
+          enum: 'Invalid status value',
+        }
+      }
+    },
+
+    bio: {
+      validation: {
+        rule: schema.string().maxLength(500),
+        message: {
+          maxLength: 'Bio cannot exceed 500 characters',
+        }
+      }
+    },
+  }
+})
+```
+
+## Model Validation (`validator.ts`)
+
+### `validateField(modelFile, params)`
+
+Validates request data against a model's attribute rules. Used internally by the framework for API request validation.
+
+```typescript
+import { validateField } from '@stacksjs/validation'
+
+// Loads model file, extracts validation rules, validates params
+const result = await validateField('User', { name: 'John', email: 'john@example.com' })
+```
+
+Behavior:
+1. Finds the model file by name in user models or framework defaults
+2. Extracts validation rules from model attributes
+3. Converts attribute names to snake_case for validation
+4. Sets custom error messages via `MessageProvider`
+5. Validates using `schema.object(ruleObject).validate(params)`
+6. Throws `HttpError(422)` with error JSON on validation failure
+7. Throws `HttpError(404)` if model not found
+8. Skips validation for attributes with default values unless `isRequired` is true
+
+### `customValidate(attributes, params)`
+
+Validates request data against custom attribute rules (not tied to a model):
+
+```typescript
+import { customValidate } from '@stacksjs/validation'
+
+const result = await customValidate({
+  email: {
+    rule: schema.string().email(),
+    message: { email: 'Invalid email' }
+  },
+  age: {
+    rule: schema.number().min(18),
+    message: { min: 'Must be at least 18' }
+  }
+}, requestData)
+```
+
+Uses `schema.object().shape(ruleObject)` for validation.
+
+### `isObjectNotEmpty(obj)`
+
+```typescript
+isObjectNotEmpty({})            // false
+isObjectNotEmpty({ a: 1 })      // true
+isObjectNotEmpty(undefined)     // false
+```
+
+## Error Reporter (`reporter.ts`)
+
+Simple error accumulator for validation:
+
+```typescript
+import { reportError, getErrors } from '@stacksjs/validation'
+
+reportError([{ message: 'Invalid', value: '', field: 'email' }])
+const errors = getErrors()   // returns accumulated MessageObject[]
+```
+
+Interface: `{ message: string, value: string, field: string }`
+
+## Error Reporter Contract (from `rules.ts`)
+
+VineJS-inspired types for the validation pipeline:
+
+```typescript
+interface FieldContext {
+  value: unknown
+  data: any              // top-level object under validation
+  meta: Record<string, any>
+  mutate: (newValue: any, field: FieldContext) => void
+  report: ErrorReporterContract['report']
+  isValid: boolean
+  isDefined: boolean
+  wildCardPath: string   // nested pointer, '*' for array members
+  parent: any
+  name: string | number
+  isArrayMember: boolean
+}
+
+interface ErrorReporterContract {
+  hasErrors: boolean
+  createError: () => Error
+  report: (message: string, rule: string, field: FieldContext, args?: Record<string, any>) => any
+}
+```
+
+## Re-exports from @stacksjs/ts-validation
+
+The package re-exports everything from `@stacksjs/ts-validation`, which includes:
+
+- `v` and `schema` -- the validation instance
+- `validator` -- the validator library (default export from lib)
+- `MessageProvider`, `setCustomMessages` -- custom message handling
+- All type definitions (ValidatorType, StringValidatorType, NumberValidatorType, etc.)
+- Configuration utilities
+
+## Validation Types (`types/index.ts`)
+
+Local type definitions:
+```typescript
+interface ValidationResult {
+  valid: boolean
+  errors?: Array<{ message: string }>
+}
+
+interface ValidationRule {
+  validate: (value: unknown) => ValidationResult
+}
+
+type ValidationBoolean = ValidationRule
+type ValidationEnum = ValidationRule
+type ValidationNumber = ValidationRule
+type ValidationString = ValidationRule
+```
+
+## Gotchas
+- `isNumber()` in `index.ts` returns FALSE for `NaN` -- this differs from `typeof NaN === 'number'`
+- `isObject()` in `index.ts` excludes arrays and null -- `isObject([])` is false
+- `isObject()` in `is.ts` uses `toString()` check (`[object Object]`) which also excludes arrays/null but through a different mechanism
+- `isPrimitive()` includes null and undefined (6 primitive types: string, number, boolean, null, undefined, symbol)
+- Numeric classification functions (`isEvenOrOdd`, etc.) return string defaults for non-numbers rather than throwing
+- Schema validators map to database column types -- `schema.integer()` creates an integer column, `schema.string()` creates a varchar, etc.
+- `validateField` converts attribute names to snake_case using `snakeCase()` from `@stacksjs/strings`
+- `validateField` skips attributes with default values unless `isRequired` is explicitly set
+- Validation error messages are customizable per-rule in model definitions via the `message` object
+- The `schema` export is the `v` instance from `@stacksjs/ts-validation` -- they are the same object
+- Custom validators can be added with `schema.custom<T>(fn, message)` for types not covered by built-in validators
+- `customValidate` uses `schema.object().shape()` while `validateField` uses `schema.object(ruleObject)` -- slightly different API

package/ai/skills/stacks-whois/SKILL.md

@@ -0,0 +1,315 @@
+---
+name: stacks-whois
+description: Use when performing WHOIS lookups in Stacks — domain queries, batch lookups, SOCKS proxy support, TLD server discovery, response parsing, the WhoIsParser class, or the built-in SocksClient. Covers @stacksjs/whois.
+license: MIT
+compatibility: Bun >= 1.3.0, TypeScript
+allowed-tools: Read Edit Write Bash Grep Glob
+---
+
+# Stacks WHOIS
+
+Domain WHOIS lookup with SOCKS proxy support, batch processing, TLD server discovery, and response parsing. Includes a native SOCKS4/SOCKS5 client implementation.
+
+## Key Paths
+- Core package: `storage/framework/core/whois/src/`
+
+## Source Files
+```
+whois/src/
+├── index.ts          # whois(), lookup(), batchWhois(), tcpWhois(), WhoIsParser, exports
+├── types.ts          # WhoIsResponse, WhoIsOptions, ProxyData, ProxyType
+├── constants.ts      # IANA_CHK_URL, PARAMETERS, SERVERS
+├── utils.ts          # shallowCopy helper
+└── socks.ts          # Native SocksClient implementation (SOCKS4/SOCKS5)
+```
+
+## Main Functions
+
+### whois() -- Primary Lookup
+```typescript
+async function whois(
+  domain: string,
+  parse?: boolean,          // default: false (but still parses with default fields)
+  options?: WhoIsOptions | null,
+): Promise<WhoIsResponse>
+```
+
+When `parse` is `false` (default), it still calls `WhoIsParser.parseData(rawData, null)` which parses with the default field set. When `parse` is `true` and `options.parseData` is provided, it uses a shallow copy of that object as the parse template.
+
+Flow:
+1. Determine TLD from domain (or use `options.tld`)
+2. Find WHOIS server: check `SERVERS` map first, then query IANA via `findWhoIsServer()`
+3. Get query parameters via `getParameters()` for the server
+4. Execute TCP query via `tcpWhois()`
+5. Parse response via `WhoIsParser.parseData()`
+6. Returns `{ _raw: string, parsedData: any | null }`
+
+### lookup() -- Parsed Lookup Shortcut
+```typescript
+function lookup(domain: string, options?: WhoIsOptions | null): Promise<WhoIsResponse>
+```
+Calls `whois(domain, true, options)` -- always parses the response.
+
+### batchWhois() -- Batch Lookups
+```typescript
+async function batchWhois(
+  domains: string[],
+  parallel?: boolean,       // default: false
+  threads?: number,         // default: 1 (batch size for parallel mode)
+  parse?: boolean,          // default: false
+  options?: WhoIsOptions | null,
+): Promise<WhoIsResponse[]>
+```
+
+- Sequential mode (`parallel=false`): processes domains one at a time
+- Parallel mode (`parallel=true`): processes in batches of `threads` size using `Promise.all`
+- If `threads > domains.length`, clamps to `domains.length`
+- Note: In parallel mode, only the last batch's results are returned (`response` is reassigned, not concatenated)
+
+### tcpWhois() -- Raw TCP Query
+```typescript
+async function tcpWhois(
+  domain: string,
+  queryOptions: string,     // server-specific prefix (e.g., '-T dn,ace')
+  server: string,
+  port: number,             // default 43
+  encoding: string,         // default 'utf-8'
+  proxy: ProxyData | null,
+): Promise<string>
+```
+
+- Without proxy: creates `Net.Socket`, connects directly to WHOIS server on specified port
+- With proxy: uses `SocksClient.createConnection()` to tunnel through SOCKS proxy
+- Sends query as `"<queryOptions> <domain>\r\n"` or `"<domain>\r\n"` if no queryOptions
+- Uses `TextDecoder` with specified encoding for response
+
+## Server Discovery
+
+### findWhoIsServer() -- Remote IANA Lookup
+```typescript
+async function findWhoIsServer(tld: string): Promise<string>
+```
+Fetches `https://www.iana.org/whois?q=<tld>` and extracts server from `whois:\s+(\S+)` regex match. Returns empty string on failure.
+
+### getWhoIsServer() -- Local Lookup
+```typescript
+function getWhoIsServer(tld: keyof typeof SERVERS): string | undefined
+```
+Looks up TLD in the built-in `SERVERS` map. Special case: `'com'` always returns `'whois.verisign-grs.com'`.
+
+### getTLD() -- Extract TLD
+```typescript
+function getTLD(domain: string): keyof typeof SERVERS
+```
+Splits domain by `.` and checks from longest suffix first against the `SERVERS` map. For example, `sub.example.co.uk` checks `co.uk` first (which exists in SERVERS), not just `uk`. Falls back to the last part if no match found.
+
+### getParameters() -- Server Query Parameters
+```typescript
+function getParameters(server: string): string | undefined
+```
+Returns server-specific query format from the `PARAMETERS` map.
+
+## WhoIsParser
+
+```typescript
+class WhoIsParser {
+  // Parse raw WHOIS text with custom or default field template
+  static parseData(rawData: string, outputData: any | null): any
+
+  // Internal iterative parser (private)
+  private static iterParse(rawData: string, outputData: any): any
+}
+```
+
+When `outputData` is `null`, `parseData()` uses this default template:
+```typescript
+{
+  'Domain Name': '',
+  'Creation Date': '',
+  'Updated Date': '',
+  'Registry Expiry Date': '',
+  'Domain Status': [],       // array collects multiple values
+  'Registrar': '',
+}
+```
+
+The parser iterates character by character through raw WHOIS text:
+- Keys are identified when a line matches a key in `outputData`
+- Values follow after `": "` separator
+- Array-typed fields (like `Domain Status`) accumulate multiple values
+- Parsing stops at `"Record maintained by"` or `">>>"` markers
+
+Custom parse templates: pass an object with the field names you want extracted. Use empty string `''` for single values, use `[]` for fields with multiple values.
+
+```typescript
+const result = await whois('example.com', true, {
+  parseData: {
+    'Domain Name': '',
+    'Domain Status': [],     // collects ALL status values
+    'Registrar': '',
+    'Name Server': [],       // collects ALL name servers
+  }
+})
+```
+
+## Types
+
+### WhoIsResponse
+```typescript
+interface WhoIsResponse {
+  _raw: string              // raw text from WHOIS server
+  parsedData: any | null    // parsed key-value pairs (null on error)
+}
+```
+
+### WhoIsOptions
+```typescript
+interface WhoIsOptions {
+  tld?: string | null              // override TLD detection
+  encoding?: string | null         // character encoding (default: 'utf-8')
+  proxy?: ProxyData | null         // SOCKS proxy configuration
+  server?: string | null           // override WHOIS server
+  serverPort?: number | null       // override port (default: 43)
+  parseData?: object | null        // custom parse template (keys to extract)
+}
+```
+
+### ProxyData
+```typescript
+interface ProxyData {
+  ip: string
+  port: number
+  username?: string | null
+  password?: string | null
+  type: ProxyType
+}
+```
+
+### ProxyType
+```typescript
+enum ProxyType {
+  SOCKS4 = 0,
+  SOCKS5 = 1,
+}
+```
+
+Note: `ProxyType.SOCKS4 = 0` and `ProxyType.SOCKS5 = 1` -- these are mapped to SOCKS versions `4` and `5` internally when creating SocksClient options.
+
+## SOCKS Proxy Support
+
+```typescript
+const result = await whois('example.com', false, {
+  proxy: {
+    ip: '127.0.0.1',
+    port: 1080,
+    type: ProxyType.SOCKS5,
+    username: 'user',        // optional
+    password: 'pass',        // optional
+  }
+})
+```
+
+## Built-in SocksClient (socks.ts)
+
+Native SOCKS client implementation using `node:net`. Replaces the `socks` npm package.
+
+```typescript
+class SocksClient {
+  static createConnection(
+    options: SocksClientOptions,
+    callback: (err: Error | null, info?: SocksClientEstablishedEvent) => void,
+  ): void
+}
+
+interface SocksClientOptions {
+  proxy: SocksProxy
+  command: 'connect' | 'bind' | 'associate'
+  destination: SocksDestination
+}
+
+interface SocksProxy {
+  host: string
+  port: number
+  type: 4 | 5               // SOCKS version
+  userId?: string
+  password?: string
+}
+
+interface SocksDestination {
+  host: string
+  port: number
+}
+
+interface SocksClientEstablishedEvent {
+  socket: Net.Socket
+  remoteHost?: string
+  remotePort?: number
+}
+```
+
+### SOCKS4 Implementation
+- Supports SOCKS4 and SOCKS4a (domain name support via special IP marker `0.0.0.1`)
+- Request format: VN(1) + CD(1) + DSTPORT(2) + DSTIP(4) + USERID(var) + NULL(1)
+- Success response: status byte `0x5A` (90)
+
+### SOCKS5 Implementation
+- Three-step handshake: greeting -> authentication (optional) -> connect request
+- Supports no-auth (`0x00`) and username/password auth (`0x02`)
+- Supports IPv4 (`0x01`), IPv6 (`0x04`), and domain name (`0x03`) address types
+- Detailed error messages for all SOCKS5 status codes (general failure, not allowed, network unreachable, host unreachable, connection refused, TTL expired, command not supported, address type not supported)
+
+## Constants
+
+### IANA_CHK_URL
+```typescript
+const IANA_CHK_URL = 'https://www.iana.org/whois?q='
+```
+
+### PARAMETERS -- Server-Specific Query Formats
+```typescript
+const PARAMETERS: Record<string, string> = {
+  'whois.denic.de': '-T dn,ace',
+  'whois.nic.fr': '-V Md5.2',
+}
+```
+
+### SERVERS -- TLD to WHOIS Server Mapping
+Comprehensive mapping of hundreds of TLDs to their WHOIS servers. Examples:
+- `'com'` -> `'whois.verisign-grs.com'`
+- `'net'` -> `'whois.verisign-grs.com'`
+- `'org'` -> `'whois.pir.org'`
+- `'io'` -> `'whois.nic.io'`
+- `'co.uk'` -> compound TLD support via `getTLD()` longest-match logic
+- Country code TLDs, new gTLDs, compound TLDs (e.g., `br.com`, `co.ca`)
+
+## Utility: shallowCopy (utils.ts)
+
+```typescript
+function shallowCopy<T>(obj: T): T
+```
+Recursively copies objects and arrays. Used to clone `parseData` templates before filling them with parsed values, so the original template is not mutated.
+
+## Exports from index.ts
+
+Functions: `whois`, `lookup`, `batchWhois`, `tcpWhois`, `findWhoIsServer`, `getWhoIsServer`, `getTLD`, `getParameters`
+Classes: `WhoIsParser`, `SocksClient`
+Constants: `IANA_CHK_URL`, `PARAMETERS`, `SERVERS`
+Types: `WhoIsResponse`, `WhoIsOptions`, `ProxyData`, `ProxyType`, `SocksClientOptions`
+
+## Dependencies
+- `node:net` -- TCP socket connections (direct WHOIS queries and SOCKS client)
+- `@stacksjs/logging` -- `log` for debug logging during lookups
+
+## Gotchas
+- `whois()` with `parse=false` still parses with default fields -- the `parse` flag controls whether custom `parseData` is used
+- `batchWhois()` in parallel mode has a bug: it reassigns `response` each batch instead of concatenating, so only the last batch's results are returned
+- `ProxyType` enum values are `0` and `1`, not `4` and `5` -- they are mapped to SOCKS versions internally
+- `getWhoIsServer()` returns `undefined` for unknown TLDs, not an empty string
+- `findWhoIsServer()` returns empty string `''` on failure (not `undefined`)
+- `getTLD()` checks compound TLDs (like `co.uk`) before simple ones via longest-suffix matching
+- The parser stops at `"Record maintained by"` or `">>>"` markers in the raw response
+- WHOIS servers are rate-limited -- batch queries should use small thread counts
+- `shallowCopy()` is a recursive deep copy despite its name -- it clones nested objects and arrays
+- TCP connections use `node:net` Socket, not `fetch` -- WHOIS is a raw TCP protocol on port 43
+- The SOCKS client uses callback-style API, not promises
+- Query options are prepended to the domain in the TCP query (e.g., `"-T dn,ace example.de\r\n"`)