@socketsecurity/lib 1.3.2 → 1.3.4

package/dist/utils/get-ipc.js

@@ -1,60 +1,3 @@
 /* Socket Lib - Built with esbuild */
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var get_ipc_exports = {};
-__export(get_ipc_exports, {
-  default: () => get_ipc_default,
-  getIpc: () => getIpc
-});
-module.exports = __toCommonJS(get_ipc_exports);
-let _ipcObject;
-async function getIpc(key) {
-  if (_ipcObject === void 0) {
-    _ipcObject = {};
-    const { env } = process;
-    if (env["SOCKET_CLI_FIX"]) {
-      _ipcObject.SOCKET_CLI_FIX = env["SOCKET_CLI_FIX"];
-    }
-    if (env["SOCKET_CLI_OPTIMIZE"]) {
-      _ipcObject.SOCKET_CLI_OPTIMIZE = env["SOCKET_CLI_OPTIMIZE"] === "true" || env["SOCKET_CLI_OPTIMIZE"] === "1";
-    }
-    if (env["SOCKET_CLI_SHADOW_ACCEPT_RISKS"]) {
-      _ipcObject.SOCKET_CLI_SHADOW_ACCEPT_RISKS = env["SOCKET_CLI_SHADOW_ACCEPT_RISKS"] === "true" || env["SOCKET_CLI_SHADOW_ACCEPT_RISKS"] === "1";
-    }
-    if (env["SOCKET_CLI_SHADOW_API_TOKEN"]) {
-      _ipcObject.SOCKET_CLI_SHADOW_API_TOKEN = env["SOCKET_CLI_SHADOW_API_TOKEN"];
-    }
-    if (env["SOCKET_CLI_SHADOW_BIN"]) {
-      _ipcObject.SOCKET_CLI_SHADOW_BIN = env["SOCKET_CLI_SHADOW_BIN"];
-    }
-    if (env["SOCKET_CLI_SHADOW_PROGRESS"]) {
-      _ipcObject.SOCKET_CLI_SHADOW_PROGRESS = env["SOCKET_CLI_SHADOW_PROGRESS"] === "true" || env["SOCKET_CLI_SHADOW_PROGRESS"] === "1";
-    }
-    if (env["SOCKET_CLI_SHADOW_SILENT"]) {
-      _ipcObject.SOCKET_CLI_SHADOW_SILENT = env["SOCKET_CLI_SHADOW_SILENT"] === "true" || env["SOCKET_CLI_SHADOW_SILENT"] === "1";
-    }
-    Object.freeze(_ipcObject);
-  }
-  return key ? _ipcObject[key] : _ipcObject;
-}
-var get_ipc_default = getIpc;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  getIpc
-});
+var e=Object.defineProperty;var K=Object.getOwnPropertyDescriptor;var n=Object.getOwnPropertyNames;var L=Object.prototype.hasOwnProperty;var t=(S,_)=>{for(var C in _)e(S,C,{get:_[C],enumerable:!0})},c=(S,_,C,E)=>{if(_&&typeof _=="object"||typeof _=="function")for(let I of n(_))!L.call(S,I)&&I!==C&&e(S,I,{get:()=>_[I],enumerable:!(E=K(_,I))||E.enumerable});return S};var A=S=>c(e({},"__esModule",{value:!0}),S);var f={};t(f,{default:()=>i,getIpc:()=>T});module.exports=A(f);let O;async function T(S){if(O===void 0){O={};const{env:_}=process;_.SOCKET_CLI_FIX&&(O.SOCKET_CLI_FIX=_.SOCKET_CLI_FIX),_.SOCKET_CLI_OPTIMIZE&&(O.SOCKET_CLI_OPTIMIZE=_.SOCKET_CLI_OPTIMIZE==="true"||_.SOCKET_CLI_OPTIMIZE==="1"),_.SOCKET_CLI_SHADOW_ACCEPT_RISKS&&(O.SOCKET_CLI_SHADOW_ACCEPT_RISKS=_.SOCKET_CLI_SHADOW_ACCEPT_RISKS==="true"||_.SOCKET_CLI_SHADOW_ACCEPT_RISKS==="1"),_.SOCKET_CLI_SHADOW_API_TOKEN&&(O.SOCKET_CLI_SHADOW_API_TOKEN=_.SOCKET_CLI_SHADOW_API_TOKEN),_.SOCKET_CLI_SHADOW_BIN&&(O.SOCKET_CLI_SHADOW_BIN=_.SOCKET_CLI_SHADOW_BIN),_.SOCKET_CLI_SHADOW_PROGRESS&&(O.SOCKET_CLI_SHADOW_PROGRESS=_.SOCKET_CLI_SHADOW_PROGRESS==="true"||_.SOCKET_CLI_SHADOW_PROGRESS==="1"),_.SOCKET_CLI_SHADOW_SILENT&&(O.SOCKET_CLI_SHADOW_SILENT=_.SOCKET_CLI_SHADOW_SILENT==="true"||_.SOCKET_CLI_SHADOW_SILENT==="1"),Object.freeze(O)}return S?O[S]:O}var i=T;0&&(module.exports={getIpc});
 //# sourceMappingURL=get-ipc.js.map

package/dist/utils/get-ipc.js.map

