The beauty of our is that there is no need to export within the same file. It works lexically.

use strict;
use warnings;

package MyPackage; # temporarily step into MyPackage
our $globalVar;
package main;      # back to main

$globalVar = 42;

print $MyPackage::globalVar, "\n";
[download]

Ahhh interesting. I didn't know that one could step in & out of a package multiple times. Thanks

Yup - and you don't even need to do so at the "top level". package statements can appear within blocks. Like...

package main;
use strict;
use warnings;

{
  package Person;
  
  use Data::Dumper ();   # load, but import nothing!
  
  sub new {
    my $class = shift;
    bless {@_}, $class;
  }
  
  sub dump {
    my $self = shift;
  
    package Data::Dumper;
  
    # The following line is executed in Data::Dumper,
    # so it can see the "Dumper" sub defined there!
  
    print Dumper($self);
  }

  # We're back to the Person package here because
  # the closing brace ended the Data::Dumper package
  printf "Line %d is in package %s\n", __LINE__, __PACKAGE__;
}

# And now we're back to the main package.
printf "Line %d is in package %s\n", __LINE__, __PACKAGE__;

my $bob = Person->new(name => 'Robert');
$bob->dump;
[download]

use Moops; class Cow :rw { has name => (default => 'Ermintrude') }; say Cow->new->name

Thanks. I hadn't realized (and perhaps still don't fully understand) the difference between compile time vs. run time errors for variables and functions. But now that I think of it, I suppose this is consistent with the fact that variables need to be declared ahead of usage (if using strict) while function definitions can follow their usage.

Is there any analogy to the run-time "BEGIN" to tell the compiler to start (or branch elsewhere)?

Your original code seems to work as long as the scalar  $globalVar is exported using its correct name, i.e., using the  $ sigil.

c:\@Work\Perl\monks>perl -wMstrict -le
"MyPackage->import;
 print $::globalVar;
 $::globalVar=1;
 print $::globalVar;
 myfunction();
 BEGIN{
   package MyPackage;
   require Exporter;
   our @ISA = qw(Exporter);
   our @EXPORT = qw($globalVar myfunction);
   our $globalVar = 42;
   sub myfunction { print 'hi from ', __PACKAGE__; }
   }
"
42
1
hi from MyPackage
[download]

Cool. It does indeed work. But why does strict cause the compiler crap-out on $globalVar but accept $::globalVar. Isn't $globalVar (when not defined as a lexical variable) just a shortcut for the (main) package variable $::globalVar aka $main::globalVar? Or is the "shortcut" only known at runtime...

Isn't $globalVar (when not defined as a lexical variable) just a shortcut for the (main) package variable $::globalVar aka $main::globalVar?

It is a 'shortcut' only if you make the lexical declaration
    our $globalVar;
Then if the first access of the package variable  $globalVar is after the declaration, everybody's happy; otherwise, the variable name must be fully qualified. See our.

Because that is what you asked it to do with  use strict 'vars';