►
From YouTube: 2022-08-26-Node.js 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
So
welcome
to
the
node.js
node
api
team
meeting
for
august
26
2022
we'll
follow
our
standard
approach
by
looking
at
the
issues
that
we've
tagged
from.
B
A
B
Yeah,
so
I've
updated
the
pr
to,
I
think,
implement
your
suggestion
where
we
unwrap
it
and
then
wrap
it
and
make
sure
that
it
hangs
and
things
ready.
A
For
a
review,
okay,
so
that's
this
pull
request.
It's
a
no
doubt
on
api
reboot
right,
yeah,.
B
A
A
A
Okay
back
to
things
here,.
A
Node
api
on
youtube.
I
know
that
nick
was
gonna
to
work
on
that,
but
he's
a
little
bit
he's
away
same
with
this
next
one
on
adding
a
list
of
non-c
language
bindings.
So
I
don't
think
there's
anything
to
talk
about
on
those
two.
Unless
somebody
has
something
specific.
A
I
think
that
one
was
there
already
right
that
was
eight
days
ago,
so
it's
just
interesting
to
see
a
number
of
other
runtimes
implementing
node
api.
It's
very
interesting
but
nothing
new.
Since
last
time
I
haven't
enabled
debug.
C
A
Okay,
my
changes
aren't
sticky.
A
Takes
us
to
looking
down
at
issues
in
the
repos,
so
any
particular
ones
in
node
add
on
api
that
people
want
to
bring
up
that.
We
should
discuss.
A
A
C
Yes,
we
just
yeah.
B
C
Thought
ci
right
now
is
breaking
like.
I
need
to
look
on
fixing
that
it
works
on
microsoft,
visual
studio.
It
seems
like
a
client
with
some
other
compilers
has
issues,
and
that's
what
I
see
like
note
version
12
has.
C
Yeah,
I
think
this
example.
This
is
new
example,
which
shows
that
how
we
can
use
javascript
proxy
to
simulate
some
of
our
v8
behavior,
so
think.
At
this
point,
this
pr
has
this
example
has
folders
for
none
in
an
api.
A
C
So
none
is
pretty
much.
I
just
picked
up
from
examples
so
from
node
api
examples
effectively
from
one
of
the
tests,
and
then
I
figured
side
by
side.
How
can
we
do
before
playing
an
api?
I
still
need
to
add
our
c
plus
plus
node
api
example.
On
top
of
it,
okay
yeah
at
least
it's
kind
of
initial
change.
A
C
A
C
A
B
Sorry,
my
internet
is
kind
of
slow
today,
I'm
not
sure
why
yeah
I
I
just
take
a
look
at
this
one
and
I
I'm
sure
this
I'm
not
sure
how
this
person
is
producing
the
memory
leak,
but
I
would
believe
it
would
be
very
helpful
if,
if
they
can
provide
an
example
to
the
problem
so
that
we
can
verify
if
the
program
exists
here
since.
B
B
A
Any
others
that
people
want
to
call
out
that
we
should
go
and
look
at
to
talk
about.
B
And
if
they're
like
I
can
talk
about,
I
can
go
through
the
pr
of
the
finalize
the
second
pass
quebec
and
if
there
are
no
other
topics.
A
B
Can
you
see
my
screen?
I
can
awesome,
so
I
have
summarized
two
problems
with
the
finalization
in
the
core
that
we
have.
We
have
in
the
core
previously,
that
is
not.
That
is
not
very
clear
about
when
to
delete
the
reference
or
yes,
that's
kind
of
this
kind
of
kinds
of
problems.
B
So
when
I'm
I'm
refractoring
I'm
working
on
this
part
of
code,
I
summarize
that
we
have
to
distinguish
two
problems
here
too,
before
we
can
go
through
the
code
base
to
understand
what's
going
on
here,
so
the
first
one
is
the
ownership,
and
previously
we
have
so
currently
we
have
several
kinds
of
references
or
exe
finalizers
that
have
different
ownerships
and
the
first
is
the
use
used
on
the
references
started
to
say:
user
have
users,
users,
users
are
responsible
to
delete
this
references
with
like,
say,
not
api
delete
references
or
not
under
api
remove
wrap,
even
if
they,
even
if
these
references
are
weaker
references.
B
A
Nappy
wrap,
though
shouldn't
once
you
like,
you
don't
need
to
remove
it.
When
the
object
gets
deleted,
it
should
delete
the
the
wrapped
object,
shouldn't
it
or
maybe.
A
B
Object,
the
wrap
is
kind
of
is
a
little
bit
different
from
the
not
a
the
reference,
not
not
pre-reference,
not
pref
types,
since
they
are
yeah,
it's
a
little
bit
different,
but
I
can
go
through
the
other
part
of
the
document.
Sure,
okay
and
the
other
kind
of
the
reference
is
that
these
references
are
automatically
deleted
by
the
runtime
and
when
the
finalizers
are
called
so
user,
can
user
didn't
get
the
handle
of
the
graph
or
any
other
kind
of
types
they
can
use
to
delete?
B
The
refer
deleted
users
can
to
delete
later,
so
it's
automatic
automatically
deleted
by
the
runtime
and
use
it
just
do
this
finalizer
just
code,
so
they
don't
have
to
do
anything
with
it.
This
includes
the
includes
the
nampi
instance
data
and
the
external
type,
and
when
the
not
not
be
wrapped
when
in
when
the
in-n-out
nappy,
rack
parameter
is
not
set
and
similar
to
the
not
added
finalizer
when
the
ignored
nuclear
parameter
is
not
set.
B
So
this
kind
of
references
are
automatically
deleted
by
the
runtime
when
the
finalizers
are
called
so,
and
this
is
the
ownership
of
ownership
part
of
the
preferences
and
for
the
use
user
on
the
references
they.
There
are
three.
B
Three
kinds
of
timings:
that
user
can
code
delete
the
first
one
is
that
user
can
delete
it
before
the
week.
Go
back
is
invoked
like
say
when
the
reference
is
a
strong
reference
and
the
user
can
delete
it
when
the
since
the
wikileaks
go
back
is
never
going
to
be
called
so
you'll
have
to
delete
it
before
the
week
go
back
or
when
the
when
the
reference
is
a
weak
reference,
and
it
is,
the
delete
is
called
before
the
week
go
back
and
the
second
one
is
that
we
have
the
v8
v8.
B
We
go
back
invoked
and
we
have
scheduled
the
second
pascal
back
to
in
to
allow
to
allow
user
to
call
into
javascript.
So
there
is
a
gap
between
the
between
the
the
viet
which
go
back
and
the
users
finalizer
are
being
called.
So
in
this
time,
user
can
still
delete
the
reference,
and
we
and
when
the
user
call
api
is
like
say,
get
the
reference
value,
then
it
will
return
a
and
now
pointer
for
the
for
users
to
fetch
in
the
reference
value
reference.
B
The
value
and
the
third
one
is
that,
when
that,
when
the
user's
finalizers
are
called
and
used,
users
use
the
code
to
and
use
the
code
deleting
the
reference
in
the
finalizers
or
after
the
finance
startdown
method
so
to
the
runtime.
It's
the
reference
is
just
deleted
after
the
finalizer
is
invoked
so.
A
B
B
Second
passcode
you
use
this
finalizer
are
invoked
in
the
second
pass
callback
so
and
possibly
in
the
environment
sheldon.
So
it's,
but
before
the
pr
of
the
of
this
one
yeah
these
two,
the
second
pass
go
back
and
the
environment
shadow
is
two
distinct
faces
that
can
collide
with
each
other.
So
that's
the
problem
we
have
before
around
there
and
I
guess
that's
right.
A
B
And
it
can
either
in
the
second
pass
or
back
or
when
the
environment
is
shortly
done.
Since
we
are,
we
are
invoking.
We
are
training.
The
immediately
called
the
right
analyzers
immediately
closer
check
the
finalizes
when
the
banner,
when
the
environment
is
shutting
down
so
that
users
data
point
can
be
deleted
when
the
environment
is
shutting
down.
A
B
And
so,
since
this
is
the
core
of
the
problem
we
have
previously
to
let's
say
creating
a
second
pass
parameter
since
the
second
pass
callback
is
not
cancelable.
So
that's
the
problem.
We
have,
let's
say,
creating
a
lot
of
intermediate
structures
to
keep
the
to
prevent
double
step
and
to
prevent
double,
free
or
free,
aft
access
after
free
right.
B
So
that
so
that's
the
point
that
we,
maybe
we
can
like
say
when
the
we
can
generally
generalize
these
two
cases
in
so
that
we
can
merge
them
into
one
that
that
is,
that
is
to
say
how
we
can
make
sure
when
the
environment
is
shut,
shut
down
and
the
second
pass
go
back.
It's
never
been
called
electric
state
to
cancel
the
second
passcode
back
since
v8
api
didn't
provide
such
mechanisms,
since
there
is
no
cancellation
handles
or
any
other
api
is
being
exposed.
B
So
the
simplest
solution
is
that
we
can
schedule
our
own.
Second
second
pass
go
back
with
set
immediate,
since
that
immediately
is
implemented
in
the
core,
and
it's
it's
and
it's
definitely
to
be
invoked
when
the
environment
shut
down.
It's
it's
guaranteed
to
be
invoked
in
the
environment
shadow,
so
we
don't
have
to
add
another
layer
of
abstraction
of
this
and
over
this
scheduling
also,
we
can
make
sure
when
the
node
api
environment
is
distracting,
we
can
join
the
final.
B
A
Maybe
I'm
just
not
completely
following
yet
so
like
that,
in
terms
of
like
emptying
the
queue.
A
B
Yeah
at
the
destruction
of
the
m,
we
are
changing
the
second
particle
back
q
and
so
that
and
oh
second
bicycle
back
are
invoked
before
the
is
is
before
the
m
is
totally
distracted.
A
Right,
can
you
just
go
back
to
that
code
again,
just
yeah
so
like
that
drain
finalizer
cube?
Was
that
an
existing
method
we
already
called
somewhere
or
is
that
a
new
method
that
you've
created.
B
A
B
It's
called:
there
is
only
two
code
side
of
the
chain
finalizer
cure.
One
is
that
in
this
set
immediate
code,
which
is
when
there
is
a
standardized
second
pascal
that
is
scheduled,
let's
say
in
queue.
Finalizer
will
set
immediate
schedules
at
the
immediate
when
there,
when
it
is
not
scheduled
and
unplug
the.
B
Not
all
references,
since
not
all
references
are
implementing
the
ref
basic
type.
Like
say,
and
let's
say
there
is
a
function.
Currently
they
have
their
own
abstraction
of
analyzing
and
about
some
applies
to
the
path
timeline.
So
we
still
have
to
call
the
this
one
thumbnail.
B
So
it
will
change
other
kinds
of
analyzers
that
are
not
checked
by
the
not
checked
by
the
second
bus.
Go
back.
B
Okay,
and
particularly
this
includes
the
instance
data,
if
I
remember
correctly,
since
it,
we
don't,
have
a
viet
handle
for
the
instance
data
and
so
the
instances
that
don't
have
a
weak
callback
or
second
pass
callback.
It's
just
a
it's
just
a
finalizer
and
it's
just
a
checked
finalizer
and
it
will
be
change
finalized
in
this
function.
C
C
C
B
A
C
B
Second,
pass
callback
is
scheduled
by
the
node
platform,
which
is
scheduled
with
the
every
loop
similar
to
the
similar
to
the
static
immediate.
So
they
are
just
sim
and
I
have
to
say
this
and
rescheduling
with
sedimented
in
the
second.
Pascal
back
is
just
unnecessary.
A
A
B
I
feel
is
just
a
it
can
be
a
mistake
and
I'm
not
sure
I
I
I
have
an
impression
that
it
it
can
be
unintentional.
I
can
recall
that
maybe
it's
my
wow,
my
pr
that.
A
A
B
And
yeah
right,
we
just
said
image:
schedules
are
limited
in
the
week,
go
back
and
and
we
can
cancel
the
the
the
the
core
problem.
Is
that
once
we
can
like
say
when
previously,
the
the
most
issue
is
about
this
one,
the
second
one
and
the
second
one
and
the
third
one
I
have
to
say
yeah
and
the
second
one.
The
problem
with
the
second
one
is
that
we
cannot
cancel
the
second
pass
callback.
B
B
B
B
Yeah
right-
and
I
use
the
second
passcode
term
here
just
to
reference
that
in
this
kind,
this
with
the
second
pascal
back,
we
can
call
into
javascript,
but
actually
in
this
pr,
we
no
longer
use
the
second
passcode
anymore.
The
v8
second
pass
go
back
anymore.
A
B
And
for
the
0.2,
the
delete
is
called
before
called
after
the
week
go
back
and
before
the
second
pass
go
back.
This
is
the
case
here
we
can
even
the
second
part.
Even
the
second
particle
pack
is
scheduled.
B
We
can
still
delete,
remove
the
schedule,
and
that
is
said
to
kill
the
finalizer
from
the
environment
so
that
it
can
no
longer
be
its
finalizer
can
no
longer
be
invoked
after
it's.
It's
been
deleted,
so
this
is.
This
is
a
point
to
circumvent
the
the
point
two,
since
we
can
now
cancel
the
scheduled
callback.
B
Yeah
it's
a
ordered
set
so
that
we
can
make
sure
each
each
left
checker
can
only
be
killed
once.
B
It's
a
list
on
it's
a
list
on
the
environment
structure:
right:
okay,
yeah!
This
is
the.
C
B
C
Another
thing
what
I
I
talked
about
it
before,
but
I
don't
really
like
us
to
call
all
these
finalizers
from
destructor,
especially
our
classes,
actually
virtual
class,
and
we
we
may
have
potential
lot
of
issues.
What
I
would
propose
that
we
don't
call
from
destructor
anymore,
but
instead
our
environment
has
a
ref
counter
right.
So
what
we
do?
We
typically
call
this
structure
that
this
ref
counter
goes
to
zero.
C
B
B
B
The
definition
is
actually
a
non-op
to
make
sure
the
subclass
method
is
not
called
in
the
base
class
this
chart.
So
I
believe
I
agree
with
your
point
that
we
should
avoid
calling
this
method
in
the
destructors,
but
I
feel
I
I
I
think
this
can
that
fit
in
the
follow-up
pr,
since
this
pr
is
kind
of
kind
of
hard
to
review,
yeah.
A
So
if
you
go
to
like
the
like
the
the
parts
we
finalized,
so
we
in
in
there
there
was
quite
a
bit
of
code
that
was
checking
things.
Maybe
it's
worth
looking
and
yeah
this
one
yeah.
So
maybe,
if
you
scroll
up
a
little
bit
like
there
was
the
comments,
the
other
one,
like
that
big
block
that's
being
deleted.
Let's
just
take
a
look
at
this,
so
right,
yeah.
B
This
part
is
a
this
party,
especially
about
the
environment
shut
down,
since
this
draft-based
finalize
can
be
called
multiple
times
with
the
environment,
shutdown
or
with
the
second
pass
callback.
That's
the
problem
of
the
left-base
finalize
and
here,
and
so
previously
we
we
have.
We
added
several
mechanisms
to
the
environment
shadow,
to
prevent
to
circumvent
the
multiple
invocation
of
this
function.
Let's
say
we
set
the
reference
code
to
zero
and
we
mark
this
mark
this
workspace
as
deleted
that
you
say
it
will
flag
this
into
a
satisfactory.
A
I
guess
like
what
I'm
trying
to
understand
is
we
had
those
those
cases
were
added?
How
do
we,
you
know
what's
being
done
instead
of
those
cases?
So,
let's,
if
you
go
back
to
that,
like
the
first
part
that
says
okay,
scroll
down
just
a
little
bit
or
up
the
other
way,
no
like
okay.
So
basically
we
said
if
it's
end
tear
down
and
the
ref
count
is
greater
than
zero
set.
The
ref
count
to
zero.
Why
don't
we
need
to
do
that
anymore?.
B
B
And
yet
I
have
to
reveal
revisit
the
history
of
this
part,
but
I
I
can
recall
that
when
we
added
this
part
of
code,
it's
it
actually
didn't
work
out
perfectly
and
we
we
counted
a
new
case
that
can
go
down
through
here.
It
can
be
deleted
twice.
B
B
We,
this
problem
can
be
much
more
simpler
here.
First,
we
can
just
remove
it
from
the
checked
finalizer
list
and
we
call
the
finalizer
and
if
it's
owned
by
the
runtime,
we
just
delete
it
and
previously
previously
we,
when
the
finalizer
is
not
owned
by
inner
on
by
the
runtime
and.
B
We'll
set
the
flag
here
that
the
analyzer
is
run
and
in
the
delete
function
when
we
have
either
final
run
or
reference
is.
There
is
in
ref
current
when
the
ref
con,
when
the
reference
is
a
strong
reference,
since
when
it
says
strong
reference,
then
there
is
no
weak,
go
back
or
second
pass
go
back
schedule
set,
so
we
can
safely
delete
the
reference
or
when
the
preference
is
owned
by
the
runtime.
B
So
we
can
delete
the
regular
deleted
reference
and
there
were
no
users.
We
are
not
deleted
a
second
time,
so
the
the
other
one
is
that
and
the
reference
is
not
owned
by
the
runtime
and
we
have
the
panelizer
run.
So
the
delete
is
called
second
time,
that
is
to
say
the
delete
and
yeah
right
here
when
the
when
we
set
the
panelizer
and
flag.
We
actually
didn't
call
this
delete
this
so
so
that
we
can
defer
the
delete
to
user's
description.
C
B
Yeah
once
the
finalizer
is
run
at
the
most
once
the
problem
can
be
much
simpler
here,
since
we
don't
have
to
reduce
most
of
the
flux
here,
especially
about
the
deleted
self
delete
itself
flag,
since
at
first
at
first
place
is
actually
designed
to
mark
the
reference
as
a
reference
only
by
the
runtime.
You
can
see
it's
it's
a
parameter
in
the
constructor
right
and
we
actually
using
it
to
mark
the
reference
as
a
reference
owned
by
the
runtime
and
the
runtime
is
responsible
to
delete
it.
B
B
B
A
A
A
And
I
guess
I'm
trying
to
think
of
the
which
case
it
was
it
was
like
there
was
definitely
cases
where
like
either
would
be
deleted
by
the.
Maybe
it
was
buy
down
the
shutdown
but
like
there
was
the
like
it
was,
you
know,
trying
to
double
delete
was
a
problem.
B
Yeah,
this
is
a
double
digit
problem
here
and
the
finalize.
Oh,
it's
actually
calling
the
rough
basis,
the
left
base,
column,
column,
finalized
and.
B
Wait
a
minute
yeah,
the
panelizer.
Previously
we
just
to
call
in
called
the
rough
base
finalize
and
in
the
left
stand
in
the
first
phase.
Let's
say
when
the
emerge:
the
environment
is
shutting
down
it,
it's
it
can
actually
didn't
delete
itself.
Since
you
can
see
it's
just
setting
the
flags
or
in
the
delete
this
it's
it
can
still
setting
the
flags
and
didn't
delete
the
reference
or
when
the
or,
when
the
or,
if
the
users.
A
B
C
B
B
So,
since
with
the
new
with
the
new
code
we
and
the
environment
components,
it
is
immediately
called
the
user's
finalized
callback,
so
user's
finalized
copy
is
not
different.
Two
lead
point,
so
we
cannot
access.
We,
we
have
a
command
here.
We
cannot
access
to
this,
since
it
can
be
deleted
if
user
have
deleted.
So
this
is
analogous
to
the
user's
finance
function.
If
the
reference
is
a
is
owned
by
the
is
owned
by
the
another
core.
A
A
A
B
B
B
And,
let's
see
what
happens
yeah
previously,
we
just
calling
the
delete
function
and
since
we,
since
now,
we
don't
have
such
flags
to
set
when,
when
at
and
deleting
we
don't
have
such
flags.
So
we
can
simply
delete
the
reference
and
all
the
scheduled
callback
will
be
immediately
cancelled
and
the
reference
in
well
immediately.
B
And
the
delete
reference
can
be
called
in
these
three
cases
right,
okay,
so
all
of
these
three
cases,
we
can
simply
cancel
this
callback
if
it's
scheduled,
so
the
reference
can
no
longer
be
used.
So
the
problem
here
can
be
much
simpler,
since
we
don't
have
so
many
flags
to
set
when
deleting
the
reference.
B
It's
actually
here
previously
we
have
the
co
finalizer
and
apparently
I
can
it's
a
wrap
red
part
of
the
code
you
can
see.
This
is
the
sedimented
in
the
code
finalizer.
So
now
we
now
the
okay
finalizer
is
just
a
simple
call
back
into
module
to
protect
the
javascript
exception.
B
B
B
A
A
We
are
past
time
anything
else.
We
should
talk
about
this
week
before
we
close
out.
A
Okay,
if
not
great
thanks
for
everybody
who
took
the
time
to
join
today
and
we'll
see
everybody
next
time.