@@ -2,6 +2,6 @@
   "version": 3,
   "sources": ["../../src/utils/get-ipc.ts"],
   "sourcesContent": ["/**\n * IPC (Inter-Process Communication) object getter.\n * Handles communication between parent and child processes.\n */\n\nexport interface IpcObject {\n  SOCKET_CLI_FIX?: string | undefined\n  SOCKET_CLI_OPTIMIZE?: boolean | undefined\n  SOCKET_CLI_SHADOW_ACCEPT_RISKS?: boolean | undefined\n  SOCKET_CLI_SHADOW_API_TOKEN?: string | undefined\n  SOCKET_CLI_SHADOW_BIN?: string | undefined\n  SOCKET_CLI_SHADOW_PROGRESS?: boolean | undefined\n  SOCKET_CLI_SHADOW_SILENT?: boolean | undefined\n}\n\nlet _ipcObject: IpcObject | undefined\n\nexport async function getIpc(): Promise<IpcObject>\nexport async function getIpc<K extends keyof IpcObject>(\n  key: K,\n): Promise<IpcObject[K]>\nexport async function getIpc(\n  key?: keyof IpcObject,\n): Promise<IpcObject | IpcObject[keyof IpcObject]> {\n  if (_ipcObject === undefined) {\n    _ipcObject = {}\n\n    // Check for IPC environment variables.\n    const { env } = process\n\n    if (env['SOCKET_CLI_FIX']) {\n      _ipcObject.SOCKET_CLI_FIX = env['SOCKET_CLI_FIX']\n    }\n\n    if (env['SOCKET_CLI_OPTIMIZE']) {\n      _ipcObject.SOCKET_CLI_OPTIMIZE =\n        env['SOCKET_CLI_OPTIMIZE'] === 'true' ||\n        env['SOCKET_CLI_OPTIMIZE'] === '1'\n    }\n\n    if (env['SOCKET_CLI_SHADOW_ACCEPT_RISKS']) {\n      _ipcObject.SOCKET_CLI_SHADOW_ACCEPT_RISKS =\n        env['SOCKET_CLI_SHADOW_ACCEPT_RISKS'] === 'true' ||\n        env['SOCKET_CLI_SHADOW_ACCEPT_RISKS'] === '1'\n    }\n\n    if (env['SOCKET_CLI_SHADOW_API_TOKEN']) {\n      _ipcObject.SOCKET_CLI_SHADOW_API_TOKEN =\n        env['SOCKET_CLI_SHADOW_API_TOKEN']\n    }\n\n    if (env['SOCKET_CLI_SHADOW_BIN']) {\n      _ipcObject.SOCKET_CLI_SHADOW_BIN = env['SOCKET_CLI_SHADOW_BIN']\n    }\n\n    if (env['SOCKET_CLI_SHADOW_PROGRESS']) {\n      _ipcObject.SOCKET_CLI_SHADOW_PROGRESS =\n        env['SOCKET_CLI_SHADOW_PROGRESS'] === 'true' ||\n        env['SOCKET_CLI_SHADOW_PROGRESS'] === '1'\n    }\n\n    if (env['SOCKET_CLI_SHADOW_SILENT']) {\n      _ipcObject.SOCKET_CLI_SHADOW_SILENT =\n        env['SOCKET_CLI_SHADOW_SILENT'] === 'true' ||\n        env['SOCKET_CLI_SHADOW_SILENT'] === '1'\n    }\n\n    Object.freeze(_ipcObject)\n  }\n\n  return key ? _ipcObject[key] : _ipcObject\n}\n\nexport default getIpc\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAeA,IAAI;AAMJ,eAAsB,OACpB,KACiD;AACjD,MAAI,eAAe,QAAW;AAC5B,iBAAa,CAAC;AAGd,UAAM,EAAE,IAAI,IAAI;AAEhB,QAAI,IAAI,gBAAgB,GAAG;AACzB,iBAAW,iBAAiB,IAAI,gBAAgB;AAAA,IAClD;AAEA,QAAI,IAAI,qBAAqB,GAAG;AAC9B,iBAAW,sBACT,IAAI,qBAAqB,MAAM,UAC/B,IAAI,qBAAqB,MAAM;AAAA,IACnC;AAEA,QAAI,IAAI,gCAAgC,GAAG;AACzC,iBAAW,iCACT,IAAI,gCAAgC,MAAM,UAC1C,IAAI,gCAAgC,MAAM;AAAA,IAC9C;AAEA,QAAI,IAAI,6BAA6B,GAAG;AACtC,iBAAW,8BACT,IAAI,6BAA6B;AAAA,IACrC;AAEA,QAAI,IAAI,uBAAuB,GAAG;AAChC,iBAAW,wBAAwB,IAAI,uBAAuB;AAAA,IAChE;AAEA,QAAI,IAAI,4BAA4B,GAAG;AACrC,iBAAW,6BACT,IAAI,4BAA4B,MAAM,UACtC,IAAI,4BAA4B,MAAM;AAAA,IAC1C;AAEA,QAAI,IAAI,0BAA0B,GAAG;AACnC,iBAAW,2BACT,IAAI,0BAA0B,MAAM,UACpC,IAAI,0BAA0B,MAAM;AAAA,IACxC;AAEA,WAAO,OAAO,UAAU;AAAA,EAC1B;AAEA,SAAO,MAAM,WAAW,GAAG,IAAI;AACjC;AAEA,IAAO,kBAAQ;",
-  "names": []
+  "mappings": ";4ZAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,aAAAE,EAAA,WAAAC,IAAA,eAAAC,EAAAJ,GAeA,IAAIK,EAMJ,eAAsBF,EACpBG,EACiD,CACjD,GAAID,IAAe,OAAW,CAC5BA,EAAa,CAAC,EAGd,KAAM,CAAE,IAAAE,CAAI,EAAI,QAEZA,EAAI,iBACNF,EAAW,eAAiBE,EAAI,gBAG9BA,EAAI,sBACNF,EAAW,oBACTE,EAAI,sBAA2B,QAC/BA,EAAI,sBAA2B,KAG/BA,EAAI,iCACNF,EAAW,+BACTE,EAAI,iCAAsC,QAC1CA,EAAI,iCAAsC,KAG1CA,EAAI,8BACNF,EAAW,4BACTE,EAAI,6BAGJA,EAAI,wBACNF,EAAW,sBAAwBE,EAAI,uBAGrCA,EAAI,6BACNF,EAAW,2BACTE,EAAI,6BAAkC,QACtCA,EAAI,6BAAkC,KAGtCA,EAAI,2BACNF,EAAW,yBACTE,EAAI,2BAAgC,QACpCA,EAAI,2BAAgC,KAGxC,OAAO,OAAOF,CAAU,CAC1B,CAEA,OAAOC,EAAMD,EAAWC,CAAG,EAAID,CACjC,CAEA,IAAOH,EAAQC",
+  "names": ["get_ipc_exports", "__export", "get_ipc_default", "getIpc", "__toCommonJS", "_ipcObject", "key", "env"]
 }

package/dist/validation/json-parser.js

@@ -1,129 +1,3 @@
 /* Socket Lib - Built with esbuild */
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var json_parser_exports = {};
-__export(json_parser_exports, {
-  createJsonParser: () => createJsonParser,
-  parseJsonWithResult: () => parseJsonWithResult,
-  parseNdjson: () => parseNdjson,
-  safeJsonParse: () => safeJsonParse,
-  streamNdjson: () => streamNdjson,
-  tryJsonParse: () => tryJsonParse
-});
-module.exports = __toCommonJS(json_parser_exports);
-const { hasOwn: ObjectHasOwn } = Object;
-function safeJsonParse(jsonString, schema, options = {}) {
-  const { allowPrototype = false, maxSize = 10 * 1024 * 1024 } = options;
-  const byteLength = Buffer.byteLength(jsonString, "utf8");
-  if (byteLength > maxSize) {
-    throw new Error(
-      `JSON string exceeds maximum size limit${maxSize !== 10 * 1024 * 1024 ? ` of ${maxSize} bytes` : ""}`
-    );
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(jsonString);
-  } catch (error) {
-    throw new Error(`Failed to parse JSON: ${error}`);
-  }
-  if (!allowPrototype && typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
-    const dangerous = ["__proto__", "constructor", "prototype"];
-    for (const key of dangerous) {
-      if (ObjectHasOwn(parsed, key)) {
-        throw new Error(
-          "JSON contains potentially malicious prototype pollution keys"
-        );
-      }
-    }
-  }
-  if (schema) {
-    const result = schema.safeParse(parsed);
-    if (!result.success) {
-      const errors = result.error.issues.map(
-        (issue) => `${issue.path.join(".")}: ${issue.message}`
-      ).join(", ");
-      throw new Error(`Validation failed: ${errors}`);
-    }
-    return result.data;
-  }
-  return parsed;
-}
-function tryJsonParse(jsonString, schema, options) {
-  try {
-    return safeJsonParse(jsonString, schema, options);
-  } catch {
-    return void 0;
-  }
-}
-function parseJsonWithResult(jsonString, schema, options) {
-  try {
-    const data = safeJsonParse(jsonString, schema, options);
-    return { success: true, data };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    return { success: false, error: message };
-  }
-}
-function createJsonParser(schema, defaultOptions) {
-  return (jsonString, options) => {
-    return safeJsonParse(jsonString, schema, { ...defaultOptions, ...options });
-  };
-}
-function parseNdjson(ndjson, schema, options) {
-  const results = [];
-  const lines = ndjson.split(/\r?\n/);
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i]?.trim();
-    if (!line || line === "") {
-      continue;
-    }
-    try {
-      const parsed = safeJsonParse(line, schema, options);
-      results.push(parsed);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      throw new Error(`Failed to parse NDJSON at line ${i + 1}: ${message}`);
-    }
-  }
-  return results;
-}
-function* streamNdjson(ndjson, schema, options) {
-  const lines = ndjson.split(/\r?\n/);
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i]?.trim();
-    if (!line || line === "") {
-      continue;
-    }
-    try {
-      yield safeJsonParse(line, schema, options);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      throw new Error(`Failed to parse NDJSON at line ${i + 1}: ${message}`);
-    }
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createJsonParser,
-  parseJsonWithResult,
-  parseNdjson,
-  safeJsonParse,
-  streamNdjson,
-  tryJsonParse
-});
+var f=Object.defineProperty;var p=Object.getOwnPropertyDescriptor;var l=Object.getOwnPropertyNames;var m=Object.prototype.hasOwnProperty;var h=(e,n)=>{for(var t in n)f(e,t,{get:n[t],enumerable:!0})},w=(e,n,t,s)=>{if(n&&typeof n=="object"||typeof n=="function")for(let r of l(n))!m.call(e,r)&&r!==t&&f(e,r,{get:()=>n[r],enumerable:!(s=p(n,r))||s.enumerable});return e};var g=e=>w(f({},"__esModule",{value:!0}),e);var k={};h(k,{createJsonParser:()=>O,parseJsonWithResult:()=>J,parseNdjson:()=>P,safeJsonParse:()=>u,streamNdjson:()=>S,tryJsonParse:()=>T});module.exports=g(k);const{hasOwn:y}=Object;function u(e,n,t={}){const{allowPrototype:s=!1,maxSize:r=10*1024*1024}=t;if(Buffer.byteLength(e,"utf8")>r)throw new Error(`JSON string exceeds maximum size limit${r!==10*1024*1024?` of ${r} bytes`:""}`);let o;try{o=JSON.parse(e)}catch(i){throw new Error(`Failed to parse JSON: ${i}`)}if(!s&&typeof o=="object"&&o!==null&&!Array.isArray(o)){const i=["__proto__","constructor","prototype"];for(const c of i)if(y(o,c))throw new Error("JSON contains potentially malicious prototype pollution keys")}if(n){const i=n.safeParse(o);if(!i.success){const c=i.error.issues.map(d=>`${d.path.join(".")}: ${d.message}`).join(", ");throw new Error(`Validation failed: ${c}`)}return i.data}return o}function T(e,n,t){try{return u(e,n,t)}catch{return}}function J(e,n,t){try{return{success:!0,data:u(e,n,t)}}catch(s){return{success:!1,error:s instanceof Error?s.message:"Unknown error"}}}function O(e,n){return(t,s)=>u(t,e,{...n,...s})}function P(e,n,t){const s=[],r=e.split(/\r?\n/);for(let a=0;a<r.length;a++){const o=r[a]?.trim();if(!(!o||o===""))try{const i=u(o,n,t);s.push(i)}catch(i){const c=i instanceof Error?i.message:String(i);throw new Error(`Failed to parse NDJSON at line ${a+1}: ${c}`)}}return s}function*S(e,n,t){const s=e.split(/\r?\n/);for(let r=0;r<s.length;r++){const a=s[r]?.trim();if(!(!a||a===""))try{yield u(a,n,t)}catch(o){const i=o instanceof Error?o.message:String(o);throw new Error(`Failed to parse NDJSON at line ${r+1}: ${i}`)}}}0&&(module.exports={createJsonParser,parseJsonWithResult,parseNdjson,safeJsonParse,streamNdjson,tryJsonParse});
 //# sourceMappingURL=json-parser.js.map

