►
From YouTube: SES Meeting: Isolated Realm Polyfill
Description
We discussed Leo’s proposal for an API oriented around just code evaluation and a function wrapper, in response to Daniel’s API proposal oriented around connect, in an effort to close an intuition gap among the API’s end users at Salesforce.
B
So
this
is
just
like
mostly
this
redmi
file
is
a
copy
and
paste
of
karidi's
original
api
design.
Here,
what
is
more
important
from
this
is
just
checking
out
what
we
have
there.
There
is
one
small
modification
in
this
class
declaration,
and
what
I
have
here
is
still
like
in
this
api.
I'm
still
writing
the
an
evolve
method
that
can
only
return
primitive
values.
B
I
have
a
function
and
async
function,
constructors
that
can
also
be
only
accept
primitive
arguments
and
can
only
return
primitive
values
as
well.
We're
gonna
have
the
import
for
injection.
I
have
I'm
gonna
discuss
some
questions.
I
already
have
about
it
and
we
have
a
draft
of
this
wrapped
callback
function.
B
This
is
a
some
some
way
still
like
that
connects
and
can
be
used
to
build
what
daniel
suggested,
but
I
I
also
have
another
suggestion:
on
top
of
this
rap
callback
function
and
daniel's
suggestion
on
how
we
actually
send
functions
to
the
other
realm
or
some.
How
do
we
enable
the
realms
that
we
create
to
to
use
callbacks
as
they
cannot
receive
non-primitive
values
such
as
functions?
B
B
That
is
a
promise
from
the
incubator
realm,
and
that
is
connected
to
the
the
import
injection
that
is
created
in
the
other
realm.
So
when
the
promise
in
the
incubator
realm
is
resolved,
it
resolves
to
this
promise
too.
There
might
be
problem
with
the
ticks,
but
there
is
still
the
problem
where
it
doesn't
resolve
to
anything.
C
B
Oh
yeah
yeah,
yes,
yes,
and
then
that
led
us
to
discuss
daniel's
connect
api,
so
mostly
of
what
this
is
doing
today
is
wrapping
of
wrapping
a
function
in
this
realm
that
cannot
and
then
allowing
this
to
be
sent
to
the
other
realm
as
a
callback,
but
it's
still
like
it
doesn't
share
around
cross-realm
identities
like
the
realms
they
never
like.
They
can
never
verify
at
the
identity
of
the
other
round,
like
both
from
inner
and
outer
rounds.
B
This
polyfill
is
just
like
one
of
the
things
that
I
I
like
in
this
polyphenol
here
is
that
out
of
the
box,
it
it
is
working
as
like.
Yes,
it
is
working
so
far.
One
of
the
things
that
I
am
actually
not
being
able
to
do
right
now
is
using
this
wrapped
callback
function
to
I
haven't
implemented
in
any
form
as
well
to
share
the
wrapped
callback
function
from
one
realm
to
another.
So
I
could
not
transfer
a
callback
from
realm
a
to
round
b
and
both
being
in
the
realms
of
realm
c.
B
So
yeah
this
is
not
implemented
yet,
but
I
I
still
have
like
valid
questions.
Let
me
open
the
the
polyfill
ripple
where
I
actually
have
some
issue
tracker
there,
and
this
is
just
like
recent-
I'm
just
using
this
as
a
proof
of
concept.
So
these
are
some
of
the
questions
that
I
identified
with
my
with
our
team
at
salesforce.
B
This
is
actually
solved
the
the
second
one.
Let's
skip
this
one.
We
need
to
explore
the
import
function
because
for
now
what
it
means
to
just
inject
code,
but
if
you
cannot
handle
the
receive
namespace
object,
the
module
namespace
object
from
the
inject
code.
So
I
might,
I
want
to
explore
the
import
function
to
to
see
if
we
can
actually
also
name
a
namespace
or
a
new
binding
or
something
that
we
can
handle
there.
A
C
C
It's
probably
a
step
toward
that
goal.
Mark
trying
to
see
what
kind
of
implementation
can
we
have
that
allows
to
implement
the
fully
functional
membrane.
I
wanted
to
try
it
with
the
actual
membrane
that
we
used
in
the
membrane,
but
we
haven't
get
to
that.
I
haven't
get
to
that.
Yet,
in
terms
of
the
api,
we
talk
about
daniel's
proposal,
which
is
a
little
bit
more
advanced,
say,
lower
level.
C
We
last
time
that
we
discussed
this,
I
believe
we
say
daniel
proposal
seems
to
solve
all
the
problems.
It's
just
very,
very
tricky
for
people
to
understand,
even
for
us
what's
difficult
to
understand
how
it
works
and
the
coordination
between
the
incubator
realm
and
the
rom
itself.
I'm
not
sure
why
leo
was
exploring
the
previous
api.
C
I
I
I
think
some
of
the
questions
still
apply
like
what
what
is
the
result
of
the
import
promise
both
cases,
both
apis
will
have
the
same
problem
like
what
is
it
that
is
resolved
too,
but,
but
I
think
it's
to
answer
your
question
mark.
I
think
it's
getting
to
the
point
where
we
can
try
a
few
things.
I
don't
think
this
is
that
far
from
daniel's
api,
by
the
way,
I
think
it's
going
to
be
super
difficult
to
go
from
these
code
to
daniel's
api
at
the
end
of
the
day.
B
So
for
the
wrap
function,
callback,
I
actually
have
some
feedback
from
the
team
that
I
I've
had
a
sync
with
the
team
for
clarification
with
everyone.
I
have
a
sync
with
the
team,
but
not
with
kari
yet
so
I
have
feedback
from
the
team
on
like
I
showed
the
team,
both
the
rap
code
function,
callback
and
daniel's
api,
and
neither
of
them
were
like
the
best
option
from
the
team.
Like
someone,
john
david
dalton
was
the
one
who
suggests
like.
Why?
B
B
B
C
C
You'll
be
able
to
create
a
realm
you'll,
be
able
to
add
a
function
to
that
realm,
saying
if
I
give
you
this
function,
return
a
symbol,
maybe-
and
when
I
see
this
symbol
coming
in
through
the
call
that
I
do
to
the
other
side,
I
will
transform
that
into
something
whatever
it
is
so
you'll
be
able
to
implement
your
own
version
of
this
is
a
function
in
one
side
that
corresponds
to
a
function
on
the
other
side
by
the
user
lab,
and
I
think,
that's
possible.
I
I
believe,
is
possible
with
daniel's
proposal.
C
I
do
believe
that
it's
going
to
be
very
complicated
for
people
and
there
will
be
a
structure.
People
will
create
libraries
to
do
this
and
yada
yada,
but
I
believe
a
mental
model
where
you
create
a
realm,
and
you
have
these
intuitions
about
what
functions
will
do
when
you
pass
them
as
a
callback
and
so
on
when
you're
talking
to
the
realm
will
be
a
much
more
nicer
approach,
but
that's
just
my
initial
reaction
to
a
very
low
level
api
like
what
daniel
is
proposing.
B
Yeah
just
for
for
the
records
as
well.
I
still
like
it.
I
am
still
in
the
early
stages
with
this
polyfill.
I
intend
to
add
to
this
polyview
an
api
that
there
is
the
api
designed
by
daniel.
I
want
to
write
tests
for
that
and
write
this
implementation
just
to
so
that
can
actually
help
me,
because
it's
still
being
tricky
for
me
to
fully
understand
how
that
api
works
and
tried,
and
how
to
explain
that.
B
C
Daniel
just
daniel
just
for
for
so
daniel,
that's
why
he
was
expecting
as
well,
but
obviously
I
haven't
been
able
to
work
with
daniel
on
the
api
trying
to
figure.
We
can
make
it
a
little
bit
more
ergonomic
and
simple.
Maybe
a
simplification.
There
will
help
in
terms
of
the
wrap
function.
Daniel
is
really
about.
I
have
a
function
in
the
incubator
round.
C
C
That's
that's
how
the
wrapping
works
is
basically
two
functions
connected
internally
by
antenna
slots
in
this
case
in
the
polyfill
troll
is
a
weak
map
and
these
two
functions
one
is
from
one
side,
one
is
from
the
other
side
and
they
are
somehow
connected.
So
when
you
call
one,
it
really
calls
the
other
one,
and
you
have
high
privilege
in
the
political
that
does
the
the
calling
on
on
the
other
side
and
try
catch
and
all
that.
D
So
I
definitely
see
how
the
api
that
I
propose
is
hard
to
understand
and
how
that
makes
it,
something
that
we
could.
That
would
be
good
to
iterate
on
what
I'm
having
trouble
understanding
about
rap
function.
Callback
is
how
you
execute
code
inside
the
realm
like.
Is
there
a
way
to
do
that
without
eval?
D
C
Around
the
wrap
function,
the
wrap
function
return
something
that
can
be
passed
through
the
regular
communication
between
the
two
sides,
and
that
is
not
a
primitive
value.
Basically,
I
mean
that
it
could
be
that
it
returns
a
symbol
that
would
work
as
well,
but
it
prepares
the
function.
So,
on
the
other
side,
they
will
get
a
function.
That
is
a
mirror
of
this
function
in
terms
of
functionality.
D
B
B
C
B
Yeah,
that's
the
thing
so
here
when
I
actually
create
a
new
instance
of
a
red
function.
By
red
I
mean
the
inner
realm.
Anything
red
is
in
a
realm.
Anything
blue
is
the
outer
or
incubator
realm.
Okay,
so
here
I
create
a
function
and
this
function
receives
an
argument,
has
a
parameter
cb
and
the
function
bodies
like
return,
type
off
of
c
c
b.
So
here
is
actually
me
running
a
function
from
the
other
realm.
B
C
Then
three
three
and
I
received
the
return
value.
398
is
the
one,
and
this
is
really
the
one
that
breaks
the
invariant
that
we
were
talking
about
in
previous
meetings,
because
now
you
you
are
calling
a
function
from
the
other
side,
but
you're
actually
passing
a
function
that
happens
to
be
a
wrap
function,
so
you're
not
only
allowing
primitive
values
now
you're,
also
allowing
kind
of
functions
that
so
that's
the
part.
That
is
a
little
bit
bad
from
question.
From
my
perspective,
yeah
right.
A
C
Asking
that's
exactly
what
I'm
asking
like:
if
it
is
a
function,
then
it's
simpler,
but
you
break
the
invariant.
If
wrap
functions
returns
a
symbol,
then
it's
fine,
because
it's
a
symbol,
but
someone
has
to
unwrap
that
symbol
in
the
way
in
because
you're
calling
a
function
on
the
other
side,
you're
passing
a
symbol
as
an
argument,
but
on
the
other
side
they
should
receive
a
function
because
that's
a
function
that
they
will
call
call
it
back.
A
Of
being
more
ergonomic
at
this,
while
being
less
low
level,
the
ergonomic
thing
that
does
wrapping
and
unwrapping
will
be
the
membrane
and
what
we
want
to
enable.
That
is
something
that's
as
as
simple,
and
you
know
as
simple
and
as
as
with
this
clear,
formal
properties
as
possible,
and
I
think
that
something
that's
not
creating
new
implicit
wrapping
and
unwrapping
semantics
at
the
low
level,
especially
if
it
costs
extra
complexity,
is,
is
more
attractive.
C
C
The
part
of
the
conversation
that
we
haven't
had
at
least
myself
and
daniel.
We
talked
about
it,
but
we
didn't
get.
We
didn't
get
a
chance
in
the
last
two
weeks
to
talk
about
it
and,
and
so
part
of
the
simplification
see
what
is
the
layering
here
like?
Can
we
have
two
different
apis
one
for
one
thing,
the
other
one
for
the
low
level.
B
B
B
But
what
my
team
suggests
was
what
I
believe
you
don't
like
that
was
of
like
implicit,
auto
wrapping
it.
Let's
say
this
is
just
a
regular
function
and
when
the
red
function
receives
this,
it
auto
wraps
any
function
that
you
give
to
them.
So
this
is
what
I'm
not
doing
today
and
that
that
was
a
question
for
my
team
and
I
believe,
that's
to
be
the
answer.
You
know
there
is
a
hand.
C
I
think
it's
a,
I
think,
a
few
more
layers
to
that
layer.
I
think
the
low
the
the
what
what
the
team
was
asking.
You
is
actually
a
more
high
level
api
yeah,
where
you
can
you
can
you
you
as
an
author
of
a
code,
the
developer,
you
don't
even
need
to
know
that
there
is
a
clear
separation
between
the
two
sides.
You
just
pass
functions
around
and
it
just
works
and
the
question
is:
can
we
do
that
in
user
land?
C
If
we
can
do
that
in
user
land
with
the
daniels
api,
then
great,
I
think
we
have
to
put
a
time
the
only
the
only
way
to
unblock
this
is
to
really
spend
the
time
on
it,
and
I
apologize
because
I
haven't
get
a
chance
to
do
that,
but
maybe
maybe
daniel
we
can.
We
can
spend
some
time
later
this
week,
one
of
the
mornings
for
me
and
and
see
what
we
can
do
there.
D
C
D
Well,
this
is
something
that
I
mentioned
last
meeting
that
I
really
feel
strongly
that
we
should
come
up
with
an
api
that
doesn't
require
you
to
eval
strings
and
that
this
api
still
still
does.
So.
I
hope
we
can
work
together
to
find
something
that
that
doesn't,
I
think,
you
know,
rather
than
connect
having
it
be,
that
you
have
this
way,
that
you
can
eval
something.
That's
that's
like
a
synchronous
function.
B
So
daniel
there
is
a
a
two-point
comment
that
I
have
here
both
for
when
you
actually
do.
Yes,
there's
this
problem
with
evaluation
of
strings,
and
yet
your
the
connect
api
there
you
that
you
need
something
that
I
believe
it's
hard
to
to
check
or
verify,
because
you
first
require
like
one
function.
That
needs
to
return
a
phone
return,
a
function
and
another
argument
is
a
string
that
evaluates
to
a
function
that
also
return
that
needs
to
return
a
function.
B
So
both
ways
are
not
only
like
the
string
evaluation,
but
you
also
like
the
need.
That
is
the
fact
that
you
need
a
function
that
returns
a
function.
It's
kind
of
it's
hard
to
verify
and
somehow,
like
test
this
wrapped
function.
Function
still
requires
like
to
to
have
for
to
send
the
red
realm
some
string
evaluation.
When
I
have
a
wrapped
function,
I
still
need.
B
I
still
send
it
through
a
function
that
I
create
through
string
valuation,
if
you
see
my
screen,
but
if
we
do
have
the
wrap
callback
function.
If
I
wrap
this,
I
like
for
wrapping,
the
wrapping
process
doesn't
need
any
string
evaluation
and
when
we
have
module
blocks
available,
we
could
definitely
explore
the
import
inject
injection
to
find
a
way
to
create
this.
So.
C
Yeah-
and
I
think
one
thing
that
I
wanted
to
note
this-
is
that
the
wrapping
on
wrapping
has
is
a
different
problem
than
evaluating
a
string.
We
could
do
it
with
modules.
We
could
do
it
different
ways.
The
wrapping
and
unwrapping
is
just.
How
are
we
going
to
allow
these
two
sides
to
communicate
with
each
other?
D
I'm
definitely
sympathetic
to
this
to
this
goal
of
making
the
api
more
intelligible.
The
api
they
designed
was
clearly
not
very
intelligible,
and
I
think
we
can
come
up
with
another
one
that
will
meet
the
important
properties,
but
not
require
you
to
eval
strings
or
to
have
these
kind
of
wrapper
indirections
that
mark
is
concerned
about.
I
think
I
think
there
are
other
ways
we
can
figure.
This.
C
C
B
B
I
am
not
sure
if
we
should.
We
should
probably
consider
expanding
this
if
we
want
multiple
names,
so
you,
if
you
send,
if
you
actually
use
an
array
of
names
that
you
want
to
use,
you
could
probably
receive
a
collection
of
names.
If
you
want
multiple,
we
we
want
to
explore.
I
I
would
like
to
explore
that,
and
this
way
it
doesn't
require,
like
you,
could
still
receive
a
wrapped
function
from
the
callback
in
code
that
you
inject
through
modules.
D
D
B
Well,
I
I
think
there
is
this
separation,
as
well
as
like
this
team
also
expect
something
that
is
more
on
the
high
level.
Of
course,
the
the
questions
are
very
valuable,
but
they
of
course,
they're
gonna,
like
we
want
to
work
on
the.
What
is
good
for
being
a
low
level
function
that
actually
doesn't
work,
there's
like
with
more
clarity
and
etc,
rather
than
just
bring
something
that
is
like
to
find
a
final
user
of
a
library.
B
D
I
mean
ultimately,
I'm
still
a
little
bit
worried
that
we
won't
meet
their
expectations
even
with
a
slightly
higher
level
api.
I
guess
this
is
along.
The
lines
of
the
point
mark
was
making
that
the
high
level
api
may
be
membranes
and
short
of
that.
Maybe
nothing
will
meet
their
expectations
or
maybe
something
would,
but
maybe
it
would
be
too
complicated.
D
C
Yeah
also
also
remember
that
this
team
of
people
that
leo
has
been
worth
working
with
these
are
library
developers.
They
are
the
ones
who
will
be
creating
abstraction
for
other
people
to
use,
at
least
for
us,
so
platform
developers
creating
on
top
of
these
api,
creating
the
layer
that
people
actually
use.
D
B
Yeah,
okay,
I
just
opened
this
issue
to
not
forget
about
what
we
say.
I
think
I'm
still
sharing
my
screen
and
I'm
gonna
stop
sharing
right
now
I
shared
this
link
of
this
polyview
in
the
zoom
chat.
I'm
gonna
make
sure
it's
in
the
agenda
and
I'm
gonna
stop
sharing
my
screen.
No,
I
think
we
have
an
good
homework
about
this
from
now.
I
don't
have
anything
to
else
to
show
unless
anyone
has
any
any
questions,
I'd
be
happy
to
try
to
answer.
C
C
C
States
there
was
a
question
on
the
where
is
going
to:
where
are
we
going
to
put
the?
If
sorry,
if
the
assertion
types
remember,
there
is
a
host
api
that
you
have
to
that.
The
this
that
is
specified
in
262
that
is
used
for
the
language
to
determine
what
are
the
types
that
are
allowed
or
supported
by
the
by
by
the
engine.
D
C
D
We
could
also
declare
those
in
a
repository
where
we
try
to
develop
these
these
common
conventions,
and
so
I
have
a
repository
for
this
calls.
I
can't
remember
what
I
called
it,
but
it's
it's
a
personal
repository.
I
would
like
it
to
not
be
a
personal
repository
if
people
feel
like
taking
it
up
and
collaborating
on
it,
and
anna
van
gastrin
was
just
proposing
that
import
assertion
types
be
standardized
there,
but
then
I
was
picturing
that
that
compartments
would
be
allowed
to
change.
That.
C
Right
and
the
question
really
is
because
the
invariants
that
are
being
described
in
the
in
the
pull
request
for
262
those
invariants
describe
what
kind
of
values
they
need
to
be
returned.
What
happens
if
you
call
it
multiple
times
and
so
on,
and
there
might
be
something
there
that
we
need
to
pay
attention
to
in
order
to
accommodate
the
potential
arrival
of
compartments
in
the
future.