►
From YouTube: 2021-04-03-Node-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
Start
the
stream
start
the
recording
okay,
so
welcome
to
the
node.js
node
api
team
meeting
for
april
30th
2021
we'll
follow
our
usual
agenda,
which
is
going
through
what
we've
tagged
from
austin
11..
Does
anybody
have
any
things
they'd
like
to
share
announcements
before
we
get.
B
Started
so
is
it
a
good
time
to
introduce
ourselves
yeah.
B
Okay,
so
I
can
just
do
it
yeah.
I
can
just
do
it
for
the
three
of
us
so
yeah.
So
thanks
for
having
us
meeting
today,
so
myself,
tutor
and
vladimir
all
from
microsoft.
B
B
So
so,
just
just
for
a
little
bit
of
background
there
as
well
like
we.
We
have
a
lot
of
scenarios
in
in
an
app
like
office
today,
where
we
want
to
do
computational,
computational,
computational
or
computations,
rather
in
javascript,
and
in
order
to
do
that,
we
embed
an
engine
and
and
for
the
past
year
or
so,
we've
been
using
chakra,
but
with
chakra
going
out
of
existence,
we've
moved
over
to
v8
and
v8,
as
you
know,
doesn't
have
an
abi
safe
layer.
B
A
A
Oh
I'm
trying
to
remember
what
was
the
javascript
engine
called
again
jury
script
right,
jerry
script
right,
so
we
have
definitely
you
know,
and
there
were
people
from
microsoft
involved
earlier
you
know,
and
so
we
had
a
chakra
support
at
some
point
as
well.
C
Babylon,
babylon
native,
was
the
reason
why
we
separated
the
the
js
native
api
from
node
api.
So
so,
and
I
believe
that
was
a
person
from
microsoft
who
was
pushing
that
effort.
C
So
what
we
basically
did
was
make
it
so
that
the
v8
implementation
of
napi
could
be
sort
of
ripped
out
of
node.js
and
used
elsewhere
as
long
as
you
had
v8
right,
and
that
means
that
things
like
things
like
async
worker
and
threat,
safe
function
and
that
kind
of
thing
are
not
present,
because
those
require
no
js
internals
right,
but
the
the
js
native
api.
So
everything
like
setting
properties,
creating
booleans
references.
C
That
kind
of
thing-
that's
all
that's
all
sort
of
rippable
out
of
node.js,
and
then
you
can
just
link
it
directly
against
v8
and
it
will
not
require
any
of
node.js
stuff
you.
You
need
to
do
a
little
bit
of
gluing,
because
one
of
the
headers
is
private
and
uses.
Node.Js
uses
a
node.js
implementation,
but
not
that
you
cannot
replace
with
with
with
v8
purely
it's
just
it's
more
efficient
to
use.
V8
like,
for
example,
turning
a
weak
reference
into
like
a
local
variable.
C
I,
if
I
remember
correctly,
there's
there's
there's
like
a
special
cast,
which
happens
to
rely
on
the
on
the
binary
representation,
which
is
faster
than
just
using
the
v8
public
api.
For
that
you
know
that
kind
of
thing,
and
so
you
know,
if
you
don't
have
that
you
would
want
to
just
go
back
to
using
the
va
public
api
right,
but
it's
a
very
small
header
and
if
you,
if
you
implement
the
macros
defined
in
that
header
differently
than
what
we
have
then
you're
good
to
go.
C
B
Sorry,
I
was
going
to
say,
like
vladimir
already
built
a
prototype,
and
so
he
can
probably
yeah.
He
can
probably
walk
through
it
as
well,
depending
on
how
much
time
you
have
or
you
can,
you
can
take
a
look
offline
but
but
part
of
the
like.
We
had
some
questions
about
that
as
well,
that
that
he
can
ask
like
whenever
it
could
be
time
in
your
agenda
to
talk
about
it.
A
A
I
mean
what
gabriel
was
talking
a
little
bit
about
here
that
we've
actually
broken
out
the
implementation
in
node
into
these
js
native
files,
and
those
are
meant
to
be
like
agnostic
and
then
node
api
wraps
those
to
provide
the
full
node
api,
but
the
subset
that
are
in
these
js
native
ones
should
work
outside
of
node
on
their
own
yeah.
The
other
thing
I
had
mentioned
to
them,
you
know,
through
the
through
the
email
that
led
to
microsoft.
A
A
If
that's
successful,
then
I
think
we
could
come
and
think
about
like.
Could
we
separate
out
the
node
files
too
right.
A
A
A
A
C
A
A
We
haven't
used
it
in
node
itself
for
everything
you
know
partially,
that's
history
partially,
that's
performance,
I
think
so
there
is
some
overhead,
obviously,
in
going
through
another
layer,
so
you
know
we
haven't,
pushed
the
hey.
Let's
change
all
the
internals.
A
We
we
pitch
node
api.
As
you
know
the
80
case
right.
So
it
covers
what
most
people
need
to
do
if,
even
if
you're
writing
a
native
module,
if
you're
doing
something
you
know
more
on
the
fringes
or
you
know
performance,
every
last
sort
of
cycle
is
important
to
you.
Then
still
you
know
it
would
be
like
go
and
use
the
direct
node
v8
api.
So
just
saying
that,
as
a
caveat
in
terms
of
I'm
not
sure
where
your
use
case
fits
in
but
yeah
you
know,
that's
that's
one
thing
to
keep
in
mind.
B
Yeah,
we
haven't
done
any
performance
investigations
yet
to
see
actually
how
how
expensive
it
is,
and
also
we
we
the
way
we're
using.
It
leads
to
like
in
fact
additional
layers
on
top
of
an
api
okay
because
of
the
way
we're
making
the
engine
pluggable.
But
I
think
I
mean
vladimir,
do
you
want
to
jump
in
and
maybe
give
a
quick
intro
on
how
things
work.
D
Yeah,
I
I
I
I
can't.
Can
you
hear
me
yeah
yep?
So
it's
I'm
glad
that
you
mentioned
babylon
naked
for
folks.
It's
exactly
how
we
became
aware
about
an
api
in
the
first
place,
because
we
working
lately
on
implementation
of
react
native
for
windows
react
music
for
mark
our
team,
mostly
for
react,
native
windows
and
then
babylon
native
folks
want
to
have
render
the
ui
inside
of
react
native,
which
actually
already
happened
once
the
issue
that
in
react,
native
they're
using
something
called
gsi.
D
D
The
issue
with
gsi
is
not
abi
safe,
they're
using
some
standard
c,
plus
plus
types,
and
so
on,
and
one
of
the
kind
of
coolest
part
about
an
api
that,
for
example,
today
we're
required
to
compile
v8
dll
using
msvc,
but
having
proper
api
safe
api,
we
can
switch
to
native
toolset
like
clank.
You
don't
need
to
do
any
extra
patching,
so
it
can
be
in
bleeding
age
of
any
kind
of
v8
related
changes.
D
D
I
guess
this
depends
been
added
late
later,
and
it
will
be
nice
to
kind
of
remove
them
completely
or
put
this
dependencies
inside
of
this
internal
kind
of
js
native
v8
internal
that
h
file,
because,
unfortunately,
right
now
inside
of
implementation,
it
was
one
of
the
kind
of
a
difficult
part.
D
We
didn't
just
had
to
change
this
internal
file,
but
we
had
to
change
extra
extra
other
files,
but
another
kind
of
part.
What
we've
done
we
also
I
have.
We
have
ported
this
unit
test.
We
have
a
test
testing
suite
for
for
this
and
apis.
You
have
effectively
also
split
up
unit
tests
in
two
sections.
Right,
like
one
of
them,
we
score
an
api
another
one
for
extended
sets.
So
thank
you
took
only
this
core
part
and
tried
to
apply
it
as
well.
D
So
thankfully
we
made
them
working
but
again,
difficulty
was,
we
didn't
run
the
whole
node.js
environment
and
this
unit
test
kind
of
they
created
in
having
no
digest
running
in
full
environment.
So
we
had
to
simulate
it.
You
test
was
much.
Each
test
is
just
g
test
and
this
just
gts
loads
with
javascript
inside
of
our
dll
and
just
as
much
the
rest
of
the
code
kind
of
almost
the
same
yeah.
That's
where.
A
Like
in
that
external
repo,
you
know
there
was
a
suggestion,
we're
receptive
it
just
takes
some
people
to
volunteer
to
actually
do
the
work,
to
figure
out
how
to
make
the
tests
more
runnable
like
outside.
So
maybe
you've
already
got
that
experience,
and
that
would
be
a
good
place
to
sort
of
capture
those.
D
A
D
Look
there
are
a
couple:
couples
include
files
which
I
I
wish
it
will
be
much
cleaner
in
this
sense
that
we
only
really
have
to
include
this
internal
file
and
change
this
internal
file
with
the
internal.h,
but
we
have
to
do
more
and
I've
seen
like
a
babylon
native
code.
D
They
didn't
have
to
do
it
before
and
it
sounds
like
this.
It
was
latest
editions
to
have
this
extra
dependency
has
been
added
there.
C
Yeah
yeah:
we
have
to
push
those
back
out
yeah
or
at
least
at
least
sort
of
crystallize
them
into
clear,
clear
dependencies
which
can
also
be
implemented
without
util
and
env.
D
A
C
Yes,
yes,
that's
why
we
need
to
move
it
out
to
internal
yeah.
D
And
as
a
proof
of
concept,
I
even
created
just
very
small
c
sharp
program.
We
see
our
programs
loads,
is
our
dll
and
capable
to
run
javascript
from
c
sharp,
so
think
it's
kind
of
shows
power,
because
a
true
abi,
safe
c
based
api
that
you
can
actually
take
c
sharp
java.
You
can
take
like
python
and
tada
yep.
C
E
I
was
capable
to
to
find
the
right
tool
to
make
this
possible
on
windows,
so
yeah.
A
And
I
know
a
number
of
projects
do
incorporate
v8
so
this
this
and
they
they
must
struggle
with
the
same
problem
that
node
has,
which
is
why
we,
you
know,
I
guess,
with
with
external
native,
we
have
a
bigger
problem
with
the
add-ons
versus
node
itself,
but
I
can
see
everybody
having
similar
issues
so
yeah.
I
I'd
be
really
happy.
If
we
ended
up
with
something
where
you
know,
you
can
more
easily
bundle
v8
and
keep
it
running.
D
Another
caveat
about
this
exercise
was
an
api
was
created,
first
of
all,
to
be
for
extension
modules,
and
if
you
talk
about
like
the
whole
v8
dll,
there
are
some
apis
needed
to
effectively
host
host
javascript
engine
like,
for
example,
we
need
to
have
stuff
which
creates
environment
and
tears
down
environment
right
like
at
least
these
two
kind
of
things
which
you
don't
want
to
expose
to
extension
modules.
But
you
do
want
to
use
it
from
a
host
environment
so
yeah.
A
Think
we
could
probably
handle
that
in
a
similar
way
of
the
layering,
where
we
have
like
this
js
native
part,
which
is
meant
to
be
the
agnostic
piece
and
then
a
node.
We
have
like
the
node
api,
which
is
built.
On
top
of
that
I
mean.
Maybe
the
same
model
works
so
that,
like
you
know,
we
keep
the
js
native
piece
as
it
is,
but
then
there's
a
layer
on
top
that
pulls
that,
in
that
adds
those
extra
hosts
kind
of
things
for
that
particular
type
use
case.
That
makes
sense
to
me.
D
Right,
yes,
I
think
those
will
make
perfect
sense.
So
in
this
case
we
can.
We.
Can
you
reuse
this
core,
like
in
different
scenarios
like
extensions
or
kind
of
hosting
engine
right,
then
you
pretty
much
depending
on
scenario.
You
have
extended
set
of
apis
like
being
inside
of
node.js
or.
D
And
another
kind
of
issue
we
faced
as
well
was
because,
like
I
said,
one
of
the
key
scenarios
us
using
react
native
and
react
native
using
gsi,
so
we
haven't
had
to
implement
gsi
on
top
of
an
api.
This
was
one
of
the
kind
of
our
discussion
points
being
with
babylon
native
folks,
as
well
like
because
right
now,
it's
much
worse.
D
What
we
have
to
do
with
that
going
directly
making
the
n
api
is
the
kind
of
core
abi
safe
layer
for
extension
modules
in
react,
native
react
native
windows.
This
was
actually
I
am
targeting
as
well
to
implement.
D
We
can
actually
do
a
lot
of
interesting
things
and
unfortunately,
some
gsi
construct
requires
some
usage
of
some
effectively
global
values,
a
little
bit
differently
from
what
napi
exposes,
namely
that
I
extremely
like
an
api
value.
It's
very
lightweight
and
no
ref
count
it's
direct
to
the
engine
perfect,
but
I
believe
an
api
ref.
It's
something
would,
I
think,
could
be
improved
and
unfortunately,
for
this
implementation
I
had
to
implement
alternative.
D
I
called
the
napi
extraf
main
reasons,
because
npirf
first
of
all
must
be
only
object,
but
in
case
of
gsi
we
want
to
be
wrap
up,
symbols
and
strings,
and
because
I
couldn't
do
it,
I
had
to
invent
something
else
without
changing
an
api
itself,
but
also
some
handling
of
even
big
pointers.
Surprisingly,
because
I
I
may
still
be
still
be
able
to
use
an
api
rf
directly,
but
yeah.
A
D
Of
I
have
to
have
a
common
denominator
for
all
these
objects,
so
pretty
much.
I
want
to
handle
objects,
symbols
and
strings
and
weak
pointers
the
same
way.
So
again,
I
have
to
come
up
with
this
custom
reference,
pointer
and-
and
I
think
like
if
we
want
to
improve
this
kind
of
global
object,
if
you
like,
maybe
we
can,
we
can
have
something
better
and
be
kind
of
use
across
the
board.
D
I
think
that's
the
key
things
and
also
mentioned
in
our
emails
that
I
found
there
is
a
implementation
implementation
bug
for
get
all
properties.
D
I
think
it
was
introduced
quite
recently,
and
it
seems
like
this
feature,
didn't
have
enough
testing
and,
as
you
know
like
you,
can
you
can
search
for
properties
using
different
criteria
and
templates
like
what
just
copy
and
paste
bug,
then
you
asking
criteria
for
be
configurable,
but
internally
you
can
see
people
using
writeable.
A
It
says
now
that
that
one,
you
know
we'll,
have
to
understand
how
recently
it
was
introduced
and
because
we
always
worry
about
breaking
like
to
maintain
the
abi
stability
right.
We
we
don't
tend
to
sometimes
even
sometimes,
even
if
it's
a
bug
we
end
up,
creating
like
okay,
here's
a
new
version
of
the
api,
so
that
if
there
are
people
using
the
old
one,
we
don't
break
them
now
it
depends
on
whether,
like
you
said,
if
that
one
was
recently
introduced,
whether
it's
an
experimental
or
actually
in
an
app.
A
C
D
But
I
think
using
this
configurable
as
a
search
criteria,
probably
so
obscure.
No,
nobody.
Nobody
probably
ever
hit
it,
because
if
somebody
ever
hit
it,
they
would
report
the
bug.
A
A
You
know
I
I
you
know
I
what
I'd
say
is.
You
know
please
get
involved
in
the
different
repos
where
we
can,
like
you,
know
those.
A
If
you
open
issues
prs,
you
know
if
you're,
if
you
have
cycles
to
start
working
in
that
test
repo
to
like
move,
you
know
the
that
you
know,
I
think
we're
don't
speak
for
the
whole
team,
but
I
think
it
sounds
interesting
to
me
and
something
we'd
want
to
support
and
I'd
feel
free
to
show
up
at
these
meetings
regularly,
like
you
can
come
every
week,
we're
always
looking
for
more
people
to
help
move
this
forward,
and
it
sounds
like
you
know,
if
you're
using
it
for
use
case
you
you
want
to
be
doing
that
too.
A
D
Excellent,
so
what
will
be
our
next
step?
Should
we
just
choose
few
emails,
so
we
have
some
kind
of
distribution
list
to
discuss
this
type
of
topics.
I.
A
Yeah,
so
yeah
github
issues
is
really
where
we
do.
Github
is
where
we
do
all
the
work.
That
way,
there's
a
there's,
a
good
record.
So
if
you
open
some
issues
in
you
know
note
that-
and
I
guess
not
necessarily
no
down
on
api,
but
the
there's.
There's
choices.
Abi
stable
note
is
probably
the
the
place
to
open.
If
you
want
to
have
like
conversations
with
this
team,
because
that's
our
team.
A
C
You
know
design
that
kind
of
thing
yeah.
A
So
that's
node.js,
slash
abi,
stablemate
api,
stable
node
for
like
a
very
specific
bug.
You
know
that
one
you
mentioned
an
issue
in
node.js:
node
would
be
the
right
place
and
then
the
third
one
just
that
we
have
is
node
add-on
api,
which
is
the
c-plus
plus
wrapper.
A
D
Yeah
we
plan
to
use
it
just
kind
of
yeah.
We
didn't
get
to
it
yet:
okay,
we
just
try
to,
but
but,
for
example,
the
babylon
native
guys
they
do
want
to
use
this
c
plus
plus
bitcoin.
Okay,.
A
So
yeah
I'd
say
open
some
issues
in
in
abi,
stable,
node
and,
and
you
know
we
can
have
the
conversations
there
yeah.
Thank
you
and
then
you
know
feel
free.
We
can.
You
can
show
up
to
these
meetings.
We
do
them
every
week
and
you
know
that's
a
good
place
to
once.
You've
opened
an
issue
we'll
have
time
to
have
looked
at
it.
We
can
talk
about
it
on
the
agenda,
like
everything
else,
yeah
exactly.
B
Thank
you
so
much
just
just
one
quick
question
before
we
wrap
up
like
do
you
think
there
would
be
any
interest
in
shipping
that
v8
wrapped
dll
from
the
from
node.js
itself
like?
Would
you
have
any
use
cases
for
that.
C
Yes,
actually,
if
you,
if
you
want
to
ship
that,
I
think
one
of
the
best
places
to
to
to
put
it
at
first
would
probably
be
the
the
test
repo,
because
if
we
move
the
tests
to
the
test
repo-
and
we
have
an
implementation
based
on
v8,
we
can
actually
run
the
tests
in
the
test.
Repo
right
and
then
and
then
that
that
would
validate
the
tests
and
it
would
validate
an
api
outside
of
node
right
and.
C
That
was
pretty
much
my
point
like
it
would
be
great
to
actually
have
like
running
tests
in
that
external
repo
and
having
having
like
you
know
that
the
dll
you
you
mentioned
would
become
sort
of
the
the
the
the
reference
implementation.
If
you
will
of
an
api
right,
because
it
would
be
completely
outside
of
node,
it
would
not
be
tied
to
any
any
project,
and
then
anybody
could
just
grab
that
thing
and
run
with
it,
and
you
would
be
the
first
customers
basically
right
now,
but
I.
A
Guess
to
the
specific
question:
I'm
not
sure
the
node
projects,
like
as
a
whole
would
be
necessarily
interested
in
shipping
v8
a
v8
wrapper
right,
because
that's
not
really
the
node
project's
business
right.
I
could
see
it
making
sense
as
a
project
for
sure
under
the
opengs
foundation,
so
I
mean
yeah.
A
C
Yeah
yeah,
yeah,
okay,
yeah,
sorry,
yeah,
that's
what
I
meant
right
right
yeah,
so
I
don't
know
if
we
would
start
making
releases
and
and
and
and
like
publishing
them
on
the
on
the
node.js
website,
but
having
having
like
working
and
tested
code
is,
is,
is
a
huge
benefit
in
and
of
itself
right
and
and
besides
this
is
this,
isn't
really
like
a
like
a
sort
of
a
end
user
product
right.
C
This
is
more
geared
for
developers
right,
so
so
they
could
like
depend
on
the
repo
right
and
then
build
their
products
on
top
right.
So
so
you
know,
and
and
yes,
we
could
cut
releases
in
the
sense
that
we
tag
we
attack
commits
in
the
repo
right
and
then
they
can
run
with
those.
But
I
don't
know
that
we
would
need
like
a
like
a
released
harbor
with
just
just
an
so
you
know,
so
I
I
mean
in
the
end
we
might
end
up.
C
I
mean
I
don't
know
where,
where
this
is
gonna
go
but
but
having
it
having
it
in
place,
I
think
would
be
great
benefit.
You.
B
Know:
okay,
okay,
yeah!
Thank
you
yeah!
So
so
we'll
we'll
discuss
it
a
little
bit
on
our
side
as
well,
and
then
we
can
chat
a
bit
more
about
it.
But
that
gives
us
good
coffee.
A
It
leverages
the
community
ci
and
you
know-
and
I
could
see
that
level
synergy
making
sense
but
yeah,
but
that
that
would
be
a
ways
down.
I
think
really,
you
know
to
start
with
it's
it's
like
we
can
work
to
try
and
make
it
so
that
it
is
a
little
bit
more
separate
in
terms
of
of
at
least
you
know,
you
don't
have
to
manually
pick
out
of
the
node
tree.
You
know
if
we
had
some
automation
to
push
the
task
to
post
exactly
that
would
be
the
place
to
target
for
today.
Yeah.
C
And
we'd
already
get
pretty
good
testing
right
because
I
mean
just
github
actions
alone
already
have
a
few
platforms.
They
don't
have
as
many
as
as
the
node.js
ci,
but
that's
still
pretty
good
coverage
and
it'll
probably
catch
a
lot
of
the
the
the
the
the
failures
you
know,
and
then
you
know,
and
and
you
know
an
api
will
continue
to
receive
extensive
testing
on
the
node.js
side
right.
So
there
would
sort
of
be
like
a
cross-pollination.
You
know.
A
Okay,
so
maybe
maybe
you
know
if
we
can
take
that
back
to
github
and
and
or
future
meetings,
that
would
be
great.
We
have
22
minutes
left.
A
The
first
one
is
the
blog
post
about
the
transition
to
nobody.
Api
is
the
name.
A
E
Go
ahead,
nicola,
okay,
I
send
to
asia,
and
I
think
that
we
planted
the
the
for
the
blog
post
for
the
the
next
monday.
Okay,.
A
And
like
after
the
weekend,
or
as
I
forget
is
a
week
out
or
like
you
know
four
days
from
now,
is
that
what
it
is
for
a.
G
E
The
node.js
version
that
will
be
yeah
updated
because
I
don't
know
if
this
is
important
to
to
specify
so.
E
The
the
documentation
will
be
updated
for
node,
15
and
16,
and
in
so,
if
you
read
the
14
yeah
you
right
yeah
you,
you
will
find
an
api,
not
node
api.
So
so
I
mean
this
is
the
only
thing
that
we
missed
in
these
blog
posts.
F
D
G
A
E
E
C
E
E
Yeah,
for
me,
it's
okay,
you
will
add
your
content,
everyone
can
add
the
the
content
and
then
I
we
will
decide
the
order
of
of
the
the
content
that
we
added.
G
E
I
hope
that
I
hope
next
week
and
then
I
will
work
to
on
the
on
the
style
for
the
slides
and
we
in
two
weeks
we
can
record
the
the
the
the
talk.
If
you
you,
you
agree
with
this
timing
so
working
this.
So
I
think
that
we
are.
We
need
to
work
this
week
to
add
the
content
and
the
the
next
week.
E
F
A
E
But
if
we
have
the
god
and
is
always
good.
A
A
Okay,
that
sounds
good
stale
issues.
I'm
just
going
to
take
a
quick
look.
I
don't
think
there
are
any
nope,
so
the
what
I
would
like
to
do
is
spend
a
bit
of
time
to
just
go
directly
to
the
issue
that
I've
been
we've
been
trying
to
debug
in
with
the
crashes,
because
I.
G
E
I
I
I
want
to
ask
something
to
gabriel.
If
I
can.
E
C
Yes,
that's
right!
Well,
no,
we
we
cannot
tack
primitives,
we
can
only
tag,
we
can
only
tag
objects
because
it
has
to
support
whatever
it
is
that
we
tack
has
to
support
properties
right
so
because
a
tag
is
implemented
as
a
private
property
right,
and
so
it's
pretty
much
limited
to
objects.
C
E
So
so
it's
a
it's,
not
a
method
for
a
value,
but
it's
a
metal
for
object.
Yes,.
E
Okay,
so
yeah.
This
is
my
my
my
dog.
If
I
I
I
I,
I
can
type
a
primitive
or
or
or
not
yeah,
so
in
this
case
the
only
object.
Okay.
So
I
I
will
try
to
add
this.
This
api.
C
Okay,
one
one
thought
is
that
one
one
very
convenient
and
transparent
way
to
do
this
might
be
to
to
just
have
like
a
like
an
object,
wrap
subclass
right.
Where
you
can
you
can,
you
can
add
the
like,
you
can
add
the
tag
as
a
as
a
template
parameter
right,
and
so
so
you
you
derive.
C
You
derive
like
the
the
user
would
derive
from
this
class
instead
of
object,
wrap
and
then
and
then
all
the
instances
would
not
only
be
instances
of
the
class,
but
they
would
also
be
tagged
right
and
and
then
and
then
they
they
need
only
specified
the
tag
in
the
class
definition
and
that's
it
and
then
you
know
the
the
api
will
take
care
of
it
internally.
G
C
That's
a
very
convenient
way
of
doing
it.
For
example,
you
know,
and
then
that
would
be.
I
don't
know
that
would
be
something
like
tagged,
object,
wrap
you
know
or
strong
object,
wrap
or
or
whatever,
and
then
we
can
explain
the
documentation
what
it
means
to
be
tagged
and
what
it
means
to
be
and
or
what
it
means
to
be
strong.
C
You
know
so
and
then
the
user
doesn't
have
to
say
you
know
like
in
every
method.
They
don't
have
to
say,
like
you
know,
get
the
tag
you
know
or
or
is
it?
Is
it
tagged
with
this?
You
know
they
we
would
do
it
for
them
before
we
called
the
the
the
instance
method
or
the
the
static
method
or
or
so
forth.
You
know
we
would
do
it
for
them,
so
you
can
solve
it
with
like
you
can
solve
it
with
with.
C
You
know
how
we
have
the
the
callback,
the
the
callback
wrappers
in
in
in
an
api,
inline
dot,
h
right.
We
have
the
callback
wrappers,
so
you
would
just
have
to
write
another
set
of
callback
wrappers
for
for
tagged
objects
and
that's
it
and
you'd
be
done.
A
Okay,
so
moving
on
to
issue
906,
I
have
managed,
I
think,
to
get
a
setup
that
actually
can
recreate
it.
At
least
you
know,
if
you
run
a
number
of
hours,
it
takes
running,
it's
basically
running
100
in
parallel,
like
I
have
a
machine
with
many
many
cores,
and
so
if
I
run
100
in
parallel
it
also,
unfortunately,
the
test
hangs.
A
It's
it's
giving
me
this
thing
where
it's
complaining
about
use
of
now,
basically
saying
I'm
doing
an
invalid
read
of
something
that
was
deleted
and
the
thing
that
it's
complaining
about
was
this
nappy
module
register
symbol.
H
H
Down
to
the
bottom,
and
just
commented
that
it's
very
similar
to
our
episode
in
testing
around
the
second
pass
callback
that
I
found,
that
is,
there
are
possibilities
that
we
are
deferring
texas,
a
buffer
of
analyzers
and
budget
finalizers
to
a
next
meet
set
with
the
environment.
That
immediate
and
that
immediate,
is
running
after
the
nappy.
H
D
H
Yeah,
okay,
it's
been
destroyed,
so
that's
the
possibility
is
that
the
those
paralyzers
are
being
run
after
the
actual
environment
being
teared
down.
So
yes,
I
have
mentioned
this.
This
situations
earlier,
but
I
haven't
had
the
time
to
like
say
reproduce
it.
So
I
found
that
this
back
trace
is
very
identical
to
the
okay
situation.
I've
I've
observed
so
maybe
we
can
submit
a
fix
to
like
say
yeah.
D
A
C
What
do
you
think
about
not
doing
set
immediate
if
the
environment
is
being
torn
down,
because
I
think
the
set
immediate
was
added
because
of
the
way
v8
does
does
garbage
collection
right,
but
when
the
environment
is
being
torn
down,
then
then
it's
not
because
then
then
we're
running
the
finalizer,
but
not
because
garbage
collection
we're
running
it
because
the
environment
is
being
torn
down
right,
and
so
we
don't
need
the
set
immediate
right,
but
inside
the
code
that
attaches
the
set
immediate,
we
need
to
be
able
to
distinguish
between.
C
H
The
a
the
problem
occurred
to
me-
that
is
my
first
thought
on
this-
is
that
the
the
the
situation
is
very
similar
to
the
second
pascal
back,
that
it
is
that
we
cannot
cancel
those
finalizes,
those
scheduled
trend,
letters
once
we
are
like,
say
the
environment
yeah.
They
are
down
here
on
the
middle
of
the
scheduling,
so
there
is
no
way
to
cancel
those
parameters.
So,
yes,.
H
A
C
C
So
so,
basically,
what
I'm
thinking
is
you
know
call
finalizer
should
behave
exactly
the
same
way
as
as
it
does
in
js
native
api
v8
dot
cc.
C
But
only
if
it's
environment
tear
down
right
because
then
you
don't
do
set
immediate.
So
the
environment
is
not
gone
right
when
you
call
the
finalizer
and
we
have
the
additional
protection
that
that
lucas
added,
which
is
to
have
like
a
disconnected
pointer
added
to
the
to
the
to
the
actual
v8
weak
callback
which
stays
alive
even
if
the
object
is
destroyed,
but
is
null
and
will
be
destroyed
unconditionally
whenever
the
finalizer
gets
called
so.
G
C
Protection
in
va
again
api.
I
guess
what
I'm
saying
is.
If
you
can
hear
me,
we
we
have
we.
We
have
one
protection
in
place
right
in
in
in
js
native
api.
We
have
this
disconnected
pointer
that
that
lucas
added,
which
is
not
part
of
the
the
actual
reference
right
so
so
that
protects
us
in
js
native
api
right.
We
need
that
same
protection
here,
but
we
also
need
a
second
protection
that
says:
if
it's
environment
tear
down,
then
call
the
finalizer
immediately.
C
Okay,
call
the
finalizer
synchronously
instead
of
using
set
immediate
because
then
because
then
we
will
have,
we
will
have
reverted
the
behavior,
but
only
during
tear
down
to
having
synchronous,
finalization
execution
right,
which
means
the
environment
will
still
be
alive
when
the
finalizer
executes
and
then
with
the
second
protection
that
that
lucas
already
added
we
will
we
will,
we
will
have
like
we
won't-
have
like
a
use
after
free
of
the
reference
either.
H
C
Yeah
yeah,
that's
right!
That's
right!
We
don't
we
don't
what
we
say
is
so
okay,
so
so
in
this
function
we
say:
if,
if
we
are
in
the
middle
of
environment,
tear
down
then
calling
to
module
else,
set
immediate
and
calling
to
module
right.
So
because
we
know
that
environment
teardown
is
not
garbage
collection,
it's
not
the
same.
We
just
want
to
make
it
look
the
same
right,
because
we
want
to
clean
up
all
the
all
the
same
things
that
we
do
during
garbage
collection.
C
C
Yes,
exactly
yes,
yes,
and
so
so
so
so
we
need
to.
We
need
to
like
be
able
to
check
that
it's
environment
tear
down
right.
I
don't
know
if
we
have
that
kind
of
check
right
now,
I
think
maybe
in
like
a
js
native
api,
v8
dot
h,
I
think
that's
where
the
teardown
happens
so
so
before
before
the
environment
goes
into
finalize.
All
we
have
to
say
something
like
you
know
and
arrow
is
tear
down,
equals
true
and
then
finalize
all
finalize
all
and
and
that's
it.
C
Be
js
native.
D
A
C
C
C
Yeah
again,
you
want
the
call
side
yeah
there.
So
so,
oh
no,
you
wait
what
oh
here
here,
yeah
these
yeah.
So
basically,
basically
we
need
to
like.
We
need
to
put
like
some
flag
in
amp
that
says
being
finalized
and
then
it's
set
to.
C
Okay,
so
so
yeah
can
you
go
back
to
where
the
finalize
all
call
site
is.
C
The
call
side
yeah
okay,
so
if
you
can
hear
me
I'm
what
I'm
suggesting
is
that
we
have
a
member
variable
in
an
api
f,
that
that
is
a
boolean.
That
is
false.
C
It's
set
to
false
during
construction
and
right
before
we
call
finalize
all
we
set
it
to
true
right,
and
then
we
have
a
function
that
retrieves
the
value
and
then
the
the
the
finalizers
will
have
we'll
be
able
to
say
and
get
is,
tear
down
right
and
that
returns
the
that
will
return
true
during
during
during
this
teardown
right,
and
it
will
return.
D
C
C
A
finalizer
has
to
have
access
to
to
to
this
new
method
on
an
api
end
that
tells
it
whether
the
end
is
being
torn
down
or
not,
and
we
we
kind
of
already
have
that
because
I
know
we
can,
we
can
do,
is
and
tear
down
oh
wait.
A
second
go
up
for
a
sec.
Go
back
to
the
call
site.
C
Finalize!
Oh
okay,
I'm
sorry
go
to
the
implementation
of
finalize
all
please,
which
I
think
was
above
yes,
okay,
so
so
we
call
finalize
with
true
right
so,
whereas
in
finalize
normally
gets
called
with
false.
So
so
so
we
should
have
access
to
whether
this
is
an
environment
tear
down
where
we
call
finalize
callback.
C
So
that
means
that
in
in
node.api.cc,
let
me
go
back
there
should
have.
We
should
have
access
to
that.
C
Okay,
so
okay,
so
buffer,
finalizer,
fine,
okay,
yeah
finalize!
Maybe
if
I
search
on
this,
no,
I
think
I
know
what
the
problem
is.
C
I
think
the
buffer
finalizer
inherits
from
finalizer,
not
from
reference
and
that's
the
problem
because
yeah
yeah
this
should
this
should
have
a
boolean
parameter,
so
yeah,
yeah,
okay,
but
anyway,
the
basically
the
the
the
value
that
is
being
given
to
finalize
during
finalize
all
needs
to
be
sort
of
threaded
into
or
woven
into
this
node
api.cc,
because
these
are
all
subclasses
of
of
regular
finalizers,
right
and
and
on
the
js
native
api
side.
We
have.
C
We
have
one
subclass,
which
is
reference
and
then
that's
that
and
then
everything
is
a
subclass
of
that
right
or
sorry.
We
have
ref
base
and
then
reference,
but
these
these
are
so
basically
the
class
hierarchy
is
finalizer
ref
base
and
reference
right
and-
and
these
I
think,
are-
are
descended
from
from
a
from
a
class
that
is
too
high
on
the
hierarchy
and
that's
why
it's
not
getting
this.
This
environment
tear
down
flag.
C
C
Well,
yeah:
we
we
need
to
trace.
Basically
what
we
need
to
trace
is
what
happens
like
how
does
finalize
all
end
up
calling
the
buffer
finalizer.
That's
what
we
need
to
trace
right,
because
finalize
all
definitely
calls
finalize
and
finalize
definitely
gets
a
boolean.
So
why
is
that?
Why
is
that
boolean
lost
as
the
call
propagates
to
the
buffer
finalizer,
it
shouldn't
be
lost.
It
should
be
transmitted
to
buffer
finalizer.
D
A
A
C
Yeah
yeah,
okay,
wow,
okay,
so
this
is.
This
is
threaded
way
deep,
but
okay,
okay,
okay,
but
then
we
can
solve
this
problem.
Okay,
see
see
on
line
41.
G
C
So
what
we
need
is,
we
need
a
new
method
on
napi
n
that
says
that
that
returns,
a
boolean
and
it's
called-
is
end,
tear
down
right
and
that
method
always
returns
false,
except
when,
when
when
it's
called
from,
except
after
the
the
the
destructor
for
an
api
and
has
already
started
executing
because
the
first
thing
the
destructor
for
an
api
f
does
is
set
set
a
value
to
true,
which
will
then
be
retrieved
here
right.
And
then,
if
that
value
is
true,
then
you
don't
call
set
immediate.
D
Gabriel,
it
will
not
work
because
this
class
is
actually
inherited
from
an
api
environment,
and
the
structure
of
an
api
environment
will
be
run
after
this
method
runs
right.
So
I
think.
C
Okay,
but
but
this
this,
this
method,
this
method
only
gets
called
after
the
the
destructor
has
already
started,
executing.
D
It
cannot
right,
because
it's
virtual-
it's
usually
the
in
destructor,
then
the
instructor
runs
we
can
overwrite
in
this
v
table.
I
think
this
method
will
be
not
visible
when
we
run
destructor
inside
of
an
api
environment
itself,.
D
I
I
had
to
solve
similar
issues
back
in
office.
What
the
way
we
do
we
we
do.
We
basically
instead
of
running
finalizer
from
destructor,
so
we
do
it
today
here
my
suggestion
would
be
effectively.
We
will
have
enough
counting
for
environment
right,
so
I
guess
that
the
recount
goes
to
zero
at
this
point.
Yes,.
C
D
If
you
look
inside
of
this
js
native
env.h,
this
knife
environment
itself
is
a
ref
counted
object,
so
thankfully
we
control.
A
D
C
D
D
Right
but
with
this
destructor
being
called
somewhere,
there
is
a
code
that
then
we
said
we
see
andre
yeah
line,
77
that
we're
saying
yeah,
that's
the
one,
the
ref
becomes
zero.
We
say
delete
right.
You
have
to
run
the
letters
before
we
call
this.
Yes,.
C
D
Right,
yes,
we
definitely
need
this
flag.
Like
everything
what
else
gabriel
said
it
would
work,
it's
only
kind
of
a
caveat
in
addition
to
what
he
suggested
right.
You
need
to
change
when
we
call
finalizer
right.
Otherwise,
this
virtual
method
will
be
never
called.
We
will
not
have
the
right
sequence
of
destruction
right.
C
Yes,
yes,
yes,
and
you
know
what
doing
that
was
we'll
solve
another
problem,
which
is
that
we
are
currently
unable
to
determine
whether
we
should
call
into
javascript
or
not
yeah.
I
I've
been
working
on
that.
You
know
the
the
the
proper
status
you
know,
distinguishing
between
pending
exception
and
unable
to
call
javascript
and-
and
what
I
saw
was
the
reason
why
we
are
not
able
to
make.
C
The
distinction
is
because
in
the
destructor,
when
I
call
can
calling
to
javascript,
it
actually
ends
up
calling
the
the
superclass,
which
always
returns
true
right,
because
the
subclass
node
node
api
n,
which
is
a
node
api
dot
cc,
is
a
subclass
of
n
api
n
and
that
one
implements
the
proper
can
calling
to
javascript
checking,
but
that
that
implementation
is
gone
by
the
time
the
the
destructor
happens,
because
the
subclass
is
already
cleaned
up,
so
so
moving
these
methods
to
to
where
we
delete
the
object
and
running
them
right
before
we
delete
the
object
is
exactly
the
right
solution.
A
A
A
C
Yeah
yeah:
well,
not
the
end.
The
the
the
reference
right
like
like
lucas's
solution
is
to
create
create
like
a
location
in
memory
that
holds
only
one
pointer
to
the
reference
which
is
which
gets
nulled
out
and
then
gets
deleted
when,
when
the
garbage
collector
calls
the
finalizer,
if,
if
it's
yeah,
it
gets
deleted
anyway,
and
if
the
contents
is
not
null,
then
the
finalizer
gets
run.
And
if
the
contents
is
null,
then
it
just
gets
deleted
without
the
finalizer
getting
run.
So
we
need
the.
C
We
need
the
same
solution
for
these
as
well
right,
but
I
was
if
I
was
looking
at.
Where
was
that?
Oh,
but
wait
a
minute?
I
don't.
I
don't.
I
think
we
benefit
from
that
solution
already,
because
because
the
buffer
finalizer
is
an
api
finalizer
right,
so
so
it
already
used
the
reference
mechanism
right,
so
we're
already
benefiting
from
from
from
lucas's
solution.
The
only
thing
that
we
still
need
to
fix
is
to
not
call
set
immediate
for
which
for
for
which
we
need
the
solution.
We
just
we
just
discovered.
H
H
C
H
Right
this
one,
it's
a
very
simple
wrap
around
the
noppy
analyzer,
the
lc
structure,
it's
it's
holding
the
data
and
then.
C
H
C
Okay,
okay,
so
yeah
it's
a
different
mechanism,
yeah
for
sure
yeah,
so
so
lucas,
I
think
you
may
you
may
have
to
implement
your
solution
again
for
for
this,
for
this
finalizer,
like
the
solution
with
that
extra
pointer
right,
what?
Where
would
be
the
extra.
C
H
C
C
G
C
So
so
so
this
finalized
buffer
callback
that
is
being
passed
to
v8
right.
C
D
C
This,
so
so
so
so
this
this,
let's
see,
okay,
so
so
so
the
void
star
hint
the
void
star
hint
would
have
to
be
like
one
of
those
pointers
that
you
created
on
the
reference
side,
and
then
you
don't
cast
it
to
a
buffer
finalizer.
C
You
cast
it
to
like
a
buffer,
finalizer
container
or
whatever,
and
then,
if
buffer
finalizer
container
arrow
finalizer
is
null,
then
don't
then
then
just
delete
the
container,
and
if
it's
not
null,
then
do
everything
you
do
here
and
then
delete
the
container
so
which
is
exactly
the
same
solution
that
you
did
for
reference,
so
that
this
is
where
this
is,
where
your
your
solution
would
go.
I
think.
H
C
C
C
C
The
reference
may
have
been
destroyed
because
of
finalize
all,
and
so
when
the
when
the,
when
the,
when
the
garbage
collection,
weak
callback
finally
gets
called,
then
that
pointer
is
stale
right
and
so
lucas's
solution
was
to
create
a
second
pointer
which
is
which
is
not
contiguous
with
where
the
reference
itself
is
being
stored
right
and
that
that
pointer
contains
a
single
value
which
is
the
reference
right
and
then
the
reference
contains
the
pointer,
and
so
so
when
the
reference
gets
destroyed.
C
It's
it
sets
the
value
inside
this
discontiguous
pointer
to
know,
and
so
when
the,
when
the
garbage
collector
finally
calls
the
finalizer
that
data
will
still
be
alive,
because
it's
not
the
reference
itself.
It's
just
a
pointer
to
the
reference
right
and
if
the
value
of
that
pointer
is
null,
then
it
just
deletes
the
pointer.
And
if
the
value
of
that
pointer
is
not
null,
then
it
runs.
The
finalizer
and
deletes
the
pointer
right.
A
A
H
It
it
goes
out
of
scope
when
the
finalizer
it's
a
unique
pointer
right.
So.
D
C
C
Well,
yeah,
it's!
The
deleter
gets
called
when
when
when,
when
this
this
this
unique
pointer
like
when
the
scope
closes
right,
then
then
the
deleter
gets
called,
and
then
that
deletes
it.
So
you
don't
have
to
have
like
a
separate
delete,
call.
A
A
C
F
C
Yeah,
okay,
so
that's
so
this
is
one
then
then
the
the
environment
flag
to
decide
whether
it's
tear
down
or
not.
That
is
the
other
and
then
the
two
together
should
solve
this
buffer
finalizer.
C
C
C
A
Okay,
I'm
going
to
try.
I
can
probably
try
the
first
one,
pretty
the
first
two
pretty
easily
yep
I'll
do
that
first
and
then
I
can.
If
I
don't
know
if
I'll
let
know
people
know
if
I've
had
a
chance
to
look
at
it
or
not.
If
not,
if
you
have
time
that
would
be
great,
but
cool.
A
Okay,
thanks!
No,
that's
good!
So
that's
if
that's
track
down.
Hopefully
that
will
resolve
it
because
it's
it
looked
to
still
recreate
in,
like
I
think
I
had
at
least
one
case
in
master
as
well
so
or
maine
all
right,
we're
long
enough
long
after
time.
So
we'll
let
everybody
go
thanks
for
everybody's
time
and
we'll
talk
to
talk
next
time.
Bye,
yep,
talk
to
you
later.