package/dist/validation/json-parser.js.map

@@ -2,6 +2,6 @@
   "version": 3,
   "sources": ["../../src/validation/json-parser.ts"],
   "sourcesContent": ["/**\n * @fileoverview Safe JSON parsing with validation and security controls.\n * Provides protection against prototype pollution, size limits, and schema validation.\n *\n * Key Features:\n * - Prototype pollution protection: Blocks `__proto__`, `constructor`, and `prototype` keys\n * - Size limits: Configurable maximum JSON string size (default 10MB)\n * - Schema validation: Optional Zod-compatible schema validation\n * - NDJSON support: Parse newline-delimited JSON streams\n * - Memory safety: Prevents memory exhaustion attacks\n */\n\nimport type { JsonParseOptions, JsonParseResult, Schema } from './types'\n\nconst { hasOwn: ObjectHasOwn } = Object\n\n/**\n * Safely parse JSON with optional schema validation and security controls.\n * Throws errors on parse failures, validation failures, or security violations.\n *\n * This is the recommended method for parsing untrusted JSON input as it provides\n * multiple layers of security including prototype pollution protection and size limits.\n *\n * @template T - The expected type of the parsed data\n * @param jsonString - The JSON string to parse\n * @param schema - Optional Zod-compatible schema for validation\n * @param options - Parsing options for security and behavior control\n * @returns The parsed and validated data\n *\n * @throws {Error} When JSON string exceeds `maxSize`\n * @throws {Error} When JSON parsing fails\n * @throws {Error} When prototype pollution keys are detected (unless `allowPrototype` is `true`)\n * @throws {Error} When schema validation fails\n *\n * @example\n * ```ts\n * // Basic parsing with type inference\n * const data = safeJsonParse<User>('{\"name\":\"Alice\",\"age\":30}')\n *\n * // With schema validation\n * import { z } from 'zod'\n * const userSchema = z.object({\n *   name: z.string(),\n *   age: z.number()\n * })\n * const user = safeJsonParse('{\"name\":\"Alice\",\"age\":30}', userSchema)\n *\n * // With size limit\n * const data = safeJsonParse(jsonString, undefined, {\n *   maxSize: 1024 * 1024 // 1MB\n * })\n *\n * // Allow prototype keys (dangerous - only for trusted sources)\n * const data = safeJsonParse(jsonString, undefined, {\n *   allowPrototype: true\n * })\n * ```\n */\nexport function safeJsonParse<T = unknown>(\n  jsonString: string,\n  schema?: Schema<T> | undefined,\n  options: JsonParseOptions = {},\n): T {\n  const { allowPrototype = false, maxSize = 10 * 1024 * 1024 } = options\n\n  // Check size limit\n  const byteLength = Buffer.byteLength(jsonString, 'utf8')\n  if (byteLength > maxSize) {\n    throw new Error(\n      `JSON string exceeds maximum size limit${maxSize !== 10 * 1024 * 1024 ? ` of ${maxSize} bytes` : ''}`,\n    )\n  }\n\n  // Parse JSON\n  let parsed: unknown\n  try {\n    parsed = JSON.parse(jsonString)\n  } catch (error) {\n    throw new Error(`Failed to parse JSON: ${error}`)\n  }\n\n  // Check for prototype pollution\n  if (\n    !allowPrototype &&\n    typeof parsed === 'object' &&\n    parsed !== null &&\n    !Array.isArray(parsed)\n  ) {\n    const dangerous = ['__proto__', 'constructor', 'prototype']\n    for (const key of dangerous) {\n      if (ObjectHasOwn(parsed, key)) {\n        throw new Error(\n          'JSON contains potentially malicious prototype pollution keys',\n        )\n      }\n    }\n  }\n\n  // Validate against schema if provided\n  if (schema) {\n    const result = schema.safeParse(parsed)\n    if (!result.success) {\n      const errors = result.error.issues\n        .map(\n          (issue: { path: Array<string | number>; message: string }) =>\n            `${issue.path.join('.')}: ${issue.message}`,\n        )\n        .join(', ')\n      throw new Error(`Validation failed: ${errors}`)\n    }\n    return result.data as T\n  }\n\n  return parsed as T\n}\n\n/**\n * Attempt to parse JSON, returning `undefined` on any error.\n * This is a non-throwing wrapper around `safeJsonParse` for cases where\n * you want to gracefully handle parse failures without try-catch blocks.\n *\n * Use this when parsing is optional or you have a fallback strategy.\n * For critical parsing where you need error details, use `safeJsonParse` or `parseJsonWithResult`.\n *\n * @template T - The expected type of the parsed data\n * @param jsonString - The JSON string to parse\n * @param schema - Optional Zod-compatible schema for validation\n * @param options - Parsing options for security and behavior control\n * @returns The parsed data on success, or `undefined` on any error\n *\n * @example\n * ```ts\n * // Graceful fallback to default\n * const config = tryJsonParse<Config>(jsonString) ?? defaultConfig\n *\n * // Optional parsing\n * const data = tryJsonParse(possiblyInvalidJson)\n * if (data) {\n *   console.log('Parsed successfully:', data)\n * }\n *\n * // With schema validation\n * const user = tryJsonParse(jsonString, userSchema)\n * ```\n */\nexport function tryJsonParse<T = unknown>(\n  jsonString: string,\n  schema?: Schema<T> | undefined,\n  options?: JsonParseOptions | undefined,\n): T | undefined {\n  try {\n    return safeJsonParse(jsonString, schema, options)\n  } catch {\n    return undefined\n  }\n}\n\n/**\n * Parse JSON and return a discriminated union result.\n * Never throws - always returns a result object with success/failure information.\n *\n * This is ideal when you need detailed error messages and type-safe result handling.\n * The discriminated union allows TypeScript to narrow types based on the `success` flag.\n *\n * @template T - The expected type of the parsed data\n * @param jsonString - The JSON string to parse\n * @param schema - Optional Zod-compatible schema for validation\n * @param options - Parsing options for security and behavior control\n * @returns Result object with either `{success: true, data}` or `{success: false, error}`\n *\n * @example\n * ```ts\n * // Type-safe error handling\n * const result = parseJsonWithResult<User>(jsonString, userSchema)\n *\n * if (result.success) {\n *   // TypeScript knows result.data is available\n *   console.log(`User: ${result.data.name}`)\n * } else {\n *   // TypeScript knows result.error is available\n *   console.error(`Parse failed: ${result.error}`)\n * }\n *\n * // Early return pattern\n * const result = parseJsonWithResult(jsonString)\n * if (!result.success) {\n *   logger.error(result.error)\n *   return\n * }\n * processData(result.data)\n * ```\n */\nexport function parseJsonWithResult<T = unknown>(\n  jsonString: string,\n  schema?: Schema<T> | undefined,\n  options?: JsonParseOptions | undefined,\n): JsonParseResult<T> {\n  try {\n    const data = safeJsonParse(jsonString, schema, options)\n    return { success: true, data }\n  } catch (error: unknown) {\n    const message = error instanceof Error ? error.message : 'Unknown error'\n    return { success: false, error: message }\n  }\n}\n\n/**\n * Create a reusable JSON parser with pre-configured schema and options.\n * Useful for parsing multiple JSON strings with the same validation rules.\n *\n * The returned parser function can accept per-call options that override the defaults.\n * This factory pattern reduces repetition when parsing many similar JSON payloads.\n *\n * @template T - The expected type of the parsed data\n * @param schema - Optional Zod-compatible schema for validation\n * @param defaultOptions - Default parsing options applied to all parse calls\n * @returns A parser function that accepts a JSON string and optional per-call options\n *\n * @example\n * ```ts\n * // Create a parser for API responses\n * import { z } from 'zod'\n * const apiResponseSchema = z.object({\n *   status: z.string(),\n *   data: z.unknown()\n * })\n *\n * const parseApiResponse = createJsonParser(apiResponseSchema, {\n *   maxSize: 5 * 1024 * 1024 // 5MB limit for API responses\n * })\n *\n * // Use the parser multiple times\n * const response1 = parseApiResponse(json1)\n * const response2 = parseApiResponse(json2)\n *\n * // Override options for specific calls\n * const response3 = parseApiResponse(json3, { maxSize: 10 * 1024 * 1024 })\n * ```\n */\nexport function createJsonParser<T = unknown>(\n  schema?: Schema<T> | undefined,\n  defaultOptions?: JsonParseOptions | undefined,\n) {\n  return (jsonString: string, options?: JsonParseOptions | undefined): T => {\n    return safeJsonParse(jsonString, schema, { ...defaultOptions, ...options })\n  }\n}\n\n/**\n * Parse newline-delimited JSON (NDJSON) into an array.\n * Each line is treated as a separate JSON object. Empty lines are skipped.\n *\n * NDJSON format is commonly used for streaming logs, bulk data transfers,\n * and event streams where each line represents a complete JSON document.\n *\n * @template T - The expected type of each parsed JSON object\n * @param ndjson - Newline-delimited JSON string (supports both `\\n` and `\\r\\n`)\n * @param schema - Optional Zod-compatible schema for validation of each line\n * @param options - Parsing options applied to each line\n * @returns Array of parsed objects, one per non-empty line\n *\n * @throws {Error} When any line fails to parse (includes line number in error message)\n *\n * @example\n * ```ts\n * // Parse NDJSON logs\n * const ndjsonString = `\n * {\"level\":\"info\",\"message\":\"Server started\"}\n * {\"level\":\"error\",\"message\":\"Connection failed\"}\n * {\"level\":\"info\",\"message\":\"Retrying...\"}\n * `\n * const logs = parseNdjson<LogEntry>(ndjsonString, logSchema)\n * console.log(logs.length) // 3\n *\n * // Parse with size limits per line\n * const entries = parseNdjson(ndjson, undefined, { maxSize: 1024 })\n *\n * // Empty lines are automatically skipped\n * const data = parseNdjson('{\"a\":1}\\n\\n{\"b\":2}\\n') // 2 objects\n * ```\n */\nexport function parseNdjson<T = unknown>(\n  ndjson: string,\n  schema?: Schema<T> | undefined,\n  options?: JsonParseOptions | undefined,\n): T[] {\n  const results: T[] = []\n  const lines = ndjson.split(/\\r?\\n/)\n\n  for (let i = 0; i < lines.length; i++) {\n    const line = lines[i]?.trim()\n    if (!line || line === '') {\n      continue\n    }\n\n    try {\n      const parsed = safeJsonParse<T>(line, schema, options)\n      results.push(parsed)\n    } catch (error: unknown) {\n      const message = error instanceof Error ? error.message : String(error)\n      throw new Error(`Failed to parse NDJSON at line ${i + 1}: ${message}`)\n    }\n  }\n\n  return results\n}\n\n/**\n * Stream-parse newline-delimited JSON (NDJSON) using a generator.\n * Yields one parsed object at a time, enabling memory-efficient processing of large NDJSON files.\n *\n * Unlike `parseNdjson` which loads all results into memory, this generator allows\n * processing each line individually, making it ideal for large datasets or streaming scenarios.\n *\n * @template T - The expected type of each parsed JSON object\n * @param ndjson - Newline-delimited JSON string (supports both `\\n` and `\\r\\n`)\n * @param schema - Optional Zod-compatible schema for validation of each line\n * @param options - Parsing options applied to each line\n * @yields Parsed objects one at a time as the generator iterates\n *\n * @throws {Error} When any line fails to parse (includes line number in error message)\n *\n * @example\n * ```ts\n * // Memory-efficient processing of large NDJSON files\n * const ndjsonString = readLargeFile('logs.ndjson')\n *\n * for (const log of streamNdjson<LogEntry>(ndjsonString, logSchema)) {\n *   if (log.level === 'error') {\n *     console.error('Error found:', log.message)\n *   }\n * }\n *\n * // Collect filtered results without loading everything\n * const errors = [...streamNdjson(ndjson)]\n *   .filter(log => log.level === 'error')\n *\n * // Early termination when condition is met\n * for (const entry of streamNdjson(ndjson)) {\n *   if (entry.id === targetId) {\n *     processEntry(entry)\n *     break // Stop processing remaining lines\n *   }\n * }\n * ```\n */\nexport function* streamNdjson<T = unknown>(\n  ndjson: string,\n  schema?: Schema<T> | undefined,\n  options?: JsonParseOptions | undefined,\n): Generator<T, void, unknown> {\n  const lines = ndjson.split(/\\r?\\n/)\n\n  for (let i = 0; i < lines.length; i++) {\n    const line = lines[i]?.trim()\n    if (!line || line === '') {\n      continue\n    }\n\n    try {\n      yield safeJsonParse<T>(line, schema, options)\n    } catch (error: unknown) {\n      const message = error instanceof Error ? error.message : String(error)\n      throw new Error(`Failed to parse NDJSON at line ${i + 1}: ${message}`)\n    }\n  }\n}\n"],
