@socketsecurity/lib 6.0.6 → 6.0.8

package/dist/ai/tier.js

@@ -0,0 +1,53 @@
+"use strict";
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/ai/tier.mts
+/**
+* Canonical tier → { model, effort }. The single source of truth for which
+* Claude model + effort each tier runs. Bump here on a model generation roll;
+* every orchestrator that imports this picks it up.
+*
+* - `haiku` / low — deterministic, regex-shaped rewrites (identifier rename,
+*   null→undefined, single-token substitution).
+* - `sonnet` / medium — control-flow / caller-chain reasoning (fetch→httpJson,
+*   sync→async), a check script, a doc edit.
+* - `opus` / high — real authoring / refactoring (module split, a brand-new hook
+*   or lint rule with its test).
+* - `fable` / xhigh — apex escalation only: a stuck compiler / native problem
+*   after cheaper tiers fail, or planning + decomposition of a large task whose
+*   chunks then run on cheaper tiers. Most expensive model on the board; never
+*   a default.
+*/
+const AI_TIER = {
+	__proto__: null,
+	fable: {
+		effort: "xhigh",
+		model: "claude-fable-5"
+	},
+	haiku: {
+		effort: "low",
+		model: "claude-haiku-4-5"
+	},
+	opus: {
+		effort: "high",
+		model: "claude-opus-4-8"
+	},
+	sonnet: {
+		effort: "medium",
+		model: "claude-sonnet-4-6"
+	}
+};
+/**
+* Resolve a tier label to its `{ model, effort }` spawn pair. A convenience
+* over indexing `AI_TIER` directly; returns the `sonnet` row for an unknown
+* label so a caller that hands in a stray string degrades to the safe default
+* rather than producing `undefined` model/effort.
+*/
+function tierToSpawn(tier) {
+	return AI_TIER[tier] ?? AI_TIER.sonnet;
+}
+
+//#endregion
+exports.AI_TIER = AI_TIER;
+exports.tierToSpawn = tierToSpawn;

package/dist/ai/types.d.mts

@@ -25,6 +25,19 @@ export type AiAgentName = 'claude' | 'codex' | 'gemini' | 'opencode';
  *   tools that mutate state.
  */
 export type PermissionMode = 'acceptEdits' | 'dontAsk' | 'plan';
+/**
+ * Reasoning-effort level for the agent session. Two agents consume it, each via
+ * its own flag — `buildArgs` translates per-agent:
+ *
+ * - Claude: `--effort <level>`, accepts low/medium/high/xhigh/max.
+ * - Codex: `-c model_reasoning_effort=<level>`, accepts minimal/low/medium/high/
+ *   xhigh (no `max` — `buildArgs` clamps `max` → `xhigh`, codex's ceiling).
+ *
+ * Gemini / opencode have no reasoning-effort flag, so they ignore it. Pair a
+ * cheap model with low effort for mechanical work and reserve high/max for
+ * tasks that genuinely need deeper reasoning.
+ */
+export type AiEffort = 'high' | 'low' | 'max' | 'medium' | 'xhigh';
 /**
  * Result of an agent spawn. Consumers should inspect `exitCode` before using
  * `stdout` — non-zero usually means the agent's CLI itself rejected, not just
@@ -34,6 +47,13 @@ export interface AgentSpawnResult {
     readonly attempts: number;
     readonly durationMs: number;
     readonly exitCode: number;
+    /**
+     * True when the spawn failed because the API stayed overloaded (HTTP 529 /
+     * "Overloaded") through every retry. Lets a caller distinguish "back off and
+     * retry later" from "the work genuinely failed" — both surface as a non-zero
+     * `exitCode`, so this is the only way to tell them apart.
+     */
+    readonly overloaded: boolean;
     readonly stderr: string;
     readonly stdout: string;
 }
