►
From YouTube: 2020-03-26-Node.js N-API Team meeting
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
So
welcome
to
the
node.js
node
api
team
meeting
for
march
26
2021
we'll
follow
our
standard
practice
of
looking
through
the
things
we've
tagged
with
milestone
11.
before
we
do
that.
Does
anybody
have
any
announcements
they'd
like
to
share.
A
A
A
I
think
it
was
back
still
to
that.
I'm
not
sure
if
everybody
was
here
when
we
were
talking
about
it
last
time,
but
it's
this
issue
is
around
during
shutdown.
A
Does
you
know
throwing
a
fatal
error
make
sense
or
not,
and
we
have
talked
about
like
we
should
probably
have
a
way
to
opt
in
to
you
know,
providing
a
better,
better
error
code
so
that
the
app
can
tell
like.
Am
I
shutting
down,
or
on
my
exception,
so
I
think
that's
sort
of
a
separate
track
that
yeah
we
should
do
that.
That
probably
will
take
a
little
bit
longer
in
terms
of
you
know.
We
need
to
fix.
A
A
I
think
separately
on
this
issue,
though,
if
we,
if
we
make
the
decision
that
doing
something
differently,
makes
sense,
we
can
do
that
because
you
know
I
I
at
least
I
think
I've
come
up
with
this
workaround.
That
says
you
know
if
you
check
beforehand,
if
there's
an
exception
pending,
then,
if
you,
if
you
get
an
error
that
tells
you
that
an
exception
is
pending,
that
means
that
it
was
the
the
shutdown
like
you
couldn't.
It
means
you
couldn't
call
into
javascript.
B
Then
does
this
work
around?
Are
there
any
situations
when
this
workaround
explains
a
situation
where
it's
not
a
shutdown?
Do
you
know
what
I'm
I'm
trying
to
ask
like
this?
This
thing
we're
fixing
that
problem
with
with
this
workaround,
but
could
we
be
maybe
affecting
other
things
with
this
workaround
or
are
we
100
sure
that
this
workaround
is
only
because
would
only
happen
if
javascript
is
shutting
down
and
you're
trying
to
call
into.
A
I'm
I'm
like
99,
because
I'm
never
100,
but
like
look
looking
at
the
code,
you
know
this.
This
nappy's
exception
pending
basically
just
says,
I'm
going
to
tell
you
whether
there's
an
exception
pending
or
not
right
on
the
thread,
and
then
we
immediately
call
this
not
be
throw,
and
the
very
first
thing
it
will
be
doing
is
checking
whether
there's
an
exception
pending
or
there
you
can.
You
can't
call
into
javascript.
C
Wait
a
second:
you
have
to
get
the
clear
exception,
first
right.
Why?
Well,
if
it's,
if
you
have
an
api's
exception
pending
and
you
don't
clear
it,
then
it
remains
pending
and
it
will
continue
to
be
pending.
And
so,
when
you
throw
it's
going
to
say
it's
going
to
return
an
api
exception
pending
because
it's
still
pending,
you
haven't
cleared
it
yet.
A
But
that
that's
what
we're
trying
to
actually
avoid
here
right,
so
you
see
that
we
say
is
it?
Is
it
pending?
If
it's
false,
then
we
call
nappy
throw
otherwise
we
just
say:
oh
the
status
was
exception
pending.
I
don't
need
to
call
throw
to
find
out
that
it's
going
to
tell
me
the
exception
was
pending.
D
A
Js
mm-hmm,
so
I'm
pretty
sure
that
you
know
it's
if
there,
if
there
is
an
exception
pending,
you
should
get
the
exact
same
answer,
because
this
throw
before
it
does
anything
should
basically
say.
Is
there
an
exception
pending,
and
so
this
status
should
be
the
exact
same
as
you
would
have
gotten.
We
just
haven't
had
to
make
the
call
and
if
it
wasn't
pending,
then
the
only
reason
that
you
should
get
this
exception
pending
is,
if
it
actually,
you
couldn't
call
into
js.
C
C
You
should
also
use
like,
like
the
other
macro,
that
actually
checks
that
there's
an
exception
pending.
Oh
my
goodness,
how
did
we
miss
this
one.
A
C
A
A
So
it's
I
mean
I
did
come
across
the
case.
So
then,
then
I
don't
know
the
stars
align
right,
so
I
I
was
investigating.
I
was
working
through
one
of
our
samples
that
we
have
in
the
the
ibm
learning
path,
and
I
noticed
that
it
was
actually
you
know
having
a,
and
I
think
I
have
that
in
here
somewhere
right.
I
I
I
came
across
this
failure
where
basically
the
throw
is
accepted,
as
javascript
exception
was
complaining
in
the
shutdown.
A
So
you
can
see
that
this
is
like.
We
were
running
the
cleanup,
it
was
running
the
cleanup
handles
and
you
know
I
I
saw
this
and
it
actually
lent
len.
In
the
end,
I
I
could
rework
the
code
so
that
it
actually
did
the
shutdown
before
like
it
was
trying
to
do
the
shutdown
of
sql83
in
an
exit
in
the
exit
hook,
and
so
what
I'm
not
100
sure
is
like
should
we
you
know
we
talked
earlier
like.
A
Maybe
we
should
let
you
run
javascript
further
into
the
process
right,
so
maybe
we
should
be.
You
know
if
we
fix
that
it
would
have
changed
this,
but
it
was
a
case
where
I
was
able
to
change
the
code
and
it
now
does
what
it
should
do
versus
what
it
shouldn't
be
doing,
which
was
like
you
know.
If
we
changed,
if
we
put
in
this
workaround,
we
wouldn't
have
seen
that
failure.
A
A
So
I
did
I
you
know
I've
asked
an
issue
in
sqlite.
I
don't
know,
I
don't
think
there's
been
any
answer
like
well.
Is
it
intentional
that
you
can
do
this,
or
is
this
like
user
error
already
right.
A
C
B
Yeah,
I
think
it
would
have
been
better
than
to
not
have
the
fix,
so
you
would
see
this
error,
because
what,
if
you
did
have
something
that
was
really
critical
in
your
cleanup
path?
Right
now,
it's
not
happening
because
we've
it's
not
happening
it.
It
would
have
never
happened
anyways
because
of
the
bug.
But
now,
if
you
introduce
this
work
around,
you
would
have
never
seen.
A
A
C
There's
there's
another
there's
another
thing
here,
like
that:
your
your
work
around,
whereby
we
detect
the
error
we
detect
the
inability
to
to
execute
javascript
may
still
be
a
good
thing
to
have,
but
the
result
of
that
should
not
be
returned.
It
should
be
to
throw
through
the
existing
exception,
as
a
fatal
as
a
fatal
exception
right
instead
of
throwing.
C
So
basically
what
I'm
saying
is
surface
the
error
surface,
the
original
error,
rather
than
the
error
caused
by
trying
to
throw
the
error,
because
that's
obscuring
the
real
reason
right
so
that
that's
a
totally
I
yeah
that
might
be
another
different
bug
so
yeah,
basically
in
this
snippet,
instead
of
the
return
you
want
to,
like
fatal
exception,
the
the
original
that
you
were
trying
to
throw
right.
C
That's
that's
the
only
change
here
and
that
that
I
think,
is
right,
because
the
only
alternative
you
have
when
you
cannot
execute
javascript
to
inform
the
user
is
through
a
fatal
error.
Regular
throwing
is
out
of
the
question
right
so,
but
you
do
need
to
surface
it.
Otherwise
we
end
up
in
this
situation.
Where
you
don't
even
know,
an
error
happened
right.
So,
like
I
don't
know,
I
don't
think
it's
a
good
idea
to
swallow
errors
right.
We
should
leave
that
up
to
the
application.
C
Yeah,
I
I
know
of
a
precedent
glib
has
this:
you
can
set
an
environment
variable
where
critical
warnings
are
considered
fatal.
Okay,
so
yeah.
That's.
E
C
And
and
then
glib
or
the
c
library
has
has,
has,
has
this
thing
where,
where
you
can
set
like
you,
can
set
an
environment
variable,
it
even
has
like
two
different
levels
where,
where,
where
malloc
failures
are
fatal
or
something.
C
A
A
C
Yeah
yeah
yeah
this
yeah
this
particular
case
would
benefit.
I
think,
for
my
user
choice,
okay
and
and
actually
I'm
I'm,
not
a
hundred
percent
sure
yeah-
I
know
I
know
doing
like
an
environment
check
is-
is-
is
a
huge
task
but
come
to
think
of
it.
It
might
be.
It
might
be
useful
to
make
the
runtime
option,
because
you
know
then,
if
this
is
happening
in
production,
you
you
don't
need
to
rebuild.
You
need
only
turn
this
on
and
and
you
can
get
the
error
you
want
and
you
can
turn
it
back
off.
C
E
C
A
C
A
B
E
E
C
C
B
Is
javascript
and
you
can
have
it
as
an
optional
boolean
that
already
has
a
value
of
like
false
or
whatever
we
want
to
be
the
default
behavior
so
that
you
wouldn't.
So
if
you
recompile,
you
don't
have
to
change
your
code.
You
just
take
the
default
so
like
this
function
here.
A
E
A
Okay,
if
I'm
doing,
if
I'm
terminating
threads,
the
only
thing,
I
think
the
problem
I
think
with
that,
actually
is
that
a
lot
of
this,
the
traces
that
were
being
reported
were
like
our
own
internal
flows.
We're
like
we
try
and
do
say
we
try
and
make
a
function
call.
E
A
C
C
C
E
C
For
returning
better,
better
status
codes,
well,
you
know,
that's
that's
something
we
store
on
the
environment,
but
it
has
to
be
done
in
core
right
and
actually
actually
I'm
starting
to
think
that
the
two
are
kind
of
coincident,
because
because
once
once
the
once
we
have
the
api
for
opting
into
better
status
codes,
then
we
will
have
the
status
code
right
and
then
we
can.
We
can
write
this
work
around
using
the
status
code.
We
can
just
check
for
the
new
status
code.
Oh
yeah,.
A
D
C
Yeah
and-
and
you
know-
and
then
you
know
we
since
this
is
new
api-
we
might
just
surface
that
status
code
to
the
user
and
let
them
deal
with
it
and
then
they
can
give
us
the
boolean,
and
you
know
so
so
b.
We
can
basically
work
this
hooking
to
know
that
on
api
once
we
have
it
and
then
and
then
that'll
be
that'll,
be
an
opportunity
to
to
handle
this
exception
better,
something
like
a
user
configurable.
So
we
could
have
like.
E
C
We
could
have
a
callback
that
says
you
know
in
case
of
failure.
You
know.
C
C
Accept
I'm
sorry
wrong.
Word
we're
probably
going
to
want
to
refine
the
occasions
when
we
throw
a
javascript
exception
right
so
right
now
we
throw
a
javascript
exception
under
any
non-ok
return
right
right,
so
we
may
want
to
say
non
okay
and
non
cannot
call
into
js
only
then,
because
that
would
be
consistent
with
what
we're
doing
now
right
and
then
in
the
in
the
cannot
call
into
js
case.
Then
don't
don't
throw
as
exception,
but
I
don't
know,
call
some
user
function.
You
know
or
just
simply
return
to
status.
A
C
Yeah
yeah,
that's
what
I'm
saying
like
basically
like
in
function
in
function,
call
and
call
and
call
right
if
the
result
of
an
api
call
function
is
anything
other
than
an
api.
Okay,
we
currently
throw
that
as
an
exception
right
yeah.
But
what
I'm
saying
is
we
refine
that
if
it's,
if
it's
not
an
api,
okay
and
it's
not
an
api-
cannot
call
into
js,
then
you,
then
you
do
whatever
you
do
now.
C
Otherwise,
if
it's
an
api,
okay,
well,
then
you're
fine,
and
if
it's
an
api
cannot
call
into
js,
then
you
invoke
a
new
code
path
right,
which
we
will
expose
to
the
user
and
the
user
will
have
a
choice
and
etc,
etc.
Now
we
we
still
have.
We
still
may
have
a
problem
where,
okay,
what
is
that
choice
right
like
okay?
So
here
we
are
holding
this.
C
An
api
cannot
call
into
js
status
in
our
hands,
but
but
the
the
function
call
routine
is
supposed
to
return
an
an
api
value
right,
the
return
value
from
the
function,
and
so
how
do
we
tell?
How
do
we
tell
the
user
that
that
that
the
status
happened
right?
C
If,
if
we
expect
a
user
to
to
register
like
some
kind
of
hook,
then
again
we're
in
the
same
situation
where,
where
do
you
store
that
hook
right?
So
so,
then
we're
still
basically
at
square
zero.
I
know
that
on
api,
but
at
least
in
core
we
have
this.
We
have
this
functionality
in
place,
so
you
know
instead
of
storing
a
boolean
somewhere.
Now
we
need
to
store
a
function
pointer
somewhere.
You
know
that
on
api,
so
right.
C
C
Obviously
we
could
introduce
a
more
midi
wrapper
around
the
environment
which
which
sets
which
sets
the
the
the
the
instance
data,
and
then
the
user
doesn't
see
that,
but
but
then
I'm
not
sure
about
about
api
compatibility
there,
because
you
know,
if
you
know
if,
if
there's
a,
if
the
user's
code
is,
is,
is
sort
of
a
mixture
between
between
core
and
wrapped
code.
So
if
the
user
makes
something.
E
C
An
api
calls
by
hand,
then
they
expect
a
bare
environment,
and-
and
you
know
we
don't
get
a
chance
to
unwrap
it
for
them
if
it,
if,
if
we
do
end
up
wrapping
the
environment,
so
so
that's
that's
going
to
break
api
right
there.
No,
not
it's!
Not!
It
doesn't
break
core
abi,
but
it
does
break
no
dead
on
api.
A
C
It's
not
it's
got
to
be
node
core
yeah
sounds
sounds
like
this
is
going
to
be
a
compile
time
option
because
doing
it
at
runtime
is
just
right.
Yeah,
it's
it's!
I
don't
see
a
way
to
do
it
at
runtime
unless
we
start
depending
on,
unlike
the
beauty
which
is.
C
A
No,
I
I
think
I
think,
like
I
think,
especially
like,
if
we're
going
to
do
it
in
phases.
Like
I
see
the
first
phase
is:
do
we
want
to?
We
want
to
do
a
work
around
just
by
changing.
You
know,
use
this
workaround
to
say
well
in
this
case
we
can
figure
out.
If
it
was
this
and
and
let
the
developer
choose
to
do
something
different,
I
think
just
a
compile-time
thing
would
be
fine
and
then
once
we
introduced
the
better,
you
know
the
way
to
opt-in
to
better
handler
error
codes.
A
A
A
A
A
C
Please
can
we
make
sure
that
we
have
a
chance
to
talk
about
the
environment,
tear
down
reference
cleanup,
because.
C
C
A
C
37-802,
okay,
so
take
it
away,
yeah!
So!
Well!
I,
as
you
can
see
there.
I
I
did
cherry
pick
your
your
fix,
but
it
sounds
like
it.
It
may
not
be.
It
may
still
not
be
a
hundred
percent
because
I
think
lucas
already
cherry-picked
it
on
his
branch
and
he's
still
getting
a
crash.
C
E
E
Yeah
and
I'm
not
sure
right
now
that
if
the
crash
is
related
to
the
one
we
are
fixing,
but
the
the
question
place
is
quite
similar
right,
it's
still
in
the
second
pascal
pack,
and
so
I'm
not
sure
I
will
have
a
quick
dig
into
the
issue
so
that
we
can
determine
if
we
maybe
land
this
before
the
next
release.
D
E
C
Okay,
you
you,
could
you
could
just
check
out
this
pr
right
and
then
that
has
this,
this
pr
is
on
the
latest
14
point
x,
and
so
you
can
just
check
out
this
pr.
Okay,
all
right!
So
so
you're
gonna
check
out
this
pr
and
and
then
see
if
you're
still
getting
this
crash,
correct.
A
Yeah
and
then,
if
you
can
find
like,
if
it
does,
I
guess
like
a
whatever
test
recreates.
It
would
be
good
yeah.
E
Yeah,
so
the
problem
seems
quite
similar,
so
I
am
not
sure.
Maybe
if
I'm
checking
the
correct
branch
and
maybe
the
problem
is
getting
fixed
anyway,
I'm
I'm
going
to
do
it
sooner
or
later.
F
C
A
Is
okay?
So
let's
move
back
to
blog
post
about
transition
to
node
api?
I
think
that's
I
don't
see.
I
don't
think
we've
made
any
progress
yet
I
don't
know
we
we
last
time
we
spent
a
little
bit
of
time.
Just
to
put
the
outline.
I
guess
it's
just
a
matter
of
you
know.
Somebody
needs
to
have
some
time
to
take
a
look
at
writing
it
up.
A
Yeah,
I
don't
think,
there's
any
more
time
anything
else
to
discuss
on
it
this
week.
No
okay!
So
this
one,
let's
see
where
we're
at
three
four.
A
Oh
okay,
so
this
one
right!
Yes,
I
remember
why
we
put
it
on
right.
Okay,
that
one,
I
think,
we've
basically
got
it
resolved.
We
submitted
a
pr
to
ref.
Was
it
nappy
ref
and
it
seemed
you
know
we
had
to
recreate
the
juice
put
together.
So
I
think
it's
all
done.
We
can
take
that
off
our
agenda
here.
F
F
A
Okay,
okay,
so
let's
go
back
to
anything
else
on
that,
one
that
you
want
to
bring.
D
Up
or
let's
see
I'll
just
continue
through
the
list,
sure.
F
We
we
have
two
issue
and
paragraphs
on
the
api.
If
you
have
time
you
can
yeah,
surely.
F
The
yeah
nine
five
three
and
nine
five
one
okay,
so,
let's
just
one,
is
for
the
documentation
and
another
is
for
the
source
code
comments
in
source
code.
F
He
he
updated
the
request.
F
Just
before
so
yeah,
I
need
to
review
the
changes
that
I
requested
to
him.
Okay,.
A
Okay,
so
that's
good,
but
yeah,
that's
another
one
along
the
same
lines
of
people,
so
if
people
can
take
a
look
and
we'll
get
those
get
those
landed,
so
that
was
this
one
right.
Okay,
so
again
it's
going
to
be
descriptions,
all
things
which
won't.
Let's
take
a
look
yeah.
It
definitely
shouldn't
have
any
any
code
effects
so.
C
C
There's
a
lot
of
white
space
stuff
here
yeah.
Can
you
turn
on?
Can
you
turn
on
minus
w
there's
the
little
gear?
That's
that's
like
that.
Actually
makes
it
very
very
worthy
to
review
where
it
says,
file,
filter,
jump
to
and
then
gear
next
to
the
the
oval
that
says
open
at
the
top
of
the
the
page.
G
C
C
A
F
No,
I
bought
the
renaming,
but
I
added
so
I
opened
the
loop
up
here.
I
guess
948.
F
I
tried
to
to
add
the
ci
configuration
for
windows,
so
we
can
test
the
they
don't
api
for
for
windows,
because
yeah
reviewing
some
tests
that
jack
made
yeah.
I
found
that.
F
They
don't
pass
on
windows
and
so
yeah,
okay,
just
being
good
with
jack.
We
think
that
it's
a
good
idea
to
have
gifts.
A
A
A
Item
okay,
stale
issues:
I
think
we
don't
have
any
stale
issues
to
discuss,
which
is
good
tracking
for
modules.
I
don't
think
there's
any
new
update
there,
although
we
can
typically
just
go
to
npm
download
that
on
api,
let's
do
a
sniff
check
of
things.
E
A
A
A
G
Not
really,
but
like
I
just
like
added
some
tests
for
the
globe
object.
So
if
you
get,
if
you
get,
you
guys
can
like
flip
it
over
one.
A
A
D
A
A
C
A
I
guess,
if
not
thanks
for
everybody
for
coming
to
the
meeting
and
everybody
who's
watching
and
we'll
see
you
in
github
and
next
week.