@boperators/mcp-server 0.2.1 → 0.3.1

package/README.md

@@ -22,7 +22,7 @@ bun add -D @boperators/mcp-server
 |------|-------------|:-------------------:|
 | [`list_overloads`](#list_overloads) | List all registered overloads in the project, with optional filtering by class or operator | ✓ |
 | [`transform_preview`](#transform_preview) | Preview the transformed output for a file or a line range within it | ✓ |
-| [`scaffold_overloads`](#scaffold_overloads) | Generate `as const` boilerplate for a set of operators on a named class | — |
+| [`scaffold_overloads`](#scaffold_overloads) | Generate method boilerplate for a set of operators on a named class | — |
 | [`validate_overloads`](#validate_overloads) | Validate overload definitions in a single file and return structured diagnostics | ✓ |
 | [`explain_expression`](#explain_expression) | Reverse-engineer a transformed call expression back to its original operator and overload metadata | optional |
 
@@ -57,11 +57,11 @@ Transforms a file and returns the original and transformed text side by side, al
 
 ### `scaffold_overloads`
 
-Generates ready-to-paste TypeScript property declarations for a list of operators on a given class. Automatically uses the correct form for each operator:
+Generates ready-to-paste TypeScript method declarations for a list of operators on a given class. Automatically uses the correct form for each operator:
 
-- **Static binary** (`+`, `-`, `*`, …) — `static readonly "+" = [(a: T, b: T): T => { … }] as const`
+- **Static binary** (`+`, `-`, `*`, …) — `static "+"(a: T, b: T): T { … }`
 - **Comparison** (`>`, `==`, …) — static, returns `boolean`
-- **Instance compound** (`+=`, `-=`, …) — instance, `function(this: T, rhs: T): void`
+- **Instance compound** (`+=`, `-=`, …) — instance, `"+="(rhs: T): void { … }`
 - **Prefix unary** (`!`, `~`) — static, one parameter
 - **Postfix unary** (`++`, `--`) — instance, no parameters, returns `void`
 
@@ -80,7 +80,7 @@ Does not require a `tsconfig` — it is purely generative.
 
 Runs the boperators scanning pipeline against a single file in isolation and returns structured diagnostics without modifying any state. Reports:
 
-- **Errors** — wrong arity, missing `as const`, return type violations
+- **Errors** — wrong arity, return type violations
 - **Warnings** — duplicate/conflicting overload registrations
 - The count of successfully parsed overloads
 
@@ -95,7 +95,7 @@ Runs the boperators scanning pipeline against a single file in isolation and ret
 
 ### `explain_expression`
 
-Given a transformed boperators expression (e.g. `Vector3["+"][0](a, b)` or `v["+="][0].call(v, rhs)`), decodes it back to the original operator, identifies whether it is static/instance and binary/unary, and optionally enriches the result with metadata from the project's overload store.
+Given a transformed boperators expression (e.g. `Vector3["+"](a, b)` or `v["+="](rhs)` or `v["++"]( )`), decodes it back to the original operator, identifies whether it is static/instance and binary/unary, and optionally enriches the result with metadata from the project's overload store.
 
 **Inputs**
 

package/dist/index.js

@@ -248869,6 +248869,29 @@ Node text: ${this.#forgottenText}`;
   exports.setScopeForNode = setScopeForNode;
 });
 
+// ../package/dist/core/helpers/getOperatorStringFromMethod.js
+var require_getOperatorStringFromMethod = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.getOperatorStringFromMethod = getOperatorStringFromMethod;
+  var ts_morph_1 = require_ts_morph();
+  function getOperatorStringFromMethod(method) {
+    const nameNode = method.getNameNode();
+    if (nameNode.isKind(ts_morph_1.SyntaxKind.ComputedPropertyName)) {
+      const expression = nameNode.getExpression();
+      if (expression.isKind(ts_morph_1.SyntaxKind.StringLiteral)) {
+        return expression.getLiteralValue();
+      }
+      const literalValue = expression.getType().getLiteralValue();
+      if (typeof literalValue === "string") {
+        return literalValue;
+      }
+    } else if (nameNode.isKind(ts_morph_1.SyntaxKind.StringLiteral)) {
+      return nameNode.getLiteralValue();
+    }
+    return;
+  }
+});
+
 // ../package/dist/core/helpers/getOperatorStringFromProperty.js
 var require_getOperatorStringFromProperty = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
@@ -248899,7 +248922,9 @@ var require_resolveExpressionType = __commonJS((exports) => {
   exports.resolveExpressionType = resolveExpressionType;
   var ts_morph_1 = require_ts_morph();
   function normalizeTypeName(typeName) {
-    return typeName.replace(/import\("[^"]*"\)\./g, "");
+    const withoutImport = typeName.replace(/import\("[^"]*"\)\./g, "");
+    const genericIdx = withoutImport.indexOf("<");
+    return genericIdx === -1 ? withoutImport : withoutImport.slice(0, genericIdx);
   }
   function resolveExpressionType(node) {
     var _a;
@@ -249298,7 +249323,7 @@ var require_OverloadInjector = __commonJS((exports) => {
             const overloadDesc = this._overloadStore.findOverload(operatorKind, leftType, rightType);
             if (!overloadDesc)
               continue;
-            const { className: classNameRaw, classFilePath, operatorString, index, isStatic } = overloadDesc;
+            const { className: classNameRaw, classFilePath, operatorString, isStatic } = overloadDesc;
             const classSourceFile = this._project.getSourceFileOrThrow(classFilePath);
             const classDecl = classSourceFile.getClassOrThrow(classNameRaw);
             const classSymbol = classDecl.getSymbol();
@@ -249306,7 +249331,7 @@ var require_OverloadInjector = __commonJS((exports) => {
               throw new Error(`No symbol for class "${classNameRaw}"`);
             const classModuleSpecifier = (0, getModuleSpecifier_1.getModuleSpecifier)(sourceFile, classSourceFile);
             const className = (0, ensureImportedName_1.ensureImportedName)(sourceFile, classSymbol, classModuleSpecifier);
-            const overloadCall = isStatic ? `${className}["${operatorString}"][${index}](${lhs.getText()}, ${rhs.getText()})` : `${lhs.getText()}["${operatorString}"][${index}].call(${lhs.getText()}, ${rhs.getText()})`;
+            const overloadCall = isStatic ? `${className}["${operatorString}"](${lhs.getText()}, ${rhs.getText()})` : `${lhs.getText()}["${operatorString}"](${rhs.getText()})`;
             this._logger.debug(`${fileName}: ${expression.getText()} => ${overloadCall}`);
             expression.replaceWithText(overloadCall);
             transformCount++;
@@ -249328,7 +249353,7 @@ var require_OverloadInjector = __commonJS((exports) => {
             const overloadDesc = this._overloadStore.findPrefixUnaryOverload(operatorKind, operandType);
             if (!overloadDesc)
               continue;
-            const { className: classNameRaw, classFilePath, operatorString, index } = overloadDesc;
+            const { className: classNameRaw, classFilePath, operatorString } = overloadDesc;
             const classSourceFile = this._project.getSourceFileOrThrow(classFilePath);
             const classDecl = classSourceFile.getClassOrThrow(classNameRaw);
             const classSymbol = classDecl.getSymbol();
@@ -249336,7 +249361,7 @@ var require_OverloadInjector = __commonJS((exports) => {
               throw new Error(`No symbol for class "${classNameRaw}"`);
             const classModuleSpecifier = (0, getModuleSpecifier_1.getModuleSpecifier)(sourceFile, classSourceFile);
             const className = (0, ensureImportedName_1.ensureImportedName)(sourceFile, classSymbol, classModuleSpecifier);
-            const overloadCall = `${className}["${operatorString}"][${index}](${operand.getText()})`;
+            const overloadCall = `${className}["${operatorString}"](${operand.getText()})`;
             this._logger.debug(`${fileName}: ${expression.getText()} => ${overloadCall}`);
             expression.replaceWithText(overloadCall);
             transformCount++;
@@ -249358,8 +249383,8 @@ var require_OverloadInjector = __commonJS((exports) => {
             const overloadDesc = this._overloadStore.findPostfixUnaryOverload(operatorKind, operandType);
             if (!overloadDesc)
               continue;
-            const { operatorString, index } = overloadDesc;
-            const overloadCall = `${operand.getText()}["${operatorString}"][${index}].call(${operand.getText()})`;
+            const { operatorString } = overloadDesc;
+            const overloadCall = `${operand.getText()}["${operatorString}"]()`;
             this._logger.debug(`${fileName}: ${expression.getText()} => ${overloadCall}`);
             expression.replaceWithText(overloadCall);
             transformCount++;
@@ -249387,9 +249412,8 @@ var require_OverloadStore = __commonJS((exports) => {
   var ts_morph_1 = require_ts_morph();
   var operatorSymbols_1 = require_operatorSymbols();
   var ErrorManager_1 = require_ErrorManager();
-  var getOperatorStringFromProperty_1 = require_getOperatorStringFromProperty();
+  var getOperatorStringFromMethod_1 = require_getOperatorStringFromMethod();
   var resolveExpressionType_1 = require_resolveExpressionType();
-  var unwrapInitializer_1 = require_unwrapInitializer();
   var operatorMap_1 = require_operatorMap();
 
   class OverloadStore extends Map {
@@ -249509,15 +249533,29 @@ var require_OverloadStore = __commonJS((exports) => {
       this._parsedFiles.add(filePath);
       const classes = sourceFile.getClasses();
       classes.forEach((classDecl) => {
+        const className = classDecl.getName();
+        if (!className)
+          return;
         const classType = (0, resolveExpressionType_1.normalizeTypeName)(classDecl.getType().getText());
-        classDecl.getProperties().forEach((property) => {
-          var _a, _b;
-          if (!ts_morph_1.Node.isPropertyDeclaration(property))
-            return;
-          const isStatic = property.isStatic();
-          const operatorString = (0, getOperatorStringFromProperty_1.getOperatorStringFromProperty)(property);
+        const methodGroups = new Map;
+        for (const method of classDecl.getMethods()) {
+          const operatorString = (0, getOperatorStringFromMethod_1.getOperatorStringFromMethod)(method);
           if (!operatorString || !operatorSymbols_1.operatorSymbols.includes(operatorString))
+            continue;
+          let group = methodGroups.get(operatorString);
+          if (!group) {
+            group = [];
+            methodGroups.set(operatorString, group);
+          }
+          const overloadSigs = method.getOverloads();
+          group.push(...overloadSigs.length > 0 ? overloadSigs : [method]);
+        }
+        methodGroups.forEach((methods, operatorString) => {
+          const overloadSigs = methods.filter((m) => !m.hasBody());
+          const sigsToProcess = overloadSigs.length > 0 ? overloadSigs : methods;
+          if (sigsToProcess.length === 0)
             return;
+          const isStatic = sigsToProcess[0].isStatic();
           const binarySyntaxKind = operatorMap_1.operatorMap[operatorString];
           const prefixUnarySyntaxKind = operatorMap_1.prefixUnaryOperatorMap[operatorString];
           const postfixUnarySyntaxKind = operatorMap_1.postfixUnaryOperatorMap[operatorString];
@@ -249526,93 +249564,74 @@ var require_OverloadStore = __commonJS((exports) => {
           const shouldBeStatic = binarySyntaxKind != null && !operatorMap_1.instanceOperators.has(binarySyntaxKind) || prefixUnarySyntaxKind != null;
           const shouldBeInstance = binarySyntaxKind != null && operatorMap_1.instanceOperators.has(binarySyntaxKind) || postfixUnarySyntaxKind != null;
           if (isStatic && !shouldBeStatic || !isStatic && !shouldBeInstance) {
-            this._errorManager.addWarning(new ErrorManager_1.ErrorDescription(`Expected overload for operator ${operatorString} ` + `to be ${isStatic ? "a static" : "an instance"} field.`, property.getSourceFile().getFilePath(), property.getStartLineNumber(), property.getText().split(`
-`)[0]));
-            return;
-          }
-          const rawInitializer = property.getInitializer();
-          if (!rawInitializer) {
-            this._addOverloadsFromTypeAnnotation(property, classDecl, classType, filePath, isStatic, operatorString, binarySyntaxKind, prefixUnarySyntaxKind, postfixUnarySyntaxKind);
+            this._errorManager.addWarning(new ErrorManager_1.ErrorDescription(`Expected overload for operator "${operatorString}" ` + `to be ${isStatic ? "a static" : "an instance"} method.`, sigsToProcess[0].getSourceFile().getFilePath(), sigsToProcess[0].getStartLineNumber(), this._minifyString(sigsToProcess[0].getText().split(`
+`)[0])));
             return;
           }
-          const hasAsConst = ts_morph_1.Node.isAsExpression(rawInitializer) && ((_a = rawInitializer.getTypeNode()) === null || _a === undefined ? undefined : _a.getText()) === "const";
-          const initializer3 = (0, unwrapInitializer_1.unwrapInitializer)(rawInitializer);
-          if (!initializer3 || !ts_morph_1.Node.isArrayLiteralExpression(initializer3)) {
-            this._errorManager.addWarning(new ErrorManager_1.ErrorDescription(`Overload field for operator ${operatorString} ` + "must be an array of overload functions.", property.getSourceFile().getFilePath(), property.getStartLineNumber(), this._minifyString(property.getName())));
-            return;
-          }
-          if (!hasAsConst) {
-            this._errorManager.addError(new ErrorManager_1.ErrorDescription(`Overload array for operator ${operatorString} must use "as const". ` + "Without it, TypeScript widens the array type and loses individual " + "function signatures, causing type errors in generated code.", property.getSourceFile().getFilePath(), property.getStartLineNumber(), this._minifyString((_b = property.getText().split(`
-`)[0]) !== null && _b !== undefined ? _b : "")));
-            return;
-          }
-          initializer3.getElements().forEach((element, index) => {
-            if (element.isKind(ts_morph_1.SyntaxKind.ArrowFunction) && !isStatic) {
-              this._errorManager.addError(new ErrorManager_1.ErrorDescription(`Overload ${index} for operator ${operatorString} must not be an arrow function. ` + "Use a function expression instead, as arrow functions cannot bind `this` correctly for instance operators.", element.getSourceFile().getFilePath(), element.getStartLineNumber(), this._minifyString(element.getText())));
-              return;
-            }
-            if (!element.isKind(ts_morph_1.SyntaxKind.FunctionExpression) && !element.isKind(ts_morph_1.SyntaxKind.FunctionDeclaration) && !element.isKind(ts_morph_1.SyntaxKind.ArrowFunction)) {
-              this._errorManager.addWarning(new ErrorManager_1.ErrorDescription(`Expected overload ${index} for operator ${operatorString} to be a function.`, element.getSourceFile().getFilePath(), element.getStartLineNumber(), this._minifyString(element.getText())));
-              return;
-            }
-            const funcElement = element;
-            const parameters = funcElement.getParameters().filter((p) => p.getName() !== "this");
+          sigsToProcess.forEach((method) => {
+            const parameters = method.getParameters().filter((p) => p.getName() !== "this");
             const paramCount = parameters.length;
             if (paramCount === 2 && isStatic && binarySyntaxKind && !operatorMap_1.instanceOperators.has(binarySyntaxKind)) {
-              this._addBinaryOverload(binarySyntaxKind, classDecl, classType, filePath, property, funcElement, parameters, operatorString, index, true);
+              this._addBinaryOverload(binarySyntaxKind, className, classType, filePath, method, parameters, operatorString, true);
             } else if (paramCount === 1 && !isStatic && binarySyntaxKind && operatorMap_1.instanceOperators.has(binarySyntaxKind)) {
-              this._addBinaryOverload(binarySyntaxKind, classDecl, classType, filePath, property, funcElement, parameters, operatorString, index, false);
+              this._addBinaryOverload(binarySyntaxKind, className, classType, filePath, method, parameters, operatorString, false);
             } else if (paramCount === 1 && isStatic && prefixUnarySyntaxKind) {
-              this._addPrefixUnaryOverload(prefixUnarySyntaxKind, classDecl, classType, filePath, property, funcElement, parameters, operatorString, index);
+              this._addPrefixUnaryOverload(prefixUnarySyntaxKind, className, classType, filePath, method, parameters, operatorString);
             } else if (paramCount === 0 && !isStatic && postfixUnarySyntaxKind) {
-              this._addPostfixUnaryOverload(postfixUnarySyntaxKind, classDecl, classType, filePath, property, funcElement, operatorString, index);
+              this._addPostfixUnaryOverload(postfixUnarySyntaxKind, className, classType, filePath, method, operatorString);
             } else {
-              this._errorManager.addWarning(new ErrorManager_1.ErrorDescription(`Overload function ${index} for operator ${operatorString} ` + `has invalid parameter count (${paramCount}) for this operator context.`, property.getSourceFile().getFilePath(), property.getStartLineNumber(), this._minifyString(funcElement.getText())));
+              this._errorManager.addWarning(new ErrorManager_1.ErrorDescription(`Overload signature for operator "${operatorString}" ` + `has invalid parameter count (${paramCount}) for this operator context.`, method.getSourceFile().getFilePath(), method.getStartLineNumber(), this._minifyString(method.getText().split(`
+`)[0])));
             }
           });
         });
       });
     }
-    _addBinaryOverload(syntaxKind, classDecl, classType, filePath, property, element, parameters, operatorString, index, isStatic) {
-      var _a, _b, _c, _d, _e, _f, _g, _h;
+    _addBinaryOverload(syntaxKind, className, classType, filePath, method, parameters, operatorString, isStatic) {
+      var _a, _b;
       let hasWarning = false;
-      const lhsType = isStatic ? (0, resolveExpressionType_1.normalizeTypeName)((_b = (_a = parameters[0]) === null || _a === undefined ? undefined : _a.getType().getText()) !== null && _b !== undefined ? _b : "") : classType;
-      const rhsType = isStatic ? (0, resolveExpressionType_1.normalizeTypeName)((_d = (_c = parameters[1]) === null || _c === undefined ? undefined : _c.getType().getText()) !== null && _d !== undefined ? _d : "") : (0, resolveExpressionType_1.normalizeTypeName)((_f = (_e = parameters[0]) === null || _e === undefined ? undefined : _e.getType().getText()) !== null && _f !== undefined ? _f : "");
+      const getParamTypeName = (p) => {
+        var _a2, _b2, _c;
+        return (0, resolveExpressionType_1.normalizeTypeName)((_c = (_b2 = (_a2 = p === null || p === undefined ? undefined : p.getTypeNode()) === null || _a2 === undefined ? undefined : _a2.getText()) !== null && _b2 !== undefined ? _b2 : p === null || p === undefined ? undefined : p.getType().getText()) !== null && _c !== undefined ? _c : "");
+      };
+      const lhsType = isStatic ? getParamTypeName(parameters[0]) : classType;
+      const rhsType = isStatic ? getParamTypeName(parameters[1]) : getParamTypeName(parameters[0]);
       if (isStatic && lhsType !== classType && rhsType !== classType) {
-        this._errorManager.addWarning(new ErrorManager_1.ErrorDescription(`Overload for operator ${operatorString} ` + "must have either LHS or RHS parameter matching its class type.", property.getSourceFile().getFilePath(), property.getStartLineNumber(), this._minifyString(element.getText())));
+        this._errorManager.addWarning(new ErrorManager_1.ErrorDescription(`Overload for operator "${operatorString}" ` + "must have either LHS or RHS parameter matching its class type.", method.getSourceFile().getFilePath(), method.getStartLineNumber(), this._minifyString(method.getText().split(`
+`)[0])));
         hasWarning = true;
       }
-      const returnType = element.getReturnType().getText();
+      const returnType = method.getReturnType().getText();
       if (operatorMap_1.comparisonOperators.has(syntaxKind) && returnType !== "boolean") {
-        this._errorManager.addWarning(new ErrorManager_1.ErrorDescription(`Overload function ${index} for comparison operator ${operatorString} ` + `must have a return type of 'boolean', got '${returnType}'.`, property.getSourceFile().getFilePath(), property.getStartLineNumber(), this._minifyString(element.getText())));
+        this._errorManager.addWarning(new ErrorManager_1.ErrorDescription(`Overload for comparison operator "${operatorString}" ` + `must have a return type of 'boolean', got '${returnType}'.`, method.getSourceFile().getFilePath(), method.getStartLineNumber(), this._minifyString(method.getText().split(`
+`)[0])));
         hasWarning = true;
       }
       if (!isStatic && returnType !== "void") {
-        this._errorManager.addWarning(new ErrorManager_1.ErrorDescription(`Overload function ${index} for instance operator ${operatorString} ` + `must have a return type of 'void', got '${returnType}'.`, property.getSourceFile().getFilePath(), property.getStartLineNumber(), this._minifyString(element.getText())));
+        this._errorManager.addWarning(new ErrorManager_1.ErrorDescription(`Overload for instance operator "${operatorString}" ` + `must have a return type of 'void', got '${returnType}'.`, method.getSourceFile().getFilePath(), method.getStartLineNumber(), this._minifyString(method.getText().split(`
+`)[0])));
         hasWarning = true;
       }
-      const operatorOverloads = (_g = this.get(syntaxKind)) !== null && _g !== undefined ? _g : new Map;
-      const lhsMap = (_h = operatorOverloads.get(lhsType)) !== null && _h !== undefined ? _h : new Map;
+      const operatorOverloads = (_a = this.get(syntaxKind)) !== null && _a !== undefined ? _a : new Map;
+      const lhsMap = (_b = operatorOverloads.get(lhsType)) !== null && _b !== undefined ? _b : new Map;
       if (lhsMap.has(rhsType)) {
-        this._errorManager.addWarning(new ErrorManager_1.ErrorDescription(`Duplicate overload for operator ${operatorString} with LHS type ${lhsType} and RHS type ${rhsType}`, property.getSourceFile().getFilePath(), property.getStartLineNumber(), this._minifyString(element.getText())));
+        this._errorManager.addWarning(new ErrorManager_1.ErrorDescription(`Duplicate overload for operator "${operatorString}" with LHS type ${lhsType} and RHS type ${rhsType}`, method.getSourceFile().getFilePath(), method.getStartLineNumber(), this._minifyString(method.getText().split(`
+`)[0])));
         hasWarning = true;
       }
       if (hasWarning)
         return;
       lhsMap.set(rhsType, {
         isStatic,
-        className: classDecl.getName(),
+        className,
         classFilePath: filePath,
         operatorString,
-        index,
         returnType
       });
       operatorOverloads.set(lhsType, lhsMap);
       this.set(syntaxKind, operatorOverloads);
-      const funcName = ts_morph_1.Node.isFunctionExpression(element) ? element.getName() : undefined;
       const sl = this._shortTypeName.bind(this);
-      const label = funcName ? `${funcName}(${sl(lhsType)}, ${sl(rhsType)})` : `(${sl(lhsType)}, ${sl(rhsType)})`;
-      this._logger.debug(`Loaded ${classDecl.getName()}["${operatorString}"][${index}]: ${label} => ${sl(element.getReturnType().getText())}${isStatic ? " (static)" : " (instance)"}`);
+      this._logger.debug(`Loaded ${className}["${operatorString}"]: (${sl(lhsType)}, ${sl(rhsType)}) => ${sl(returnType)}${isStatic ? " (static)" : " (instance)"}`);
       let fileEntries = this._fileEntries.get(filePath);
       if (!fileEntries) {
         fileEntries = [];
@@ -249620,35 +249639,34 @@ var require_OverloadStore = __commonJS((exports) => {
       }
       fileEntries.push({ syntaxKind, lhsType, rhsType });
     }
-    _addPrefixUnaryOverload(syntaxKind, classDecl, classType, filePath, property, element, parameters, operatorString, index) {
-      var _a, _b, _c;
+    _addPrefixUnaryOverload(syntaxKind, className, classType, filePath, method, parameters, operatorString) {
+      var _a, _b, _c, _d, _e, _f;
       let hasWarning = false;
-      const operandType = (0, resolveExpressionType_1.normalizeTypeName)((_b = (_a = parameters[0]) === null || _a === undefined ? undefined : _a.getType().getText()) !== null && _b !== undefined ? _b : "");
+      const operandType = (0, resolveExpressionType_1.normalizeTypeName)((_e = (_c = (_b = (_a = parameters[0]) === null || _a === undefined ? undefined : _a.getTypeNode()) === null || _b === undefined ? undefined : _b.getText()) !== null && _c !== undefined ? _c : (_d = parameters[0]) === null || _d === undefined ? undefined : _d.getType().getText()) !== null && _e !== undefined ? _e : "");
       if (operandType !== classType) {
-        this._errorManager.addWarning(new ErrorManager_1.ErrorDescription(`Prefix unary overload for operator ${operatorString} ` + "must have its parameter matching its class type.", property.getSourceFile().getFilePath(), property.getStartLineNumber(), this._minifyString(element.getText())));
+        this._errorManager.addWarning(new ErrorManager_1.ErrorDescription(`Prefix unary overload for operator "${operatorString}" ` + "must have its parameter matching its class type.", method.getSourceFile().getFilePath(), method.getStartLineNumber(), this._minifyString(method.getText().split(`
+`)[0])));
         hasWarning = true;
       }
-      const operatorOverloads = (_c = this._prefixUnaryOverloads.get(syntaxKind)) !== null && _c !== undefined ? _c : new Map;
+      const operatorOverloads = (_f = this._prefixUnaryOverloads.get(syntaxKind)) !== null && _f !== undefined ? _f : new Map;
       if (operatorOverloads.has(operandType)) {
-        this._errorManager.addWarning(new ErrorManager_1.ErrorDescription(`Duplicate prefix unary overload for operator ${operatorString} with operand type ${operandType}`, property.getSourceFile().getFilePath(), property.getStartLineNumber(), this._minifyString(element.getText())));
+        this._errorManager.addWarning(new ErrorManager_1.ErrorDescription(`Duplicate prefix unary overload for operator "${operatorString}" with operand type ${operandType}`, method.getSourceFile().getFilePath(), method.getStartLineNumber(), this._minifyString(method.getText().split(`
+`)[0])));
         hasWarning = true;
       }
       if (hasWarning)
         return;
-      const returnType = element.getReturnType().getText();
+      const returnType = method.getReturnType().getText();
       operatorOverloads.set(operandType, {
         isStatic: true,
-        className: classDecl.getName(),
+        className,
         classFilePath: filePath,
         operatorString,
-        index,
         returnType
       });
       this._prefixUnaryOverloads.set(syntaxKind, operatorOverloads);
-      const funcName = ts_morph_1.Node.isFunctionExpression(element) ? element.getName() : undefined;
       const sl = this._shortTypeName.bind(this);
-      const label = funcName ? `${funcName}(${sl(operandType)})` : `(${sl(operandType)})`;
-      this._logger.debug(`Loaded ${classDecl.getName()}["${operatorString}"][${index}]: ${operatorString}${label} => ${sl(returnType)} (prefix unary)`);
+      this._logger.debug(`Loaded ${className}["${operatorString}"]: ${operatorString}(${sl(operandType)}) => ${sl(returnType)} (prefix unary)`);
       let fileEntries = this._prefixUnaryFileEntries.get(filePath);
       if (!fileEntries) {
         fileEntries = [];
@@ -249656,34 +249674,33 @@ var require_OverloadStore = __commonJS((exports) => {
       }
       fileEntries.push({ syntaxKind, operandType });
     }
-    _addPostfixUnaryOverload(syntaxKind, classDecl, classType, filePath, property, element, operatorString, index) {
+    _addPostfixUnaryOverload(syntaxKind, className, classType, filePath, method, operatorString) {
       var _a;
       let hasWarning = false;
-      const returnType = element.getReturnType().getText();
+      const returnType = method.getReturnType().getText();
       if (returnType !== "void") {
-        this._errorManager.addWarning(new ErrorManager_1.ErrorDescription(`Overload function ${index} for postfix operator ${operatorString} ` + `must have a return type of 'void', got '${returnType}'.`, property.getSourceFile().getFilePath(), property.getStartLineNumber(), this._minifyString(element.getText())));
+        this._errorManager.addWarning(new ErrorManager_1.ErrorDescription(`Overload for postfix operator "${operatorString}" ` + `must have a return type of 'void', got '${returnType}'.`, method.getSourceFile().getFilePath(), method.getStartLineNumber(), this._minifyString(method.getText().split(`
+`)[0])));
         hasWarning = true;
       }
       const operandType = classType;
       const operatorOverloads = (_a = this._postfixUnaryOverloads.get(syntaxKind)) !== null && _a !== undefined ? _a : new Map;
       if (operatorOverloads.has(operandType)) {
-        this._errorManager.addWarning(new ErrorManager_1.ErrorDescription(`Duplicate postfix unary overload for operator ${operatorString} with operand type ${operandType}`, property.getSourceFile().getFilePath(), property.getStartLineNumber(), this._minifyString(element.getText())));
+        this._errorManager.addWarning(new ErrorManager_1.ErrorDescription(`Duplicate postfix unary overload for operator "${operatorString}" with operand type ${operandType}`, method.getSourceFile().getFilePath(), method.getStartLineNumber(), this._minifyString(method.getText().split(`
+`)[0])));
         hasWarning = true;
       }
       if (hasWarning)
         return;
       operatorOverloads.set(operandType, {
         isStatic: false,
-        className: classDecl.getName(),
+        className,
         classFilePath: filePath,
         operatorString,
-        index,
         returnType
       });
       this._postfixUnaryOverloads.set(syntaxKind, operatorOverloads);
-      const funcName = ts_morph_1.Node.isFunctionExpression(element) ? element.getName() : undefined;
-      const label = funcName ? `${funcName}()` : "()";
-      this._logger.debug(`Loaded ${classDecl.getName()}["${operatorString}"][${index}]: ${this._shortTypeName(operandType)}${operatorString} ${label} (postfix unary)`);
+      this._logger.debug(`Loaded ${className}["${operatorString}"]: ${this._shortTypeName(operandType)}${operatorString} () (postfix unary)`);
       let fileEntries = this._postfixUnaryFileEntries.get(filePath);
       if (!fileEntries) {
         fileEntries = [];
@@ -249691,155 +249708,6 @@ var require_OverloadStore = __commonJS((exports) => {
       }
       fileEntries.push({ syntaxKind, operandType });
     }
-    _addOverloadsFromTypeAnnotation(property, classDecl, classType, filePath, isStatic, operatorString, binarySyntaxKind, prefixUnarySyntaxKind, postfixUnarySyntaxKind) {
-      var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
-      const propertyType = property.getType();
-      if (!propertyType.isTuple())
-        return;
-      const tupleElements = propertyType.getTupleElements();
-      const className = classDecl.getName();
-      if (!className)
-        return;
-      const sl = this._shortTypeName.bind(this);
-      for (let index = 0;index < tupleElements.length; index++) {
-        const elementType = tupleElements[index];
-        const callSigs = elementType.getCallSignatures();
-        if (callSigs.length === 0)
-          continue;
-        const sig = callSigs[0];
-        const params = [];
-        for (const sym of sig.getParameters()) {
-          const name = sym.getName();
-          if (name === "this")
-            continue;
-          const decl = sym.getValueDeclaration();
-          if (!decl)
-            continue;
-          params.push({
-            name,
-            type: (0, resolveExpressionType_1.normalizeTypeName)(decl.getType().getText())
-          });
-        }
-        const paramCount = params.length;
-        const returnType = sig.getReturnType().getText();
-        if (paramCount === 2 && isStatic && binarySyntaxKind && !operatorMap_1.instanceOperators.has(binarySyntaxKind)) {
-          const lhsType = params[0].type;
-          const rhsType = params[1].type;
-          if (lhsType !== classType && rhsType !== classType) {
-            this._errorManager.addWarning(new ErrorManager_1.ErrorDescription(`Overload for operator ${operatorString} ` + "must have either LHS or RHS parameter matching its class type.", filePath, property.getStartLineNumber(), this._minifyString((_a = property.getText().split(`
-`)[0]) !== null && _a !== undefined ? _a : "")));
-            continue;
-          }
-          if (operatorMap_1.comparisonOperators.has(binarySyntaxKind) && returnType !== "boolean") {
-            this._errorManager.addWarning(new ErrorManager_1.ErrorDescription(`Overload function ${index} for comparison operator ${operatorString} ` + `must have a return type of 'boolean', got '${returnType}'.`, filePath, property.getStartLineNumber(), this._minifyString((_b = property.getText().split(`
-`)[0]) !== null && _b !== undefined ? _b : "")));
-            continue;
-          }
-          const operatorOverloads = (_c = this.get(binarySyntaxKind)) !== null && _c !== undefined ? _c : new Map;
-          const lhsMap = (_d = operatorOverloads.get(lhsType)) !== null && _d !== undefined ? _d : new Map;
-          if (lhsMap.has(rhsType))
-            continue;
-          lhsMap.set(rhsType, {
-            isStatic: true,
-            className,
-            classFilePath: filePath,
-            operatorString,
-            index,
-            returnType
-          });
-          operatorOverloads.set(lhsType, lhsMap);
-          this.set(binarySyntaxKind, operatorOverloads);
-          this._logger.debug(`Loaded ${className}["${operatorString}"][${index}]: (${sl(lhsType)}, ${sl(rhsType)}) => ${sl(returnType)} (static, from .d.ts)`);
-          let fileEntries = this._fileEntries.get(filePath);
-          if (!fileEntries) {
-            fileEntries = [];
-            this._fileEntries.set(filePath, fileEntries);
-          }
-          fileEntries.push({ syntaxKind: binarySyntaxKind, lhsType, rhsType });
-        } else if (paramCount === 1 && !isStatic && binarySyntaxKind && operatorMap_1.instanceOperators.has(binarySyntaxKind)) {
-          const lhsType = classType;
-          const rhsType = params[0].type;
-          if (returnType !== "void") {
-            this._errorManager.addWarning(new ErrorManager_1.ErrorDescription(`Overload function ${index} for instance operator ${operatorString} ` + `must have a return type of 'void', got '${returnType}'.`, filePath, property.getStartLineNumber(), this._minifyString((_e = property.getText().split(`
-`)[0]) !== null && _e !== undefined ? _e : "")));
-            continue;
-          }
-          const operatorOverloads = (_f = this.get(binarySyntaxKind)) !== null && _f !== undefined ? _f : new Map;
-          const lhsMap = (_g = operatorOverloads.get(lhsType)) !== null && _g !== undefined ? _g : new Map;
-          if (lhsMap.has(rhsType))
-            continue;
-          lhsMap.set(rhsType, {
-            isStatic: false,
-            className,
-            classFilePath: filePath,
-            operatorString,
-            index,
-            returnType
-          });
-          operatorOverloads.set(lhsType, lhsMap);
-          this.set(binarySyntaxKind, operatorOverloads);
-          this._logger.debug(`Loaded ${className}["${operatorString}"][${index}]: (${sl(lhsType)}, ${sl(rhsType)}) => void (instance, from .d.ts)`);
-          let fileEntries = this._fileEntries.get(filePath);
-          if (!fileEntries) {
-            fileEntries = [];
-            this._fileEntries.set(filePath, fileEntries);
-          }
-          fileEntries.push({ syntaxKind: binarySyntaxKind, lhsType, rhsType });
-        } else if (paramCount === 1 && isStatic && prefixUnarySyntaxKind) {
-          const operandType = params[0].type;
-          if (operandType !== classType) {
-            this._errorManager.addWarning(new ErrorManager_1.ErrorDescription(`Prefix unary overload for operator ${operatorString} ` + "must have its parameter matching its class type.", filePath, property.getStartLineNumber(), this._minifyString((_h = property.getText().split(`
-`)[0]) !== null && _h !== undefined ? _h : "")));
-            continue;
-          }
-          const operatorOverloads = (_j = this._prefixUnaryOverloads.get(prefixUnarySyntaxKind)) !== null && _j !== undefined ? _j : new Map;
-          if (operatorOverloads.has(operandType))
-            continue;
-          operatorOverloads.set(operandType, {
-            isStatic: true,
-            className,
-            classFilePath: filePath,
-            operatorString,
-            index,
-            returnType
-          });
-          this._prefixUnaryOverloads.set(prefixUnarySyntaxKind, operatorOverloads);
-          this._logger.debug(`Loaded ${className}["${operatorString}"][${index}]: ${operatorString}(${sl(operandType)}) => ${sl(returnType)} (prefix unary, from .d.ts)`);
-          let fileEntries = this._prefixUnaryFileEntries.get(filePath);
-          if (!fileEntries) {
-            fileEntries = [];
-            this._prefixUnaryFileEntries.set(filePath, fileEntries);
-          }
-          fileEntries.push({ syntaxKind: prefixUnarySyntaxKind, operandType });
-        } else if (paramCount === 0 && !isStatic && postfixUnarySyntaxKind) {
-          if (returnType !== "void") {
-            this._errorManager.addWarning(new ErrorManager_1.ErrorDescription(`Overload function ${index} for postfix operator ${operatorString} ` + `must have a return type of 'void', got '${returnType}'.`, filePath, property.getStartLineNumber(), this._minifyString((_k = property.getText().split(`
-`)[0]) !== null && _k !== undefined ? _k : "")));
-            continue;
-          }
-          const operandType = classType;
-          const operatorOverloads = (_l = this._postfixUnaryOverloads.get(postfixUnarySyntaxKind)) !== null && _l !== undefined ? _l : new Map;
-          if (operatorOverloads.has(operandType))
-            continue;
-          operatorOverloads.set(operandType, {
-            isStatic: false,
-            className,
-            classFilePath: filePath,
-            operatorString,
-            index,
-            returnType
-          });
-          this._postfixUnaryOverloads.set(postfixUnarySyntaxKind, operatorOverloads);
-          this._logger.debug(`Loaded ${className}["${operatorString}"][${index}]: ${sl(operandType)}${operatorString} () (postfix unary, from .d.ts)`);
-          let fileEntries = this._postfixUnaryFileEntries.get(filePath);
-          if (!fileEntries) {
-            fileEntries = [];
-            this._postfixUnaryFileEntries.set(filePath, fileEntries);
-          }
-          fileEntries.push({ syntaxKind: postfixUnarySyntaxKind, operandType });
-        }
-      }
-    }
     _getTypeChain(typeName) {
       var _a, _b;
       const cached2 = this._typeChainCache.get(typeName);
@@ -250085,7 +249953,7 @@ var require_validateExports = __commonJS((exports) => {
 // ../package/dist/index.js
 var require_dist4 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
-  exports.SyntaxKind = exports.Project = exports.Node = exports.operatorSymbols = exports.Operator = exports.validateExports = exports.toV3SourceMap = exports.computeEdits = exports.isPrefixUnaryOperatorSyntaxKind = exports.isPostfixUnaryOperatorSyntaxKind = exports.isOperatorSyntaxKind = exports.OverloadStore = exports.OverloadInjector = exports.unwrapInitializer = exports.resolveExpressionType = exports.getOperatorStringFromProperty = exports.ErrorManager = exports.ErrorDescription = exports.loadConfig = exports.ConsoleLogger = undefined;
+  exports.SyntaxKind = exports.Project = exports.Node = exports.operatorSymbols = exports.Operator = exports.validateExports = exports.toV3SourceMap = exports.computeEdits = exports.isPrefixUnaryOperatorSyntaxKind = exports.isPostfixUnaryOperatorSyntaxKind = exports.isOperatorSyntaxKind = exports.OverloadStore = exports.OverloadInjector = exports.unwrapInitializer = exports.resolveExpressionType = exports.getOperatorStringFromProperty = exports.getOperatorStringFromMethod = exports.ErrorManager = exports.ErrorDescription = exports.loadConfig = exports.ConsoleLogger = undefined;
   var BopConfig_1 = require_BopConfig();
   Object.defineProperty(exports, "ConsoleLogger", { enumerable: true, get: function() {
     return BopConfig_1.ConsoleLogger;
@@ -250100,6 +249968,10 @@ var require_dist4 = __commonJS((exports) => {
   Object.defineProperty(exports, "ErrorManager", { enumerable: true, get: function() {
     return ErrorManager_1.ErrorManager;
   } });
+  var getOperatorStringFromMethod_1 = require_getOperatorStringFromMethod();
+  Object.defineProperty(exports, "getOperatorStringFromMethod", { enumerable: true, get: function() {
+    return getOperatorStringFromMethod_1.getOperatorStringFromMethod;
+  } });
   var getOperatorStringFromProperty_1 = require_getOperatorStringFromProperty();
   Object.defineProperty(exports, "getOperatorStringFromProperty", { enumerable: true, get: function() {
     return getOperatorStringFromProperty_1.getOperatorStringFromProperty;
@@ -263293,58 +263165,48 @@ var postfixUnaryOperatorStrings = new Set(["++", "--"]);
 function generateOverloadProperty(className, operator) {
   if (postfixUnaryOperatorStrings.has(operator)) {
     return [
-      `	public readonly "${operator}" = [`,
-      `		function (this: ${className}): void {`,
-      "\t\t\t// TODO: implement",
-      "\t\t},",
-      "\t] as const;"
+      `	public "${operator}"(): void {`,
+      "\t\t// TODO: implement",
+      "\t}"
     ].join(`
 `);
   }
   if (exclusivePrefixUnaryStrings.has(operator)) {
     return [
-      `	public static readonly "${operator}" = [`,
-      `		(a: ${className}): ${className} => {`,
-      "\t\t\t// TODO: implement",
-      `			return new ${className}();`,
-      "\t\t},",
-      "\t] as const;"
+      `	public static "${operator}"(a: ${className}): ${className} {`,
+      "\t\t// TODO: implement",
+      `		return new ${className}();`,
+      "\t}"
     ].join(`
 `);
   }
   if (instanceOperatorStrings.has(operator)) {
     return [
-      `	public readonly "${operator}" = [`,
-      `		function (this: ${className}, other: ${className}): void {`,
-      "\t\t\t// TODO: implement",
-      "\t\t},",
-      "\t] as const;"
+      `	public "${operator}"(other: ${className}): void {`,
+      "\t\t// TODO: implement",
+      "\t}"
     ].join(`
 `);
   }
   if (comparisonOperatorStrings.has(operator)) {
     return [
-      `	public static readonly "${operator}" = [`,
-      `		(a: ${className}, b: ${className}): boolean => {`,
-      "\t\t\t// TODO: implement",
-      "\t\t\treturn false;",
-      "\t\t},",
-      "\t] as const;"
+      `	public static "${operator}"(a: ${className}, b: ${className}): boolean {`,
+      "\t\t// TODO: implement",
+      "\t\treturn false;",
+      "\t}"
     ].join(`
 `);
   }
   return [
-    `	public static readonly "${operator}" = [`,
-    `		(a: ${className}, b: ${className}): ${className} => {`,
-    "\t\t\t// TODO: implement",
-    `			return new ${className}();`,
-    "\t\t},",
-    "\t] as const;"
+    `	public static "${operator}"(a: ${className}, b: ${className}): ${className} {`,
+    "\t\t// TODO: implement",
+    `		return new ${className}();`,
+    "\t}"
   ].join(`
 `);
 }
 server2.registerTool("scaffold_overloads", {
-  description: "Generate TypeScript boilerplate for operator overload definitions on a class. " + "Returns code ready to paste into a class body, with correct static/instance " + "placement, as const assertions, and this parameters for instance operators.",
+  description: "Generate TypeScript boilerplate for operator overload definitions on a class. " + "Returns code ready to paste into a class body, with correct static/instance " + "placement and parameter types.",
   inputSchema: {
     className: exports_external.string().describe("The class name to generate overloads for."),
     operators: exports_external.array(exports_external.string()).describe(`Array of operator strings. Valid operators: ${import_boperators2.operatorSymbols.join(", ")}`)
@@ -263384,7 +263246,7 @@ function createCapturingLogger(warnings) {
   };
 }
 server2.registerTool("validate_overloads", {
-  description: "Validate operator overload definitions in a single file. " + "Returns structured diagnostics: errors (wrong arity, bad types, missing as const) " + "and warnings (e.g. conflicting overloads). Does not transform the file.",
+  description: "Validate operator overload definitions in a single file. " + "Returns structured diagnostics: errors (wrong arity, bad types) " + "and warnings (e.g. conflicting overloads). Does not transform the file.",
   inputSchema: {
     tsconfig: exports_external.string().describe("Absolute path to tsconfig.json for the project."),
     filePath: exports_external.string().describe("Absolute path to the TypeScript file to validate.")
@@ -263436,75 +263298,83 @@ server2.registerTool("validate_overloads", {
     };
   }
 });
-var instanceCallPattern = /\["([^"]+)"\]\[(\d+)\]\.call\(/;
-var staticCallPattern = /^(\w+)\["([^"]+)"\]\[(\d+)\]\(/;
+var postfixCallPattern = /\["([^"]+)"\]\(\)$/;
+var instanceCallPattern = /^([a-z_$]\w*)\["([^"]+)"\]\(/;
+var staticCallPattern = /^([A-Z]\w*)\["([^"]+)"\]\(/;
 server2.registerTool("explain_expression", {
-  description: "Explain a transformed boperators expression. " + 'Given an expression like Vector3["+"][0](a, b) or v["++"][0].call(v), ' + "identifies the operator kind, class, and overload entry. " + "Optionally looks up full overload metadata when tsconfig is provided.",
+  description: "Explain a transformed boperators expression. " + 'Given an expression like Vec2["+"](a, b) or a["+="](b) or a["++"](), ' + "identifies the operator kind, class, and overload entry. " + "Optionally looks up full overload metadata when tsconfig is provided.",
   inputSchema: {
-    expression: exports_external.string().describe(`The transformed expression to explain, e.g. 'Vector3["+"][0](a, b)'.`),
+    expression: exports_external.string().describe(`The transformed expression to explain, e.g. 'Vec2["+"](a, b)'.`),
     tsconfig: exports_external.string().optional().describe("Absolute path to tsconfig.json. When provided, the overload is looked up " + "in the project for richer metadata (file path, parameter types).")
   }
 }, async ({ expression, tsconfig }) => {
   try {
     const trimmed = expression.trim();
+    const postfixMatch = trimmed.match(postfixCallPattern);
+    if (postfixMatch) {
+      const [, operator] = postfixMatch;
+      const result = {
+        kind: "postfix unary",
+        operator,
+        isStatic: false,
+        originalExpression: `operand${operator}`,
+        explanation: `Postfix unary operator "${operator}": mutates the operand in place.`
+      };
+      if (tsconfig) {
+        const overloadInfo = lookupOverload(tsconfig, operator, false);
+        if (overloadInfo)
+          Object.assign(result, overloadInfo);
+      }
+      return {
+        content: [
+          { type: "text", text: JSON.stringify(result, null, 2) }
+        ]
+      };
+    }
     const instanceMatch = trimmed.match(instanceCallPattern);
     if (instanceMatch) {
-      const [, operator, indexStr] = instanceMatch;
-      const index = Number.parseInt(indexStr, 10);
-      const callArgs = trimmed.slice(trimmed.indexOf(".call(") + 6, trimmed.lastIndexOf(")"));
-      const hasSecondArg = callArgs.includes(",");
-      const kind = hasSecondArg ? "instance binary" : "postfix unary";
-      const originalPattern = hasSecondArg ? `lhs ${operator} rhs` : `operand${operator}`;
+      const [, , operator] = instanceMatch;
       const result = {
-        kind,
+        kind: "instance binary",
         operator,
-        index,
         isStatic: false,
-        originalExpression: originalPattern,
-        explanation: hasSecondArg ? `Instance binary operator "${operator}": mutates the left-hand side in place (e.g. compound assignment).` : `Postfix unary operator "${operator}": mutates the operand in place.`
+        originalExpression: `lhs ${operator} rhs`,
+        explanation: `Instance binary operator "${operator}": mutates the left-hand side in place (e.g. compound assignment).`
       };
       if (tsconfig) {
-        const overloadInfo = lookupOverload(tsconfig, operator, index, false);
+        const overloadInfo = lookupOverload(tsconfig, operator, false);
         if (overloadInfo)
           Object.assign(result, overloadInfo);
       }
       return {
         content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
+          { type: "text", text: JSON.stringify(result, null, 2) }
         ]
       };
     }
     const staticMatch = trimmed.match(staticCallPattern);
     if (staticMatch) {
-      const [, className, operator, indexStr] = staticMatch;
-      const index = Number.parseInt(indexStr, 10);
+      const [, className, operator] = staticMatch;
       const argsStr = trimmed.slice(trimmed.indexOf("](") + 2, trimmed.lastIndexOf(")"));
-      const argCount = argsStr.split(",").length;
+      const argCount = argsStr.trim() === "" ? 0 : argsStr.split(",").length;
       const kind = argCount >= 2 ? "static binary" : "prefix unary";
       const originalPattern = argCount >= 2 ? `lhs ${operator} rhs` : `${operator}operand`;
       const result = {
         kind,
         operator,
-        index,
         className,
         isStatic: true,
         originalExpression: originalPattern,
         explanation: argCount >= 2 ? `Static binary operator "${operator}": returns a new value from two operands.` : `Prefix unary operator "${operator}": returns a new value from a single operand.`
       };
       if (tsconfig) {
-        const overloadInfo = lookupOverload(tsconfig, operator, index, true, className);
+        const overloadInfo = lookupOverload(tsconfig, operator, true, className);
         if (overloadInfo)
           Object.assign(result, overloadInfo);
       }
       return {
         content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
+          { type: "text", text: JSON.stringify(result, null, 2) }
         ]
       };
     }
@@ -263513,8 +263383,9 @@ server2.registerTool("explain_expression", {
         {
           type: "text",
           text: `Could not parse expression as a boperators transformed call. ` + `Expected patterns:
-` + `  Static:   ClassName["op"][index](args)
-` + `  Instance: expr["op"][index].call(expr, args)`
+` + `  Static:   ClassName["op"](args)
+` + `  Instance: expr["op"](other)
+` + `  Postfix:  expr["op"]()`
         }
       ],
       isError: true
@@ -263531,15 +263402,13 @@ server2.registerTool("explain_expression", {
     };
   }
 });
-function lookupOverload(tsconfig, operator, index, isStatic, className) {
+function lookupOverload(tsconfig, operator, isStatic, className) {
   try {
     projectManager.initialize(tsconfig);
     const allOverloads = projectManager.overloadStore.getAllOverloads();
     const match = allOverloads.find((o) => {
       if (o.operatorString !== operator)
         return false;
-      if (o.index !== index)
-        return false;
       if (className && o.className !== className)
         return false;
       if (o.isStatic !== isStatic)

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@boperators/mcp-server",
-	"version": "0.2.1",
+	"version": "0.3.1",
 	"license": "MIT",
 	"description": "MCP server for boperators - gives AI assistants access to operator overload information.",
 	"repository": {
@@ -42,7 +42,7 @@
 	],
 	"dependencies": {
 		"@modelcontextprotocol/sdk": "^1.12.1",
-		"boperators": "0.2.1",
+		"boperators": "0.3.1",
 		"zod": "^3.25.0"
 	},
 	"devDependencies": {