@@ -55,27 +75,32 @@ export interface SpawnAiAgentOptions {
     /**
      * Optional explicit agent. Defaults to claude when discovered.
      */
-    readonly agent?: AiAgentName;
+    readonly agent?: AiAgentName | undefined;
     /**
      * Allow-list extras (Bash glob patterns, MCP tools, etc.).
      */
-    readonly allow?: readonly string[];
+    readonly allow?: readonly string[] | undefined;
     /**
      * Extra dirs the agent can read (e.g. parent of cwd for monorepo).
      */
-    readonly addDirs?: readonly string[];
+    readonly addDirs?: readonly string[] | undefined;
     /**
      * Tool denylist — required to enforce the lockdown.
      */
     readonly disallow: readonly string[];
+    /**
+     * Reasoning-effort level (claude `--effort`); agent default if absent.
+     * claude-specific — other agents ignore it.
+     */
+    readonly effort?: AiEffort | undefined;
     /**
      * Override the agent's flag list (rare; for one-off advanced cases).
      */
-    readonly extraArgs?: readonly string[];
+    readonly extraArgs?: readonly string[] | undefined;
     /**
      * Model name override; agent default if absent.
      */
-    readonly model?: string;
+    readonly model?: string | undefined;
     /**
      * Permission mode — see PermissionMode docstring.
      */
@@ -91,7 +116,7 @@ export interface SpawnAiAgentOptions {
     /**
      * Per-call timeout (ms). Caller should set for predictable bounds.
      */
-    readonly timeoutMs?: number;
+    readonly timeoutMs?: number | undefined;
     /**
      * Tool allowlist. Required to enforce the lockdown.
      */

package/dist/ai/worktree.d.mts

@@ -22,23 +22,23 @@ export interface WorktreeRunOptions {
     /**
      * Branch to merge results into. Default: current branch of baseRepo.
      */
-    readonly branch?: string;
+    readonly branch?: string | undefined;
     /**
      * Cleanup policy. Default 'always'.
      */
-    readonly cleanup?: WorktreeCleanup;
+    readonly cleanup?: WorktreeCleanup | undefined;
     /**
      * Parallel cap. Default 4, max 8.
      */
-    readonly concurrency?: number;
+    readonly concurrency?: number | undefined;
     /**
      * Prefix for worktree branch + dir names. Default 'agent-task'.
      */
-    readonly namePrefix?: string;
+    readonly namePrefix?: string | undefined;
     /**
      * Where worktrees live on disk. Default: `${tmpdir}/${prefix}-<n>`.
      */
-    readonly worktreeRoot?: string;
+    readonly worktreeRoot?: string | undefined;
 }
 export interface WorktreeRunContext {
     /**
@@ -56,7 +56,7 @@ export interface WorktreeRunContext {
 }
 export interface WorktreeRunSettled<T> {
     readonly cleanup: 'removed' | 'kept';
-    readonly error?: unknown;
+    readonly error?: unknown | undefined;
     readonly merged: boolean;
     readonly status: 'fulfilled' | 'rejected';
     readonly value?: T | undefined;

package/dist/ai/worktree.js

@@ -133,6 +133,10 @@ async function runOne(item, index, worktreeBranch, worktreePath, baseRepo, branc
 *   ```
 */
 async function spawnAiAgentsInWorktrees(items, fn, options) {
+	options = {
+		__proto__: null,
+		...options
+	};
 	const cleanup = options.cleanup ?? "always";
 	const namePrefix = options.namePrefix ?? "agent-task";
 	const concurrency = require_primordials_math.MathMax(1, Math.min(options.concurrency ?? DEFAULT_CONCURRENCY, MAX_CONCURRENCY));
@@ -161,7 +165,7 @@ function tryGit(cwd, ...args) {
 			output: git(cwd, ...args)
 		};
 	} catch (e) {
-		if (/* @__PURE__ */ require_process_spawn_errors.isSpawnError(e)) return {
+		if (require_process_spawn_errors.isSpawnError(e)) return {
 			ok: false,
 			output: String(e.stderr ?? e.stdout ?? "")
 		};

package/dist/ansi/strip.d.ts

@@ -19,7 +19,7 @@
  *   ```
  */
 export declare function ansiRegex(options?: {
-    onlyFirst?: boolean;
+    onlyFirst?: boolean | undefined;
 }): RegExp;
 /**
  * Strip ANSI escape codes from text. Uses the inlined ansi-regex for matching.

package/dist/ansi/strip.js

@@ -26,7 +26,6 @@ const ANSI_REGEX = /\x1b\[[0-9;]*m/g;
 *   ansiRegex({ onlyFirst: true }) // matches only the first code
 *   ```
 */
-/*@__NO_SIDE_EFFECTS__*/
 function ansiRegex(options) {
 	const { onlyFirst } = options ?? {};
 	return new require_primordials_regexp.RegExpCtor(`(?:\\u001B\\][\\s\\S]*?(?:\\u0007|\\u001B\\u005C|\\u009C))|[\\u001B\\u009B][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]`, onlyFirst ? void 0 : "g");
@@ -40,7 +39,6 @@ function ansiRegex(options) {
 *   stripAnsi('\u001b[1mBold\u001b[0m') // 'Bold'
 *   ```
 */
-/*@__NO_SIDE_EFFECTS__*/
 function stripAnsi(text) {
 	return require_primordials_string.StringPrototypeReplace(text, ANSI_REGEX, "");
 }

package/dist/archives/_internal.js

@@ -15,8 +15,8 @@ let node_fs = require("node:fs");
 const DEFAULT_MAX_FILE_SIZE = 100 * 1024 * 1024;
 const DEFAULT_MAX_TOTAL_SIZE = 1024 * 1024 * 1024;
 const DEFAULT_MAX_ENTRIES = 1e5;
-let _AdmZip;
-let _tarFs;
+let admZip;
+let tarFs;
 /**
 * Assert that an archive file exists on disk before handing it to the
 * underlying extractor. Normalizes the "missing archive" surface across all
@@ -38,15 +38,13 @@ function assertArchiveExists(archivePath) {
 		throw err;
 	}
 }
-/*@__NO_SIDE_EFFECTS__*/
 function getAdmZip() {
-	if (_AdmZip === void 0) _AdmZip = /*@__PURE__*/ require("../external/adm-zip.js");
-	return _AdmZip;
+	if (admZip === void 0) admZip = /*@__PURE__*/ require("../external/adm-zip.js");
+	return admZip;
 }
-/*@__NO_SIDE_EFFECTS__*/
 function getTarFs() {
-	if (_tarFs === void 0) _tarFs = /*@__PURE__*/ require("../external/tar-fs.js");
-	return _tarFs;
+	if (tarFs === void 0) tarFs = /*@__PURE__*/ require("../external/tar-fs.js");
+	return tarFs;
 }
 /**
 * Validate that a resolved path is within the target directory. Prevents path
@@ -61,7 +59,7 @@ function getTarFs() {
 * @throws Error if path is outside the base directory
 */
 function validatePathWithinBase(targetPath, baseDir, entryName) {
-	const path = /* @__PURE__ */ require_node_path.getNodePath();
+	const path = require_node_path.getNodePath();
 	const resolvedTarget = path.resolve(targetPath);
 	const resolvedBase = path.resolve(baseDir);
 	if (!require_primordials_string.StringPrototypeStartsWith(resolvedTarget, resolvedBase + path.sep) && resolvedTarget !== resolvedBase) throw new require_primordials_error.ErrorCtor(`Path traversal attempt detected: entry "${entryName}" would extract to "${resolvedTarget}" outside target directory "${resolvedBase}"`);

package/dist/archives/extract.js

@@ -31,7 +31,7 @@ const require_archives_zip = require('./zip.js');
 async function extractArchive(archivePath, outputDir, options = {}) {
 	const format = require_archives_detect.detectArchiveFormat(archivePath);
 	if (!format) {
-		const ext = (/* @__PURE__ */ require_node_path.getNodePath()).extname(archivePath).toLowerCase();
+		const ext = require_node_path.getNodePath().extname(archivePath).toLowerCase();
 		throw new require_primordials_error.ErrorCtor(`Unsupported archive format${ext ? ` (extension: ${ext})` : ""}: ${archivePath}. Supported formats: .zip, .tar, .tar.gz, .tgz`);
 	}
 	switch (format) {

package/dist/archives/tar.js

@@ -4,8 +4,8 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_runtime = require('../_virtual/_rolldown/runtime.js');
 const require_primordials_error = require('../primordials/error.js');
 const require_paths_normalize = require('../paths/normalize.js');
-const require_archives__internal = require('./_internal.js');
 const require_fs_safe = require('../fs/safe.js');
+const require_archives__internal = require('./_internal.js');
 let node_fs = require("node:fs");
 let node_process = require("node:process");
 node_process = require_runtime.__toESM(node_process);
@@ -42,12 +42,12 @@ let node_zlib = require("node:zlib");
 async function extractTar(archivePath, outputDir, options = {}) {
 	require_archives__internal.assertArchiveExists(archivePath);
 	const { maxEntries = require_archives__internal.DEFAULT_MAX_ENTRIES, maxFileSize = require_archives__internal.DEFAULT_MAX_FILE_SIZE, maxTotalSize = require_archives__internal.DEFAULT_MAX_TOTAL_SIZE, strip = 0 } = options;
-	const normalizedOutputDir = /* @__PURE__ */ require_paths_normalize.normalizePath(outputDir);
+	const normalizedOutputDir = require_paths_normalize.normalizePath(outputDir);
 	await require_fs_safe.safeMkdir(normalizedOutputDir);
 	let totalExtractedSize = 0;
 	let entryCount = 0;
 	let destroyScheduled = false;
-	const extractStream = (/* @__PURE__ */ require_archives__internal.getTarFs()).extract(normalizedOutputDir, {
+	const extractStream = require_archives__internal.getTarFs().extract(normalizedOutputDir, {
 		map: (header) => {
 			/* c8 ignore start - destroyScheduled is set by the same map() when a
 			security limit trips; only fires after the schedule. */
@@ -73,7 +73,7 @@ async function extractTar(archivePath, outputDir, options = {}) {
 				});
 				return header;
 			}
-			if (header.type === "symlink" || header.type === "link") {
+			if (header.type === "link" || header.type === "symlink") {
 				destroyScheduled = true;
 				node_process.default.nextTick(() => {
 					extractStream.destroy(new require_primordials_error.ErrorCtor(`Symlink detected in archive: ${header.name}. Symlinks are not supported for security reasons.`));
@@ -127,12 +127,12 @@ async function extractTar(archivePath, outputDir, options = {}) {
 async function extractTarGz(archivePath, outputDir, options = {}) {
 	require_archives__internal.assertArchiveExists(archivePath);
 	const { maxEntries = require_archives__internal.DEFAULT_MAX_ENTRIES, maxFileSize = require_archives__internal.DEFAULT_MAX_FILE_SIZE, maxTotalSize = require_archives__internal.DEFAULT_MAX_TOTAL_SIZE, strip = 0 } = options;
-	const normalizedOutputDir = /* @__PURE__ */ require_paths_normalize.normalizePath(outputDir);
+	const normalizedOutputDir = require_paths_normalize.normalizePath(outputDir);
 	await require_fs_safe.safeMkdir(normalizedOutputDir);
 	let totalExtractedSize = 0;
 	let entryCount = 0;
 	let destroyScheduled = false;
-	const extractStream = (/* @__PURE__ */ require_archives__internal.getTarFs()).extract(normalizedOutputDir, {
+	const extractStream = require_archives__internal.getTarFs().extract(normalizedOutputDir, {
 		map: (header) => {
 			/* c8 ignore start - destroyScheduled is set by the same map() when a
 			security limit trips; only fires after the schedule. */
@@ -158,7 +158,7 @@ async function extractTarGz(archivePath, outputDir, options = {}) {
 				});
 				return header;
 			}
-			if (header.type === "symlink" || header.type === "link") {
+			if (header.type === "link" || header.type === "symlink") {
 				destroyScheduled = true;
 				node_process.default.nextTick(() => {
 					extractStream.destroy(new require_primordials_error.ErrorCtor(`Symlink detected in archive: ${header.name}. Symlinks are not supported for security reasons.`));

package/dist/archives/zip.js

@@ -2,13 +2,13 @@
 /* Socket Lib - Built with rolldown */
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_primordials_error = require('../primordials/error.js');
+const require_primordials_map_set = require('../primordials/map-set.js');
 const require_paths_normalize = require('../paths/normalize.js');
 const require_primordials_array = require('../primordials/array.js');
-const require_primordials_map_set = require('../primordials/map-set.js');
 const require_node_path = require('../node/path.js');
 const require_primordials_promise = require('../primordials/promise.js');
-const require_archives__internal = require('./_internal.js');
 const require_fs_safe = require('../fs/safe.js');
+const require_archives__internal = require('./_internal.js');
 
 //#region src/archives/zip.ts
 /**
@@ -32,10 +32,10 @@ const require_fs_safe = require('../fs/safe.js');
 async function extractZip(archivePath, outputDir, options = {}) {
 	require_archives__internal.assertArchiveExists(archivePath);
 	const { maxEntries = require_archives__internal.DEFAULT_MAX_ENTRIES, maxFileSize = require_archives__internal.DEFAULT_MAX_FILE_SIZE, maxTotalSize = require_archives__internal.DEFAULT_MAX_TOTAL_SIZE, strip = 0 } = options;
-	const normalizedOutputDir = /* @__PURE__ */ require_paths_normalize.normalizePath(outputDir);
+	const normalizedOutputDir = require_paths_normalize.normalizePath(outputDir);
 	await require_fs_safe.safeMkdir(normalizedOutputDir);
-	const zip = new (/* @__PURE__ */ require_archives__internal.getAdmZip())(archivePath);
-	const path = /* @__PURE__ */ require_node_path.getNodePath();
+	const zip = new (require_archives__internal.getAdmZip())(archivePath);
+	const path = require_node_path.getNodePath();
 	const entries = zip.getEntries();
 	/* c8 ignore start */
 	if (entries.length > maxEntries) throw new require_primordials_error.ErrorCtor(`Archive has too many entries: ${entries.length} (limit: ${maxEntries})`);
@@ -60,8 +60,6 @@ async function extractZip(archivePath, outputDir, options = {}) {
 		for (const entry of entries) if (!entry.isDirectory) require_archives__internal.validatePathWithinBase(path.join(normalizedOutputDir, entry.entryName), normalizedOutputDir, entry.entryName);
 		zip.extractAllTo(normalizedOutputDir, true);
 	} else {
-		const path = /* @__PURE__ */ require_node_path.getNodePath();
-		const entries = zip.getEntries();
 		const dirsToCreate = new require_primordials_map_set.SetCtor();
 		for (const entry of entries) {
 			if (entry.isDirectory) continue;

package/dist/argv/flag-predicates.d.ts

@@ -11,6 +11,18 @@
  *      accepts both `--quiet` and `--silent`).
  */
 import type { FlagInput } from './flag-types';
+/**
+ * Get the appropriate log level based on flags. Returns 'silent', 'error',
+ * 'warn', 'info', 'verbose', or 'debug'.
+ *
+ * @example
+ *   ;```typescript
+ *   getLogLevel() // 'info' (default)
+ *   getLogLevel({ quiet: true }) // 'silent'
+ *   getLogLevel(['--debug']) // 'debug'
+ *   ```
+ */
+export declare function getLogLevel(input?: FlagInput): string;
 /**
  * Build a flag predicate that accepts `FlagValues`, `string[]`, or `undefined`
  * (in which case it consults the frozen `processArg`).
@@ -165,15 +177,3 @@ export declare const isVerbose: (input?: FlagInput) => boolean;
  *   ```
  */
 export declare const isWatch: (input?: FlagInput) => boolean;
-/**
- * Get the appropriate log level based on flags. Returns 'silent', 'error',
- * 'warn', 'info', 'verbose', or 'debug'.
- *
- * @example
- *   ;```typescript
- *   getLogLevel() // 'info' (default)
- *   getLogLevel({ quiet: true }) // 'silent'
- *   getLogLevel(['--debug']) // 'debug'
- *   ```
- */
-export declare function getLogLevel(input?: FlagInput): string;

package/dist/argv/flag-predicates.js

@@ -21,6 +21,23 @@ node_process = require_runtime.__toESM(node_process);
 */
 const processArg = [...node_process.default.argv];
 /**
+* Get the appropriate log level based on flags. Returns 'silent', 'error',
+* 'warn', 'info', 'verbose', or 'debug'.
+*
+* @example
+*   ;```typescript
+*   getLogLevel() // 'info' (default)
+*   getLogLevel({ quiet: true }) // 'silent'
+*   getLogLevel(['--debug']) // 'debug'
+*   ```
+*/
+function getLogLevel(input) {
+	if (isQuiet(input)) return "silent";
+	if (isDebug(input)) return "debug";
+	if (isVerbose(input)) return "verbose";
+	return "info";
+}
+/**
 * Build a flag predicate that accepts `FlagValues`, `string[]`, or `undefined`
 * (in which case it consults the frozen `processArg`).
 *
@@ -183,23 +200,6 @@ const isVerbose = makeFlagPredicate(["--verbose"]);
 *   ```
 */
 const isWatch = makeFlagPredicate(["--watch"], ["-w"]);
-/**
-* Get the appropriate log level based on flags. Returns 'silent', 'error',
-* 'warn', 'info', 'verbose', or 'debug'.
-*
-* @example
-*   ;```typescript
-*   getLogLevel() // 'info' (default)
-*   getLogLevel({ quiet: true }) // 'silent'
-*   getLogLevel(['--debug']) // 'debug'
-*   ```
-*/
-function getLogLevel(input) {
-	if (isQuiet(input)) return "silent";
-	if (isDebug(input)) return "debug";
-	if (isVerbose(input)) return "verbose";
-	return "info";
-}
 
 //#endregion
 exports.getLogLevel = getLogLevel;

package/dist/argv/flag-types.d.ts

@@ -8,22 +8,22 @@
  */
 export interface FlagValues {
     [key: string]: unknown;
-    quiet?: boolean;
-    silent?: boolean;
-    verbose?: boolean;
-    help?: boolean;
-    all?: boolean;
-    fix?: boolean;
-    force?: boolean;
-    'dry-run'?: boolean;
-    json?: boolean;
-    debug?: boolean;
-    watch?: boolean;
-    coverage?: boolean;
-    cover?: boolean;
-    update?: boolean;
-    staged?: boolean;
-    changed?: boolean;
+    quiet?: boolean | undefined;
+    silent?: boolean | undefined;
+    verbose?: boolean | undefined;
+    help?: boolean | undefined;
+    all?: boolean | undefined;
+    fix?: boolean | undefined;
+    force?: boolean | undefined;
+    'dry-run'?: boolean | undefined;
+    json?: boolean | undefined;
+    debug?: boolean | undefined;
+    watch?: boolean | undefined;
+    coverage?: boolean | undefined;
+    cover?: boolean | undefined;
+    update?: boolean | undefined;
+    staged?: boolean | undefined;
+    changed?: boolean | undefined;
 }
 /**
  * Accepted input types for flag checking functions. Can be parsed flag values,
@@ -45,12 +45,12 @@ export declare const COMMON_FLAGS: {
         default: boolean;
         description: string;
     };
-    coverage: {
+    cover: {
         type: 'boolean';
         default: boolean;
         description: string;
     };
-    cover: {
+    coverage: {
         type: 'boolean';
         default: boolean;
         description: string;

package/dist/argv/flag-types.js

@@ -18,15 +18,15 @@ const COMMON_FLAGS = {
 		default: false,
 		description: "Target changed files"
 	},
-	coverage: {
+	cover: {
 		type: "boolean",
 		default: false,
-		description: "Run with coverage"
+		description: "Run with coverage (alias)"
 	},
-	cover: {
+	coverage: {
 		type: "boolean",
 		default: false,
-		description: "Run with coverage (alias)"
+		description: "Run with coverage"
 	},
 	debug: {
 		type: "boolean",

package/dist/argv/parse.d.ts

@@ -3,12 +3,30 @@
  *   yargs-parser with a Node.js parseArgs-compatible surface for booleans,
  *   strings, arrays, aliases, defaults, and coercion.
  */
+/**
+ * Yargs parser options interface.
+ */
+export interface YargsOptions {
+    boolean?: string[] | undefined;
+    string?: string[] | undefined;
+    array?: string[] | undefined;
+    alias?: Record<string, string | string[]> | undefined;
+    default?: Record<string, unknown> | undefined;
+    coerce?: Record<string, (value: unknown) => unknown> | undefined;
+    'unknown-options-as-args'?: boolean | undefined;
+    'parse-numbers'?: boolean | undefined;
+    'parse-positional-numbers'?: boolean | undefined;
+    'boolean-negation'?: boolean | undefined;
+    'halt-at-non-option'?: boolean | undefined;
+    configuration?: Record<string, boolean | string> | undefined;
+    strict?: boolean | undefined;
+}
 /**
  * Yargs parser result interface.
  */
-interface YargsArguments extends Record<string, unknown> {
+export interface YargsArguments extends Record<string, unknown> {
     _: string[];
-    $0?: string;
+    $0?: string | undefined;
 }
 /**
  * Options for configuring argument parsing, similar to Node.js util.parseArgs.
@@ -95,4 +113,3 @@ export declare function parseArgs<T = Record<string, unknown>>(config?: ParseArg
  *   ```
  */
 export declare function parseArgsWithDefaults<T = Record<string, unknown>>(config?: ParseArgsConfig): ParsedArgs<T>;
-export {};

package/dist/argv/parse.js

@@ -2,9 +2,9 @@
 /* Socket Lib - Built with rolldown */
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_runtime = require('../_virtual/_rolldown/runtime.js');
+const require_primordials_object = require('../primordials/object.js');
 const require_primordials_string = require('../primordials/string.js');
 const require_primordials_array = require('../primordials/array.js');
-const require_primordials_object = require('../primordials/object.js');
 let node_process = require("node:process");
 node_process = require_runtime.__toESM(node_process);
 let src_external_yargs_parser = require("../external/yargs-parser");

package/dist/arrays/_internal.js

@@ -1,6 +1,7 @@
 "use strict";
 /* Socket Lib - Built with rolldown */
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_primordials_intl = require('../primordials/intl.js');
 
 //#region src/arrays/_internal.ts
 /**
@@ -8,8 +9,8 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 *   instances for conjunction (and) and disjunction (or) joins. Constructed
 *   lazily because `new Intl.ListFormat(...)` is a measurable startup cost.
 */
-let _conjunctionFormatter;
-let _disjunctionFormatter;
+let conjunctionFormatter;
+let disjunctionFormatter;
 /**
 * Get a cached Intl.ListFormat instance for conjunction (and) formatting.
 *
@@ -28,15 +29,14 @@ let _disjunctionFormatter;
 * @returns Cached Intl.ListFormat instance configured for conjunction
 *   formatting.
 */
-/*@__NO_SIDE_EFFECTS__*/
 function getConjunctionFormatter() {
-	if (_conjunctionFormatter === void 0)
- /* c8 ignore start */
-	_conjunctionFormatter = new Intl.ListFormat("en", {
+	if (conjunctionFormatter === void 0)
+ /* c8 ignore start - lazy singleton init runs once; not worth a dedicated test */
+	conjunctionFormatter = new require_primordials_intl.IntlListFormat("en", {
 		style: "long",
 		type: "conjunction"
 	});
-	return _conjunctionFormatter;
+	return conjunctionFormatter;
 }
 /**
 * Get a cached Intl.ListFormat instance for disjunction (or) formatting.
@@ -56,15 +56,14 @@ function getConjunctionFormatter() {
 * @returns Cached Intl.ListFormat instance configured for disjunction
 *   formatting.
 */
-/*@__NO_SIDE_EFFECTS__*/
 function getDisjunctionFormatter() {
-	if (_disjunctionFormatter === void 0)
- /* c8 ignore start */
-	_disjunctionFormatter = new Intl.ListFormat("en", {
+	if (disjunctionFormatter === void 0)
+ /* c8 ignore start - lazy singleton init runs once; not worth a dedicated test */
+	disjunctionFormatter = new require_primordials_intl.IntlListFormat("en", {
 		style: "long",
 		type: "disjunction"
 	});
-	return _disjunctionFormatter;
+	return disjunctionFormatter;
 }
 
 //#endregion

package/dist/arrays/chunk.js

@@ -40,7 +40,6 @@ const require_primordials_error = require('../primordials/error.js');
 *
 * @throws {Error} If chunk size is less than or equal to 0
 */
-/*@__NO_SIDE_EFFECTS__*/
 function arrayChunk(arr, size) {
 	const chunkSize = size ?? 2;
 	if (chunkSize <= 0) throw new require_primordials_error.ErrorCtor("Chunk size must be greater than 0");