►
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
And
last
time
we
met
Michael
fake,
presented
a
rewrite
that
was
specific
to
Jesse
for
rewriting
ACMA
script
modules
into
evaluable
scripts
and
packaging
them
together.
That
was
a
much
more
original
text
and
original
scoping,
preserving
rewrite
rewrite.
That
was
much
more
clearly,
not
introducing
accidental
semantic
changes,
and
it
got
me
thinking
about
doing
the
same
for
a
full
SES
with
some
restrictions
that
I
did
want
to
talk
about
I
hope
to
actually
have
to
have
something
to
present
on
that
by
today.
But
I
do
not.
C
D
A
Yes,
yes,
the
the
not
the
original
intent,
but
the
original
public,
meaning
now
a
different
set
of
distinctions,
but
just
just
to
say
a
little
bit
more
one.
At
Agora,
we've
been
testing
our
code
against
a
whole
variety
of
different
existing
packagers,
which
actually
relates
to
some
of
the
things
that
Cait
will
be
announcing
today.
A
C
A
A
E
E
Well,
the
rewrite
transformed
my
module
into
a
function
that
that
basically
uses
an
escape
approach
to
define
the
import
and
export
statements,
because
obviously
they're
not
top-level
anymore,
but
mafia.
So
this
is
a
simulated
runtime
module.
It's
it's!
It
tries
to
behave
like
ESM
modules.
Obviously,
I
didn't
think
of
all
the
edge.
You
know
edge
cases,
but
I
was
just
trying
to
avoid
writing
the
code
as
a
function
and
instrumenting
it
to
behave
like
a
module.
E
I
was
rather
doing
a
runtime
round
like
approach
for
a
module
scope
like
the
way
you
would
do
the
realms,
but
I
was
basically
simulating
a
module
scope
and
doing
all
the
bindings
functionally.
So
there
is
there
an
example.
You
can
point
it
yeah.
So
that's
my
experiment.
That's
I
showed
it
before
it's.
It's
hardly
descriptive.
Let
me
share
my
screen
so.
C
A
E
A
C
Yeah
I
mean
you
could
say
yes,
that
that
would
be
a
problem,
but
we're
not
prepared
to
do
something
about
that
problem
right
now,
as
opposed
to
we
that
that's
just
a
general
issue
with
lots
of
I
want
to
say
institutional
process,
but
organizations
where
we're
you
know
we're
just
simply
acknowledging
the
problem,
even
though
you're
not
going
to
do
something
about
it
could
be
clarifying,
but
for
various
defensive
reasons
they
don't
want
to
acknowledge
the
problem
either.
Yeah.
E
I
think
that
really
hits
the
nail
acknowledging
the
problem
and
telling
me
they
cannot
do
anything
about
it,
but
it's
a
problem
would
have
helped.
Maybe
keep
me
on,
but
many
times
they
just
say
that
no,
it's
not
a
problem,
and
then
they
give
you
like,
like
the
we're.
Just
you
know
thing
that
don't
really
help
so
so
this
is.
This
is
the
half
of
my
experiment
that
focused
about
using
a
proxy
to
shim
the
modules
code
and
basically
the
missing
part
here
was
the
rewrite
of
the
imports
and
exports.
E
That
was
the
dad
without
a
scope
that
was
a
scope
of
another
thing,
I'm
still
working
on,
but
but
for
experimental
purposes,
and
if
I
can
scroll,
yeah
I'm,
basically
giving
a
pre
function
wrapped,
you
know
representation
of
what
my
module
would
look
like
and
just
because
I
didn't
want
to
do
a
lot
of
work
that
is
out
of
scope.
I
use
template
strings
to
define
the
import
and
export
statements
because,
obviously,
if
they're
in
a
function,
they
would
not
even
reach
a
point
where
I
can
work
with
them.
You
know
it's
gonna,
be
this.
A
E
That's
that's
just
a
demo
that
uses
my
engine
that
would
that
would
shim
the
modules
as
human
that
at
some
point,
I
rewrote
the
modules
and
the
fermented
accepts.
So
that's
kind
of
like
my
specs
or
my
tests
and
I
use.
I
use
a
module
constructor
given
a
module
name
and
basically
a
a
proxy
of
what
the
module
would
have
done
and
then.
A
E
A
E
Here
there
are
zero
differences,
that's
my
canary
kind
of
test
that
tests
everything
except
for
the
bindings,
so
it
tests
the
global
scope
really
and
the
tests.
If
you
get
the
right
errors,
when
you
try
to
refer
to
things
as
if
it
was
a
module
scope,
so
if
I
get
the
right
behavior
of
the
code
as
if
it
was
it
at
a
module
before
I,
import
and
export,
that
tells
me
that
my
wiring
before
bindings
is
faithful.
It's
obviously
not
100%
faithful,
but
it
was
just
me
taking
a
step
in
exploring
it.
E
So
you
know
that
was
accomplished
as
far
as
I
can
you
know
get
to
that
level
of
the
experiment
and
after
compiling
it
evaluates-
and
you
know,
I
wrote
this
test
function
that
I
have
in
my
global
scope,
so
that
I
can
you
know,
get
the
output
nicely
aligned
in
a
transcript
that
I
can
verify.
You
know
when
I
stray
where
problems
occur
and
everything
and
you
would
get
the
behaviors
you
would
expect.
If
you
have
something
referring
to
an
undefined
variable
in
a
module
scope,
it
is
not
defined.
E
A
D
E
E
They
gave
my
global
scope.
I
basically
have
here
a
something
that
takes
the
global
scope
and
it
kind
of
creates
a
secondary
scope
with
allowing
me
to
make
certain
changes
to
some
of
the
global
variables
or
insert
new
ones
or
whatever.
Once
I
have
my
Global's
I
set
the
prototype
of
my
Global's
to
the
actual
global
scope,
so
my
proxy
is
the
Global's
and
the
prototype
of
which
is
the
actual
global
scope.
E
I
do
some
function
handling
to
trap
the
this
reference
to
the
actual
global
in
my
getter.
So
if
it's
a
function,
I
keep
a
local
proxy
to
the
function
unless
it
changes
and
then
I
make
a
new
one,
making
sure
that
if
the
proxy
is
called
on,
what
would
be
the
global
scope?
It
does
not
call
it
on
the
proxy,
but
it
calls
on
the
actual
global
scope.
Okay,.
A
Let
me
make
sure
I'm
understanding
this
is
the
proxy
I
see
that
the
produced
proxy
has
an
explicit,
get
trap
yeah.
This
is
anti
set
trap.
This
is
the
proxy
that
you
then
somewhere
else,
do
a
width
on
and
hope
you're
looking
at
valuates,
somehow
within
that
with
exactly
okay.
So,
let's
just
take.
Let's,
let's
talk
specifically
through
what
the
get
trap
does
in
the
two
examples
that
I'm
curious
about
one
where
you
have
just
an
undefined
variable
name
and
the
second
of
which,
where
you
have
type
up
the
same
undefined.
Okay,.
E
So
let
me
first
just
say
the
set
trap,
because
it's
easy
and
we'll
get
to
the
get
trap
that
this
set
basically
says
that
if
the
receiver
is
not
the
module
scope,
then
you
should
never
so
nothing
escapes
to
the
global
I.
You
know
I
might
have
changed
my
strategy
a
bit,
but
otherwise
in
sets
one
Operator.
E
Oh,
that's,
that's
a
ligature.
This
is
what
you
see
is
not
what
you
get.
What
you
get
is
literally
this
without
spaces
or
like
yeah.
So
if
I
do
this,
you
get
an
illusion
of
a
cool
not
equals
to
okay.
This
is
all
just
font.
Based,
like
a
you
know:
typography,
it's
very
cool
yeah.
So
ligatures
has
been
the
thing
you
know.
I.
Think
last
year
was
like
the
year
it
it
became.
You
know,
mainstream
because
of
chrome
and
vs
Cove
I.
Think
that's
terrible.
E
Yeah,
so
so
the
getter.
Now
that's
that's
the
interesting
part
up
to
here,
because
we're
not
dealing
with
functions
yet
right,
so
undefined
is
not
defined
in
the
scope
and
the
getter
will
do
the
following.
If
it's
my
Global's
return
is
from
my
Global's
without
escaping
to
the
you
know:
Perry
the
the
prototype
of
the
Global's,
which
is
the
global
okay.
D
E
Then
I
get
the
value
if
the
value
isn't
the
global
scope,
because
I
didn't
return
so
I'm
continuing
then
I.
All
I
need
us
to
check
the
global
scope
because
otherwise
it
wouldn't
exist.
Okay
and
then
I
type
of
property
is
a
string.
Then
we
get
it.
If
it's
not
a
string,
then
you're
doing
something
that
you
shouldn't.
Not.
The
width
is
not
you're
getting
to
this.
So
I
just
returned
on
the
point,
because
there
is
no
access
to
symbols
without
I.
E
A
E
Don't
have
a
has
trap
and
I
think
adding
the
hash
trap
is.
You
know
like
in
its
I've
played
around
with
the
hash
trap
and
it
always
returns.
False
and
I
didn't
want
that
behavior.
So
let
me
look
somewhere
else
if
I'm
not
getting
the
right
code
that
would
present
this
behavior,
because
no,
this
is
not
the
one
yeah.
So
you
know
we'll
have
to
untangle
a
lot
of
things
here.
Sorry
about
that.
B
A
So
also
Michael
fig
has
joined
us
Michael.
There
were
two
topics
that
we
suggested
to
talk
about.
One
is
kate
talking
about
the
new
0.5
release,
which
we
have
not
yet
done,
and
the
other
one
was
I
was
very
inspired
by
your
presentation
of
a
rewrite
fraud
for
Jesse,
from
Atma
script
modules
to
evaluable
scripts
and
packaged
them
all
evaluable
scripts.
A
So
I've
been
thinking
about
how
to
expand
on
that
or
do
something
like
that
for
full
SES
I
had
hoped
to
have
something
to
prepare
but
haven't
gotten
there,
and
it
was
from
that
second
observation
that
we
go
then
to
examining
the
rewriting
and
packaging.
That's
all
has
been
working
on.
Ok,
ok!
So
when
we
take
this
opportunity
to
switch
to
kids,
ok.
B
So
yeah
we
last
week
we
released
and
the
primary
takeaway
is
that
there
are
a
number
of
obstacles
that
were
stopping
people
from
actually
using
cess
in
normal
JavaScript
development.
So
if
you
have
bundlers
as
part
of
your
normal
workflow,
such
just
wasn't
working
for
various
reasons.
One
of
those
reasons
had
to
do
with
roams,
so
there
was
a
fix
that
was
put
into
realms,
but
specific,
there
was
a
not
to
go.
B
I
won't
go
too
far
into
depth
on
this,
but
there
was
a
check
to
see
whether
it
was
in
the
browser
or
whether
it
was
a
note
and
the
specific
case
of
a
bundler
that
may
shim.
Some
of
these
things
was
was
breaking
that
logic,
so
there
was
a
fix
put
into
realms,
which
is
now
integrated
into
this
fast
release.
B
B
So
to
ensure
that
none
of
those
have
strange
behavior
that
isn't
working
what's
that,
so
this
is
no
part
of
our
continuous
integration
process.
So,
every
time
that
we
put
out
that
we
actually
make
a
change
to
assess
that
goes
through
these
tests
and
the
tests
have
allowed
us
to
check
like
right
now
the
tests
only
run
in
chrome.
So
we
don't
have
full
coverage
over
all
the
different
browsers,
but
it
has
allowed
us
to
catch
that
chrome
had
a
simple
natural
addition
that
needed
to
be
white
listed
in
order
for
our
test
today,.
B
B
B
A
C
You
just
figure
out
a
pattern
for
semantics:
preserving
something
like
bundling.
You
could
probably
get
a
lot
of
the
bundlers
to
adopt
it.
If
you
could
just
I
think
a
lot
of
the
problems
that
have
been
flying
or
problems
because
well,
as
I
said
before,
they
may
not
even
be
aware
of
it,
but
also
it's
easy
to
ignore
problems
that
you
don't
know
what
to
do
about
them
anyway.
So.
B
B
Well,
like
I
presume,
it's
really
a
precise,
but
also
I'm,
not
quite
sure,
exactly
what
like
ESM
is
doing
so
I'm
kind
of
beat
imprecise
on
purpose,
but,
like
you
know
the
fact
that
they
rewrite
the
evil
portion
to
be
something
else.
I,
don't
really
know
why
they're
doing
that,
but
by
the
time
that
you
actually
by
the
time
that
we
stringify
it
we're
in
the
middle
of
the
process
that,
obviously
they
assume
will
continue
and
we're
kind
of
are.
B
C
C
C
You
know,
and
it's
and
it's
a
successful
strategy
for
a
lot
of
people,
because
if
they
just
ignore
the
problems,
they
know
how
to
don't
know
how
to
deal
with
and
just
bet
that
in
their
case
the
problem
won't
actually
come
up.
That's
often
a
pretty
good
bet,
I
think
there's
might
be
some
of
that
going
on
here.
A
C
Incompatibility
seriously,
if
you
can
present
them
the
solution
along
with
presenting
them
with
the
problem,
I
think
it'll
a
lot
easier.
Okay,
I.
A
Think
one
of
the
philosophical
differences
that
is,
that
they
are
trying
to
produce
a
they're
trying
to
take
the
opportunity
to
bundle
to
also
are
reduce
runtime
costs.
So
what
do
we
do?
Nope
analysis,
statically,
right
price
of
doing
that
is
doing
you
know,
manipulation
of
variable
names
in
order
to
create
less
scopes
and
to
do
more
static
linkage,
as
opposed
to
dynamic
linkage
for
us,
the
that
difference
in
efficiency
makes
no,
you
know,
makes
little
difference
for
our
purposes
and
the
semantics
preservation
is
much
much
higher
priority
right
and
so
Michael.
E
There
is
actually
a
secondary
thing
just
just
before
we
straight
about
the
runtime
thing.
Sorry,
what
they
try
to
preserve
is
is
the
errors
so
troubleshooting
wise.
They
want
their
end
users
to
get
errors
that
make
sense
to
them,
so
they
instrument
code
to
try
to
give
them
the
right.
The
right
traces,
okay,
that.
E
Yeah
well
true,
but
then
you
usually
get
an
error
that
does
not
meet
their.
You
know
crystal
ball
and
you're
left.
You
know
unable
to
really
know
what
happens
until
you
actually
figure
out
how
they're
bundler
works,
but
you
know
by
by
breaking
things
so
much
to
try
to
give
you
a
coherent
error
message.
You
oftentimes
have
a
serious
error
when
it
doesn't
fit
that
a
predictive
strategy.
A
So
a
solid
just
going
back
to
what
you
were
just
showing
us
I
do
have
I
think
one
high-level
question:
you're,
because
you
don't
have
it.
You
said
you
don't
have
a
hash
trap
and
therefore
you
get
them
the
default
has
behavior
on
the
default.
Has
behavior
would
be
that
if
it's
not
defined
on
your
with
object,
yeah
the
object
you're
doing
with
on
I
need
approximately.
If
it's
not
the
fight
there,
then
your
has
then
the
default
has
trap
will
return
false.
A
A
E
E
What
I
do
with
object?
Not
document
and
I,
know
I'm
playing
it
close
to
the
best,
but
it
exists
in
I,
say,
object
and
then
I
set
it
to
undefined
and
I
expected
to
be
on
the
point
and
then
I
set
it
back
to
object,
and
it
gives
me
a
reference
error
object
is
not
the
fine
and
I
think
that
has
to
do
with
assigning
to
it
a
behavior
that
I
thought
I
fixed
at
some
point.
So
let's
see
I.
A
D
A
A
E
E
A
E
So
here
I
tried
that
test
when
I
said,
if
document
is
maybe
I'm
actually
not
getting
an
up-to-date
module
here,
cuz
document
yeah,
so
it
seems
that
it's
escapes
my
scope
unless
I'm
actually
running
code.
That
is
not
behaving
as
expected.
You
know
what
I
I
can't
trust
the
changes
I
did
to
the
module
itself
here.
So,
let's,
let's
not
yet
get
too
deep
into
experimenting
life
and
distracting
out
of
the
original
topic.
Okay,.
A
D
E
A
E
Like
I
have
a
global
that
inherits
from
the
global
scope
and
and
as
such
a
proxy
out
that
will
the
prototype
chain
directly
to
the
global.
That's
that's
what
I
was
trying
to
say
so
here,
even
when
I
say
return,
Falls
for
a
document,
it's
it's
moving
to
the
global
scope
and
getting
document
from
there,
because
the
proxy
is
saying
it
doesn't
have
it
and
it
doesn't
even
hit
the
get
trap
for
it.
So
that's
what's
been
happening
really:
okay,.
D
D
A
D
E
A
E
E
B
D
D
D
D
E
It's
a
very,
very
tricky
thing,
so
yep
on
date,
cyclical
references
with
this
pattern.
I,
you
know
this
is
the
only
pattern
that
people
use
by
the
way
without
bindings,
you
don't
get
a
cyclical
behavior
and
that
that's
basically
the
only
issue
that
stands
in
allowing
commonjs
to
have
first-class
interaction
with
ESM.
Okay,.
D
D
A
E
Do
cyclic
imports?
There
is
just
the
concern
of
causality
here
just
because
defaults
don't
result
in
binding
like
behavior
that
can
potentially
have
cyclical
references.
It
is
not
the
cause
of
the
problem
with
cyclical
references
here.
The
problem
with
cyclical
references
here
is
crossing
the
sink
acing
boundary
by
having
a
promised
in
the
middle
of
that
chain,
you're,
basically
deferring
synchronous
code
from
continuing
until
the
promise
results
and
if
the
cyclical
reference
occurs
because
of
the
promise-
and
it
cannot
refer
to
the
result
of
the
promise
on
throw
the
promise
resolves.
D
A
And
and
because
Jessie
modules
are
pair,
you
can
get
away
with
that
and
still
say
it's
a
subset
of
the
ESM
semantics,
whereas
for
full
SES,
because
we
have
resource
modules
that
can
be
stateful
in
which
are
sensitive
to
order
of
execution.
I
think
we
are
not
use
this
as
the
underlying
mechanism
because,
because
they
won't
be,
it
won't
be
semantics:
preserving
for
stateful
modules.
Yes,.
E
There's
a
secondary
aspect,
though
I'm
not
sure
Michael.
Can
you
elaborate
if
all
loads
of
a
graph
have
to
finish
before
any
evaluation
of
any
member
of
the
graph
can
actually
occur?
So
this
is
a
static,
static,
binding
related
artifact,
where
if,
if
one
of
your
modules
is
an
error
as
an
it
cannot
be
loaded,
then
the
entire
graph
never
evaluates.
Is
that
behavior
present
here
or
will
some
code
evaluate
and
then
the
graph
interrupts
Midway,
because
some
fetch
failed
only
after
he
evaluated
a
bit
of
your
code.
D
E
Real-Life
side
effects,
like
a
program
that
never
finishes,
has
done
something
that's
something
being
unpredictable
and
in
crete
is
the
problem
with
that
pattern.
So
if
a
father
there
is
no
side
effects
level
no
I
mean
in
real
life.
Any
program
makes
a
side
effect
and
that
that's
where
the
program
this.
D
E
D
E
E
D
D
E
A
So
one
thing
I
was
thinking
about
in
order
to
have
a
translation
for
full
SES
is,
first
of
all,
one
of
the
restrictions
that
Michael
was
making
for
Jesse.
You
can
think
of
it
as
a
restriction
imposed
by
the
rewrite
as
a
shim.
That
would
not
be
a
restriction
in
the
full
Jessie
language
as
specified.
Is
that
this
pattern
of
introduced
variable
names
like
dollar
h,
underbar,
define,
if
I
understand
correctly
you're,
basically
reserving
the
namespace
of
all
variable
names
named
dollar
identifiers
characters,
underbar
identifiers
characters
is
that
about
right,
I,
just.
A
D
A
E
More
one
more
thing
on
that
sorry,
I
and
I
actually
want
to
ask
you
mark.
Do
you
know
if
all
JavaScript
runtimes
support
the
Unicode
escape
notation
like
do
all
do
all
places
where
Jesse
and
and
say
Bakula
script
will
be
running
I?
Do
they
all
support
with
Unicode
escapes
as
part
of
variable
declarations,
because
I've
gotten
to
a
point
where
to
avoid
accidental
things,
I
use
combining
graph,
Emmys
or
glyphs
that
are
a
considered
valid
echo
script
identifier,
you
know
it
just
makes
it
that
you
wouldn't
reasonably
clash
with
a
reasonably
named
variable.
E
A
A
Presumably
that
means
that
they
would
also
shed
the
part
that
classifies
non-ascii
characters
into
identifiers
versus
non
identifier
characters,
but
I
don't
know.
The
other
thing
is
that
the
representation
Eckman
script
strings
is
utf-16.
The
XS
uses
utf-8.
So
so,
therefore,
anything
about
the
encoding
of
echo
script,
that's
specific
to
UT
x16
such
as
representing.
A
The
the
large
characters,
the
characters
that
are
bigger
than
16
bits
in
ACMA
script.
You
write
them
with
their
utf-16
encoding
as
a
pair
of
utf-16
surrogate
characters,
yeah,
that's
not
in
excess,
other
XS
I
believe
everybody
does.
The
full
unicode
has
specified,
including
the
use
of
escapes
inside
a
debt
inside
variable
names,
so.
A
E
It's
yeah
the
zero
width,
Joyner
I,
think
or
none
Joyner
in
active
script
that
I
think
is
sometimes
fee.
That
is
a
kind
of
like
a
whitespace
character.
But
but
let
me
maybe
say
the
thing
that
was
recently
added
to
the
JSON
subset
or
from
the
JSON
subset,
which
is
the
paragraph
and
line
separator
I'm
just
checking
the
numbers
for
those
yeah.
A
D
A
In
any
case,
so
I
know
that
ink
in
the
SES,
the
old
SES
in
kaha,
where
I
scanned
the
source
text
for
all
identifiers
for
all
for
all
possible
variable
names
that
I
had
logic
to
deal
with
Unicode
escapes
and
variable
names,
but
I,
don't
remember
what
that
logic
is
I.
Remember
that
I
we
had
to
think
about
it
very
carefully
to
know
that
it
was
safe.
A
A
A
C
E
That
it's
literal
string
that
avoids
the
pitfall
of
double
byte
encoding,
that
is,
platform
dependent,
sometimes,
and
it's
not
always
adhering
and-
and
they
literally
include
the
character.
The
slash
you
and
the
four
digits
to
tell
the
the
parser
to
consider
this
as
an
escape
sequence
that
that
refers
to
a
single
character
of
the
particular
UTF
code.
C
E
A
Okay,
we'll
see
you
trip
all
righty
okay,
so
returning
out
of
Unicode
I
mean
clearly
anything
we're
doing.
Processing
the
source
text
has
to
make
sure
that
it's
made
safe
in
the
presence
of
allowed
Unicode.
One
of
the
ways
to
say
stay
safe
is
to
just
say
that
in
the
subset
were
that
that
our
show
accepts
we're
just
going
to
reject
anything
that
we
can't
do
that.
We
can't
easily
deal
with
safely,
but
going
back
to
the
restrictions
compared
to
the
one.
E
D
E
E
Rabbit
hauled
rabbit,
oh
let's
stay
out
of
examples
here,
but
like
I
I
would
export
estate
at
a
status
of
my
of
my
module,
for
instance,
and
then
that
status
changes
after
something
some,
you
know
whatever
depend
that
occurs.
Maybe
a
counter,
so
I
can
export
a
counter
of
how
many
times
a
function
was
called
and
I
update
that
counter
Wow
right,
so
so
that
let
count
is
significant
for
debugging,
behavior
and
I.
Don't
necessarily
mind
of
other
people
can
have
read-only
access
to
it.
It's
a.
D
A
Okay,
so
my
my
my
my
plan
just
got
killed
on
that
I
was
planning
to
I
was
I
was
about
to
suggest
that
SES
as
implemented
by
the
Shem
different
from
SCSS
specified
by
rejecting
any
programs
that
have
an
assignment
to
an
exported
variable
and
I
was
about
to
suggest
that,
under
the
assumption
that
nobody
actually
does
that
in
practice
and
that
are
really
wrong.
Yeah.
E
A
E
No
like
what
I
was
trying
to
say
is
that
my
bundler
experiment
that
preceded
me
doing
the
live
bindings
manually
and
in
a
width
in
a
width
proxy
that
that
one
used
a
pattern.
Initially,
data
URLs
in
the
browsers
and
all
I
did
was
I.
Did
there
we
re
linking
against
the
URLs
which
doesn't
work
for
cyclic,
but
then
I
used
the
serviceworker
or
in
nodejs
I
created
virtual
modules
using
the
VM
module
and
those
were
basically
the
source
text
of
the
of
the
actual
modules
executing
as
real
modules.
A
E
Have
a
real
atmosphere
modules.
Yes,
that
was
my
initial
experiment:
ok,
and
with
service
workers,
you
could
inject
module
code
as
into
a
cache
and
return
that
when
it's
being
fetched,
so
you
would
do
your
linking
by
returning
a
response
with
the
module
source
and
and
that
that
means
when
it's
evaluated
in
decline,
it's
like
the
real
module,
but
it
came
down
as
one
one
concatenated
file
and
the
runtime
behavior
is
a
hundred
percent
ESM,
because
it's
a
hundred
percent
ESM.
A
Does
not
depend
on
a
just
on
a
user
written
JavaScript
compiler
being
correct
in
order
to
assure
in
order
to
ensure
that
potentially
malicious
code
is
properly
confined.
Now
it
does
rely.
Obviously,
on
a
you
know,
anytime,
you
have
a
parser
and
rewriter.
It
does
rely
on
the
correctness
of
the
parser
and
rewriter
to
preserve
the
meaning
of
code,
for
which
my
security
depends
on
my
own
code.
E
That
was
exactly
what
I
was
going
for
with
that
with
the
initial
idea,
and
it
was
only
because
there
was
no
predictable
similarity.
Iii
have
a
shim
that
allowed
me
to
run
the
same
code
in
node
and
in
in
the
web
browser
and
it
loaded
modules
from
strings
of
the
source
text.
Ie
I
could
have
one
file.
That
is
a
bundle
that
says
in
this
a
particular
entry
point.
The
source
text
of
the
module
is
X
and
at
runtime.
A
But
but
the
the
module-
that's
parsed
by
the
runtime,
yes
might
assuming
you
do
not
have
a
accurate
user
level,
parser
and
you're
handing
module
text
that
you
can
therefore
not
accurately
examine
ahead
of
time.
Your
go
ahead:
the
runtime
execution
engine.
How
do
you
prevent
that
module
text
from
accessing?
Let's
say
in
the
browser
accessing
the
real
document?
Okay,.
E
So
those
are
I
think
separate
concerns,
so
my
bundle
can
add
a
little
bit
of
trust
by
it,
saying
that
I'll
get
the
bundle,
but
I
already
know
what
the
SA
you
know,
whatever
what
what
the
hash
will
be
for
the
module
that
I'm
going
to
be
evaluating
from
this
bundle.
I
have
all
the
hashes
and
if
the
text
appears
not
to
match,
then
I'm
going
to
say
that
this
bundle
is
not
trusted,
so
I
can
throw
because
the
source
seems
not
to
reflect
what
it
should
have
been.
Okay,
so.
E
If
you
pre
validate
code
in
order
for
you
to
get
a
hash
trigger
a
how
well
like
the
TOEFL
tool,
saves
the
SH
like
the
in
code
like
I,
don't
know
what
the
word
is.
The
hashing
of
the
module
source
text
is
saved,
and
that
says
that,
eventually,
when
I
get
this
source
text,
in
my
run
time,
I
know
what
it
should
compute
to
and
if
that
source
tax
changed
from
the
point
where,
where
I
said
it
was
trustworthy,
but.
A
E
Initially,
when
I
created
the
the
you
know
the
trust
hashes
of
the
source
code.
I
did
this
in
you
know
not
at
runtime.
I
did
this
at
the
point
of
compiling
this
bundle
and
I
saved
those
hashes
at
runtime.
The
runtime
just
has
to
know
that
the
code
is
faithful
to
the
point
you
know
to
what
it
was
at
the
point
where
I
could
do
a
full
analysis
of
it.
Okay,.
E
E
That
is
one
layer.
The
second
layer
is
in
the
experiment
that
I
was
screen.
Sharing
was
if
I,
create,
proxies
and
use
those
proxies
to
enforce
security,
but
I
wasn't
enforcing
security.
Yet
right
I
was
just
shimming,
the
behavior
of
the
module
scope,
but
in
that
proxy
you
could.
You
know
separate
from
the
fact
that
your
source
is
trusted
or
not
by
deferring
validate
into
tooling
okay.
A
E
Aside
from
simulating
that
references
to
arguments
inside
this
eval
would
be
an
error,
the
use
strict
on
the
function
almost
entirely.
Obviously,
without
the
export
and
import
static
declarations,
it
behaves
like
a
module
scope
aside
from
bindings
and
and
and
the
degree
of
separation
from
the
global
scope.
Okay,.
A
A
But
but
just
I
want
to
verify
that
we
that
we
came
to
a
mutual
understanding
here,
given
that
we're
trying
to
be
safe
against
code,
we
have
not
parsed,
including
including
modules
we
have
not
parsed
and
we
want
to
prevent
them
from
having
access.
We
didn't
authorize
that,
if
we're
going
to
have
a
minimally-invasive
translation
of
those
modules
so
that
we
can
run
them
safely,
then
there
is
no
minimally-invasive
translation
where
we
get
to
run
them
directly
as
a
module.
A
E
So
it's
a
really
good
way.
You
distilled
it,
but
here
you
know
all
of
a
sudden
I'm
reminded
of
a
year
ago,
when
I
joined
the
modules
team,
that
I
was
the
only
one
fighting
to
ensure
that
you
can
create
a
virtual
module
from
source
text
and
habit
act
as
if
it
it
comes
from
a
particular
path
on
your
in
your
module
map.
I
wanted
just
as
I
could
use
the
caches
and
serviceworker
to
actually
execute
my
unbundled
modules
from
a
concatenated
string,
as
in
I
put
them
in
the
cache
and
I.
E
The
client
is
unaware
from
the
fact
that
came
from
a
string
that
that
that
was
a
possible
case
in
the
browser
and
I
was
a
year
ago,
and
I
still
am
until
now
fighting
to
ensure
that
there
will
always
be
a
way
to
do
this.
A
note
so
so
yes,
without
having
real,
full-fledged
ESM
virtual
modules,
browsers
have
them
node
should
have
them
things
go
as
planned,
but
without
them.
Yes,
there's
definitely
no
way.
You
can
evaluate
ESM
modules
as
first-class
code.
E
E
Mean
you
know
my
experiment
was
for
me
to
learn
more
about
the
findings,
but
it
would
like
we
can.
We
can
clean
up
my
experiment
a
bit
if
you
want
me
to
do
that
and
just
show
that
if
you
use
with-
and
you
do
bind
things
we're
actually
binding,
you
know
I
I,
simply
use
an
error
function
to
define
a
binding
from
the
scope
and
that's
my
getter
and.
A
A
I
was
thinking
that
all
of
the
modules
that
are
conceptually
executing
within
the
same
compartment
could
be
packaged
like
Michaels
packaging,
where
the
entire
thing
was
one
evaluable
string,
where
each
module
within
that
evaluable
string
was
a
separate
function
rather
than
having
the
each
module
itself
be
a
separate,
valuable
string.
Because,
because,
since
the
since.
A
The
the
AMD
like
rewrite.
That
Michael
showed
gives
each
module
its
own
set
of
important
of
imports
because
they
turn
into
function
parameters.
But
in
order
to
give
each
module
its
own
set
of
bound
Y
findings,
which
the
text
inside
the
function
body
can
use.
Simply
by
using
a
variable
name.
I
would
have
to
make
I
would
have
to
have
the
packaging.
Have
each
module
be
represented
in
the
packaging
as
a
separate
literal
string.
That
has
to
be
separately
evaluated
at
runtime
that
that.
A
D
A
Right
you.
E
E
It's
not
like
people
write
that
style
of
code
every
day,
so
I'm
just
going
to
say
that
if
you
write
a
bundler
that
handles
SES
edge
cases
and
people
use
it
with
cases
that
are
not
edge,
cases
for
normal
bind
and
bundlers,
you
will
end
up
with
someone
who
is
really
getting
a
bad
day
every
day.
Well,.
A
It
depends
how
much
additional
pain
were
imposing
for
the
education
and
when
I
was
hoping
for
is
something
that
correct
I
mean
in
general.
What
we're
trying.
What
we
try
to
achieve
is
something
that
remains
correct
on
the
edge
cases,
without
imposing
significant
extra
expense
for
the
normal
cases,
and
usually
we
achieve
that.
I'm.
D
What
I'd
like
to
add
is
that
in
this,
in
this
particular
case
of
importing
live
bindings,
we
have
one
rule
which
is
the
import
can
only
be
at
the
module
level
scope,
so
it
needs
to
be
at
the
module
level,
which
is
all
your
party
is
doing,
is
intercepting
things
that
hit
the
module
level.
Well,
import
can
only
be
a
pure
name.
It
cannot
be
anything,
that's
a
data
structure
or
function
valid
or
otherwise.
I'm.
E
A
hundred
percent
with
with
you
guys
that
it's
possible
to
do
the
rewrite
and
it's
a
valid
exercise,
that
it
has
a
lot
of
Merit
but
I
I,
think
what
I?
What
I
haven't
said
so
far
is
that
I've
been
I've
been
keen
on
this
idea
of
reflective
modules
like
reflect
dot
dot.
You
know
create
module
like
this
is
what
what
the
pop
culture
says.
It
is
I
think
that
ACMA
scrip.
E
You
know
something
that
I
can
do
like.
I
can
write
in
my
code:
new
module,
here's,
the
URL
and
here's
the
source
text,
and
it
should
actually
become
a
a
real
module
in
the
Montello
man.
Doing
it
the
right
way,
though
I'm
very
sloppy,
and
how
on
the
screen
discussing
this,
but
all
the
headache
of
bundling,
existed
for
a
language
that
did
not
have
a
module
format
that
makes
sense.
But
since
now
there
is
a
module
format,
a
bundler
should
use
the
is
of
the
module
format
of
that
made
in
are
native
to
that
language.
E
E
E
E
Already
eliminated,
the
you've
already
put
a
restriction
on
at
least
one
variable
now
being
allowed
in
your
module
text
that
object
from
which
you're
accessing
property
names
as
humans
called
module
or
module
scope.
That
word
that
that
identifier
has
become
a
resort
identifier
in
any
bundled
code.
Right.
A
E
Somehow
a
this
reference
returning
the
exports
object
where
it
is
not
expected
and-
and
that
becomes
you
can
reflectively
inspect
something
that
does
not
exist
in
the
original
code,
so
you're
gonna
have
to
simulate
some
type
of
you
cannot
do
that.
That's
why
SM
the
J
dolphins,
yes,
I'm,
a
node!
That's
why
it
instruments
variables
for
every
single
module
scope
so
that
you
can
throw
an
error
when
you
try
to
access
a
variable
that
exists
in
a
module
scope.
That
is
not
the
model
scope
where
it
is
being
evaluated
directly.
A
So,
in
the
case,
it
sounds
like
the
the
particular
prohibition
that
the
SM
is
trying
to
do.
There
is
because
they're
merging
scopes
across
multiple
original
module
texts,
whereas
the
really
nice
thing
about
the
a
and
B
pattern
is
that
every
module
searchtext
executes
in
a
different
scope.
They
have
yet
essentially
the
same
scope.
Separation
between
modules
as
bundled
as
you
had
original.
E
Yes,
but
but
the
case
they
I
think.
The
reason
why
you
end
up
with
with
additional
instrumentation
is
not
because
your
your
design
will
anticipate
it
leakage
of
a
variable
in
a
place
where
it
shouldn't
be.
So
you
need
to
know
I
think
what
happens
is
when
a
user
reports
an
edge
case
you
start
to
put
in
guards
and
those
guards
keep
growing.
Could
you
show
me
an
example
of
a.
A
E
A
A
E
E
E
A
So
actually
so
the
case
that
cake
was
mentioning
before
actually
does
explain
why
the
rewrite
we
were
just
talking
about
would
be
unpleasantly
and
invasive.
Let's
say
that,
there's
a
lexical
reference
to
the
variable
foo
that
inside
a
module
where
foo
was
imported
as
a
wide
binding
from
another
module
mm-hmm,
and
this
this
use
occurrence
of
foo
is
inside
function
where
we
then
elsewhere
use
function,
prototype
to
string
to
get
the
string
applied
form
of
that
function
in
order
to
send
that
string
elsewhere
to
be
evaluated.
Yes,
the
rewrite.
A
However,
rewriting
usage
occurrences
of
variables
can
and
does
appear
inside
function,
bodies
and
rewriting.
That
means
that
when
you
then
evaluate
the
function
elsewhere,
the
rewrite
of
the
use
occurrence
of
the
variable
now
disrupts
its
meaning.
If
you
you,
should
you
should
have
if
you,
if
you
said
through
inside
the
function,
you
should
have
been
able
to
evaluate
that
function,
source
text
elsewhere,
if
you
were
providing
it
with
a
binding
for
foo,
and
now
that
won't
mean,
like
you
thought
it
meant.
Yeah.
D
E
A
good
point,
so
so
that's
what
I
tried
to
preserve,
with,
with
my
module
experiment,
its
I
actually
called
this
ESX
and
I
was
gonna.
You
know
make
my
next
big
package
I,
never
finished
and
and
tell
people
that
we
needed
module
formats
other
than
the
SM
before
ESM.
This
is
the
first
module
format
that
actually
comes
after
year
SEM,
and
the
idea
was
that
it
would
translate
your
code
to
retain
the
semantics
and
use
the
exact
shim
and
and
and
do
bindings
so
that
you
don't
end
up
exactly
with
this
kind
of.
E
Theoretically,
obviously
it's
it's
fake
ASM
that
looks
like
us
em
into
a
module
loader
that
it
itself
has
been
bundled
as
all
module
formats
and
preserved
retained,
its
behavior,
regardless
of
which
bundling
method
was
used
and
in
the
browser
and
unknown
okay.
But
obviously
a
lot
of
work
goes
to
making
this
actually.
A
workable
thing,
like
all
I
did,
was
prove
to
myself
that
it's
possible.
A
D
E
Yeah
I
the
live,
binding,
naturally
does
and
and
I
still
have.
You
know
a
lot
of
work
on
that
part,
but
but
the
compiler
ie,
given
source
text,
give
me
a
function
that
will
evaluate
the
multiple
it
has
has
no
clue
what
imports
mean
it's
it's
clueless.
It
just
knows
that
those
variables
will
be
in
it
endoscope,
given
the
wiring.
That
will
happen.
A
A
Having
the
bundler
represent,
each
module
source
text
has
a
separate,
translated,
literal
string
rat.
That
is,
that
that
is
intended
to
be
executed
from
within
the
with
on
a
proc
city,
so
that
the
so
that,
in
the
absence
of
better
information,
all
of
the
imported
variables
are
provided
by
the
proxy
so
that
they
can
be
live
and
but
and
doing
that
also
gives
me
everything.
I
need
in
order
to
deal
with
cycles
on,
and
this
is
a
much
more
expensive
bundling
than
I
was
hoping
for,
but
I
can
preserve
all
the
semantics
that.
A
E
A
The
dollar
age
underbar
would
be
lexical
variables
inserted
into
the
translation.
You
know
into
the
translation
of
import
and
export.
So,
for
example,
if
I
was
importing,
you
import,
open,
curly,
foo,
comma
bar
close
curly
from
specifier
string
that
that
source
text
does
not
name
the
exports
object
that
I
got
from
that
module.
A
E
So
so,
but
but
there's
there's
a
thing
here,
though,
we're
used
to
the
module
dot,
exports
pattern
of
comma
J
s
being
an
object
for
which,
if
I
put
something
on
it,
it
becomes
an
export.
But
if
you're,
if
you're,
semantically
mimicking
ESM,
then
your
exports
should
not
be
a
thing
that
you
can
address.
It
should
be
a
thing
that
expects
you
to
call
off
right.
A
Right
right,
right,
no
you're
cool
you're,
completely
right
in
order
to
emulate
ESM.
Okay.
So
let
me
let
me
let
me
talk
this
out
yeah.
This
is
based
on
this
is
inspired
by
just
to
make
sure
to
make
it
clear
that
it's
not
trying
to
be
literally
based
on
inspired
by
the
JavaScript
API
for
a
wasm
module.
A
So
the
translation
of
an
atmospheric
module
into
okay
since
I
have
to
have
a
separate
strain
per
thing.
I
might
as
well
just
translate
the
modules
separately
and
then
the
packaging
is
basically
just
concatenated
together
those
separate
packaging's,
so
each
Atma
script
module
would
be
translated
into
a
an
object
literal,
one
of
whose
members
was
let's
say,
SRC,
whose
value
was
the
translated
source
and
then
the
other
members
of
the
object.
A
Exports
live
binding
food
module,
B
imports
live
binding,
foo
in
both
cases
under
the
variable
name,
foo
the
both
at
well
yeah.
Let
let
just
take
this
example,
even
though
maybe
it's
a
little
bit
too
simple,
there
is
a
separate
proxy
made
for
a
and
made
for
B
the
proxy
made
for
a
honours,
both
a
get
and
a
set
to
the
name
food
by
upgrade
by
by
by
updating
some
internally
maintained
state.
A
That's
the
current
value
of
the
proxy
for
B
would
also
honor
a
get
on
the
name
foo,
but
not
a
set
on
the
name
film,
and
when
there
was
a
get
on
the
name
through
the
proxy.
The
proxy
for
B
would
know
to
consult
the
a
state
maintained
by
the
proxy
for
a
in
order
to
provide
the
current
value
for
fit
I'm.
E
Sorry
that
complicates
it
a
little
it's
it's,
semantically,
correct,
okay,
so
so
I
found
that
bindings
are
literally
an
arrow
function
that
you
create
in
the
scope.
So
I
passed
that
as
the
getter
that
gets
installed
on
the
particular
proxy
of
the
importer
for
whatever
name
that
importer
is,
it
will
import
this
g1
and
that
Gator
is
the
one
function
that
actually
becomes
the
actual
Gator
across
the
modules
when
I
when
I
export
an
alias
I.
Just
you
know,
III
used
the
two
string
method
to
see
the
first
identifier
that
occurs
in
this
exporter.
E
A
Okay,
okay,
let
me
see,
let
me
I
liked
the
idea
of
using
together
the
getter
is
a
function
that
you
would
evaluate
within
the
scope
of
the
width
on
the
proxy
set
up.
Yes,
that
scope
wait
a
second
there's,
there's
a
circularity
problem:
I,
don't
know
how
to
break
there.
Well,
if
the
getter
is
evaluated
in
the
scope,
then.
E
It's
not
evaluated
in
the
scope.
The
getter
is
is
the
function
is
is,
is
it
is
the
expression
the
error
expression
refers
to
the
variable
being
exported.
It
is
being
defined
at
some
point
in
the
same
scope,
but
as
soon
as
as
the
export
is
done
and
I'm
using
a
generator
here
and
because,
theoretically,
I
could
for
cyclical
I
would
just
say,
yield
exports
once
that
reference
to
the
variable
occurs.
E
D
E
E
E
E
E
So
the
fact
that
the
module
was
constructed
regard
it
respect
about
the
fact
that
they
are
of
string
initially
in
the
module,
but
they
just
hinted
to
the
module
constructor
to
resolve
this
specifier
and
to
make
sure
that
there
is
a
variable
in
the
scope
called
exactly
that
and
that
variable
is
initialized
by
a
getter.
That
looks
something
like
that
from
that
result:
scope
when
it
evaluates.
E
E
E
E
E
A
E
Actually
converts
this
to
a
string
and
looks
for
the
first
identifier
if
I
want
to
export
something
as
I
just
changed,
the
parentheses
with
the
as
part.
So
when
I
write
the
you
know,
the
exports
are
here
and
in
this
string
it's
a
little
bit
ugly
to
see
all
of
my
exports
here
are
one
to
one.
There
aren't
any
as
renames.
A
E
I
haven't
exercised
something
I
cleverly
solved.
That's
weird.
Sorry
I
usually
like
to
solve
a
problem,
so
I
can
play
with
it,
but
I
didn't
so
no,
this
doesn't
export
in
direct
exports.
Maybe
here
we
go
so
export,
g1
has
and
again
I
didn't
know.
This
is
not
right.
This
one.
Oh
sorry,
housing
export
yeah.
So
here
it
says,
export
g2
as
dollars.
Good.
D
E
E
A
B
E
A
E
I
I
did
have
the
one
question
and
I
just
don't
know
what
to
do
about
it.
I
have
to
calendar
listings.
Does
anybody
have
that
as
well?
You.
A
Know
yeah.
The
reason
is
that
I
moved
that
to
Tuesday
one
to
Thursday,
I
want
to
concede
to
consolidate
them
right
now.
They
have
overlap
largely
overlapping
in
the
Indy
key
lists.
So
I
need
to
consolidate
that
the
one
thing
that
used
to
be
on
Tuesday
is
owned
by
me,
so
I.
The
thing
that
used
to
be
that
was
continues
to
be
Thursday
that
was
on
Thursday,
is
owned
by
curry,
so
I
need
coordinating
with
kriti
to
consolidate
those
two
one
calendar
entry.
So
sorry
about
that,
no.
B
B
E
For
yarn,
when
there
is
a
new
release,
because
yarn
yarn
releases
we're
going
unnoticed,
you're
actually
lets,
you
know
that
you're
in
now
has
an
update.
If
you
want
to
install
it
and
they
don't
do
it
in
an
invasive
way,
it's
not
like
every
time
you
run
run
yarn.
It's
going
to
keep
bugging
you
until
you
update.
So,
but
how
do
they,
like?
You
know,
I'm
the
command
line?
They
just
say.
Oh
by
the
way,
you
know
don't
forget,
there's
an
update,
and
you
can
run
this
command
right
here
and
give
me
the
update.
B
E
A
E
A
E
A
A
That
was
a
heart
that
was,
you
know
difficult
requirement
to
meet
I'm,
not
saying
we
knew
how
to
meet
it,
but
we
considered
an
absolute
requirement
and
the
current
web,
where
the
the
site's
serving
the
document
you're
reading,
cannot
only
know
what
documents
you're
reading
that
can
know
where
you
scroll
to
and
how
you're
moving
your
mouse
over
it.
It
just
astonishes
me
that
people
are
willing
to
read
under
those
conditions,
yeah.