►
From YouTube: Node.js N-API Team meeting 2020-02-03
Description
A
C
A
A
A
C
C
A
C
A
C
C
A
C
C
C
A
C
A
Okay,
so
then
it's
let's
keep
going
yeah.
C
A
A
This
one
so
yeah
I
looked
at
I
looked
at
this
issue
and
it
turns
out
that
that
we
were
right
the
first
time
around,
in
that
the
the
remover
app
should
only
be
called
when
when
when
the
constructor
fails.
Otherwise
it's
not
the
mo
to
remove
the
wrap,
because
when,
when
the
instance
is
garbage
collected,
then
the
native
site
will
be
notified,
and
so
all
that
will
remain
on
the
instance
that
is
about
to
die
anyway,
is
a
v8
private
with
the
pointer
which
is
now
stale.
A
A
The
funny
thing
is,
we
had
a
we
had
it
working
before,
but
it
was.
It
was
a
super,
convoluted
solution.
So
so
now,
because
we
introduced
this
crash,
we
actually
fixed
the
crash
reverting
to
the
state
in
which
we
were.
But
now
it's
a
lock.
The
code
is
a
lot
simpler,
so
so
huzzah
for
crashes,
but
yeah.
So
that's
I,
guess
that's
662.
If
I'm
not
mistaken
down
here.
No,
that's
662,
so
I
have
one
review
for
that.
So,
if
you
could
please
cast
a
cast
a
glance
upon
it.
A
I
would
much
appreciate
that
so
then,
okay,
so
this
is
the
context
of
our
stuff.
I
looked
at
it
and
boy.
If,
if
we
did,
if
we
did
go
with
an
add-on
class,
then
we'd
have
to
like
reimplementation
you
and
and
define
class
and
everything
so
so
I
figured
instead
of
doing
that,
lets
just
tack
it
on
the
environment
and
so
there's
a
PR
for
that
it
cannot
land
until
we've
back
ported
everything
to
210
and
the
last.
A
So
there's
no
type
safety
there
and
Anna
suggested
that
we
use
a
type
ID
and
and
store
that
on
the
environment,
along
with
the
pointer,
but
I
realized
that
we
don't
have
any
runtime
type
information
and
we
never
had
so
I,
so
I
think
Anna's,
okay
with
it
so
far,
but
again
needs
to
need
some
need
some
eyes
and
it
cannot
land
until
we
pack
ports
the
the
instance
data
two
to
ten
so
that
we
have
all
the
LTS
versions
covered.
Even
experimentally,
okay,
passing
up,
okay,
I
haven't
seen
this
one.
A
B
Yes,
wasn't
exactly
sure
about
this
one
either,
but
it's
what
I
ended
up
doing
was
creating.
We
had
a.
We
were
missing
a
test
for
the
property
to
scripture
property
descriptor
with
functions
that
have
custom
data,
so
I
added
a
test
in
that
PR.
That's
linked
in
this
tape
and
my
comment
therefore
take
a
look
at
the
files
changed
around
so
I
just
created
I
showed
him
an
example
of
how
you
would
create
how
to
do
it.
So
I,
don't
know,
I
haven't
gotten
any
response
back
from
that,
so.
A
A
C
A
A
We
should
I
believe
we
agreed
that
we,
this
should
be
like
in
an
extra
repo,
so
I
am
tempted
to
just
suggest
that
they
they
released
this
as
a
package
and
then
based
on
how
how
it
performs
on
NPM.
We
can
consider
adding
it
because
this
is
purely
additional
functionality
right,
so
we
would
normally
go
in
like
extras.
Mm-Hmm.
E
A
B
Something
here
that
I'm
not
seeing,
which
is
oh
six,
five
three
context
parameter
on
thread:
safe
function.
That's
a
little
up.
Contacts
parameter
on
thread;
safe
function,
callback,
yeah
right,
yes,
yeah!
Okay,
here
it
is
yeah.
I
want
to
talk
about
this
one
yeah,
so
Lucas
brought
this
one
out.
Basically,
what
we
saw
is
that
the
context
is
not
being
passed
to
the
callback,
that's
being
provided,
and
you
can
see
it's
actually
being
completely
ignored
in
this
and
that.
B
I'm
not
100%
sure
that
the
best
approach,
if
it's,
how
to
accomplish
this
in
a
backwards
compatible
manner
because
now
I
feel
like
the
next
function
like.
If
we
were
to
modify
the
signature,
we
would
have
to
add
the
context
to
the
existing
code.
That's
already
existing.
That
already
has
whatever
signature.
It
has
so
I'm,
not
sure
unless
we
create
some
sort
of
other
way
to
construct
a
new
thread.
Safe
function
like
a
different
new
method
or
something
I,
don't
know,
I'm
just
throwing
ideas
out
so.
A
I'm,
just
trying
to
figure
out
is
this
context
not
being
passed
to
do
the
JavaScript
callback,
even
even
in
core
I.
B
B
A
B
Okay,
so
what
ends
up
happening
is
so
we
end
up
calling
the
user-provided
function
only
with
the
the
environment
and
the
original
call
that
was
given.
We
that
was
registered
with
the
thread-safe
function.
We
completely
just
don't
pass
the
context
on
line
four
five:
eight
yeah,
it's
just
completely
ignored
so
I,
don't
know
how
we
would
be
able
to
add
an
additional
parameter
there
right.
A
Yeah
bond
four
five:
a
yeah
yeah
yeah,
okay,
okay,
we
don't
have.
We
don't
have
like
two
two
additional
parameters:
yeah
right,
right,
right,
I,
understand,
yeah,
I,
think
yeah
I.
You
know
when
when
when
when
I
wrote,
the
threats
a
function,
I
I
may
have
overdone
it
with
with
the
would
avoid
stars
right
because
then
there
was
there
was
a
comment
at
the
time
like.
Why
do
you
need
two
of
them?
One
for
the
context,
one
for
the
data.
C
A
So
yeah
that
okay,
so
I
think
if
I
remember
correctly
and
it's
been
a
while.
The
distinction
is
that
the
context
is
available
on
any
thread
and
you
can
retrieve
it
with
nappy,
get
thread
safe,
function,
context
here,
as
whereas
the
data
I
believe
is
just
the
thing
that
we
passed
to
to
the
JavaScript
callback
so
that
it
might
have
some
data
which
JavaScript
callbacks
tend
to
have
yeah.
A
E
A
D
C
A
So
because,
like
you
know,
if
you
want,
if
you
want
to
use
the
context
in
the
C
function,
then
that
would
have
to
be
passed
as
a
as
a
parameter,
because
you
don't
normally
get
it.
If
I
remember
correctly,
you
just
get
the
environment
and
yeah
you
get
the
environments
to
call
back
right,
but
you
don't
get
the
threats
a
function
itself.
So
if
you
want
it
to
use
that,
you
would
have
to
use
that
as
one
of
the
parameters
and
you
wouldn't
it
couldn't
be
the
context.
B
A
B
A
A
A
A
Okay,
so
the
context
is
really
the
data
in
this
case
right,
whereas
whereas
the
data
is
is
like
the
per
invocation
data,
so
you
know
I,
just
I
just
have
an
inkling
of
an
idea,
so
please
shoot
it
down
immediately.
If
it's
got
holes
in
it
already,
could
we
use?
Could
we
use
like
a
different
call
back
in
for,
like
maybe
a
subclass
of
our
yeah?
No,
not
a?
What
is
that
nappy
yeah
its
callback
info
right?
A
Could
we
use
a
subclass
of
callback
info
for
the
thread
safe
function,
which
has
like
an
additional
message?
Besides,
like
this
and
and
so
forth,
where,
where
okay
I
know,
data
is
taken
right?
So
so
you
know
the
data
would
be
would
be
the
context
in
this
case,
because
that's
that's.
The
purpose
that
it
serves
elsewhere
is
like
this
that
the
thing
that
is
associated
with
the
binding
right,
and
so
we
would
have
something
like
like
cue
item
or
something
like
that.
A
B
So
a
now,
while
we're
thinking
about
this
there's
also
another
thread-safe
function
issue
with
the
semantic
differences
and
that's
issue.
Five,
nine
four,
so
I'm
wondering
if
just
like
there's
needs
to
be
some
complete
overhaul
and
what
we
need
to
do
so.
This
story
here
talks
about
how
there's
differences
between
we
know:
Dada,
api's
implementation
of
blocking
call
and
non
blocking
call,
because
here
we
pass
a
callback
and
we
don't
have
that
ability
in
the
C
function
right
and
the
C
functions
his
passive.
B
B
A
There
is
a
trade-off
between
between
performance
and
and
this
flexibility
that
the
class
introduces
and
I
know
that
I
know
that
in
the
original
implementation
there
there
were
calls
to
to
make
it
to
make
make
it
possible
to
pass
a
function
pointer
back
from
one
of
the
threads
and
have
it
run
on
the
main
thread,
so
that
so
that
there
isn't
a
single
call
j/s,
but
rather
there's
a
different
call
J
as
for
each
data
item.
So
so
yes,
that
that
was
not
that
that
that's
not
unheard
of
okay,.
B
A
A
Cuz
I
mean
if
we,
if
we
take
away
this
flexibility
right,
you
can
still
do
like
an
if
this
then
called
that
function,
otherwise
called
that
function
otherwise
call
another
function.
You
can
still
do
this
in
the
college
as
for
yourself
right
and
then,
and
then
that
would
that
would
not
have
to
be
wrapped
and
you
wouldn't
we
wouldn't
have.
We
wouldn't
be
doing
this
like
function,
signature,
translation,
all
the
time
and
all
that
so
so
yeah
yeah
these
are
yeah.
These
these
both
seem
like
fairly
fundamental
issues
and
yeah.
A
A
C
A
A
A
A
D
D
C
A
A
A
B
A
Truth
in
truth,
the
milestones
were
more
relevant
when,
when
we
were
sort
of
ramping
up
an
API
now
we're
kind
of
you
know
main
sequence,
so
to
speak.
So
so
things
things
are
slow
and
and
they're
just
kind
of
accumulating,
but
I
guess
I
guess
this
has
become
sort
of
a
issues
tracker
that
is
sort
of
elevated
and
the
things
that
we're
focusing
on
is
basically
listed
here
and
that
changes
for
the
time.
I
guess
right.
A
Mind
you,
but
it
does
change
so
so
I,
don't
know
honestly,
okay,
you
know
what
I'll
make
the
milestone
and
we
can
move
it
to
this
one.
If
we
disagree
later
so,
I
just
don't
know
how
to
make
a
milestone.
How
does
one
make
a
milestone.
A
A
A
A
Okay,
how
about
this?
For
now
we
will
we'll
figure
it
out
put
okay,
but
this
is.
This
is
fairly
core
okay,
so
then,
let's
keep
going
because
we
only
have
17
minutes
butter,
butter,
butter
butter.
Where
were
we
okay,
so
that
these
were
some
of
the
issues?
Okay,
so
no
to
repo,
not
much
if
I
remember
correctly,
but
that
could
be
mistaken.
So.
A
A
A
D
D
A
Okay,
yeah,
okay,
that's
cool,
that's
cool,
okay,
good
yeah!
That
works!
That's
great
yeah,
so
so
by
the
time
on
we're
complete,
gets
called
the
the
thread-safe
function
is
guaranteed
to
not
only
be
gone,
but
also
be
empty.
Good.
Okay,
that's
great
yep,
okay,
all
right
good!
So,
okay,
so
okay!
So
we!
A
We
could
still
do
this,
though,
though
in
core
I'm,
not
sure,
if
I'm
not
sure
how
to
do
this,
so
that
you
know
if
you,
if
you
call
release
release,
doesn't
return
until
the
finalizar
was
called
right
because
in
court,
that's
how
you
would
do
it
synchronously
and
in
order
to
do
that,
the
only
way
that
I
can
think
of
is
after
is
you.
You
just
start
an
event
loop
that
that
holds
the
the
control
at
at
the
point
past
release
at
just
past
release.
A
Until
until
the
finalize
gets
called
you
know,
and
then
you
have
a
flag
which
says:
okay,
finalize
what's
called,
and
then
you
say:
okay
terminate
this
evently
return
this
function
and
go
back
to
your
original
event.
Look
like
I've
done
that
before,
but
it's
generally
not
a
good
idea
to
start
the
second
event
of
just
for
this
event,.
A
We're
only
talking
about
the
JavaScript
thread
right,
so
so,
basically
the
idea
is
this.
You
know
nappy
release,
thread
safe
function,
you
know,
UV
blue
new
new
run,
and
then
you
know,
or
or
while
threats
a
function,
not
signaled
as
being
dead.
Uv
loop
run,
one
run
one
iteration
of
the
loop
right
and
then
and
then
you
know
that
flag
gets
set.
A
You
don't
need
to
worry
about
new
taxes
because
it
gets
set
on
the
same
thread,
because
the
finalized
runs
on
the
same
thread
as
as
this,
this
baby
loop,
which
is
simply
waiting
right
and
then
it
gets
set.
And
then
you
know
the
this
loop
terminates.
You
clean
up
this
loop
and
you
return
the
function
right.
So
it's
a
trick.
I've
used
it
before,
but
it's
not
a
good
idea,
because
you
know
the
UV
invent
loop
is
not
something
to
play
with
lightly
right.
A
So
so
and
but
but
the
effect
would
be
that
you
know
all
the
other
file
descriptors
everything
they
will
still
drain.
They
will
still
make
callbacks
into
JavaScript
and
so
forth,
but
there
could
be
a
myriad
implications
on
one
of
the
myriad
platforms
on
which
we
run.
You
know
that
would
probably
make
this
not
such
a
good
idea.
You
know
to
do
it
that
way,
but
that's
how
you
would
that's
how
you
would
simulate
synchronous,
draining
and
and
and
destruction
on
in
core.
A
That's
the
only
way
I
can
think
of,
because
you
can't
use
a
you
can't
use
like
a
thread
synchronization
variable,
because
then
that
would
block
the
entire
JavaScript
thread
right,
and
so
so
you
know
it
would
be.
You
would
be
acing
sending
all
these
things
right,
but
on
the
JavaScript
thread,
the
the
call
just
wouldn't
run
anymore,
because
the
thread
is
blocked
right.
So
you
can't
use
a
synchronization
primitive.
The
only
primitive
you
can
use
is
this
stay
here
basically
run
the
event
loop.
A
While
some
variable
is
still
false
or
true
or
whatever
you
choose
you
know
so
then
you,
your
your
thread,
still
runs,
but
control
doesn't
pass
away
from
from
from
that
function.
You
know,
and
that's
still
asynchronous
in
a
way
right,
because
you'll
be
getting
all
kinds
of
events
that
the
drain
events
will
still
be
happening,
so
so
yeah
I,
don't
know
that
we
have
that
option.
C
A
A
Oh
I,
don't
know
what
happened
here.
Oh
okay,
right!
Yes,
yes,
that
was
a
good
addition.
The
no
return
with
you
I
think
the
no
return
for
Windows
was
just
empty
and
this
person
came
up
with
with
the
actual
definition
that
works
well
in
Windows,
so
yeah
this
necklace
back.
They
have
I.
Remember
that
okay,
so
okay,
syntax
fix.
That's
a
good
one.
A
B
A
Okay,
so
so
it's
a
it's
a
conceptual
thing
right.
When
you
throw
when
you
throw
a
JavaScript
exception,
then
you're,
basically
forcing
forcing
a
certain
a
certain
way
of
handling
it
right,
whereas,
whereas
if
you're
just
throwing
an
error
status,
then
you're
leaving
it
up
to
the
to
the
add-on
developer
to
either
through
handle
that
as
an
exception
or
handle
it
otherwise,
and
so
so
you're
giving
more
control
to
the
to
the
add-on
developer.
Does
it
mean.
A
To
throw
an
exception
right
so
if
you
throw
an
extent
their
behalf
and
they
don't
want
that
now
they
have
to
like
catch
the
exception,
clear
the
exception
and
then
do
whatever
it
is
that
they
wanted
to
do
so.
So
that's
that's!
That's
basically
like
doing
a
giant
dance
so
that
you
can
do
something
really
small.
You.
A
Indication
and
then
you
can
keep
it
small
or
you
can
blow
it
up
into
an
exception.
If
you
choose,
you
know
right
kind,
more
control
to
the
add-on
develop,
and
so
so
I've
a
little
bit
late
in
the
game.
I
admit:
I
I've
made
it
my
principle
not
to
throw
exceptions
from
core
if
at
all
possible,
you
know
just
let
let
the
add-on
decide
whether
that's
worth
an
exception
or
not.
A
Because
then,
then,
if
you're
no
longer
throwing
an
exception,
then
add-ons
that
are
out
there
are
handling
an
exception
which
is
now
no
longer
being
thrown
and
they're
not
handling
the
status
which
now
is
being
set
right.
So
so
so
so
this
is
good
to
make
this
change,
while
it's
still
experimental,
because
after
that,
it's
it's,
it's
not
only
is
its
Ember
major,
its
Ember
major
for
napi
right.
So
then
that's
not
very
likely
to
ever
happen
unless
we
ever
have
on
an
API
version
tree.
A
A
Yeah,
however,
I
believe
that
it's
gonna
land
in
the
napi
six,
which
which
were
still
sort
of
which
is
beginning
to
crystallize,
slowly
but
surely,
and
then
and
then,
once
once
we
once
we've
decided
what
we're
gonna
make
part
of
an
API
six.
Then
we're
gonna
have
a
series
of
back
boards
which
which
moves
those
those
functions.
C
C
A
Then,
and
at
that
point
they
shall
be
set
in
stone
forever
and
ever
amen
all
right
all
right.
So,
let's
see
what
we
have
open
here,
only
one
page,
which
is
always
good
okay.
So,
yes,
this
issue
remains
open,
backport
still
hasn't
landed,
hoping
that'll,
land,
soonish,
I'm
being
told
January
February.
So
of
that
one
is
already
gone.
A
Alright,
so,
okay,
this
yeah,
this
yeah
there
are
I,
think
two
of
them
that
are
in
that
December
major.
So
so
we
this
landed
with
nappy
exception.
Pending
you
know.
If
the
environment
is
being
torn
down,
there
is
now
no
distinction
between
whether
whether
you
know
you
know
there's
an
exemption
pending
because
there's
an
exception
pending
or
there's
an
exception
pending,
because
the
environment
is
being
torn
down
and
you
can't
even
run
JavaScript.
So
that's
that's
a
that's
a
bad
ambiguity,
I
think,
but
too
late.
A
So,
okay,
okay,
so
yeah.
We
still
have
this
open
I'm,
not
sure
where
this
is
going
I'm
kind
of
following,
but
not
very
closely,
so
the
error
status.
That's
basically!
This
is
where
we
sort
of
hashed
out
this.
This
exception
versus
versus
status
thing,
and
some
of
it
is
December
major.
Unfortunately,
so
nick
has
been
working
on
this
for
a
while,
still
working
on
it.
This
thing
should
be
okay,
once
once
version
v8
version,
seven
point
eight
is
available
everywhere.
You
should
go
away
because
we've
established
this
is
a
v8
issue.
A
A
Some
people
might
need
this
and
I
don't
know,
I'll
keep
thinking
it
every
once
in
a
while.
This
is
for
very
strong
typing,
where
you
can
just
take
any
object
and
just
sort
of
paint
it
with
a
certain
color
that
everybody
recognizes,
and
one
of
the
core
features
will
be
that
the
color
survived
a
module
like
the
module
disappearing
and
then
reappearing
in
in
the
environment.
A
So
that's
why,
in
this
one
I
went
with
you,
you
IDs
before
I,
used
to
use
like
a
pointer
to
a
global
static,
but
then
I
realized,
if
you
unload
the
module
and
you
reload
the
module
that
pointer
may
change,
and
so
if
there
are
objects
which,
having
been
garbage
collected
from
the
previous
instance
of
the
module,
they
would
no
longer
be
recognized
as
being
of
that
fight.
So
so
that's
that's
where
that's
at
it's
moving
very
slowly!
A
A
C
A
One
of
the
tests
for
threads
a
function
is
such
that
okay
run
run
like
a
million
iterations
of
this,
because
by
then
the
thread
that
the
queue
will
have
filled
up
for
sure
you
know,
but
it's
one
of
those
it's
one
of
those
who
gets
there.
First,
it's
basically
an
intentional
race
condition
and
and
Windows
has
the
threading
setup
in
such
a
way
that,
even
if
there's
a
million
runs
of
the
thread,
it'll
still
finish
and
it'll
still
not
fill
the
queue
so,
and
that
happens
sometimes
not
always
so.
A
The
the
the
good
solution
here
would
be
you
just
to
just
have
like
something
that
is
deterministic
as
much
as
possible
and
still
simulate
the
idea
that
the
P
fills
up,
because
the
other
thread
is
busy
okay.
So
this
this
has
been
sort
of
lingering.
This
shared
the
rate
buffer,
I
review
it
every
once
in
a
while
when
I
get
a
chance
and
then
the
issue
that
that
spawned
it
and
this
this
is
a.
This-
is
a
an
overall.
C
A
That
that,
basically,
now
that
we
have
worker
threads,
this
might
actually
get
wound
up
again,
because
workers
rights
have
become
stable
and-
and
this
is
this
is
sort
of
like
you
know.
Why
not
have
a
nappy
new
end
right?
Where
you
will
you
spawn
this
whole
nodejs,
and
now
you
have
an
end
to
it.
So
now
you
can
do
things
in
the
end
better
as
a
native
add-on
or
as
I
mean
better
of
nodejs
and
so
figuring
out
at
what
point
I
wanted,
what
does
it
mean
to
launch
a
no
js'
instance?
A
A
Okay,
so
then
I
think
we
would
need
Nick
for
this.
One
I
don't
know
if
this
is
still
relevant,
because
we
don't
have
any
gold
alerts
coming
up
soon.
This
thing,
I,
don't
think
it's
changed
from
last
week,
but
please
correct
me:
if
I'm
wrong
is
this
thing?
We've
had
a
little
bit
of
work
with
now
that
we've
established
that
the
validation
thing
should
be
an
extra
rather
than
part
of
no,
that
on
API
and
then
the
tutorials.
A
C
Know:
okay,
I
regret
that
Kevin
dropped
off,
because
what
we
need
to
do
is
move
the
example.
Projects
onto
the
Foundation's
example
site
and
I
believe
Kevin
has
one
of
those
so
I
will.
My
plan
now
is
to
identify
the
mother.
They
examples
that
meet
need
to
be
moved
over
to
the
repo
and
then
all
I
believe
Kevin
has
one
of
those
so
I
will
I
will
paint
Kevin
on
this
issue.