►
From YouTube: Node-API Team Meeting - 2022-02-25
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
Hello,
everybody
welcome
to
the
february
25th
meeting
of
the
node
api
team,
we're
going
to
go
through
our
usual
agenda,
but
before
we
do
that,
if
anybody
has
any
announcements,
please
make
them.
A
No
announcements,
okay,
that
works
all
right.
So
let's
see
the
agenda
then,
but
but
I'm
just
gonna
close
some
tabs
here
from
last
time
and
new
one
with
the
agenda.
A
A
A
This
all
right.
Okay,
all
right,
no
worries,
okay.
So
so
then,
let's,
let's
leave
it
open
and
move
on.
That's
fine!
Okey-Dokey!
A
B
B
D
D
Yeah
the
issue
is
helicopter
because
we
store
inside
yeah
to
char
star
yeah.
D
And
goes
out
of
scope
and
I
think
people
can.
We
can
have
pointer
to
some
memory,
maybe
on
the
call
stack
or
something
which
can
be.
A
Yeah
we
need
to.
We
need
to
copy
this,
but
then,
if
we
copy
it,
we
need
to
free
it.
Oh
yeah,
why
do
we
do
this?
I
suppose
yeah
yeah,
it's
pretty
clear.
What's
going
on,
I
mean.
Maybe
this
can
be
solved
with
documentation,
because
you
know
if,
if
people,
if
people
did
the
did
a
vector
of
strings
filled
the
string
with
the
names
and
then
just
iterated
over
the
vector
created
the
property
descriptors.
A
So
if
you
had
two
loops
here
right,
one
one
is
to
create
a
standard
vector
of
strings.
Then
you
create
a
property
descriptor.
Then
you
call
define
properties.
Then
you're,
fine
right.
D
A
Okay:
okay:
let's
see
what
the
documentation
says.
A
A
Oh,
I
see
people
they're
like
okay,
I
see
so
so.
People
use
string
literals
here.
C
Oh
come
on:
where
is
the?
Where
are
the
static
methods?
I
think
that
you
need
to
see
at
the
object
wrap
the
windage
is
need
to
see
what
the
object
wrap
documentation.
Oh.
A
Oh
okay,
there
we
go
sorry,
okay,
so
where
were
we
okay?
A
A
Okay,
I
think
I
think
I
think
we
can
solve
this
with
documentation.
We
can
simply
say
you
know
the
the
the
scope
of
the
strings
has
to
be
maintained
until
somebody
actually
calls
to
find
him.
Oh.
E
God,
but
it
was
a
property
descriptor
in
the
object
class
yeah.
The
example
was
was
with
the
the
object
class,
so
we
use
property
descriptor
on
define
properties,
yeah
find
the
property
yep.
A
E
Yeah
yeah,
I
see
that
new
object
and
then
yeah
he
yeah
assigned
to
the
object.
The
the
the
the
property
script.
A
Yeah,
I
know
I'm
just
trying
to
figure
out
where
we
should
add
that
okay
yeah
like
where
should
we
document
that
that
the
the
that
the
utf-8
name
has
to
be
has
to
remain
in
scope.
So
so,
basically
we
have
to
say
that
the
property
descriptor
does
not
take
ownership
of
the
utf-8
name
pointer,
that's
it
we
have
to.
We
have
to
say
that,
because
that
tells
everybody
that
okay,
I
need
to
maintain
the
pointer.
Until
I
call
I
use
the
property
descriptors
for
something.
A
So
this
this
is
a
good
place,
so
here
we
can
say
now
terminate
the
string.
That
represents
the
name
of
the
static
property
right
and
we
should
add
the
property.
Descriptor
does
not
take
ownership
of
the
name.
It
is
the
responsibility
of
the
caller
to
maintain
the
utf-8
name
pointer
until
it
is
needed
so
yeah.
I
think
I
think
we
should
add
that
here
and
then
it
becomes
clear
that
you
need
to
maintain
the
pointer.
A
D
Yeah
this
one
seems
to
be
wrong:
okay,
because
this
talks
about
object
trap,
but
we.
A
D
Thank
you
for
informing
and
we
do
have
overload
which
receives
us
to
string.
I
guess
the
question
will
be:
do
we
want
to
be
with
two
string
to
be
kind
of
a
convenience
method
and
to
create
an
api
value
out
of
it?
So
because,
certainly
in
prop
descriptor,
we
have
an
option
either
provide
an
api
value
or
we
can
provide
a
pointer
to
the
chart.
A
D
Yes,
so
if
we
want
to
keep
it
just
kind
of
pointer
size
and
being
able
to
do
this,
always
interpret
costs
and
stuff,
we
definitely
have
no
room.
A
True,
which
means?
Which
means
we
have
no
room,
which
means
we
have
to
convert
to
an
api
value
in
all
cases,
even
with
cons,
car
star,
right
and.
E
D
D
A
Okay,
I
think
I
know
where
I
did
this
yeah
these,
these
all
don't
have
it.
I
think
it
was
set
property
or
something
like
that.
A
D
Technical,
this
stuff
should
be
responsible
for
lifetime
management
of
a
stream
yeah
exactly.
A
For
the
pointer,
yeah
yeah
so-
and
even
that's-
that's
also
true
for
for
for
for
this-
I
mean
what
the
heck
where's
my
mouse,
okay.
So
so
for
this
thing,
it's
pretty
clear
that
they
have
to
maintain
the
lifetime
of
the
pointer,
because
this
is
a
reference
right
so
well.
We
still
have
to
say
that
we
don't
copy
it,
and
so
but
but
it
is
a
little
bit
clearer
here
that
we
don't
actually
take
like
a
utf-8
name
ish,
but
this
one
this
one.
A
We
definitely
have
to
document
that
they
have
to
maintain
the
pointer
and
then
I
think
separately
we
can
provide.
We
can
provide
overrides
with
with
the
that,
take
the
environment
yeah.
That's
that's
like
two
separate
things
we
can
do.
A
And
the
ones
that
take
the
environment
they
would,
they
would
create
an
api
values
from
the
pointers.
D
D
Maybe
to
add
what
you
said
initially
that
just
to
solve
this
immediate
issue
that
the
developer
can
create
vector.
First,
two
strings
good
point:
good
point:
yes,.
B
A
A
B
Then,
let's
close
up
shop
here
and
move
on
to
the
next
item
tracking
issues.
A
Wow,
this
is
very
cool
yeah.
This
is
this
is
cumulative
downloads,
I'm
assuming
or.
A
Yeah,
that's
pretty
crazy,
though
wow
this.
This
basically
blows
npm
out
of
the
water,
like
the
the
the
numbers
we're
getting
from
npm.
A
E
Yeah,
I
think
yeah
I
I
I
I
can
check.
E
Yeah
but,
but
now
knows
us,
we
will
decrease
because
they
they
changed
the
api
yeah
right.
E
So
I
think
that
it's
not
for
it's
not
bear
week.
It's
it's.
E
Yeah
but
they
use
the
the
c.
A
Api
yeah,
exactly,
which
is
why,
which
is
why
we're
we're
not
seeing
it
as
a
as
a
as
a
dependency
right
yeah.
So
so,
whenever
somebody
installs
fs
events,
it
doesn't
mean
that
they're
also
going
to
install
know
that
on
api,
and
so
we're
not
getting
the
download
numbers
because
we're
not
linked
right.
E
Yeah,
I
don't
download,
I
think
that
it's
more
it's
it's
permanent.
In
that
case,
oh.
C
E
A
Okie
dokie
drive
towards
full
coverage.
I
guess
we
would
have
to
have
jack
for
this
and
then
in
the
debug
testing.
We
need
michael
for
that.
Okay,
so
let's
burn
down
some
issues.
A
E
E
A
E
Yeah,
it's
the
same.
If
you
write
cost
native
obj,
equal
new
native
objects,
because
the
create
need
on
that
case
do
the
same.
But
from
the
native
side
you
can
yeah
yeah,
you
can
see
the
you
can
see.
The
code
in
in
our
repo
yeah
see
this
progression
repository
on
top
of
the
yeah.
F
E
So
yeah
the
the
the
the
javascript
is
very
simple
yeah.
Just
all
in
a
for
loop,
the
creation
of
a
native
object
rob
an
easy
vote,
so
yeah
yeah.
A
E
Okay,
what
I
experimented
is
that
when
you
go
out
of
the
loop.
E
The
memory
will
be
free,
it
will
be
released,
oh
yeah,
so
I
think
that
the
garbage
collection
happen
after
the
the
four
loop.
I
I
yeah.
E
E
The
the
the
memory
increase
depends
on
where
you
are.
I
I
tested
on
mac
os
and
on
windows
and
increase
until
you
are
in
the
loop
and
when
you
go
out
of
the
room.
D
E
He
he
use
a
weight.
You
promise
at
immediate.
A
There
is
there
is,
I
think,
it's
a
little
more
complicated
than
that,
because,
because,
if
you
do,
if
you
do
a
weight,
you
promise
immediate
right,
then
you
never
exit
the
loop
right.
You
just
do
a
weight.
You
promise
immediate
right,
but
I
think
what's
happening
is
when
you,
when
you
do
that
you
you
run
the
the
micro
task,
queue
right
and
without
exiting
the
loop,
and
I
think
the
garbage
collector.
A
If
you,
if
you
don't
exit
the
loop,
I
think
the
garbage
collector
does
destroy
the
javascript
object,
but
it
doesn't
call
the
the
the
the
the
native
destructors
right.
It
doesn't
call
the
the
weak
callbacks
because
because
it
doesn't
get
a
chance
right,
the
weak
callbacks
are
on
the
micro
test
queue
and
if
you
never
run
the
micro
task
queue,
then
then
the
the
the
weak
callbacks
never
get
called
so
so
I
think
the
leak
here
is
not
from
v8.
A
The
leak
is,
is:
is
the
accumulation
of
of
weak
callbacks
on
the
microtask
queue
and
the
memory
that
they
need
to
do
the
the
memory
that
they
need
to
free
right?
Because
for
every
native
object
you
do
you
do
an
api,
wrap
right
and
so
an
api
rap
means
there
is
some
native
data
that
needs
to
be
freed
and
that
native
data
cannot
get
freed
synchronously
it
has
to.
It
has
to
be
free
using
the
the
micro
task,
queue
yeah
and
that's.
Why
that's?
Why?
A
If
you,
if
you
uncomment
this,
you
give
the
micro
task
q
a
chance
to
free
the
memory
okay.
So
so
it's
bad
in
a
sense
that,
yes,
you
cannot
do
an
infinite
loop,
where
you
just
create
native
objects
and
expect
it
to
work
as
if
they
were
pure
javascript
objects.
That's
true
that
doesn't
work,
but
but
there
is
a
way
out
which
is
a
well.
You
know
as
soon
as
you
exit
the
loop
they're
gone
right,
so
you
know
pace
yourself.
A
You
know
I.
I
don't
know
that.
I
don't
know
that.
There's
necessarily
anything
we
can
do
about
this
because
of
this.
Because
of
the
way
we
do
weak,
callbacks,
there's
just
you
just
can't
do
it.
I
don't
think
the
engine
even
allows
us
to
do
this,
because
we
cannot.
We
cannot
run
the.
A
We
cannot
run
the
the
weak
callback
during
garbage
collection
because
the
the
engine
is
in
is
in
an
inconsistent
state.
So
so
that's
why
we
we
had
to
do
this.
This
ultimately
asynchronous
weak
callback,
if
I
remember
correctly
so
so
then,
yes,
this
is
true.
It
is
a
memory
leak,
but
only
for
for
native
objects.
D
When
I
was
working
on
implementing
node
api
for
hermes,
I
because
I
didn't
have
this
facility
coming
from
hermes
running
all
these
different
finalizers
and
I
had
to
mimic
it
so
the
way
I've
done
it
in
the
end
of
each
function
call
I'm
kind
of
running
all
these
different.
Exactly
like
finalizer,
I
kind
of
drain
finalizer
queue
myself,
yeah
yeah,
because.
A
A
Yes,
yeah,
that's
that's
what
we
do.
That's
what
we
do
when
the
environment
shuts
down,
we,
we
actually
maintain
our
own
list
of
finalizers,
so
every
finalizer
is
in
that
list
and
then
we
we
drain.
We
drain
the
list
ourselves
because
we
know
that
the
the
engine
isn't
going
to
do
it
anymore,
because
it's
shutting
down
but
but
yeah
during
during
normal
operations.
We
we
don't
do
this
and-
and
I
think,
even
if
we
did
right
for
for
every
finalizer,
that
that
was
supposed
to
get
called.
A
We
still
wouldn't
be
able
to
to
to
to
remove
the
the
memory
leak
because
well
we
never
get
a
chance
to
to
call
even
one,
let
alone
like,
even
if
we
change
their
code
to
to
to
iterate
over
all
the
finalizers.
If
the
first
one
doesn't
get
called,
then
you
know
we
don't
get
a
chance
to
run
the
code
and
it's
just
complication
for
no
reason
so
so
yeah.
I
don't
think
we
can
do
this
during
normal
operations.
D
The
way
it
works
in
the
code
I
wrote
for
hermits.
It
was
actually
that
the
pretty
much
then,
when
the
letter
run
from
from
garbage
collector
this
panel,
everything
what
it
does.
It
puts
my
finalizement
special
finalizer
q.
So
thank
you
and
then
in
the
end
of
each
function,
native
function,
I
just
drain
in
this
queue
most
cases,
probably
building.
No,
oh.
A
When
you
say
native
call,
you
mean
like
at
the
end
of
each
api
like.
A
Properties,
napi
create
boolean
or
or
new
boolean
or
whatever.
Oh
I
see
so
so
you've.
So,
okay,
I
see
so
so
you
take
the
opportunity
yeah.
Okay,
that's
that's
kind
of
that.
That's
kind
of
a
heuristic
like
if
somebody
calls
this,
then
chances
are
that
that
that
you
know
that
they're
not
doing
something
else,
yeah
yeah
yeah.
That's
that's
not
bad.
It's
kind
of
a
it's
kind
of
a
preamble
or
or
an
epilogue.
Basically,
yes
for
every
api
call.
D
A
E
D
E
Gabriel,
we
we,
we
lost
you
for
one
two
minutes,
and
I
think
that
you
was
talking
alone.
D
D
D
A
A
Anywho,
so
I
I
was
saying
this
is
a
good
idea
this
this
this
epilogue,
and
maybe
we
should
discuss
this
further.
Let's
keep
this
issue
sort
of
on
our
radar.
I
don't
know
what
the
best
way
of
doing
that
is.
G
D
D
D
A
D
D
During
the
environment,
shutdown,
but
going
through
all
of
them,
every
single
time
will
be
expensive.
A
Okay,
but
there
won't
be
that
many
right
because
you've
gone
over
them
and
you've
removed
all
of
them
right.
So
at
the
end
of
each
node
api
call,
there
will
be
zero,
presumably.
D
Right
yeah,
but
in
this
case
we
need
to.
We
need
to
create
new
new
finalizer
queue.
We
don't
have.
We
don't
have
it
yet
in
in
node.js
implementation
for
v8.
D
A
A
A
So
so
then
so
then
you
know
at
the
when
the
at
the
end
of
environment
shutdown,
that
queue
is
guaranteed
to
be
zero
length
right.
Yes,
so
so
I
guess
what
I'm
asking
is:
will
many
many
many
of
these
finalizers
accumulate
between
node
api
calls.
If
we
clean
the
queue
at
every
node
api
call
right
or
will
it
just
be
like
zero,
zero?
Zero?
Two
two
three
two
three
two
two.
D
A
Yeah,
so
so
so
so,
let's
see
so
for
this
example
with
the
loop
right.
The
correct
me:
if
I'm
wrong
the
the
the
queue
there
would
be
a
huge
backup
right
in
the
queue,
because
we've
created
all
these
objects
and
we
haven't
had
it.
Oh
no.
No,
there
won't
be
right
because
every
time,
every
time
you
create
an
object,
wrap
you,
you
crea
you,
you
call
you
at
least
call
an
api
rap
right
in
order
to
to
create
the
you
know,
the
the
hybrid
javascript
native
object
right.
A
Only
drain
as
many
objects
as
the
garbage
collector
has
had
a
chance
to
to
collect
over
the
past,
whatever
the
heuristics
are
of
the
garbage
collector
right
right.
So
so
then,
so
then,
since
the
garbage
collector
runs
runs
in
parallel
on
a
separate
thread
that
that
q
could
be
could
be,
large
could
be
small,
we
don't
know
right,
but
but
the
the
work
of
of
draining
the
finalizer
queue
has
to
be
done
it
it's
it's
just
work
that
has
to
be
done
right.
A
So
so
then,
if
we
drain
the
finalizer
queue
as
part
of
an
api
wrap,
then
we
have
essentially
distributed
the
work
into
the
the
loop
rather
than
waiting
for
the
loop
to
exit,
as
nikola
has
noticed
that
if
the
loop
exits,
then
the
memory
is
free,
meaning
meaning
all
those
finalizers
finally
get
called
right.
Yes,
so,
but
that's
that
still
means
we
can
use
the
the
the
existing
finalizer
queue.
D
Technically,
yes,
but
because
just
kind
of
just
for
my
reference,
like
you,
you
you're
talking
about
this
finalizer
queue,
is
pretty
much
our
collection
for
references
with
finalizers
right.
C
D
What
about,
I
think
like
this,
this
the
whole
kind
of
queue
like
this,
it's
kind
of
long,
but
what
we
can
do,
maybe
they
never
like
garbage
collector,
runs
finalizer
and
because
we
can't
do
some
expensive
stuff.
At
this
point,
we're
saying:
oh,
we
kind
of
differ
into
this
second
pass
and
second
passes.
We
probably
don't
see
it,
but
what?
If,
instead
of
deferring
to
second
pass,
we
put
it
in
special,
smaller
queue,
because
we
know
like
this:
guy
must
die
right.
A
Yeah
yeah
yeah
yeah,
yeah,
you're,
right,
yeah,
okay.
So
what
I'm
saying
is
we
already
have
a
cube
right?
Yes,
because
we
we
have
it
on
the
on
the
environment
right
and
so,
and
we
add
all
all
the
all
the
references
to
that
queue,
because
I
think
even
the
ones
that
don't
have
a
user
finalizer.
They
still
need
to
be
finalized
right
because
we
have.
We
have
things
like
like
the
the
the
the
data
associated
with
the
function,
call
right.
That
also
needs
to
be
finalized.
Yeah,
the.
D
Only
thing
is
we
just
put
them
in
different
queues,
mostly
for
like
environment
shutdown
purpose
like
yeah
run,
your
customer
call
custom
code.
First.
A
A
A
And
I
think
one
another
thing
we
could
do
is
if
the
queue
is
too
big.
We
can
simply
just
you
know,
delete
this
many
items.
You
know
or
delete
like
a
percentage
or
something
like
that,
because
we
know
we're
going
to
get
another
chance,
because
I
mean
the
the
add-on
is
going
to
keep
calling
apis
right.
So
we
will
have
a
chance,
you
know
and
if
not
well
we're
going
to
do
it
during
environment
shutdown
anyway.
So
we
will
delete
these
items
at
some
point
right.
D
It's
good,
but
I
just
should
we
add
just
a
few
words
to
developer
because
we
kind
of
talked
about
solution.
But
maybe
it's
worth
to
say
yes
to
admit
the
issue
that
and.
G
G
A
Okay,
cool
yeah
yeah:
this
is,
we
should
definitely
discuss
this
yeah.
Where
should
we
put
this
so
that
we
discuss
it?
Maybe.
A
Oh
well,
here
we
go
michael
tuskey
with
him.
A
A
A
All
right,
if,
if
everybody's
okay-ish,
then
thank
you
all
for
joining
and
we
will
talk
again
next
week,
bye
all.