@codeyam/codeyam-cli 0.1.0-staging.bbe4da9 → 0.1.0-staging.dd216e0

package/analyzer-template/packages/ai/src/lib/dataStructure/ScopeDataStructure.ts

@@ -210,6 +210,17 @@ export interface FunctionCallInfo {
    * are encountered, they get merged into one FunctionCallInfo but we track all signatures.
    */
   allCallSignatures?: string[];
+  /**
+   * Variable names that receive the return value of each call.
+   * For example, in `const result1 = db.select(query1)`, the receiving variable is 'result1'.
+   * This enables generating separate mock data for each call site.
+   */
+  receivingVariableNames?: string[];
+  /**
+   * Maps each call signature to the variable that receives its return value.
+   * For example: { "db.select(query1)": "result1", "db.select(query2)": "result2" }
+   */
+  callSignatureToVariable?: Record<string, string>;
 }
 
 /**
@@ -307,7 +318,12 @@ const ALLOWED_EQUIVALENCY_REASONS = new Set([
   'Array.from() equivalency',
   'propagated sub-property equivalency',
   'propagated function call return sub-property equivalency',
+  'propagated parent-variable equivalency', // Added: propagate child scope equivalencies to parent scope when variable is defined in parent
   'where was this function called from', // Added: tracks which scope called an external function
+  'MUI DataGrid renderCell params.row equivalency', // Added: links DataGrid renderCell params.row to rows array elements
+  'MUI Autocomplete getOptionLabel option equivalency', // Added: links Autocomplete getOptionLabel callback param to options array
+  'MUI Autocomplete renderOption option equivalency', // Added: links Autocomplete renderOption callback param to options array
+  'MUI Autocomplete option property equivalency', // Added: propagates property accesses from Autocomplete callbacks
 ]);
 
 const SILENTLY_IGNORED_EQUIVALENCY_REASONS = new Set([
@@ -370,6 +386,10 @@ export class ScopeDataStructure {
   private externalFunctionCallsIndex: Map<string, FunctionCallInfo> | null =
     null;
 
+  // Tracks internal functions that have been filtered out during captureCompleteSchema
+  // Prevents re-adding them via subsequent equivalency propagation (e.g., from getReturnValue)
+  private filteredInternalFunctions: Set<string> = new Set();
+
   // Debug tracer for selective path/scope tracing
   // Enable via: CODEYAM_DEBUG=true CODEYAM_DEBUG_PATHS="user.*,signature" npm test
   private tracer: DebugTracer = new DebugTracer({
@@ -528,6 +548,8 @@ export class ScopeDataStructure {
       const efcName = this.pathManager.stripGenerics(efc.name);
       for (const manager of this.equivalencyManagers) {
         if (manager.internalFunctions.has(efcName)) {
+          // Track this so we don't re-add it via subsequent finalize calls
+          this.filteredInternalFunctions.add(efcName);
           return false;
         }
       }
@@ -555,13 +577,51 @@ export class ScopeDataStructure {
         const baseName = this.pathManager.stripGenerics(
           candidate.scopeNodeName,
         );
+        // Check if this is a local variable path (doesn't contain function call pattern)
+        // Local variables like "surveys[]" or "items[]" are important for tracing data flow
+        // from parent to child components (e.g., surveys[] -> SurveyCard().signature[0].survey)
+        const isLocalVariablePath =
+          !candidate.schemaPath.includes('()') &&
+          !candidate.schemaPath.startsWith('signature[') &&
+          !candidate.schemaPath.startsWith('returnValue');
+
         return (
           validExternalFacingScopeNames.has(baseName) &&
           (candidate.schemaPath.startsWith('signature[') ||
-            candidate.schemaPath.startsWith(baseName)) &&
+            candidate.schemaPath.startsWith(baseName) ||
+            isLocalVariablePath) &&
           !containsArrayMethod(candidate.schemaPath)
         );
       });
+
+      // If all sourceCandidates were filtered out (e.g., because they belonged to
+      // internal functions like useState), look for the highest-order intermediate
+      // that belongs to a valid external-facing scope
+      if (
+        entry.sourceCandidates.length === 0 &&
+        Object.keys(entry.intermediatesOrder).length > 0
+      ) {
+        // Find intermediates that belong to valid external-facing scopes
+        const validIntermediates = Object.entries(entry.intermediatesOrder)
+          .filter(([pathId]) => {
+            const [scopeNodeName, schemaPath] = pathId.split('::');
+            if (!scopeNodeName || !schemaPath) return false;
+            const baseName = this.pathManager.stripGenerics(scopeNodeName);
+            return (
+              validExternalFacingScopeNames.has(baseName) &&
+              !containsArrayMethod(schemaPath)
+            );
+          })
+          .sort((a, b) => b[1] - a[1]); // Sort by order descending (highest first)
+
+        if (validIntermediates.length > 0) {
+          const [pathId] = validIntermediates[0];
+          const [scopeNodeName, schemaPath] = pathId.split('::');
+          if (scopeNodeName && schemaPath) {
+            entry.sourceCandidates.push({ scopeNodeName, schemaPath });
+          }
+        }
+      }
     }
 
     this.propagateSourceAndUsageEquivalencies(
@@ -919,13 +979,69 @@ export class ScopeDataStructure {
       }
     }
 
+    // Skip self-referential equivalencies that would create infinite loops.
+    // Case 1: Direct self-reference (path === equivalentPath)
+    // FunctionCallManager adds equivalency(subPath, subPath, externalFunctionName, ...)
+    // For simple calls like buildBranchFileMap(), this is fine.
+    // But for chained calls like query.where().where().where(), each method call adds
+    // a .functionCallReturnValue segment, and the equivalency processing creates an infinite loop.
+    // We detect chained calls by counting .functionCallReturnValue occurrences in the path.
+    if (
+      path === equivalentPath &&
+      equivalencyReason === 'equivalency to external function call'
+    ) {
+      // Count how many .functionCallReturnValue segments are in the path
+      const functionCallReturnValueCount = (
+        path.match(/\.functionCallReturnValue/g) || []
+      ).length;
+      // Skip if there are multiple chained calls (2+ .functionCallReturnValue segments)
+      if (functionCallReturnValueCount >= 2) {
+        return;
+      }
+    }
+
+    // Case 2: Circular reference where equivalentPath contains path as a prefix
+    // e.g., path="query" and equivalentPath="query.where(...).functionCallReturnValue"
+    // This happens with method chaining patterns where a variable is reassigned to
+    // the result of a method call on itself: query = query.where(...)
+    // Resolving this equivalency would require resolving query first, creating infinite recursion.
+    if (
+      equivalentPath.startsWith(path + '.') ||
+      equivalentPath.startsWith(path + '(')
+    ) {
+      return;
+    }
+
     if (!equivalentScopeName) {
-      console.warn('Debug Propagation: missing equivalent scope name', {
-        path,
-        equivalentPath,
-        equivalentScopeName,
-        scopeNodeName: scopeNode.name,
-      });
+      console.error(
+        'CodeYam Error: Missing equivalent scope name - FULL CONTEXT:',
+        JSON.stringify(
+          {
+            path,
+            equivalentPath,
+            equivalentScopeName,
+            scopeNodeName: scopeNode.name,
+            equivalencyReason,
+            tree: scopeNode.tree,
+            equivalencyValueChain: equivalencyValueChain?.map((ev) => ({
+              id: ev.id,
+              source: ev.source,
+              reason: ev.reason,
+              currentPath: ev.currentPath,
+              previousPath: ev.previousPath,
+            })),
+            scopeNodeFunctionCalls: scopeNode.functionCalls?.map((fc) => ({
+              name: fc.name,
+              callSignature: fc.callSignature,
+              callScope: fc.callScope,
+            })),
+            instantiatedVariables: scopeNode.instantiatedVariables,
+            parentInstantiatedVariables: scopeNode.parentInstantiatedVariables,
+          },
+          null,
+          2,
+        ),
+      );
       throw new Error('CodeYam Error: Missing equivalent scope name');
     }
 
@@ -1083,10 +1199,22 @@ export class ScopeDataStructure {
       const existingFunctionCall =
         this.getExternalFunctionCallsIndex().get(searchKey);
       if (existingFunctionCall) {
-        existingFunctionCall.schema = {
+        // Merge schemas using selectBestValue to preserve specific types like 'null'
+        // over generic types like 'unknown'. This ensures ref variables detected
+        // earlier (marked as 'null') aren't overwritten by later 'unknown' values.
+        const mergedSchema: Record<string, string> = {
           ...existingFunctionCall.schema,
-          ...functionCallInfo.schema,
         };
+        for (const key in functionCallInfo.schema) {
+          const existingValue = existingFunctionCall.schema[key];
+          const newValue = functionCallInfo.schema[key];
+          mergedSchema[key] = selectBestValue(
+            existingValue,
+            newValue,
+            newValue,
+          );
+        }
+        existingFunctionCall.schema = mergedSchema;
 
         existingFunctionCall.equivalencies = {
           ...existingFunctionCall.equivalencies,
@@ -1119,8 +1247,15 @@ export class ScopeDataStructure {
           );
 
         if (isExternal) {
-          this.externalFunctionCalls.push(functionCallInfo);
-          this.invalidateExternalFunctionCallsIndex();
+          // Check if this function was already filtered out as an internal function
+          // (e.g., useState was filtered in captureCompleteSchema but finalize is trying to re-add it)
+          const strippedName = this.pathManager.stripGenerics(
+            functionCallInfo.name,
+          );
+          if (!this.filteredInternalFunctions.has(strippedName)) {
+            this.externalFunctionCalls.push(functionCallInfo);
+            this.invalidateExternalFunctionCallsIndex();
+          }
         }
       }
     }
@@ -1295,6 +1430,23 @@ export class ScopeDataStructure {
     return this.pathManager.joinPathParts(pathParts);
   }
 
+  /**
+   * Extracts the root variable name from a path.
+   * E.g., "collected[]" -> "collected", "foo.bar" -> "foo", "collected[0]" -> "collected"
+   */
+  extractRootVariable(path: string): string | null {
+    const parts = this.splitPath(path);
+    if (parts.length === 0) return null;
+
+    const firstPart = parts[0];
+    // Strip array notation: "collected[]" -> "collected", "collected[0]" -> "collected"
+    const bracketIndex = firstPart.indexOf('[');
+    if (bracketIndex > 0) {
+      return firstPart.substring(0, bracketIndex);
+    }
+    return firstPart;
+  }
+
   // PRIVATE METHODS //
 
   private uniqueId(params: {
@@ -1390,6 +1542,41 @@ export class ScopeDataStructure {
     const { isolatedStructure, isolatedEquivalentVariables } =
       scopeNode.analysis;
 
+    // DEBUG: Log all equivalencies related to useFetcher
+    if (
+      Object.keys(isolatedEquivalentVariables || {}).some(
+        (k) => k.includes('Fetcher') || k.includes('fetcher'),
+      )
+    ) {
+      console.log(
+        'CodeYam DEBUG determineEquivalenciesAndBuildSchema:',
+        JSON.stringify(
+          {
+            scopeNodeName: scopeNode.name,
+            fetcherEquivalencies: Object.entries(
+              isolatedEquivalentVariables || {},
+            )
+              .filter(
+                ([k, v]) =>
+                  k.includes('Fetcher') ||
+                  k.includes('fetcher') ||
+                  String(v).includes('Fetcher') ||
+                  String(v).includes('fetcher'),
+              )
+              .reduce(
+                (acc, [k, v]) => {
+                  acc[k] = v;
+                  return acc;
+                },
+                {} as Record<string, string>,
+              ),
+          },
+          null,
+          2,
+        ),
+      );
+    }
+
     const allPaths = Array.from(
       new Set([
         ...Object.keys(isolatedStructure || {}),
@@ -1416,6 +1603,47 @@ export class ScopeDataStructure {
           'original equivalency',
         );
 
+        // Propagate equivalencies involving parent-scope variables to those parent scopes.
+        // This handles patterns like: collected.push({...entity}) where 'collected' is defined
+        // in a parent scope. The equivalency collected[] -> push().signature[0] needs to be
+        // visible when tracing from the parent scope.
+        const rootVariable = this.extractRootVariable(path);
+        const equivalentRootVariable =
+          this.extractRootVariable(equivalentValue);
+
+        // Skip propagation for self-referential reassignment patterns like:
+        //   x = x.method().functionCallReturnValue
+        // where the path IS the variable itself (not a sub-path like x[] or x.prop).
+        // These create circular references since both sides reference the same variable.
+        //
+        // But DO propagate for patterns like collected[] -> collected.push(...).signature[0]
+        // where the path has additional segments beyond the root variable.
+        const pathIsJustRootVariable = path === rootVariable;
+        const isSelfReferentialReassignment =
+          pathIsJustRootVariable && rootVariable === equivalentRootVariable;
+
+        if (
+          rootVariable &&
+          !isSelfReferentialReassignment &&
+          scopeNode.parentInstantiatedVariables?.includes(rootVariable)
+        ) {
+          // Find the parent scope where this variable is defined
+          for (const parentScopeName of scopeNode.tree || []) {
+            const parentScope = this.scopeNodes[parentScopeName];
+            if (parentScope?.instantiatedVariables?.includes(rootVariable)) {
+              // Add the equivalency to the parent scope as well
+              this.addEquivalency(
+                path,
+                equivalentValue,
+                scopeNode.name, // The equivalent path's scope remains the child scope
+                parentScope, // But store it in the parent scope's equivalencies
+                'propagated parent-variable equivalency',
+              );
+              break;
+            }
+          }
+        }
+
         // Propagate sub-property equivalencies when the equivalentValue is a simple variable
         // that has sub-properties defined in the isolatedEquivalentVariables.
         // This handles cases like: dataItem={{ structure: completeDataStructure }}
@@ -1492,6 +1720,16 @@ export class ScopeDataStructure {
             scopeNode,
             allPaths,
           );
+
+          // Track which variable receives the return value of each function call
+          // This enables generating separate mock data for each call site
+          this.trackReceivingVariable(path, equivalentValue);
+        }
+
+        // Also track variables that receive destructured properties from function call return values
+        // e.g., "userData" -> "db.query('users').functionCallReturnValue.data"
+        if (equivalentValue.includes('.functionCallReturnValue.')) {
+          this.trackReceivingVariable(path, equivalentValue);
         }
       }
     }
@@ -1562,6 +1800,86 @@ export class ScopeDataStructure {
     }
   }
 
+  /**
+   * Tracks which variable receives the return value of a function call.
+   *
+   * When we encounter an equivalency like:
+   *   result1 -> db.select(query1).functionCallReturnValue
+   *
+   * This method extracts the call signature (db.select(query1)) and maps it
+   * to the receiving variable (result1) on the corresponding FunctionCallInfo.
+   *
+   * This enables generating separate mock data for each call site when the same
+   * function is called multiple times with different arguments.
+   */
+  private trackReceivingVariable(
+    receivingVariable: string,
+    equivalentValue: string,
+  ): void {
+    // Extract the call signature by finding the .functionCallReturnValue part
+    // and taking everything before it
+    // Handles both:
+    //   "db.select(query1).functionCallReturnValue" -> "db.select(query1)"
+    //   "db.query('users').functionCallReturnValue.data" -> "db.query('users')"
+    const funcReturnIdx = equivalentValue.indexOf('.functionCallReturnValue');
+    if (funcReturnIdx === -1) {
+      return;
+    }
+    const callSignature = equivalentValue.substring(0, funcReturnIdx);
+
+    // Skip if the receiving variable is not a simple identifier
+    // (e.g., skip if it's a path like "obj.property" or contains array access)
+    if (receivingVariable.includes('.') || receivingVariable.includes('[')) {
+      return;
+    }
+
+    // Find the FunctionCallInfo that matches this call signature
+    const searchKey = getFunctionCallRoot(callSignature);
+    const functionCallInfo =
+      this.getExternalFunctionCallsIndex().get(searchKey);
+
+    // DEBUG: Track useFetcher calls
+    if (searchKey === 'useFetcher' || callSignature.includes('useFetcher')) {
+      console.log(
+        'CodeYam DEBUG trackReceivingVariable:',
+        JSON.stringify(
+          {
+            receivingVariable,
+            equivalentValue,
+            callSignature,
+            searchKey,
+            foundFunctionCallInfo: !!functionCallInfo,
+            existingRecvVars: functionCallInfo?.receivingVariableNames,
+            existingCallSigToVar: functionCallInfo?.callSignatureToVariable,
+          },
+          null,
+          2,
+        ),
+      );
+    }
+
+    if (!functionCallInfo) {
+      return;
+    }
+
+    // Initialize arrays if needed
+    if (!functionCallInfo.receivingVariableNames) {
+      functionCallInfo.receivingVariableNames = [];
+    }
+    if (!functionCallInfo.callSignatureToVariable) {
+      functionCallInfo.callSignatureToVariable = {};
+    }
+
+    // Add the receiving variable to the list (if not already present)
+    if (!functionCallInfo.receivingVariableNames.includes(receivingVariable)) {
+      functionCallInfo.receivingVariableNames.push(receivingVariable);
+    }
+
+    // Map the call signature to its receiving variable
+    // Use the full call signature (not the search key) for precise mapping
+    functionCallInfo.callSignatureToVariable[callSignature] = receivingVariable;
+  }
+
   /**
    * Propagates returnValue.* sub-properties from a callback scope to the usage path.
    *
@@ -2909,7 +3227,12 @@ export class ScopeDataStructure {
       );
     }
 
+    // CRITICAL: Set onlyEquivalencies to true to prevent database modifications
+    // during this "getter" method. See comment in getFunctionSignature.
+    const wasOnlyEquivalencies = this.onlyEquivalencies;
+    this.onlyEquivalencies = true;
     this.validateSchema(scopeNode, true, fillInUnknowns);
+    this.onlyEquivalencies = wasOnlyEquivalencies;
 
     const { schema } = scopeNode;
 
@@ -3010,6 +3333,7 @@ export class ScopeDataStructure {
         (candidate) => candidate.scopeNodeName === scopeNode.name,
       ),
     );
+
     return entries.reduce(
       (acc, entry) => {
         if (entry.usages.length === 0) return acc;
@@ -3072,7 +3396,14 @@ export class ScopeDataStructure {
       equivalencies,
     );
 
+    // CRITICAL: Set onlyEquivalencies to true to prevent database modifications
+    // during this "getter" method. validateSchema triggers manager.finalize which
+    // can call addToSchema -> addToEquivalencyDatabase -> mergeEquivalencyDatabaseEntries,
+    // which would incorrectly remove entries from the database.
+    const wasOnlyEquivalencies = this.onlyEquivalencies;
+    this.onlyEquivalencies = true;
     this.validateSchema(tempScopeNode, true, fillInUnknowns);
+    this.onlyEquivalencies = wasOnlyEquivalencies;
 
     return tempScopeNode.schema;
   }
@@ -3084,6 +3415,15 @@ export class ScopeDataStructure {
     functionName?: string;
     fillInUnknowns?: boolean;
   }) {
+    // Trigger finalization on all managers to apply any pending updates
+    // (e.g., ref type propagation to external function call schemas)
+    const rootScope = this.scopeNodes[this.scopeTreeManager.getRootName()];
+    if (rootScope) {
+      for (const manager of this.equivalencyManagers) {
+        manager.finalize(rootScope, this);
+      }
+    }
+
     const scopeName = functionName ?? this.scopeTreeManager.getRootName();
     const scopeNode = this.scopeNodes[scopeName];
 
@@ -3094,7 +3434,8 @@ export class ScopeDataStructure {
         scopeNode: scopeNode,
       });
     } else {
-      for (const externalFunctionCall of this.externalFunctionCalls) {
+      // Use getExternalFunctionCalls() which cleans cyScope from schemas
+      for (const externalFunctionCall of this.getExternalFunctionCalls()) {
         const functionNameParts = this.splitPath(functionName).map((p) =>
           this.functionOrScopeName(p),
         );
@@ -3150,7 +3491,12 @@ export class ScopeDataStructure {
 
     const tempScopeNode = this.createTempScopeNode(scopeName, resolvedSchema);
 
+    // CRITICAL: Set onlyEquivalencies to true to prevent database modifications
+    // during this "getter" method. See comment in getFunctionSignature.
+    const wasOnlyEquivalencies = this.onlyEquivalencies;
+    this.onlyEquivalencies = true;
     this.validateSchema(tempScopeNode, true, fillInUnknowns);
+    this.onlyEquivalencies = wasOnlyEquivalencies;
 
     return tempScopeNode.schema;
   }
@@ -3158,6 +3504,8 @@ export class ScopeDataStructure {
   /**
    * Replaces cyScope placeholder references (e.g., cyScope10()) in schema keys
    * with the actual callback function text from the corresponding scope node.
+   * If the scope text can't be found, uses a generic fallback to avoid leaking
+   * internal cyScope names into stored data.
    */
   private replaceCyScopePlaceholders(
     schema: Record<string, string>,
@@ -3173,10 +3521,10 @@ export class ScopeDataStructure {
       for (const match of matches) {
         const cyScopeName = `cyScope${match[1]}`;
         const scopeText = this.findCyScopeText(cyScopeName);
-        if (scopeText) {
-          // Replace cyScope10() with the actual callback text
-          newKey = newKey.replace(match[0], scopeText);
-        }
+        // Always replace cyScope references - use actual text if available,
+        // otherwise use a generic callback placeholder
+        const replacement = scopeText || '() => {}';
+        newKey = newKey.replace(match[0], replacement);
       }
 
       result[newKey] = value;
@@ -3298,7 +3646,12 @@ export class ScopeDataStructure {
       relevantSchema,
     );
 
+    // CRITICAL: Set onlyEquivalencies to true to prevent database modifications
+    // during this "getter" method. See comment in getFunctionSignature.
+    const wasOnlyEquivalencies = this.onlyEquivalencies;
+    this.onlyEquivalencies = true;
     this.validateSchema(tempScopeNode, true, final);
+    this.onlyEquivalencies = wasOnlyEquivalencies;
 
     return {
       name: variableName,
@@ -3307,8 +3660,123 @@ export class ScopeDataStructure {
     };
   }
 
-  getExternalFunctionCalls() {
-    return this.externalFunctionCalls;
+  getExternalFunctionCalls(): FunctionCallInfo[] {
+    // Replace cyScope placeholders in all external function call data
+    // This ensures call signatures and schema paths use actual callback text
+    // instead of internal cyScope names, preventing mock data merge conflicts.
+    return this.externalFunctionCalls.map((efc) =>
+      this.cleanCyScopeFromFunctionCallInfo(efc),
+    );
+  }
+
+  /**
+   * Cleans cyScope placeholder references from a FunctionCallInfo.
+   * Replaces cyScopeN() with the actual callback text in:
+   * - callSignature
+   * - allCallSignatures
+   * - schema keys
+   */
+  private cleanCyScopeFromFunctionCallInfo(
+    efc: FunctionCallInfo,
+  ): FunctionCallInfo {
+    const cyScopePattern = /cyScope\d+\(\)/g;
+
+    // Check if any cleaning is needed
+    const hasCyScope =
+      cyScopePattern.test(efc.callSignature) ||
+      (efc.allCallSignatures &&
+        efc.allCallSignatures.some((sig) => /cyScope\d+\(\)/.test(sig))) ||
+      (efc.schema &&
+        Object.keys(efc.schema).some((key) => /cyScope\d+\(\)/.test(key)));
+
+    if (!hasCyScope) {
+      return efc;
+    }
+
+    // Create cleaned copy
+    const cleaned: FunctionCallInfo = { ...efc };
+
+    // Clean callSignature
+    cleaned.callSignature = this.replaceCyScopeInString(efc.callSignature);
+
+    // Clean allCallSignatures
+    if (efc.allCallSignatures) {
+      cleaned.allCallSignatures = efc.allCallSignatures.map((sig) =>
+        this.replaceCyScopeInString(sig),
+      );
+    }
+
+    // Clean schema keys
+    if (efc.schema) {
+      cleaned.schema = this.replaceCyScopePlaceholders(efc.schema);
+    }
+
+    // Clean callSignatureToVariable keys
+    if (efc.callSignatureToVariable) {
+      cleaned.callSignatureToVariable = Object.entries(
+        efc.callSignatureToVariable,
+      ).reduce(
+        (acc, [key, value]) => {
+          acc[this.replaceCyScopeInString(key)] = value;
+          return acc;
+        },
+        {} as Record<string, string>,
+      );
+    }
+
+    return cleaned;
+  }
+
+  /**
+   * Replaces cyScope placeholder references in a single string.
+   * If the scope text can't be found, uses a generic fallback to avoid leaking
+   * internal cyScope names into stored data.
+   *
+   * Handles two patterns:
+   * 1. Function call style: cyScope7() - matched by cyScope(\d+)\(\)
+   * 2. Scope name style: parentName____cyScopeXX or cyScopeXX - matched by (\w+____)?cyScope([0-9A-Fa-f]+)
+   */
+  private replaceCyScopeInString(str: string): string {
+    let result = str;
+
+    // Pattern 1: Function call style - cyScope7()
+    const functionCallPattern = /cyScope(\d+)\(\)/g;
+    const functionCallMatches = [...str.matchAll(functionCallPattern)];
+    for (const match of functionCallMatches) {
+      const cyScopeName = `cyScope${match[1]}`;
+      const scopeText = this.findCyScopeText(cyScopeName);
+      // Always replace cyScope references - use actual text if available,
+      // otherwise use a generic callback placeholder
+      const replacement = scopeText || '() => {}';
+      result = result.replace(match[0], replacement);
+    }
+
+    // Pattern 2: Scope name style - parentName____cyScopeXX or just cyScopeXX
+    // This handles hex-encoded scope IDs like cyScope1F
+    const scopeNamePattern = /(\w+____)?cyScope([0-9A-Fa-f]+)/g;
+    const scopeNameMatches = [...result.matchAll(scopeNamePattern)];
+    for (const match of scopeNameMatches) {
+      const fullMatch = match[0];
+      const prefix = match[1] || ''; // e.g., "getTitleColor____"
+      const cyScopeId = match[2]; // e.g., "1F"
+      const cyScopeName = `cyScope${cyScopeId}`;
+
+      // Try to find the scope text, checking both with and without prefix
+      let scopeText = this.findCyScopeText(cyScopeName);
+      if (!scopeText && prefix) {
+        // Try looking up with the full prefixed name
+        scopeText = this.findCyScopeText(`${prefix}${cyScopeName}`);
+      }
+
+      if (scopeText) {
+        result = result.replace(fullMatch, scopeText);
+      } else {
+        // Replace with a generic identifier to avoid leaking internal names
+        result = result.replace(fullMatch, 'callback');
+      }
+    }
+
+    return result;
   }
 
   getEnvironmentVariables() {
@@ -3397,34 +3865,58 @@ export class ScopeDataStructure {
   }
 
   toSerializable(): SerializableDataStructure {
-    // Helper to convert ScopeVariable to SerializableScopeVariable
+    // Helper to clean cyScope from a string
+    const cleanCyScope = (str: string): string =>
+      this.replaceCyScopeInString(str);
+
+    // Helper to convert ScopeVariable to SerializableScopeVariable (with cyScope cleaned)
     const toSerializableVariable = (
       vars:
         | ScopeVariable[]
         | Pick<ScopeVariable, 'scopeNodeName' | 'schemaPath'>[],
     ): SerializableScopeVariable[] =>
       vars.map((v) => ({
-        scopeNodeName: v.scopeNodeName,
-        schemaPath: v.schemaPath,
+        scopeNodeName: cleanCyScope(v.scopeNodeName),
+        schemaPath: cleanCyScope(v.schemaPath),
       }));
 
+    // Helper to clean cyScope from all keys in a schema
+    const cleanSchemaKeys = (
+      schema: Record<string, string>,
+    ): Record<string, string> => {
+      return Object.entries(schema).reduce(
+        (acc, [key, value]) => {
+          acc[cleanCyScope(key)] = value;
+          return acc;
+        },
+        {} as Record<string, string>,
+      );
+    };
+
     // Helper to get function result for a given function name
     const getFunctionResult = (
       functionName?: string,
     ): SerializableFunctionResult => {
       return {
-        signature: this.getFunctionSignature({ functionName }) ?? {},
-        signatureWithUnknowns:
+        signature: cleanSchemaKeys(
+          this.getFunctionSignature({ functionName }) ?? {},
+        ),
+        signatureWithUnknowns: cleanSchemaKeys(
           this.getFunctionSignature({ functionName, fillInUnknowns: true }) ??
-          {},
-        returnValue: this.getReturnValue({ functionName }) ?? {},
-        returnValueWithUnknowns:
+            {},
+        ),
+        returnValue: cleanSchemaKeys(
+          this.getReturnValue({ functionName }) ?? {},
+        ),
+        returnValueWithUnknowns: cleanSchemaKeys(
           this.getReturnValue({ functionName, fillInUnknowns: true }) ?? {},
+        ),
         usageEquivalencies: Object.entries(
           this.getUsageEquivalencies(functionName) ?? {},
         ).reduce(
           (acc, [key, vars]) => {
-            acc[key] = toSerializableVariable(vars);
+            // Clean cyScope from the key as well as variable properties
+            acc[cleanCyScope(key)] = toSerializableVariable(vars);
             return acc;
           },
           {} as Record<string, SerializableScopeVariable[]>,
@@ -3433,7 +3925,8 @@ export class ScopeDataStructure {
           this.getSourceEquivalencies(functionName) ?? {},
         ).reduce(
           (acc, [key, vars]) => {
-            acc[key] = toSerializableVariable(vars);
+            // Clean cyScope from the key as well as variable properties
+            acc[cleanCyScope(key)] = toSerializableVariable(vars);
             return acc;
           },
           {} as Record<string, SerializableScopeVariable[]>,
@@ -3442,9 +3935,10 @@ export class ScopeDataStructure {
       };
     };
 
-    // Convert external function calls
+    // Convert external function calls - use getExternalFunctionCalls() which cleans cyScope
+    const cleanedExternalCalls = this.getExternalFunctionCalls();
     const externalFunctionCalls: SerializableFunctionCallInfo[] =
-      this.externalFunctionCalls.map((efc) => ({
+      cleanedExternalCalls.map((efc) => ({
         name: efc.name,
         callSignature: efc.callSignature,
         callScope: efc.callScope,
@@ -3452,20 +3946,24 @@ export class ScopeDataStructure {
         equivalencies: efc.equivalencies
           ? Object.entries(efc.equivalencies).reduce(
               (acc, [key, vars]) => {
-                acc[key] = toSerializableVariable(vars);
+                // Clean cyScope from the key as well as variable properties
+                acc[cleanCyScope(key)] = toSerializableVariable(vars);
                 return acc;
               },
               {} as Record<string, SerializableScopeVariable[]>,
             )
           : undefined,
+        allCallSignatures: efc.allCallSignatures,
+        receivingVariableNames: efc.receivingVariableNames,
+        callSignatureToVariable: efc.callSignatureToVariable,
       }));
 
     // Get root function result
     const rootFunction = getFunctionResult();
 
-    // Get results for each external function
+    // Get results for each external function (use cleaned calls for consistency)
     const functionResults: Record<string, SerializableFunctionResult> = {};
-    for (const efc of this.externalFunctionCalls) {
+    for (const efc of cleanedExternalCalls) {
       functionResults[efc.name] = getFunctionResult(efc.name);
     }