-  "mappings": "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",
-  "names": []
+  "mappings": "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",
+  "names": ["json_parser_exports", "__export", "createJsonParser", "parseJsonWithResult", "parseNdjson", "safeJsonParse", "streamNdjson", "tryJsonParse", "__toCommonJS", "ObjectHasOwn", "jsonString", "schema", "options", "allowPrototype", "maxSize", "parsed", "error", "dangerous", "key", "result", "errors", "issue", "defaultOptions", "ndjson", "results", "lines", "i", "line", "message"]
 }

package/dist/validation/types.js

@@ -1,17 +1,3 @@
 /* Socket Lib - Built with esbuild */
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var types_exports = {};
-module.exports = __toCommonJS(types_exports);
+var r=Object.defineProperty;var o=Object.getOwnPropertyDescriptor;var d=Object.getOwnPropertyNames;var u=Object.prototype.hasOwnProperty;var i=(a,e,t,n)=>{if(e&&typeof e=="object"||typeof e=="function")for(let s of d(e))!u.call(a,s)&&s!==t&&r(a,s,{get:()=>e[s],enumerable:!(n=o(e,s))||n.enumerable});return a};var c=a=>i(r({},"__esModule",{value:!0}),a);var f={};module.exports=c(f);
 //# sourceMappingURL=types.js.map

package/dist/validation/types.js.map

