►
From YouTube: SES-mtg: Packages as units of module encapsulation
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
A
So
specifically,
I
think
what
solid
it
communicated
earlier
as
something
like
the
same
origin
policy,
but
for
packages.
I
think
I
understand
a
bit
differently
now
that
if
our
module
maps
can
only
or
a
given
scope
like
whether
it's
a
package
prefix
or
an
at
symbol,
prefix
or
some
prefix,
the
module
map
should
only
be
able
to
rewrite
references
to
other
prefixes.
Rather
than
rewrite
things
within
that
prefix.
A
So
the
main
idea
is
that,
if,
if
a
package
has
sub
components
like
sub
modules
that
are
all
part
of
that
package,
they
would
all
I
under
the
same
prefix.
So
a
Tagore,
for
example,
would
be
one
of
these
prefixes
and
what
Saleh
was
explaining
is
that,
before
the
idea
of
modules,
we
have
bundles
right.
A
It's,
although
this
isn't
really
a
resource
module,
it's
how
do
I
explain
it.
It's
not
it's!
It's
that
most
packages
cannot
be
resource
modulus
in
a
sense
they
may
contain
Global's
and
references
to
other
packages,
but
they
themselves
can't
implement
the
resource
because
that's
only
possible
by
the
oldest,
so
something
I
did.
There's.
C
This
is
actually
a
note.
Right
now
note
has
in
the
new
module
system
export
package
JSON
and
in
the
experts
field,
you
could
block
exporting
from
a
folder
right
and
modules
inside
your
package
are
using
relative
module,
specifiers
and
they're
getting
access
to
modules
in
that
folder,
but
your
exports
is
blocking
others
from
importing
things
in
that
folder.
The
idea
here
is
that,
if
that
was
bundled,
these
things
would
would
all
be.
You
know
if
you
wrapped
or
whatever
and
so
you're.
Just
writing.
C
C
D
A
D
A
That
that's
what
I
would
try
to
advocate
in
the
sense
that,
when
dealing
with
Jesse,
for
example,
I
found
I
would
want
to
do
separate
modules
for
the
reasons
of
factoring,
but
then
to
obey
all
the
jesse
constraints
between
those
modules
made
is
very
difficult
to
do.
The
refactoring
I
was
I
would
have
to
put
them
all
in
one
module,
yeah
a
unified
thing,
so
that's
kind
of
a
different
direction.
We're
saying
that
a
package
or
some
kind
of
abstraction
that
said
these
are
the
exports
within
this
modules-
have
access
to
one
another.
So.
B
A
A
C
B
C
Json
web
tokens,
so
so,
if,
if
you're
serving
your
github
api
as
origin,
CSP
modules-
and
these
modules
are,
you
know-
are
expected
to
hold
onto
a
token
and
have
a
shared
state
stuff
like
that,
you
don't
want
to
like
use
import
Maps,
which
is
not
yet
been
approved
by
other
browsers
chrome.
Maybe
you
don't
want
to
eat,
perhaps
to
insert
someone
in
the
middle
and
be
like.
Okay
I'll
extract
that
you.
A
E
Okay,
Michael:
whatever
we
talk
about
packages,
especially
for
an
API
like
compartment
mm-hmm,
it
becomes
a
little
bit,
maybe
of
a
mix
of
two
different
environments
that
should
be
separated.
Okay,
because
packages-
we
probably
we
won't
be.
We
won't
the
compartment
API
to
be
available
in
the
browser
and
the
browser
doesn't
have
the
luxury
of
accessing
a
file
system
in
order
to
help
in
the
resolution
of
of
modules
right.
A
E
Well,
it's
something:
it's
a
concept
that
node
uses
when
it
defines
the
four
types
of
linking
between
modules
and
deep
linking
is
when
you
go
and
you
get
a
specific
file
inside
of
a
package.
Yes,
so
so
that's
that's
what
they
call
deep,
linking
and
I
believe
that,
once
we
get
into
deep
linking
it's
not
a
concern
of
the
client
or
the
component
API,
but
it's
more
about
a
a
there.
E
We
go
deep
import
specific
and
it's
more
concerned
about
how
they're
the
the
publisher
or
the
server
or
whatever
module
they
decide
to
export
itself,
will
accept
or
deny
a
access
to
something.
That's
internal,
so
yeah.
It
turns
out
that
the
module
API
can
probably
abstract
that
and
not
be
aware
of
it,
and
that
will
probably
work
better
in
a
client
service
situation
like
which
won't
include
trying
to
resolve
all
so.
C
E
Would
not
know
that
clean
exactly
yes,
yes,
exactly
yeah,
so
the
way
I
see
this,
and-
and
this
is
why
I
was
starting
with
with
the
review
of
the
API
from
the
principle
of
new
Authority-
is
when
we
looked
at
the
global
when
I
create
a
compartment
in
my
environment,
I
can
only
pass
to
it.
The
Global's
that
I
have
access
to
the
same
thing.
The
module
map
I
can
only
pass
or
deny
what
I
have
access
to
so
correct.
E
I
can
yeah,
I
can
reduce
the
power
I
can,
and
maybe
the
module
map
can
be
a
simple
map
between
specifier
to
specifier,
so
between
Anaya
and
Elias
and
and
what-what
did
agree.
It
actually
resolves
to.
In
my
environment
it
can
be
a
proxy,
so
I
can
do
a
dynamic
look
up,
but
going
any
further
than
what
the
parent
environment
has
and
also
the
parent
environment,
meaning
the
environment
that
is
actually
creating
the
compartment
and
is
is
getting
into
it.
E
Feels
like
it
and
in
the
case
of
the
XS
API,
where
they
have
a
bit
of
trickery
there.
It
feels
that
it
opens
the
door
to
something
else.
That
goes
beyond
the
capability
that
are
given
to
the
parent,
so
the
parents
should
not
be
able
to
give
access
to
module
it
doesn't
have
to
and
if
and
then
it's
deferred
to
the
underlying
system
to
do
the
rest
of
the
stuff
to
know.
If
there's
any
more
restriction
to
this
so.
E
E
C
With
it
with
that
code,
think
it's
running
in
the
scope,
or
will
it
think
it's
running
from
the
source
URL,
because
that
means
a
lot
in
the
browser
as
well,
but
but
it
also
means
a
lot
about
what,
if
that
code
relied
on
a
file
right
next
to
it
that
that
easy.
This
is
this
is
where
that
the
the
whole
like
attempts
to
draft
this
over
the
past
here
I
think
this
is
a
yeah.
E
B
E
All
first
that
consists
in
this
mark,
so
really
sorry
I
want
I
want
to
tackle
three
points.
Really
brief.
Briefly,
first
of
all,
if
we
talk
about
important
metal
URL,
we're
talking
about
an
API
that
is
I'm
in
my
sense
very
problematic,
because
it
reveals
the
current
file
system,
the
current
user
name,
you
know
just
by
important
matter.
You
know
if
you're
running
on
a
Mac
or
Windows
or
different
types
of
system,
and
that
violates
the
one
of
the
principles
that
we
wrote,
which
is
host,
preserve
those
virtualize
ability
yeah.
E
D
E
Martha
and
I
was
we're
discussing
about
this
a
little
while
ago,
we're
doing
running
and
poking
around
it
and
then
and
then
psych
I
think
it's
yeah.
It's
we
don't
have
to
discuss
a
lot
of
things.
Just
you
know
it's
like
key.
You
see
file
/user
with
cattle,
you
I
know
I'm
on
a
Mac
and
then
you
say
I
see
my
username
like
come
on,
like
these
guys.
I
understand.
E
E
A
B
D
C
B
If
we
were
dealing
with
a
simply
with
a
new
world
that
is
being
built
for
the
system,
we're
creating
I
think
that
the
case
for
not
remapping
within
a
package
would
make
sense,
given
what
we're
actually
trying
to
do,
which
is
do
the
whole
toast
tofu
plus
manual
policy
decisions
to
and
retro
actively
impose
a
lot
of,
least
Authority
constraints
on
existing
code
that
was
not
written
to
live
in
that
environment.
I
think
that
overall
we
do
need
the
flexibility
for
doing
the
invasive
remapping
as
well.
B
A
B
B
A
D
A
A
B
But
but
the
thing
is:
there's
many
modules
within
that
bundle
and
the
fact
some
of
them,
one
that
you
know
the
fact
that
module
X
reference
is
given
someone
outside
power
and
module.
Z
is
given
another
outside
power.
If
the.
If
we
can
diminish
the
possibility
of
contagious
corruption
from
X
to
Z.
Well,
then
we're
diminishing
the
possibility
that
abuse
of
power
of
the
power
given
to
X
is
contagious.
Oh
yeah.
A
B
A
B
A
B
B
With
regard
to
FS
yep,
we
want
to
to
the
extent
that
we
can
impose
restrictions
on
the
interaction
between
X
and
Z
that
we
believe
will
not
prevent
their
legitimate
interaction,
but
will
impede
contagion
of
corruption
between
X
and
Z
and,
and
one
way
to
do
that
is
to
create,
let's
say,
X
important,
said,
to
create
going
back
to
the
to
do.
Example.
The
microcosm
to
do
example
by
creating
an
alt
Z
from
the.
A
A
B
A
A
E
I
think
it's
the
also
time
to
tie
this
to
the
discussion
we
had
about
how
in
excess
the
concept
the
kopaka
API
is
mixing
together
the
concept
of
access
and
authority,
and
there
needs
to
be
something
something
different
in
there
and
by
that
I
mean
probably
the
easiest
way
to
understand
that
is
the
compartment.
The
compatible
API
should
be
probably
something
along.
E
E
We'll
need
to
use
the
compartment
API
and
can
do
in
a
situation
where
to
come
to
a
parent
component
like
an
important
important
important
without
having
to
do
itself
like
I,
don't
have
to
grab
the
importer
more
power
because
it
needs
to
feed
it
to
the
important
that
doesn't
happen
in
their
station
or
lava
mode,
because
lava
mole
can
provide
more
power
to
child
and
then
to
a
parent
which
is
not.
This
is
the
case
where
the
parent
is
itself
importing
a
child
without
the
this.
E
B
Because
the
existing
code
does
not
express
any
parent-child
relationship
between
modules
with
regard
to
creation,
yes,
yeah
existing
code
clearly
expresses
an
import
relationship.
Yes,
if
all
expression
of
parent-child
would
be
new
code
using
the
compartment
API,
yes,
and
that
does
seem
like
for
the
for
that
parent-child
relationship.
It's
necessarily
the
case
that
the
that
the
parent
can't
grant
to
the
child
any
more
power
than
parent
has
yes,.
E
Yes,
if,
if
the
parent
is
using
the
compartment
API,
but
if
it's
an
environment
that
takes
code,
that's
never
been
written
with
that
system,
then
then
it
can
do
more
things
that
then,
then,
there's
like,
like
the
lava
moat
situation,
so
through
imports
bar
lava
mode
can
say:
I'm
gonna
give
through
just
what
it
needs
and
I'm
gonna
give
it
in
bar.
Just
what
it
needs
right
are
might
won't
have
access
to
xml
httprequest,
but
I
don't.
The
lava
mode
doesn't
need
to
give
it
to
to
who
that
imports
bar.
It.
A
E
It's
only
a
bar
cat
who
can
only
create
bar
using
that
compartment
API
if
who
itself
has
access
to
all
of
what
bar
needs
good
and
we
can
pass
it
to
it,
yeah
yeah.
So
it's
very
like
mark
like
in
that
discussion.
We
were
we're
looking
at
the
access
API
and
mark
really
like
took
a
step
back
and
say
wow.
Look
at
this.
We
accesses
it's
kind
of
mixing
the
creation
yeah
and
in
the
authority
into
one
API,
which
is
which
is
a
little
bit
yeah,
nothing
other
things
yeah.
E
Flash
too
fast
I
can
attenuate
the
powers
that
I
give
to
that
flasher
module,
so
I
can
restrict
the
light,
bulb,
flashing,
speed
or
color
or
whatnot
or
brightness
okay,
but
it
doesn't
have
to
do
it
like
a
bobble
is,
doesn't
necessarily
need
to
do
the
lava
mode
or
a
lava,
Moton
steroid
case
where
I
would
say
laughs
about
this
at
the
package
level
currently,
but
it
could
go
further
than
the
package
at
all.
It
could
go
deeper
into
it,
which
would
would
be
laughable
in
stories.
Okay,.
C
So
so
all
this
talk
that
I,
did
you
mind
if
I
have
a
package
that
in
it
has
internal
or
private
or
whatever
internal
modules
is
a
good
way
to
call
it,
and
it
exposes
a
a
bundle,
light
version
of
itself
and
a
single
instance
that
does
not
expose
the
instances
of
the
internals.
Then
we
can
say:
ok,
it
compartmentalizes
that
graph
and
exports
star
from
the
you
know
the
entry
point
that
would
have
been
the
outer
facing
interface
of
the
bundle.
C
So
so
it
could
be
that
you
know
at
this
point
modules
creating
the
compartment
API
would
would
not
have
the
benefits
of
you
know,
binding
against
things
that
are
coming
from
compartments.
Unless
we
say
ok,
let's
do
a
syntax
that
would
allow
a
module
to
be
a
compartmentalized
exporter
that
creates
the
compartment,
wires
the
modules
and
determines
what
would
be
exported
and
all
can
be
done.
Synchronously
basically,.
A
C
E
A
B
Make
sure
I
understand
what
the
concern
is
here.
We're
saying
that
if
our
system
allows
this
invasive
modification
of
the
internals
of
a
package
that
people
will
seek
to
evade
our
surgery
on
their
package
by
changing
their
system
into
something
for
which
our
invasive
surgery
does
not
apply,
that
we
currency
wasn't.
A
I'm
kind
of
suggesting
that-
and
it
goes
from
the
other
way
to
that,
if
to
functions
in
the
same
module,
have
a
different
have
a
different
interface
between
the
two
than
they
do.
When
they're
in
separate
modules,
then
that
kind
of
drives
things
that
go
in
for
one
module
and,
on
the
other
hand,
oh
I,
hope
I,
don't
miss
this
B.
A
The
other
thing
I
was
thinking
about
was
how
it's
it's
commonplace
in
our
modules,
2d
structure,
Global's
at
the
module
level
and
then
use
those
D
structured
functions
later,
because
we're
defending
against
people
changing
the
Global's.
Well,
even
even
if
the
compartment
API
is
for
good
reason-
and
we
have
great
reasons
to
do
this
surgery,
I
talented
at
attacker,
like
X
Melia,
could
use
the
compartment
API
to
break
the
links
between
modules
that
were
supposed
to
be
close
together.
That's
kind
of
what
I'm
saying.
B
B
B
A
This
is
the
kind
of
bizarre
trust
thing
that
the
partitioning
of
modules
does
not
matter
in
this
case
when
it's
just
a
regular
program.
But
when
this
takes
me,
it
took
me
a
long
time
to
understand,
because
I
think
Jeff
and
Caridi
were
also
talking
about
this.
The
idea
that
we're
placing
a
prototype
or
poisoning
a
prototype
could
also
lead
to
the
leak
of
secrets,
just
information
that
wasn't
supposed
to
be
given,
because
people
aren't
expecting
that
boundary
to
be
potential
transponder
e
they're.
Just
saying.
Oh,
my
code
is
factored
better.
B
So
so,
ok,
so
let
me
just
so
what
I
have
in
mind.
So
the
scenario
you're
raising
is
is
a
is
outside
of
the
scenarios
I
had
in
mind,
so
it's
great
you're
raising
it
because
I
haven't
considered
it
well
it
to
be
so
to
be
very
explicit.
I
had
in
mind,
basically
that
there's
old
packages
that
are
written
without
not
any
knowledge
of
our
system
and
there.
A
B
Was
not
thinking
about
invasive
remapping,
because
new
package
being
a
unit
of
maintenance,
treating
it
as
a
encapsulated
unit
that
somebody
else's,
whose
internals
or
somebody
else's
responsibility
is
great,
but
the
third
case
that
you're
bringing
up
well,
they
just
state
it
to
make
sure
we're
in
sync
is
that
if
we
provide
the
invasive
mechanism,
whose
purpose
is
to
do
surgery
little
packages,
then
some
will
use
it
to
do
surgery
or
new
packages.
And
then
the
authors
of
new
packages
will
find
the
that
they're
drawn
into
defending
that.
B
A
So
I
guess
what
I
was
getting
to
is
that
this
surgery
mechanism
is
much
better
accomplished
by
just
cocking
the
package
into
your
own
and
then
doing
the
surgery
as
you
need
it.
They
calling
your
own
namespace,
because
any
surgery
you
do
will
likely
or
not
likely,
but
it
may
be
broken
by
upgrades
to
that
package
and
the
dopant
stuff.
So
if
you
want
to
basically
rewrite
something
in
the
package,
use
the
source
code,
don't
use
the
runtime
evaluator.
D
Without
actually
wearing
to
modify
the
thing
but
there's
but
wrapping
it
in
a
sort
of
an
attenuator
or
whatever
the
way
you
said,
that's
still,
you
may
displayed
earlier
that
it's
still
brittle
in
the
face
of
maze.
Yes,
I
think
it's
it's
brittle
in
the
face
of
ordinary
maintenance,
not
just
a
change.
D
Attempting
to
evade
this
mechanism
and
therefore
it
seems
like
if
you're
going
to
you
have
that
there
needs
to
be
somehow
associated
with
whatever
you
using
to
make
sure
you've
got
version,
compatibility
or
something
version
tracking,
so
that
this
is
applied
specifically.
There's
no
specific
version
of
that,
so
that
the
surgery
module
itself
will
explicitly
bring
what
it
was
designed
to
work
with
changes.
B
A
B
A
D
Is
ven
during
me
copying
it
into
your
own
right
source
tree,
so
we've
seen
multiple
attempts
of
trying
to
essentially
have
duplicated
modules,
as
we've
tried
to
roll
out
ES
modules
and
note
when
people
naively
do
this,
they
often
encounter
errors.
Unfortunately,
some
of
them
are
from
I
did
identity
discontinuity
of
the
package
itself.
D
D
Other
things
like
various
styles
of
loggers
things
that
are
stateful
in
some
way
or
have
some
sort
of
shared
resource,
also
fail,
because
they
expect
to
have
either
some
sort
of
guarantee
about
the
references
that
they're
operating
on,
and
so
once
you
start
passing
references
between
them.
Their
backing
stores
don't
match
up
their
IDs
might
not
match
up
or
other
things
in
general.
D
If
you
look
at
dual
packages,
they
suffer
exactly
this
kind
of
problem
of
duplication
where
a
lot
of
people
tried
to
ship
both
a
common
jeaious
version
of
their
package
and
an
es
module
version
of
their
package.
So
they
actually
just
shipped
two
different
versions
and
what
they
noticed
was
by
duplicating
things.
D
C
The
issue
first
first
started
happening.
The
the
discontinuity
was
I
guess,
a
staple
of
early
web
components,
experiments
on
NPM,
so
they
use
Bower,
and
this
way
they
use
the
flat
dependency
tree
and
NPM
without
yarn,
basically
meant
that
web
components
were
duplicate
in
the
chain
if
they
were
dependencies
of
each
other
and,
of
course,
and
web
components
you
have
a
fatal
like
you
can
guard
against
it.
D
A
A
B
The
I
mean
the
thing
I'm
defining
is
invasive
surgery
is
where
you're
you're
you're
modifying
the
internal
coupling
within
the
package,
the
coupling
between
the
the
package
and
other
packages,
that's
always
been
something
I've
considered
fair
game
and
I
thought
that
was
sort
of
an
assumption
in
the
conversation.
So.
A
What
I'm
saying
is,
if
package
a
package,
food
exports
x
and
y,
as
well
as
the
root
food,
if
it
exports
y
means,
we
can
replace
it
and
fairly
confident
that
the
dapi
service
has
not
changed
because
it's
being
used,
it
might
be
used
internally.
But
it's
been
exported
and
advertised
as
an
external
interface.
A
D
D
D
A
B
E
B
E
It's
a
it's
a
very
interesting
to
develop
web
pages
without
having
to
do
a
bundler
and
just
use
the
rope
yeah.
It's
it's
quite
an
interesting
where
it
leads
us
to
and
the
to
API
is
I
are
getting
so
close
to
each
other.
What's
supported
in
the
browser
prepared
when
they're
supported
and
know
that
it's
great
to
have
that
same
lateral
movement
capability
between
the
two
environment,
yeah.
B
E
A
E
A
B
A
Yeah
because
then
we
just
winged
allah
says
quote
the
import
module,
Fuli
implementation,
guess
where
it
would
be
logical,
like
what
I
found
in
Jessica.
Is
it's
logical
to
divide
up
the
interpreter
into
the
different
layers
of
parsers
that
we
have?
But
when
I
do
that,
the
the
rules
for
hardening
things
between
modules
get
in
the
way
a
lot
and
they're
going
to
force
a
lot
of
convulsions
unless
we
can
somehow
say
Justin
and
Jesse
and
Jason
are
all
part
of
the
same
package,
a
lot
of
them
to
share
stuff.
So.
B
I'm
surprised
to
hear
this
I'd
love
to
see
some
examples.
Yeah
the
I've
generally
been
thinking
about
Jesse
in
terms
of
static
hardening
rules
that
are
don't
really
care
that
much
about
module
boundaries
rather
than
membrane
rules,
but
but
but
I
have
not
been
but
I've,
but
I've
I've
known
that
that
story
was
not
adequate
for
the
disk
apparition.
A
E
Yeah
that
that's
interesting
could
it
could
lead
to
interesting
behavior,
though,
if
what
is
happening
between
module
is
not
depending
on
the
year
are
key
between
modules,
the
harding
will
be
different
and
because
harding
can
be
transitive,
a
module
can
work
differently
if
it's
important
in
in
in
a
different
approach
right.
So
if
food
imports
bar
and
who
exports
something
of
bar,
then
the
harming
will
impact
bar.
E
A
B
B
Need
to
implement
is
that
for
any
object
defined
by
bar.
There
is
no
notion
of
a
mutable.
There
is
no.
This
observable
notion
of
a
mutable
property
that,
by
the
time,
anybody
else
can
observe
any
object
that
that
bar
created
it's
completely.
It's
always
hard.
Nobody
can
observe
a
non
hardened
object
created
by
bar
okay.
B
A
B
B
B
E
B
The
corresponding
subset
of
typescript,
but
since
syntactically,
but
since
typescript
already
has
to
be
transformed
into
JavaScript
as
soon
as
you've
taken
step,
two
Tessie
you're
no
longer
in
a
no
Translate
system,
so
that
we
can
additionally
define
the
Tessie
to
Jesse
translation.
To
do
something
that
the
typescript
to
JavaScript
translation
does
not
do,
which
is
to
insert
a
hardened
every
place.
That
Jesse
insists
on
a
burden
so
that
the
output
of
the
translator
passes
the
Jesse
static
Wars,
and
that
means
that
our
se
programmer
never
has
to
write
those
hardens
they're
provided
for
them.
B
A
So
what
I,
what
I
found
in
writing?
Jesse
with
the
strict
hardener
roles,
is
that
it
drives
the
one
it
drives
everything
into
one
function,
its
discourages
modularity
by
breaking
out
separate
functions
and
then,
when
I
relax,
that's
just
the
module.
I
thought
that
the
spurious
modularity
by
breaking
out
into
separate
modules,
I.
B
A
B
C
B
There's
there's
this
further
hope
with
Tessie.
That
at
this
point,
is
just
a
hope,
because
nobody
is
I
believe
has
done
much
investigation
of
this
Michael
correct
me.
If
anybody
has,
it
would
be
you
so
correct
me
if
I'm
getting
this
wrong,
but
the
hope
is
that,
if
the
escape
from
declared
types
in
Tessie
is
only
the
typescript
unknown,
rather
than
the
typescript
any
that
it's
possibly
the
case,
that
Tessie
might
be
statically
type
safe.
B
The
distinction
between
unknown
and
any
is,
if
the
variable
foo
is
of
type
any.
The
typescript
is
perfectly
valid
in
a
food
dot
bar,
whereas
if
it's
of
type
unknown,
you
must
first
do
effectively
a
dynamic
type
test
that
ensures
that
it's
actually
a
kind
of
thing
that
implement
has
a
bar
property,
typed
bar
property,
and
only
then
can
you
do
a
food
bar.
So
these
dynamic
type
tests
are
like
the
dynamic
casting
job
is
Java
is
statically
typed
safe?
B
Not
that
you
won't
get
any
dynamic
cast
failures,
but
in
the
sense
that
all
of
your
that
trouble
prior
to
Java
generics,
Java
generics
quincas
up
but
prior
to
Java
generics
Java.
You
could
say
that
Java
was
statically
type
site
in
that
the
only
run
time
type
failures
was
cast
failures
or
using
going
through
the
reflection
API,
which
is
another
matter.
A
Yeah,
so
that's
that's
accurate.
So
long
as
the
the
function
said
assess
the
types
are
correctly
typed
themselves
and
they
don't
use
any
dynamic
count
and
that's
that's.
The
dynamic
has
tonight
scripted,
actually
just
a
static,
override,
much
like
casting
and
see.
So
we
have
to
eliminate
that
as
well
as
any
I.
A
A
A
A
A
D
E
E
So
if
taking
it
down
into
smaller
pieces,
which
are
all
isolated
with
Harden
I,
believe
that
you
get
a
much
more
reliable
and
predictable
behavior
of
what
is
where
the
where
the
mutable
state
resides,
because
you
know
some
something
that
happens
to
be
exported
is
not
hardened,
but
only
when
it's
exported
becomes
hardened.
So
it's
it
could
be
yeah
interesting,
cold
path
there,
some
muffin
buying
by
Rick.
My
reaction
to
this
would
be
okay,
I,
both
divide
things
into
smaller
bits,
I'm,
it's
easier
today,
but
I
I.
A
A
Yeah,
which,
which
I
accepted
into
the
jessica
program
simply
by
providing
as
I
compute
index
endowment,
so
it's
something
that
bypasses
one
of
the
Jessie
restrictions
just
to
be
able
to
build
up
objects
piece
by
piece.
Instead
of
having
to
create
a
separate
data
structure
that
I
append
to,
and
then
we
apply
that
into
it.
A
B
C
C
C
D
C
C
So
we
talked
about
exporting
from
compartmentalized
instances
and
I'm
pretty
sure
this
is
not
the
kind
of
syntax
we
want,
but
it
should
be
possible
for
a
module
to
say,
listen,
there's
only
one
reference
to
that
compartment
chain
and
it's
being
exposed,
and
you
basically
cannot
override
anything
I'm
doing
here
to
expose
that
public
facing
interface.
You
could
override
that
module
and
attenuated
or
replace
it
all
together,
which
you
know
does
not
invade
whatever
it
does
in
its
own
compartment.
Oh.
B
C
I
mean
I'm
just
winging
compartments,
API
and
I'm,
just
saying
whatever
the
API
decides.
Somehow
the
modules
would
expect
somehow
to
know
whether
or
not
they
are
being
bootstrapped
safely
and
if
they
are,
they
know
they
can
do
whatever
they
need.
If
they're
not,
they
can
be
like
okay,
well
I'm,
just
gonna
export
undefined
or
something
yeah.
C
C
B
C
E
E
So
you
can
see
you
can
see
my
screen.
Yes,
so
what
I
won't
be
API
to
be
used
for
is
a
simple
way
for
somebody
to
express
Pola
to
say,
I'm
importing
something
but
I,
don't
trust
it.
I
want
to
use
something
that
easily
allows
me
to
control
that
import
so
going
from
a
static
import
here,
add
a
unique
import
and
then
to
compartment.
Api
provides
a
natural
gradation
where
I
can
suddenly
use
with
a
minimal
amount
of
code.
The
right
akkanee
ation
is
required
for
the
module
I
want
to
use.
Oh.
E
D
E
This
gets
around
their
problem,
so
I'm
going
to
respec
and
trying
to
see
if
something
is
like
this
as
possible,
but
I
I
mean
I'm
in
terms
of
ergonomics
like
if
I
won't
what
I
won't
Express,
which
is
Pola
in
an
environment.
That
I
really
understand.
I
think
this
is
very,
very
least
intrusive
and
gives
me
the
the
attenuation
that
are
required.
Okay,.
E
And
now
the
module
map
is
I,
have
this
somewhere
somewhere
else
and
in
the
in
the
API,
which
is
the
the
module
map
is,
is
I'm
trying
through
with
the
current
proposal
of
the
module
map
except
I.
The
thing
is
the
the
scope,
I'm
less
confident
about
it,
but
it's
it's
the
idea
that
the
Global's
and
the
module
can
only
be
passed
if
you
have
access
to
them.
So
the
resolution
will
respect
your
current
resolution,
so
you
cannot
give
somebody
access
to
things
that
you
don't
have.
E
E
E
B
B
E
Believe
for
the
simple
case,
probably
because
we're
talking
about
module
map
like
I,
think
I
want
to
make
this
simple
case
trivial
and
the
advanced
case
possible.
So
if
supporting
a
proxy
is
possible,
then
I
did
a
couple.
Look
on
the
proxy
object.
A
couple.
Look
we'll
use
a
module
knock
and
somebody
who
wants
doesn't
want
to
create
a
function
and
and
and
and
and
do
all
the
wizardry
around
it
can
just
provide
a
microphone.
A
D
D
B
C
E
B
Yeah,
it
is
interesting
that
you
can
say:
have
it
either
be
object
which
might
be
a
proxy
with
a
get
trap
or
a
function
and
and
have
the
same
ultimate
expressiveness
but
kind
of
different
okay
sense
of
what's
simple
I
think
I
would
still
prefer
a
function
because
the
function
is
a
really
simple
function
and
when
you
want
to
express
it
as
an
object
literal,
it's
easy.
The
the
amount
of
extra
boilerplate
to
turn
a
object,
literal
expressing
a
mapping
into
a
function
expressing
a
mapping
which
is
just
you
know.
E
I'm,
you
know
this
is
great
feedback.
I'm
I'm,
looking
at
this
I'm
looking
at
what
morrible
is
also
doing
with
their
variation
cases,
which,
in
terms
of
code
review
ability,
if
we
have
I,
think
we
need
to
do
some
examples
of
this
and
see
how
it
declines
to
and
and
maybe
my
objection
to
like
or
by
liking.
This
of
a
a
lob
check
would
go
away,
yeah
yeah,
exactly
yeah.
Why
not.
E
D
E
E
So
yeah
so
in
our
case
I
think
in
the
swingset
it
it
opens
the
door
to
say:
I
can
freeze
the
global
and
then
I
have
basically
the
implementation
of
a
frozen
round
that
we
wanted
to
have.
We
were
looking
at
it's
not
that
frozen
realm.
It's
a
frozen
compartment,
but
it's
everything
inside
it
is.
It
behaves
like
a
frozen
realm
yeah
as
long
as
we
assure
that
the
lexical
scope
is
not
mutable
or
it's
not
getting
it
from
one
import
to
the
other.
That
then
we
okay
note
and
by
a
by
accident.
E
If
it's
frozen,
you
can
but
it
if
yeah
nothing
prevents
a
module
from
it
for
exporting
to
the
global
scope
yeah.
So
if
you
really
wanted
to
reuse
like
what
app
are
getting
is
is
easy,
easy
I
want
to
make
this
as
simple
as
possible,
so
it's
usable
in
many
places
easy
to
read,
and
so
ok,
let's
make
it
lightweight.
D
D
B
A
Jeff
I
I
had
one
question
about.
If
so,
if
we
import,
if
a
module
appears
in
a
parent
compartments
import
map,
and
then
we
re
importnat
module
in
our
compartments
like
we
provided
in
our
in
or
map
for
the
child
compartment.
Yes,
what
is
the
relationship
between
the
Global's
of
the
child
compartment
and
the
Global's
of
Eron
compartment
in
regards.
A
A
C
E
B
B
B
E
Are
all
specifiers
because
we
don't
get
into
the
wizardry
of
dealing
with
the
specifiers?
It's
the
parent
or
the
the
the
code
that
is
actually
calling.
The
compartment
is
wont
to
provide
a
resolution
in
their
meaning
or
whatever
environment,
that
whatever
it
means
in
the
environment,
a
specifier
to
the
child
to
the
component
has
been
created.
So
if,
in
my
environment,
I
have
access
to
dot
/foo
and
the
compartment
wants
to
import
foo
in
in
in
its
code,
it
doesn't
import.
E
B
E
E
E
B
That
code
is
instantiated
in
the
new
compartment
collect,
so
how
so
the
expressiveness
that
I
need
that
I'm,
not
that
I'm
I
think
I'm
purposely
not
seeing
is
how
do
I
give
foo
when
it
says
import
bar
from
bar.
How
do
I
give
it
access
to
a
bar,
since
that
has
been
instantiated
in
a
different
compartment.
B
E
B
B
D
B
A
B
E
B
D
D
B
D
B
B
So
ever
everybody
correct
me
if
I
get
this
wrong,
but
it
necessarily
has
a
fresh
identity.
That's
one-to-one
with
the
module
instance,
yes,
okay.
So
that
means
that
a
it's
a
natural
thing
to
use
as
a
capability
for
designating
the
module
instance,
because
it
actually
is
a
capability
to
the
things
that
the
module
exports
and
its
identity
is
exactly
one
to
one
with
the
instance.
Okay,.
E
C
E
B
C
A
D
A
E
At
the
world,
oh
but
I
believe
so
because
making
at
what
is
happening
in
node
versus
the
browser
versus
the
module
Maps
proposal,
there's
I
understand
that
build
can
go
a
little
bit
deeper
because
it
has
access
to
the
file
system,
but
with
the
module
method,
the
browser
they
already
know
as
a
precondition
for
that
proposal
that
they
cannot
go.
They
cannot
do
so
much
all
of
that
wizardry.
So
so.
B
B
If
there's
multiple
modules
in
the
compartment
then
and
multiple
modules
are
something
that
the
that
that
are
it
is,
is,
let's,
let's
say
we're
just
trying
to
emulate
the
conventional
slash
algebra
right.
So
if
you've
got
multiple
modules
that
represent
different
points
in
a
local
tree
that
when
something
down
the
tree
says
import
dot,
slash
bar
you've
got
to
know
who's.
Doing
the
importing
yeah.
E
E
E
Because
in
this
case,
what
I
could
do
my
module
can
say?
Well,
subha
wants
to
import,
ABC,
I
can
say:
okay,
I
will
attenuate
this
power.
I
will
only
say,
you
know
a
is
possible
and
you
know
and
I
can
give
the
path
to
a
or
not
and
B
as
possible,
right
and
then,
and
then
this
whatever.
If
it
wants
you
to
import
this,
then
you
know
the
left
side
is
what's
happening
in
the
resolution.
That's
happening
inside
of
the
compartment,
and
this
is
the
map
to
what's
happening
in
my
compartment,
but.
B
B
A
E
D
A
And
I
I
think
take
take
these
as
you
want.
Yeah
I.
Don't
expect
you
to
implement
the
necessary
this
way
or
it
is
specified
in
this
way.
But
if
the,
if
the
primitive
to
map
from
specifier
to
goes
to
a
module
name
space,
then
the
namespace
is
the
capability,
and
as
long
as
we
have
a
second
argument
of
what
the
refer
is
or
is
somehow
that
not
can
obtain
that
in
order
to
give
out
capabilities-
and
that's
that's
all-
you
need
to
do
all
the
events
about.
E
E
B
B
E
A
E
E
B
E
A
E
E
A
E
And
isn't
this?
This
proposal
is
trying
to
find
a
combination
of
existing
building
block
instead
of
you
know
like
in
this
case
it's
a
combative
API
and
it's
very
simple
to
specify
it
right
and
and
but
we
can
find
a
combination
with
other
aspects
like
this.
The
the
export
map
to
you
have
suddenly
like
combining
these
two
things,
a
lot
more
richness
to
what
we
can
do
with
it.
Yeah.
E
C
I
guess,
from
my
perspective,
I
it
felt
more
intuitive
to
do
it
as
an
export,
not
as
an
import
and
then
export
and
I
guess
you
know
just
opening
that
question
for
for
a
discussion
further
I
do
understand
that.
Sometimes
you
want
to
run
code
on
the
modules,
and
you
know
I'm
not
sure
if
importing
or
exporting
is
the
difference
at
this
point,
but
whether
or
not
you're
going
to
attenuate
a
module
as
part
of
the
early
error
phase.
C
C
I
explored
the
idea
of
undefined
as
a
name
that
no
longer
exists
in
the
graph,
but
I
think
it's
a
static
analysis
consideration
for
development
tools
that
if
they
do
type
check
compartmentalizing
modules,
they
would
want
to
assume
that
this
phase
and
they're
giving
developers
the
road
insights
by
static
analysis
before
before
you
know
any
code
executes
right,
so
so
yeah.
So
that's.
E
C
E
C
E
B
Okay
guys,
it
sounds
like
we're
at
a
good
low
and
it
is
already
we're
20
minutes
over
so
I,
so
let's
first
stop
recording
which
I
will
do
now.
Okay,.