Debugging in "strict mode" while using external library assets

Question

Hi everyone. A new ActionScript-3 user here with a question on strict mode.
   I have multiple Flash pages which use the same art assets. To support modularity and possibly decrease total download time, I have implemented this by placing the shared assets into the library of a shared .swf file (the other .swf files all load this shared .swf file). The shared .swf contains ActionScript routines to place instances of the assets onto the stage and to perform other common functionality.
   A drawback to this strategy is that, correct me if I'm wrong, "strict mode" can not be used to debug calls to functions which exist in external .swf files. That is, if the parent .swf makes a call to a function which is defined within an externally loaded .swf, that function call will be reported as an error in strict-mode because Flash is unaware of the contents of an external .swf at compile time (though it is aware at run-time.)
   My understanding is that shared code can be compiled under strict-mode if the shared code exists purely as an external .as file, not as an external .swf file. However, again please correct me if I'm wrong, art assets which are shared at run-time must exist in an external .swf file. Therefore, by my understanding, if run-time shared assets are desired, then strict mode will not properly compile the projects.
   Is my understanding correct?
   Thanks for any help,
     - Rashid

Answer 1

      Posting an update.
      I have since found a way to compile in strict mode a project which loads an external .swf and acesses its functions. This external swf is able to have a library of its own which is accessed in the external swf's own ActionScript.
      Unfortunately, the solution I have found increases the size of the project's compiled swf. If anyone knows of a way to solve this problem without increasing swf size, I would be quite grateful if you were to share your knowledge.
      Posted below is the solution I am aware of, which increases file size. In these steps, “main project” refers to the top-level Flash project which is attempting to load other swf's. “External project” refers to an swf which is to be loaded by the main project.
1) Publish the external projects as swc files. “Swc” is a class file, and is to be accessed by the main project when debugging under strict mode. The .swc presumably contains information about external project's library items which are to be exported for ActionScript.
      To create an .swc file, head to “File->Publish Settings...->Flash”. Check the “Export SWC” box.
2) In the main project, add the external projects' .swc files to the external library path. This is found in, “File->Publish Settings...->Flash->Settings->External library path”. Either individual swc files can be added here (via the SWC file button) or the name of the directory where they reside (via the Path button). Both approaches should work.
3) Somewhere in the main project's ActionScript, the external project is likely being loaded via a line of code similar to myLoaderObject.load( myURLRequest ). For this new approach, it is now necessary to make use of the second parameter to load(), the loader context. Here's the new line of code:
myLoaderObject.load( myURLRequest, new LoaderContext( false, ApplicationDomain.currentDomain ) );
      If the LoaderContext parameter is NOT passed, then Flash unfortunately shall not report this as an error. Instead, you may observe strange behavior when the external swf attempts to use its exported library items.
4) If the main project's code refers to the external project's class by name, then that class will need to be “import”ed into the main project's code. Without this, the compiler will complain about not recognizing the class.
5) In the main project, edit  “File->Publish Settings...->Flash->Settings->Source path”.  Add the path to the external project's .as class file. Without this, the main project shall give a run-time error of not being able to find the external class.
   This final step, 5, is what increases the size of the main project's swf. I have a project with a few nested .swf loads, and the main project's swf increased by about 10Kb when using this solution.
      This does not seem proper. That is, one would desire the sizes of the final swf's to remain unchanged regardless of the level of compile-time error reporting. If my interpretation of an .swc class file is correct, then it seems logical to presume that step 5 above should not even be necessary, because the class information is given to the compiler/debugger through the .swc.
   Anyone know what I am doing wrong, or otherwise how to get around this problem?
   Thanks bunches.