@@ -2,6 +2,6 @@
   "version": 3,
   "sources": ["../../src/validation/types.ts"],
   "sourcesContent": ["/**\n * @fileoverview Validation type definitions.\n * Provides core types for schema validation and JSON parsing with security features.\n */\n\n/**\n * Result of a schema validation operation.\n * Contains either successful parsed data or error information.\n *\n * @template T - The expected type of the parsed data\n *\n * @example\n * ```ts\n * const result: ParseResult<User> = schema.safeParse(data)\n * if (result.success) {\n *   console.log(result.data) // User object\n * } else {\n *   console.error(result.error) // Error details\n * }\n * ```\n */\nexport interface ParseResult<T> {\n  /** Indicates whether parsing was successful */\n  success: boolean\n  /** Parsed and validated data (only present when `success` is `true`) */\n  data?: T | undefined\n  /** Error information (only present when `success` is `false`) */\n  error?: any\n}\n\n/**\n * Base schema interface compatible with Zod and similar validation libraries.\n * Provides both safe and throwing parsing methods.\n *\n * @template T - The expected output type after validation\n *\n * @example\n * ```ts\n * import { z } from 'zod'\n *\n * const userSchema = z.object({\n *   name: z.string(),\n *   age: z.number()\n * })\n *\n * // Schema satisfies this interface\n * const schema: Schema<User> = userSchema\n * const result = schema.safeParse({ name: 'Alice', age: 30 })\n * ```\n */\nexport interface Schema<T = any> {\n  /**\n   * Safely parse data without throwing errors.\n   * Returns a result object indicating success or failure.\n   *\n   * @param data - The data to validate\n   * @returns Parse result with success flag and data or error\n   */\n  safeParse(data: any): ParseResult<T>\n\n  /**\n   * Parse data and throw an error if validation fails.\n   * Use this when you want to fail fast on invalid data.\n   *\n   * @param data - The data to validate\n   * @returns The validated and parsed data\n   * @throws {Error} When validation fails\n   */\n  parse(data: any): T\n\n  /**\n   * Optional schema name for debugging and error messages.\n   * Useful for identifying which schema failed in complex validation chains.\n   */\n  _name?: string | undefined\n}\n\n/**\n * Options for configuring JSON parsing behavior with security controls.\n *\n * @example\n * ```ts\n * const options: JsonParseOptions = {\n *   maxSize: 1024 * 1024, // 1MB limit\n *   allowPrototype: false // Block prototype pollution\n * }\n * ```\n */\nexport interface JsonParseOptions {\n  /**\n   * Allow dangerous prototype pollution keys (`__proto__`, `constructor`, `prototype`).\n   * Set to `true` only if you trust the JSON source completely.\n   *\n   * @default false\n   *\n   * @example\n   * ```ts\n   * // Will throw error by default\n   * safeJsonParse('{\"__proto__\": {\"polluted\": true}}')\n   *\n   * // Allows the parse (dangerous!)\n   * safeJsonParse('{\"__proto__\": {\"polluted\": true}}', undefined, {\n   *   allowPrototype: true\n   * })\n   * ```\n   */\n  allowPrototype?: boolean | undefined\n\n  /**\n   * Maximum allowed size of JSON string in bytes.\n   * Prevents memory exhaustion from extremely large payloads.\n   *\n   * @default 10485760 (10 MB)\n   *\n   * @example\n   * ```ts\n   * // Limit to 1KB\n   * safeJsonParse(jsonString, undefined, { maxSize: 1024 })\n   * ```\n   */\n  maxSize?: number | undefined\n}\n\n/**\n * Discriminated union type for JSON parsing results.\n * Enables type-safe handling of success and failure cases.\n *\n * @template T - The expected type of the parsed data\n *\n * @example\n * ```ts\n * const result: JsonParseResult<User> = parseJsonWithResult(jsonString)\n *\n * if (result.success) {\n *   // TypeScript knows result.data is available\n *   console.log(result.data.name)\n * } else {\n *   // TypeScript knows result.error is available\n *   console.error(result.error)\n * }\n * ```\n */\nexport type JsonParseResult<T> =\n  | { success: true; data: T }\n  | { success: false; error: string }\n"],
-  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;",
-  "names": []
+  "mappings": ";kWAAA,IAAAA,EAAA,kBAAAC,EAAAD",
+  "names": ["types_exports", "__toCommonJS"]
 }

package/dist/versions.js

@@ -1,155 +1,3 @@
 /* Socket Lib - Built with esbuild */
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var versions_exports = {};
-__export(versions_exports, {
-  coerceVersion: () => coerceVersion,
-  compareVersions: () => compareVersions,
-  filterVersions: () => filterVersions,
-  getMajorVersion: () => getMajorVersion,
-  getMinorVersion: () => getMinorVersion,
-  getPatchVersion: () => getPatchVersion,
-  incrementVersion: () => incrementVersion,
-  isEqual: () => isEqual,
-  isGreaterThan: () => isGreaterThan,
-  isGreaterThanOrEqual: () => isGreaterThanOrEqual,
-  isLessThan: () => isLessThan,
-  isLessThanOrEqual: () => isLessThanOrEqual,
-  isValidVersion: () => isValidVersion,
-  maxVersion: () => maxVersion,
-  minVersion: () => minVersion,
-  parseVersion: () => parseVersion,
-  satisfiesVersion: () => satisfiesVersion,
-  sortVersions: () => sortVersions,
-  sortVersionsDesc: () => sortVersionsDesc,
-  versionDiff: () => versionDiff
-});
-module.exports = __toCommonJS(versions_exports);
-var import_semver = __toESM(require("./external/semver"));
-function coerceVersion(version) {
-  const coerced = import_semver.default.coerce(version);
-  return coerced?.version;
-}
-function compareVersions(v1, v2) {
-  try {
-    return import_semver.default.compare(v1, v2);
-  } catch {
-    return void 0;
-  }
-}
-function filterVersions(versions, range) {
-  return versions.filter((v) => import_semver.default.satisfies(v, range));
-}
-function getMajorVersion(version) {
-  const parsed = import_semver.default.parse(version);
-  return parsed?.major;
-}
-function getMinorVersion(version) {
-  const parsed = import_semver.default.parse(version);
-  return parsed?.minor;
-}
-function getPatchVersion(version) {
-  const parsed = import_semver.default.parse(version);
-  return parsed?.patch;
-}
-function incrementVersion(version, release, identifier) {
-  return import_semver.default.inc(version, release, identifier) || void 0;
-}
-function isEqual(version1, version2) {
-  return import_semver.default.eq(version1, version2);
-}
-function isGreaterThan(version1, version2) {
-  return import_semver.default.gt(version1, version2);
-}
-function isGreaterThanOrEqual(version1, version2) {
-  return import_semver.default.gte(version1, version2);
-}
-function isLessThan(version1, version2) {
-  return import_semver.default.lt(version1, version2);
-}
-function isLessThanOrEqual(version1, version2) {
-  return import_semver.default.lte(version1, version2);
-}
-function isValidVersion(version) {
-  return import_semver.default.valid(version) !== null;
-}
-function maxVersion(versions) {
-  return import_semver.default.maxSatisfying(versions, "*") || void 0;
-}
-function minVersion(versions) {
-  return import_semver.default.minSatisfying(versions, "*") || void 0;
-}
-function parseVersion(version) {
-  const parsed = import_semver.default.parse(version);
-  if (!parsed) {
-    return void 0;
-  }
-  return {
-    major: parsed.major,
-    minor: parsed.minor,
-    patch: parsed.patch,
-    prerelease: parsed.prerelease,
-    build: parsed.build
-  };
-}
-function satisfiesVersion(version, range) {
-  return import_semver.default.satisfies(version, range);
-}
-function sortVersions(versions) {
-  return import_semver.default.sort([...versions]);
-}
-function sortVersionsDesc(versions) {
-  return import_semver.default.rsort([...versions]);
-}
-function versionDiff(version1, version2) {
-  return import_semver.default.diff(version1, version2) || void 0;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  coerceVersion,
-  compareVersions,
-  filterVersions,
-  getMajorVersion,
-  getMinorVersion,
-  getPatchVersion,
-  incrementVersion,
-  isEqual,
-  isGreaterThan,
-  isGreaterThanOrEqual,
-  isLessThan,
-  isLessThanOrEqual,
-  isValidVersion,
-  maxVersion,
-  minVersion,
-  parseVersion,
-  satisfiesVersion,
-  sortVersions,
-  sortVersionsDesc,
-  versionDiff
-});
+var a=Object.create;var s=Object.defineProperty;var p=Object.getOwnPropertyDescriptor;var d=Object.getOwnPropertyNames;var f=Object.getPrototypeOf,c=Object.prototype.hasOwnProperty;var g=(r,n)=>{for(var t in n)s(r,t,{get:n[t],enumerable:!0})},u=(r,n,t,o)=>{if(n&&typeof n=="object"||typeof n=="function")for(let i of d(n))!c.call(r,i)&&i!==t&&s(r,i,{get:()=>n[i],enumerable:!(o=p(n,i))||o.enumerable});return r};var m=(r,n,t)=>(t=r!=null?a(f(r)):{},u(n||!r||!r.__esModule?s(t,"default",{value:r,enumerable:!0}):t,r)),l=r=>u(s({},"__esModule",{value:!0}),r);var w={};g(w,{coerceVersion:()=>x,compareVersions:()=>b,filterVersions:()=>V,getMajorVersion:()=>h,getMinorVersion:()=>j,getPatchVersion:()=>y,incrementVersion:()=>q,isEqual:()=>v,isGreaterThan:()=>T,isGreaterThanOrEqual:()=>E,isLessThan:()=>D,isLessThanOrEqual:()=>G,isValidVersion:()=>L,maxVersion:()=>M,minVersion:()=>O,parseVersion:()=>S,satisfiesVersion:()=>A,sortVersions:()=>P,sortVersionsDesc:()=>R,versionDiff:()=>k});module.exports=l(w);var e=m(require("./external/semver"));function x(r){return e.default.coerce(r)?.version}function b(r,n){try{return e.default.compare(r,n)}catch{return}}function V(r,n){return r.filter(t=>e.default.satisfies(t,n))}function h(r){return e.default.parse(r)?.major}function j(r){return e.default.parse(r)?.minor}function y(r){return e.default.parse(r)?.patch}function q(r,n,t){return e.default.inc(r,n,t)||void 0}function v(r,n){return e.default.eq(r,n)}function T(r,n){return e.default.gt(r,n)}function E(r,n){return e.default.gte(r,n)}function D(r,n){return e.default.lt(r,n)}function G(r,n){return e.default.lte(r,n)}function L(r){return e.default.valid(r)!==null}function M(r){return e.default.maxSatisfying(r,"*")||void 0}function O(r){return e.default.minSatisfying(r,"*")||void 0}function S(r){const n=e.default.parse(r);if(n)return{major:n.major,minor:n.minor,patch:n.patch,prerelease:n.prerelease,build:n.build}}function A(r,n){return e.default.satisfies(r,n)}function P(r){return e.default.sort([...r])}function R(r){return e.default.rsort([...r])}function k(r,n){return e.default.diff(r,n)||void 0}0&&(module.exports={coerceVersion,compareVersions,filterVersions,getMajorVersion,getMinorVersion,getPatchVersion,incrementVersion,isEqual,isGreaterThan,isGreaterThanOrEqual,isLessThan,isLessThanOrEqual,isValidVersion,maxVersion,minVersion,parseVersion,satisfiesVersion,sortVersions,sortVersionsDesc,versionDiff});
 //# sourceMappingURL=versions.js.map

package/dist/versions.js.map

@@ -2,6 +2,6 @@
   "version": 3,
   "sources": ["../src/versions.ts"],
   "sourcesContent": ["/** @fileoverview Version comparison and validation utilities for Socket ecosystem. */\n\nimport semver from './external/semver'\n\n/**\n * Coerce a version string to valid semver format.\n */\nexport function coerceVersion(version: string): string | undefined {\n  const coerced = semver.coerce(version)\n  return coerced?.version\n}\n\n/**\n * Compare two semantic version strings.\n * @returns -1 if v1 < v2, 0 if v1 === v2, 1 if v1 > v2, or undefined if invalid.\n */\nexport function compareVersions(\n  v1: string,\n  v2: string,\n): -1 | 0 | 1 | undefined {\n  try {\n    return semver.compare(v1, v2)\n  } catch {\n    return undefined\n  }\n}\n\n/**\n * Get all versions from an array that satisfy a semver range.\n */\nexport function filterVersions(versions: string[], range: string): string[] {\n  return versions.filter(v => semver.satisfies(v, range))\n}\n\n/**\n * Get the major version number from a version string.\n */\nexport function getMajorVersion(version: string): number | undefined {\n  const parsed = semver.parse(version)\n  return parsed?.major\n}\n\n/**\n * Get the minor version number from a version string.\n */\nexport function getMinorVersion(version: string): number | undefined {\n  const parsed = semver.parse(version)\n  return parsed?.minor\n}\n\n/**\n * Get the patch version number from a version string.\n */\nexport function getPatchVersion(version: string): number | undefined {\n  const parsed = semver.parse(version)\n  return parsed?.patch\n}\n\n/**\n * Increment a version by the specified release type.\n */\nexport function incrementVersion(\n  version: string,\n  release:\n    | 'major'\n    | 'minor'\n    | 'patch'\n    | 'premajor'\n    | 'preminor'\n    | 'prepatch'\n    | 'prerelease',\n  identifier?: string | undefined,\n): string | undefined {\n  return semver.inc(version, release, identifier) || undefined\n}\n\n/**\n * Check if version1 equals version2.\n */\nexport function isEqual(version1: string, version2: string): boolean {\n  return semver.eq(version1, version2)\n}\n\n/**\n * Check if version1 is greater than version2.\n */\nexport function isGreaterThan(version1: string, version2: string): boolean {\n  return semver.gt(version1, version2)\n}\n\n/**\n * Check if version1 is greater than or equal to version2.\n */\nexport function isGreaterThanOrEqual(\n  version1: string,\n  version2: string,\n): boolean {\n  return semver.gte(version1, version2)\n}\n\n/**\n * Check if version1 is less than version2.\n */\nexport function isLessThan(version1: string, version2: string): boolean {\n  return semver.lt(version1, version2)\n}\n\n/**\n * Check if version1 is less than or equal to version2.\n */\nexport function isLessThanOrEqual(version1: string, version2: string): boolean {\n  return semver.lte(version1, version2)\n}\n\n/**\n * Validate if a string is a valid semantic version.\n */\nexport function isValidVersion(version: string): boolean {\n  return semver.valid(version) !== null\n}\n\n/**\n * Get the highest version from an array of versions.\n */\nexport function maxVersion(versions: string[]): string | undefined {\n  return semver.maxSatisfying(versions, '*') || undefined\n}\n\n/**\n * Get the lowest version from an array of versions.\n */\nexport function minVersion(versions: string[]): string | undefined {\n  return semver.minSatisfying(versions, '*') || undefined\n}\n\n/**\n * Parse a version string and return major, minor, patch components.\n */\nexport function parseVersion(version: string):\n  | {\n      major: number\n      minor: number\n      patch: number\n      prerelease: ReadonlyArray<string | number>\n      build: readonly string[]\n    }\n  | undefined {\n  const parsed = semver.parse(version)\n  if (!parsed) {\n    return undefined\n  }\n  return {\n    major: parsed.major,\n    minor: parsed.minor,\n    patch: parsed.patch,\n    prerelease: parsed.prerelease,\n    build: parsed.build,\n  }\n}\n\n/**\n * Check if a version satisfies a semver range.\n */\nexport function satisfiesVersion(version: string, range: string): boolean {\n  return semver.satisfies(version, range)\n}\n\n/**\n * Sort versions in ascending order.\n */\nexport function sortVersions(versions: string[]): string[] {\n  return semver.sort([...versions])\n}\n\n/**\n * Sort versions in descending order.\n */\nexport function sortVersionsDesc(versions: string[]): string[] {\n  return semver.rsort([...versions])\n}\n\n/**\n * Get the difference between two versions.\n */\nexport function versionDiff(\n  version1: string,\n  version2: string,\n):\n  | 'major'\n  | 'premajor'\n  | 'minor'\n  | 'preminor'\n  | 'patch'\n  | 'prepatch'\n  | 'prerelease'\n  | undefined {\n  return semver.diff(version1, version2) || undefined\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,oBAAmB;AAKZ,SAAS,cAAc,SAAqC;AACjE,QAAM,UAAU,cAAAA,QAAO,OAAO,OAAO;AACrC,SAAO,SAAS;AAClB;AAMO,SAAS,gBACd,IACA,IACwB;AACxB,MAAI;AACF,WAAO,cAAAA,QAAO,QAAQ,IAAI,EAAE;AAAA,EAC9B,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAKO,SAAS,eAAe,UAAoB,OAAyB;AAC1E,SAAO,SAAS,OAAO,OAAK,cAAAA,QAAO,UAAU,GAAG,KAAK,CAAC;AACxD;AAKO,SAAS,gBAAgB,SAAqC;AACnE,QAAM,SAAS,cAAAA,QAAO,MAAM,OAAO;AACnC,SAAO,QAAQ;AACjB;AAKO,SAAS,gBAAgB,SAAqC;AACnE,QAAM,SAAS,cAAAA,QAAO,MAAM,OAAO;AACnC,SAAO,QAAQ;AACjB;AAKO,SAAS,gBAAgB,SAAqC;AACnE,QAAM,SAAS,cAAAA,QAAO,MAAM,OAAO;AACnC,SAAO,QAAQ;AACjB;AAKO,SAAS,iBACd,SACA,SAQA,YACoB;AACpB,SAAO,cAAAA,QAAO,IAAI,SAAS,SAAS,UAAU,KAAK;AACrD;AAKO,SAAS,QAAQ,UAAkB,UAA2B;AACnE,SAAO,cAAAA,QAAO,GAAG,UAAU,QAAQ;AACrC;AAKO,SAAS,cAAc,UAAkB,UAA2B;AACzE,SAAO,cAAAA,QAAO,GAAG,UAAU,QAAQ;AACrC;AAKO,SAAS,qBACd,UACA,UACS;AACT,SAAO,cAAAA,QAAO,IAAI,UAAU,QAAQ;AACtC;AAKO,SAAS,WAAW,UAAkB,UAA2B;AACtE,SAAO,cAAAA,QAAO,GAAG,UAAU,QAAQ;AACrC;AAKO,SAAS,kBAAkB,UAAkB,UAA2B;AAC7E,SAAO,cAAAA,QAAO,IAAI,UAAU,QAAQ;AACtC;AAKO,SAAS,eAAe,SAA0B;AACvD,SAAO,cAAAA,QAAO,MAAM,OAAO,MAAM;AACnC;AAKO,SAAS,WAAW,UAAwC;AACjE,SAAO,cAAAA,QAAO,cAAc,UAAU,GAAG,KAAK;AAChD;AAKO,SAAS,WAAW,UAAwC;AACjE,SAAO,cAAAA,QAAO,cAAc,UAAU,GAAG,KAAK;AAChD;AAKO,SAAS,aAAa,SAQf;AACZ,QAAM,SAAS,cAAAA,QAAO,MAAM,OAAO;AACnC,MAAI,CAAC,QAAQ;AACX,WAAO;AAAA,EACT;AACA,SAAO;AAAA,IACL,OAAO,OAAO;AAAA,IACd,OAAO,OAAO;AAAA,IACd,OAAO,OAAO;AAAA,IACd,YAAY,OAAO;AAAA,IACnB,OAAO,OAAO;AAAA,EAChB;AACF;AAKO,SAAS,iBAAiB,SAAiB,OAAwB;AACxE,SAAO,cAAAA,QAAO,UAAU,SAAS,KAAK;AACxC;AAKO,SAAS,aAAa,UAA8B;AACzD,SAAO,cAAAA,QAAO,KAAK,CAAC,GAAG,QAAQ,CAAC;AAClC;AAKO,SAAS,iBAAiB,UAA8B;AAC7D,SAAO,cAAAA,QAAO,MAAM,CAAC,GAAG,QAAQ,CAAC;AACnC;AAKO,SAAS,YACd,UACA,UASY;AACZ,SAAO,cAAAA,QAAO,KAAK,UAAU,QAAQ,KAAK;AAC5C;",
-  "names": ["semver"]
+  "mappings": ";6iBAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,mBAAAE,EAAA,oBAAAC,EAAA,mBAAAC,EAAA,oBAAAC,EAAA,oBAAAC,EAAA,oBAAAC,EAAA,qBAAAC,EAAA,YAAAC,EAAA,kBAAAC,EAAA,yBAAAC,EAAA,eAAAC,EAAA,sBAAAC,EAAA,mBAAAC,EAAA,eAAAC,EAAA,eAAAC,EAAA,iBAAAC,EAAA,qBAAAC,EAAA,iBAAAC,EAAA,qBAAAC,EAAA,gBAAAC,IAAA,eAAAC,EAAAtB,GAEA,IAAAuB,EAAmB,gCAKZ,SAASrB,EAAcsB,EAAqC,CAEjE,OADgB,EAAAC,QAAO,OAAOD,CAAO,GACrB,OAClB,CAMO,SAASrB,EACduB,EACAC,EACwB,CACxB,GAAI,CACF,OAAO,EAAAF,QAAO,QAAQC,EAAIC,CAAE,CAC9B,MAAQ,CACN,MACF,CACF,CAKO,SAASvB,EAAewB,EAAoBC,EAAyB,CAC1E,OAAOD,EAAS,OAAOE,GAAK,EAAAL,QAAO,UAAUK,EAAGD,CAAK,CAAC,CACxD,CAKO,SAASxB,EAAgBmB,EAAqC,CAEnE,OADe,EAAAC,QAAO,MAAMD,CAAO,GACpB,KACjB,CAKO,SAASlB,EAAgBkB,EAAqC,CAEnE,OADe,EAAAC,QAAO,MAAMD,CAAO,GACpB,KACjB,CAKO,SAASjB,EAAgBiB,EAAqC,CAEnE,OADe,EAAAC,QAAO,MAAMD,CAAO,GACpB,KACjB,CAKO,SAAShB,EACdgB,EACAO,EAQAC,EACoB,CACpB,OAAO,EAAAP,QAAO,IAAID,EAASO,EAASC,CAAU,GAAK,MACrD,CAKO,SAASvB,EAAQwB,EAAkBC,EAA2B,CACnE,OAAO,EAAAT,QAAO,GAAGQ,EAAUC,CAAQ,CACrC,CAKO,SAASxB,EAAcuB,EAAkBC,EAA2B,CACzE,OAAO,EAAAT,QAAO,GAAGQ,EAAUC,CAAQ,CACrC,CAKO,SAASvB,EACdsB,EACAC,EACS,CACT,OAAO,EAAAT,QAAO,IAAIQ,EAAUC,CAAQ,CACtC,CAKO,SAAStB,EAAWqB,EAAkBC,EAA2B,CACtE,OAAO,EAAAT,QAAO,GAAGQ,EAAUC,CAAQ,CACrC,CAKO,SAASrB,EAAkBoB,EAAkBC,EAA2B,CAC7E,OAAO,EAAAT,QAAO,IAAIQ,EAAUC,CAAQ,CACtC,CAKO,SAASpB,EAAeU,EAA0B,CACvD,OAAO,EAAAC,QAAO,MAAMD,CAAO,IAAM,IACnC,CAKO,SAAST,EAAWa,EAAwC,CACjE,OAAO,EAAAH,QAAO,cAAcG,EAAU,GAAG,GAAK,MAChD,CAKO,SAASZ,EAAWY,EAAwC,CACjE,OAAO,EAAAH,QAAO,cAAcG,EAAU,GAAG,GAAK,MAChD,CAKO,SAASX,EAAaO,EAQf,CACZ,MAAMW,EAAS,EAAAV,QAAO,MAAMD,CAAO,EACnC,GAAKW,EAGL,MAAO,CACL,MAAOA,EAAO,MACd,MAAOA,EAAO,MACd,MAAOA,EAAO,MACd,WAAYA,EAAO,WACnB,MAAOA,EAAO,KAChB,CACF,CAKO,SAASjB,EAAiBM,EAAiBK,EAAwB,CACxE,OAAO,EAAAJ,QAAO,UAAUD,EAASK,CAAK,CACxC,CAKO,SAASV,EAAaS,EAA8B,CACzD,OAAO,EAAAH,QAAO,KAAK,CAAC,GAAGG,CAAQ,CAAC,CAClC,CAKO,SAASR,EAAiBQ,EAA8B,CAC7D,OAAO,EAAAH,QAAO,MAAM,CAAC,GAAGG,CAAQ,CAAC,CACnC,CAKO,SAASP,EACdY,EACAC,EASY,CACZ,OAAO,EAAAT,QAAO,KAAKQ,EAAUC,CAAQ,GAAK,MAC5C",
+  "names": ["versions_exports", "__export", "coerceVersion", "compareVersions", "filterVersions", "getMajorVersion", "getMinorVersion", "getPatchVersion", "incrementVersion", "isEqual", "isGreaterThan", "isGreaterThanOrEqual", "isLessThan", "isLessThanOrEqual", "isValidVersion", "maxVersion", "minVersion", "parseVersion", "satisfiesVersion", "sortVersions", "sortVersionsDesc", "versionDiff", "__toCommonJS", "import_semver", "version", "semver", "v1", "v2", "versions", "range", "v", "release", "identifier", "version1", "version2", "parsed"]
 }

package/dist/words.js

@@ -1,52 +1,3 @@
 /* Socket Lib - Built with esbuild */
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var words_exports = {};
-__export(words_exports, {
-  capitalize: () => capitalize,
-  determineArticle: () => determineArticle,
-  pluralize: () => pluralize
-});
-module.exports = __toCommonJS(words_exports);
-// @__NO_SIDE_EFFECTS__
-function capitalize(word) {
-  const { length } = word;
-  if (length === 0) {
-    return word;
-  }
-  if (length === 1) {
-    return word.toUpperCase();
-  }
-  return `${word.charAt(0).toUpperCase()}${word.slice(1).toLowerCase()}`;
-}
-// @__NO_SIDE_EFFECTS__
-function determineArticle(word) {
-  return /^[aeiou]/.test(word) ? "an" : "a";
-}
-// @__NO_SIDE_EFFECTS__
-function pluralize(word, options) {
-  const { count = 1 } = { __proto__: null, ...options };
-  return count === 1 ? word : `${word}s`;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  capitalize,
-  determineArticle,
-  pluralize
-});
+var i=Object.defineProperty;var u=Object.getOwnPropertyDescriptor;var o=Object.getOwnPropertyNames;var a=Object.prototype.hasOwnProperty;var l=(t,e)=>{for(var n in e)i(t,n,{get:e[n],enumerable:!0})},p=(t,e,n,s)=>{if(e&&typeof e=="object"||typeof e=="function")for(let r of o(e))!a.call(t,r)&&r!==n&&i(t,r,{get:()=>e[r],enumerable:!(s=u(e,r))||s.enumerable});return t};var c=t=>p(i({},"__esModule",{value:!0}),t);var x={};l(x,{capitalize:()=>f,determineArticle:()=>g,pluralize:()=>z});module.exports=c(x);function f(t){const{length:e}=t;return e===0?t:e===1?t.toUpperCase():`${t.charAt(0).toUpperCase()}${t.slice(1).toLowerCase()}`}function g(t){return/^[aeiou]/.test(t)?"an":"a"}function z(t,e){const{count:n=1}={__proto__:null,...e};return n===1?t:`${t}s`}0&&(module.exports={capitalize,determineArticle,pluralize});
 //# sourceMappingURL=words.js.map

package/dist/words.js.map

@@ -2,6 +2,6 @@
   "version": 3,
   "sources": ["../src/words.ts"],
   "sourcesContent": ["/**\n * @fileoverview Word manipulation utilities for capitalization and formatting.\n * Provides text transformation functions for consistent word processing.\n */\n\n/**\n * Capitalize the first letter of a word.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function capitalize(word: string): string {\n  const { length } = word\n  if (length === 0) {\n    return word\n  }\n  if (length === 1) {\n    return word.toUpperCase()\n  }\n  return `${word.charAt(0).toUpperCase()}${word.slice(1).toLowerCase()}`\n}\n\n/**\n * Determine the appropriate article (a/an) for a word.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function determineArticle(word: string): string {\n  return /^[aeiou]/.test(word) ? 'an' : 'a'\n}\n\nexport interface PluralizeOptions {\n  count?: number\n}\n\n/**\n * Pluralize a word based on count.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function pluralize(\n  word: string,\n  options?: PluralizeOptions | undefined,\n): string {\n  const { count = 1 } = { __proto__: null, ...options } as PluralizeOptions\n  // Handle 0, negatives, decimals, and values > 1 as plural.\n  return count === 1 ? word : `${word}s`\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AASO,SAAS,WAAW,MAAsB;AAC/C,QAAM,EAAE,OAAO,IAAI;AACnB,MAAI,WAAW,GAAG;AAChB,WAAO;AAAA,EACT;AACA,MAAI,WAAW,GAAG;AAChB,WAAO,KAAK,YAAY;AAAA,EAC1B;AACA,SAAO,GAAG,KAAK,OAAO,CAAC,EAAE,YAAY,CAAC,GAAG,KAAK,MAAM,CAAC,EAAE,YAAY,CAAC;AACtE;AAAA;AAMO,SAAS,iBAAiB,MAAsB;AACrD,SAAO,WAAW,KAAK,IAAI,IAAI,OAAO;AACxC;AAAA;AAUO,SAAS,UACd,MACA,SACQ;AACR,QAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,MAAM,GAAG,QAAQ;AAEpD,SAAO,UAAU,IAAI,OAAO,GAAG,IAAI;AACrC;",
-  "names": []
+  "mappings": ";4ZAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,gBAAAE,EAAA,qBAAAC,EAAA,cAAAC,IAAA,eAAAC,EAAAL,GASO,SAASE,EAAWI,EAAsB,CAC/C,KAAM,CAAE,OAAAC,CAAO,EAAID,EACnB,OAAIC,IAAW,EACND,EAELC,IAAW,EACND,EAAK,YAAY,EAEnB,GAAGA,EAAK,OAAO,CAAC,EAAE,YAAY,CAAC,GAAGA,EAAK,MAAM,CAAC,EAAE,YAAY,CAAC,EACtE,CAMO,SAASH,EAAiBG,EAAsB,CACrD,MAAO,WAAW,KAAKA,CAAI,EAAI,KAAO,GACxC,CAUO,SAASF,EACdE,EACAE,EACQ,CACR,KAAM,CAAE,MAAAC,EAAQ,CAAE,EAAI,CAAE,UAAW,KAAM,GAAGD,CAAQ,EAEpD,OAAOC,IAAU,EAAIH,EAAO,GAAGA,CAAI,GACrC",
+  "names": ["words_exports", "__export", "capitalize", "determineArticle", "pluralize", "__toCommonJS", "word", "length", "options", "count"]
 }

package/dist/zod.js

@@ -1,29 +1,3 @@
 /* Socket Lib - Built with esbuild */
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var zod_exports = {};
-__export(zod_exports, {
-  z: () => import_zod.z
-});
-module.exports = __toCommonJS(zod_exports);
-var import_zod = require('./external/zod');
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  z
-});
+var m=Object.defineProperty;var x=Object.getOwnPropertyDescriptor;var z=Object.getOwnPropertyNames;var a=Object.prototype.hasOwnProperty;var b=(r,o)=>{for(var f in o)m(r,f,{get:o[f],enumerable:!0})},c=(r,o,f,p)=>{if(o&&typeof o=="object"||typeof o=="function")for(let e of z(o))!a.call(r,e)&&e!==f&&m(r,e,{get:()=>o[e],enumerable:!(p=x(o,e))||p.enumerable});return r};var d=r=>c(m({},"__esModule",{value:!0}),r);var g={};b(g,{z:()=>t.z});module.exports=d(g);var t=require('./external/zod');0&&(module.exports={z});
 //# sourceMappingURL=zod.js.map

package/dist/zod.js.map

@@ -2,6 +2,6 @@
   "version": 3,
   "sources": ["../src/zod.ts"],
   "sourcesContent": ["/**\n * @fileoverview Zod schema validation library wrapper for type-safe runtime validation.\n * Provides access to zod's schema builder through the z object.\n */\n\nexport { z } from 'zod'\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,iBAAkB;",
-  "names": []
+  "mappings": ";4ZAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,4BAAAE,EAAAF,GAKA,IAAAG,EAAkB",
+  "names": ["zod_exports", "__export", "__toCommonJS", "import_zod"]
 }