►
From YouTube: 2022-04-01-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
april
1st.
Hopefully
it
won't
be
a
joke
and
we
will
follow
our
our
regular
approach
of
looking
at
the
things
we're
tagged
for
milestone
11.
before
we
get
started.
Does
anybody
have
any
announcements
they'd
like
to
share.
A
So
the
first
part
is
the
drive
towards
full
coverage.
I
don't
think
there's
any
updates
on
that.
Does
anybody
have
any
to
share.
A
C
Sorry,
I
didn't
didn't
look
on
it.
E
Okay,
I'm
just
reading
the
latest.
I
don't
know
if
there's
any
more
updates
on
that.
That
was,
I
guess,
a
while
back.
A
F
A
Okay,
but
we'll
just
leave
it
on
the
list
and
I
think
that's
actually
all
the
ones
from
the
stale.
So
that's
good,
so
I
guess
it's
on
to
or
we
can
look
at
there's
any
new
modules
that
were
mentioned.
No.
Let's
take.
A
A
G
I
pushed
a
pr
for
formatting
the
code.
We
had
an
issue
to
format
everything
in
node
add-on,
api
yep.
G
So
with
this
one,
there
were
some
non-auto
fixable,
javascripts,
okay,
so
those
and
then
that's
that
first
log
in
the
first
question
there
and
then
had
to
be
manually
addressed
okay,
and
it
would
be
like
this
set
here-
no
unused
variables
camel
casing
using
triple
equals.
Things
like
that,
so
I
had
to
manually
address
those
I
did
not.
G
I
put
all
of
the
javascript
changes
in
one
commit.
I
I'm
starting
to
think.
Maybe
it
would
have
been
better
to
put
the
auto
fixable
ones
one
commit
and
then
the
manual
changes
in
another
so
that
those
could
be
better
reviewed.
But
I'm
not
sure
I
can
do
that
if
it's
necessary.
Otherwise
it
can
be
just
reviewed,
as
is.
G
Yes,
and
some
of
them
were
fixed
by
by
disabling
certain
rules
for
the
whole
file,
because
it,
I
guess
some
one
of
them-
was
like
no
unnecessary
blocks
or
something
like
that,
and
it
looked
like
in
that
in
some
of
those
tests,
it
was
using
blocks
to
sort
of
differentiate,
different
sections
of
the
test
right,
so
I
was
like
okay,
so,
instead
of
just
actually
changing
the
code
to
remove
the
blocks,
I
think
it
would
have
been
better
to
just
disable
that
rule
for
that
file
right,
okay,
so
it
can
either
be
reviewed,
as
is
or
I
can
separate
the
javascript
changes
into
two
separate
commits.
A
Yeah,
I
think
it's
one
we
want
to.
We
need
to
review
and
land
quickly
because
it's
going
to
be
continual
continual
merge,
conflicts
right.
A
G
A
A
If
we,
if
you
went
back
and
put
it
into
different
commits,
are
people
going
to
go
and
look
at
the
one
commit
that
has
the
non-autofix
things
more
carefully
or
should
we
just
look
at
this
and
you
know,
say:
okay,
there's
lots
of
changes
but
we're
pretty
comfortable
they're
just
going
to
be
formatting.
Therefore,
let's
land
it
and
you
know-
rely
on
the
test
suite
to
cover
us,
and
you
know,
stick
with
that.
G
So
like,
for
example,
one
of
the
manual
ones
is
right
here,
if
you
scroll
up
a
little
bit
just
in
this
index.js
there
for
include
underscore
directory
right,
something
for
non-camel
case.
So
that
was
one
that
had
to
be
done
manually.
A
I
think
the
other
thing
is
this
is
mostly
in
tests
too
right.
So
you
know
the
the
worst
case
is
we
have
a
test
which
isn't
quite
testing
as
well
as
we
did
before,
but
on
the
other
hand,
we
don't
have
full
coverage
side,
I'm
doing
the
risk
assessment
in
my
head
right,
like
I
think,
if
we
look
at
the
risk
assessment,
you
know
the
nappy,
inl
and
inl
dot
h
are
the
highest
risk
ones
right,
correct.
G
A
Yeah,
I
guess
I'm
kind
of
like
yeah.
It
was
mostly
mechanical.
It's
only
in
the
tests.
You
know
are
people
pouring
over
this
gonna?
Is
it
gonna
actually
reduce
our
risk
by
very
much?
My
guess
is
no
and
I'm
kind
of
happy
to
say
yeah.
This
was
mostly
mechanical,
let's
just
land,
but
I
I
wonder
what
other
people
think
like.
If
there's
somebody
else
who's
gonna
say
no,
let's
break
it
up
into
two
I'll
spend
a
lot
of
time.
Looking
at
more
time,
looking
at
the
non-mechanical
ones,
then
maybe
we
should
do
that,
but.
A
A
A
C
I
still
need
to
go
back
to
this
pull
request
here.
But
sorry
I
didn't
do
changes
yet,
which
one
was
that
the
it
was
about
this
automatic
formatting
stuff.
A
Did
I
land
that?
Oh,
I
think
I
ended
up
landing
it
because
I
I
remember
we
discussed
it.
Yes,
but
in
the
end
it
was
like
the
it
needed
to
be
custom
in
the
two
cases,
so
right,
cool
thanks.
There
was
a
suggestion.
We
could
use
the
path,
so
I
think
you
know
we
could
go
back
and
add
that
in,
but
I
don't
think
it
was
critical
one
way
or
the
other
in
the
end,
because
you
still
had
to
add
the
trailer.
A
H
A
A
A
So
I
I
opened
this:
we
we
had
that
long
discussion
about
the
const
pr,
and
so
I
ended
up
landing
that
minus
one
of
the
changes
one
of
the
commits,
which
was
to
remove
some
things,
but
the
other
commits
actually
removed
these
three
methods
because
adding
cons
to
them
so
adding
const
to
the
property.
L
value
versions
actually
can
make
some
conflict
with
these,
so
the
pr
had
removed
them.
A
But
the
problem
is
that
actually
breaks
some
existing
code,
and
that
was
this
is
the
code
that
would
break
from
the
the
issue
that
was
opened.
So
I
added
that
code
into
the
test
into
the
tests
that
test
the
the
particular
place
and
it
passes
reverting
those
and
fails
without
them.
So
we
did
actually
break
something.
A
I
think
we
might
spend
some
more
time
looking
to
understand
that
specific
case
and
maybe
do
something
on
purpose,
but
I
I
think
backing
them
out
for
now,
because
we
didn't
intend
to
break
anything
by
adding
the
cons
any
existing
code.
So
if
we
do
do
that,
I
think
we
should
take
some
more
time
and
understand
it,
make
a
choice.
A
F
A
E
E
G
Yes,
from
my
understanding
he's
expecting
that
id
property
to
be
printed
when
you
just
console
log
the
object
and
he
has
to
use.
I
guess
when
you
define
this
instant
successor,
it's
a
hidden
property
because
he
has
to
use
this
show
hidden
in
order
for
it
to
to
come
up
but
and
he's
using
the
napi
innumerable.
G
A
Copyrightable
nappy
innumerable,
I
have
some
feeling
we
came
up
with
a
nappy
default
node.js
api.
B
B
Actually,
I'm
just
going
to
make
sure
I
have
the
chat
open
in
case.
Okay,
there's
no
chat.
G
C
H
C
G
Yes,
so
I
just
did
a
quick
check
with
like.
Am
I
muted?
No
okay?
I
just
did
a
quick
check
in
in
the
console
using
finding
an
object
and
then
doing
object,
defined
property
that
has
a
getter
method
and
a
new
growable,
true
and
configurable
true
and
console
logging.
That
object
does
not
return
that
property,
but
then
object
get
on
property
names
of
return
of
that
object
does
show
that
property
and
I'm
not
sure
if
what
the
equivalent
of
the
util
inspect
show
hidden
is
in
chrome.
G
Yes,
I
can
just
put
this
in
the
chat,
I
guess
real
quick
chat,
yeah,
yeah
and
hopefully
it'll
render
correctly.
Yes,.
G
C
Yeah,
it
seems
like
it
does
not
it's
not
an
issue
with
node
api,
it's
more
like
behavior
for
console.log
right.
C
Showing
up
and
if
maybe
like
they
have
scenarios,
and
they
want
to
show
this
property
like
to
force
to
show
something.
I
guess
there
is
something
like
people
can
define
like
special
method
associated
with
object
to
in
numerate
properties.
C
This
kind
of
enumerator
you
can
associative
object
with
some
kind
of
method
called
enumerator,
or
something
like
this.
G
G
So
I
think
that's
probably
that's
just
the
behavior
of
properties
that
have
instant
prop
accessors
property,
accessors
and
that's
another
reason
in
his
example,
where
he
showed
that
the
when
he
did
the
inspect
with
hidden,
it
was
showing
just
the
the
text
of
getter
setter
or
something
like
that,
and
I
think
it's
because
retail
inspect
does
not
want
to
explicitly
run
the
property's
accessor
method.
B
A
Yeah,
I
guess
the
question:
if
they
wanted
to
make
it
visible
by
default,
that
I
guess
there's
no
other
attributes
that
we
can
really
set
right.
A
C
C
A
C
Yes,
I
kind
of
most
have
like
biggest
questions
about
one
when
we
remember
like
we
talked
about
this
memory
leakage
and
you
know,
implemented
running
finalizers
as
part
of
a
second
gc
pass,
and
people
saying
like
two
contentious
issues
with
this
pr,
like
one
of
them
should
we
have
a
kind
of
local
finalizer
air
handler?
C
And
second
one
is,
I
think
it's
even
more
important
that
are
we
okay
to
run
analyzers
in
some
random
places,
because
when
letters
may
invoke
some
javascript
and
what
I
understood
that
it
may.
H
C
C
Right
so
I
guess
my
question
to
this
group
like,
should
we
introduce
such
such
thing
as
a
pure
finalizers,
where
we
prohibit
using
calling
to
javascript
during
finalization,
because
we
can
say
this
analyzers
is
only
for
cleaning
up
your
native
resources.
C
Right,
because
if
people
still
want
to
do
some
javascript
calls-
probably
we
don't
have
better
way
than
as
we
do
today
to
call
them
from
set
immediate.
C
But
for
the
second
pass
to
to
clean
up
some
negative
resources,
like
I
mentioned,
you
have
some
kind
of,
if
managed,
javascript
objects,
you
have
to
shade
some
c
plus
plus
object,
and
then
this
javascript
object
is
dying.
We
want
to
just
call
this
structure
in
our
c
plus
plus
class.
H
C
Everything
we
care
about,
or
cleaning
up
some
other
native
resources,
which
I
think
like
majority
scientists
would
be
like
this.
The
fact
that
some
people
may
call
javascript
from
this
finalizers
it's
more
like
rather
obscure
scenario.
It's
like
not
not
so
common,
but
exactly
this
usage
makes
all
these
different
difficulties
with
the
second
pass
all
together,
because
we
don't
even
need
second
pass
for
pure
finalizers.
We
can
do
it
right
in
first
pass.
A
C
Right,
as
we
saw
like
in
this
original
bug,
it
seems
like
developer.
They
work
on
on
some
kind
of
javascript
and
node
api
code,
which
work
with
some
graphics
like
as
a
part
of
this
javascript
execution.
They
may
produce
a
lot
of
native
objects
responsible
for
some
ui
elements
and
imagine
some
kind
of
gaming
environment.
It
can
be
literally
millions
of
kind
of
objects
created
at
that
time.
C
And
they
want
to
cone
efficiently
being
able
to
allocate
them
to
allocate
them.
Maybe
they
don't
even
use
normal
kind
of
memory,
location
technique,
but
rather
using
some
internal
resource
management
techniques.
So
I
don't
know
people
using
some
graphics
cards
objects,
I'm
not
a
game
developer.
So
I
don't
know
all
these
different
integrity
details,
how
people
can
optimize
and
all
these
different
graphics,
rendering.
A
C
C
H
Hear
me:
okay,
okay,
great!
Yes,
I
I'm
able
to
talk
now,
so
the
the
finalizer
hint
is
is
exactly
what
michael
said:
it's
arbitrary
data.
We
we
can't.
We
can't
dress
that
up
in
any
way.
We
have
to
leave
that
up
to
the
user,
but
but
but
I
am
in
favor
of
of
of
adding
a
pure
finalizer
that
doesn't
accept
or
doesn't
receive
a
an
api
environment.
H
So
it
just
receives
that
two
pointers,
the
the
object
to
be
destroyed
and
the
hint
that's
it,
and
then
that
makes
it
clear
that
you
cannot
call
into
javascript
from
there
and
I
think
we
can
use.
We
can
use
like
a
new
api
that
is
similar
to
an
api
at
finalizer,
because
a
finalizer
can
be
added
to
any
object
nowadays.
H
A
H
C
When
environment
usage
can
be
illegal
is
to
access
instance
data,
so
thankfully,
what
what
we
do?
We
associate
a
point
add-on
with
environment,
through
instance,
data.
So
one
thing
we
can
do
we
procure
and
like
pure
finalizer,
to
pass
this
instance
data
as
a
instead
of
environment
right.
H
That's
a
good
point.
Well,
okay,
then,
let's
see,
let's
see,
let's,
let's
examine
the
the
implications
of
providing
the
environment
we
do.
Then
we
have
to
document
that
no
javascript
must
be
executed
and
then
we
we
may
need
to
sort
of
annotate
all
our
apis
saying
this
is
javascript
safe.
This
is
not
javascript
safe
and
I
suspect
that
that
annotation
coincides
with
which
api
uses
an
api
preamble
and
which
one
simply
uses
like
the
basic
wrappers
like
for
checking
the
environment
is
null
and
doesn't
have
any
preamble.
D
H
D
H
Yeah,
so
so
so
the
so
yeah,
so
a
a
status
code
of
can't
call
into
js
would
be
useful
and
we
would
already
have
a
place
where,
instead
of
an
api
pending
exception,
we
would
return
an
api
cannot
call
into
js
yeah,
but
but
that
would
be
api
breaking,
and
so
so
we
we,
we
didn't,
do
that.
H
We
we
still
return
an
api
pending
exception,
but
you
know
you
know
not
using
it
for
that
purpose,
but
introducing
it
would
be
okay,
I
suppose,
and
then
because
this
is
a
new
scenario
in
which
we
would
use
such
a
status
code.
Never
before
seen
so
we
wouldn't
be
breaking
anything.
We
would
be
adding
a
new
feature
and
adding
the
status
code
would
be
a
good
place
to
this
would
be
a
good
place
to
start
adding
the
status
quo.
I
guess
so
yeah,
that's
not
not
a
bad
idea.
Actually.
H
Well,
I
mean
that's
that
that
is
a
maintenance
burden
right,
because
you
know
we
you
have
to
you
know
you
have
to
know
all
the
methods,
all
the
public
apis
that
we
have,
that
should
return
it
and
then
have
them
return
it
if
they
get
called.
A
H
Well,
I
mean
yes,
I
guess
yeah
I
mean
yeah,
it's
a
it's.
A
short
circuit,
like
you
know.
If,
if
and
currently
inside
finalizer,
then
return
an
api
set
last
error
or
you
know
new
status
code-
yeah,
that's
true,
I
mean
it
would
it
would
make
the
call
into
like
set
property
and
stuff
a
little
bit
fatter.
H
Yeah,
I
don't
know,
maybe
maybe
then
maybe
then
the
solution
is
to
just
have
one
that
doesn't
take
an
environment
and
and
see
see
how
much
you
see
how
useful
that
is.
Maybe
maybe
do
an
assessment
ahead
of
time.
H
I
don't
know
do
like,
like
a
poll
to
see
how
many
folks
could
use
that
if
it
meant
you
know
not
having
this
this
accumulation
of
of
memory
in
a
tight
loop,
because
you
know
we,
you
know
vladimir
said
that
it's
the
majority
of
cases
but
based
on
what
data
right
so
do
we
know
for
a
fact
that
most
people
don't
call
into
into
don't
call
an
api
stuff
when,
when
in
from
their
finalizers,
you
know
it'd
be
good
to
have
some
data
on
that.
C
And
I
think,
like
the
fact
that
you're
not
passing
node
api,
which
is
creating
additional
complexity,
but
if
people
want
to
pass
it
for,
for
whatever
reason
like
they
can
do
it
for
finalizer
hints
for
some
other
means,
so
they
will
basically
will
be
able
to
achieve
the
exactly
the
same
situation
that
they
can
shoot
themselves
in
the
food.
So
thank
you
right.
If
we
still
need
to
implement
these
checks
in
all
our
functions,
to
make
sure.
H
Well,
no
yeah,
I
mean
ideally
we
would,
but,
but
given
the
performance
impact,
we
might
just
say,
listen
if
you
want
to
shoot
yourself
in
the
foot,
here's
the
gun.
You
know
but
be
aware
that
this
is
a
shot
in
the
foot
and
not
something
else.
I
mean.
A
Right
you're
right
right,
so
I
think
one
that
doesn't
have
it
seems
like
a
reasonable
like
if
that
doesn't
work
in
the
case
that
you
already
have
vladimir,
then
that's
the
signal
that
well
wait
a
second.
We
have
to
do
something
more
complicated
if
it
does
solve
this
case,
then,
maybe,
like
you,
said,
there's
a
workaround.
If
there's
like
you
know
some
really
edge
cases,
but
if
you're
going
to
use
it
in
those
cases,
you
better
know
what
you're
doing
right
and
we
can't
protect
everybody
from
every
case.
Yeah.
H
Yeah,
we
need
to
document
that
that,
and
you
know
I
mean
this-
is
this:
is
gonna,
be
new
documentation
right,
so
we
can
start
it
out
by
saying
that
you
know
we
can
start
right
off
the
bat
saying
that
this
this
is.
H
You
know
we
we
point
out
that
the
reason
that
the
environment
isn't
passed
in
is
because
these
no
no
node
apis
are
supposed
to
get
called
from
these
finalizers.
H
H
Because
we
are,
we
already
do
that
for
for
environment
shutdown
like
you
can
you
can
get
or
no,
not
environment
shutdown.
Where
is
it
in
threat?
Safe
function,
there
yeah
in
threat
say
function.
H
There
is
an
instance
where
you
receive
where
the
the
napi
n
parameter
is
null,
and
and
so
you
you
need
to
deal
with
that,
and
and
it's
documented
that
the
an
api
parameter
may
be
null,
and
I
think
it's
in
the
case
where
the
environment
is
shutting
down,
so
you
can't
make
any
more
javascript
calls
and
I
think
what
what
that
would
buy
us
is
that
if,
in
the
future
we
decide
to
take
on
this
maintenance
burden-
and
maybe
we
do
in
the
future-
we
we
don't
consider
it
to
be
such
a
big
performance
impact,
because
I
don't
know
the
compiler
optimizes
things
out
or
whatever.
H
Then
we
can,
we
can
remove
the
we
can
remove
the
the
the
restriction
that
an
api
end
is
always
know.
We
can
say
okay,
henceforth,
it
is
no
longer
always
null
and
you
can
start
adding.
You
know
conditions
there
saying.
C
Yeah
I
I
like
this
approach
better
because
yeah
it
gives
us
some
ability
to
grow.
H
C
C
Ways
to
do
it
today,
right,
like
one
of
them,
is
then
we're
creating,
I
think
object
crop
we
have.
We
have
explicit
an
api,
add
finalizer,
add
underscore
yeah,
it's
it's
something
we
can
add
to
any.
C
C
C
So
my
proposal
would
be,
then
we
introduced
new
functions
which
creating
finalizers,
but
rather
than
calling
it
pure
something
what
we
can
do.
We
can
just
simply
have
a
new
signature
which
receives
additional
parameter,
which
will
be
some
flags,
and
if
people
pass
a
special
pure
a
flag,
then
then
fertilizer
becomes
pure.
Otherwise
it
will
be
just
exactly
the
same
as
the
previous
version
of
this
function,
like
in
the
pro.
C
H
Why
not
simply
why
not
simply
add
the
new
method,
and
then
you
can
call
an
api
wrap
with
the
null
finalizer,
I
mean
you,
you
can
still
today
call
it
right
or
maybe
not.
I
don't
know
if
the
fight,
if
is
the
finalizer
required
for
an
api
rap.
A
H
Okay
but
then,
but
then
you
can
only
add
like
after
the
fact
like.
If
we
don't
provide
the
same
kind
of
alternative
api
to
an
api,
add
finalizer,
then
then
you
know
wrap.
Will
now
have
this
ability
to
offer
you
the
the
possibility
of
adding
a
a
pure
finalizer,
but
an
api
add
finalizer
will
not
have
the
pure
finalizer
equivalent.
C
That
works
the
same
for
external,
create
external.
I
can
see
it's
also
it's.
It
also
has
finalized
so
pretty
much
the
proposal.
Actually,
let's,
let's
add
this
additional
flag
to
all
our
functions
which
receiving
this
analyzer
callback.
B
A
H
C
Right,
like
yeah.
C
If
it's
not
pure,
we
will
do
it
as
it
is
today,
instead
of
set
immediate
yeah.
Okay,
thank
you
speaking.
We
can
kill
a
second
pass
all
together.
If
you
like,.
H
D
H
C
C
There's
no
rush,
so
in
this
context
let
me
ask
a
question
about
naming
preferences
how
we
would
name
with
new
functions.
C
H
Yeah
yeah.
Definitely
that's.
That's.
That's
definitely
the
way
to
go
so
so
the
prefix
is
node
underscore
api,
not
an
api
anymore.
That
much
is
certain.
As
for
the
rap.
As
for
the
rest,
I
don't
know
a
node
api
wrap
with
flags.
A
C
H
H
H
Yeah
and
node
api
add
finalizer
and
what's
the
other
one
node
api
create
external
yeah.
A
A
H
H
A
Because
we
yeah
we're
almost
at
time,
but
let's
go
back
to
if
I
can
get
my
mouse
cursor.
What
was.
C
The
other
one,
it's
something
that
I
submitted
probably
last
night,
is
about.
I'm
proposing
this
new
ref
counted
type,
an
api,
persistent,
okay.
I
need
to
rename
it
which
we
just
discussed.
Yes,
this
one.
I
I
need
to
rename
it
with
node.score
api,
but
yeah
so
yeah
the
idea
that,
instead
of
using
an
api
rf,
let's
let's
have
new
type,
which
will
be
just
like
normal
pure,
I
have
counted
and
it
cannot
be
applied
to
all
napi
values.
H
C
Yes,
and
here
as
soon
as
we
go
to
zero,
we
we
deleting
it
it's.
It
behaves
like
normal
rough
conjugate
object
and
also
because
it
does
not
support
weak
reference
semantic
we
can.
We
can
have
any
value
of
any
type.
So
pretty
much
like
we
have
an
api
value,
an
api.
Well,
you
can
can
become
persistent,
you
can.
You
can
keep
it
inside
of
your
classes
as
a
as
a
field
and
would
not
it
doesn't
matter
what
value
type
you
have
so
it
can
be.
C
If
you
look,
for
example,
test.js
sorry
like
yeah,
this
is
what
tess
does
like
you
see,
I'm
creating
values
of
different
types,
right,
yeah,
undefined
now
boolean,
what
not
I'm
putting
them
in
array
and
then
I'm
trading
through
this
array-
and
this
is
what
I
do
I
creating
a
permanent
for
all
these
different
different
value
types.
C
Then
I'm
able
to
read
a
value
out
of
this
pyramid
stuff
and
also
kind
of
doing
this
ad
reference
and
ref,
right
and
and
ref
also
has
this
optional,
boolean
parameter,
which
can
tell
us
if
object
is
deleted
or
not.
C
I
don't
like
the
fact
that
we
return
current
ref
count
because
in
multi-threaded
environment,
usually,
if
people
know
exactly
ref
count,
they
may
you
can
use
it
wrong
way
and
it
may
cause
some
a
lot
of
unexpected
errors.
But
maybe
people
just
want
to
know
if
this
was
final
ref
count
and
do
something
additional
stuff,
so
it
can
be
useful,
maybe
return
just
boolean,
but
otherwise,
like
we're
not
telling.
I
have
a.
H
Question
about
this,
you
know
if,
if
if
the
benefit
here
is
that
it
supports
any
data
type,
then
why?
Why
is
this
useful
in
in
native
code,
I
mean,
if
you
want
to
store
an
integer
in
a
in
a
native
class,
then
why
don't
you
just
store
an
integer
in
a
native
class?
Why
do
you
have
to
store
it
as
a
javascript
value.
C
So
imagine
like
you,
you
do
have
javascript
objects
which
come
from
for
your
api.
You
just
want
to
keep
it
like.
Essentially,
it's
kind
of
kind
of
like
a
variant.
An
api
value
is
a
variant
also.
H
H
C
C
It's
just
kind
of
fun
so
anyway,
like
it's
nothing,
but
I
want
I
own
the
propose
and
kind
of
if
you,
if
you,
if
you
have
time
to
review
it,
think
about
it.
I
would
appreciate
it
just
just
based.
A
A
C
I
I
would
love
to
see
it
like.
Yes,
if
we,
if
we
can,
if,
if
we
apply
the
same
approach,
we
create
this
node
api
prefix
for
some
existing
apis
which,
using
and
api
references
and
add
additional
flags
that
are
saying
like
this
npi
reference
now
like
it
can
be
of
any
type.
C
It
does
not
support
the
weak
semantics,
so
it
means
like
it
automatically
can
be
any
type,
because
we,
we
can
just
simply
say
weak
semantic
requires
it
type
to
be
object,
like
I
mean
object
like
it's
like
can
be
function,
can
be
object.
It
can
be
whatever
right,
whatever
being
supported
by
vxemanity
but
say
number
or
boolean.
A
A
H
A
second
you
don't
even
need
a
flag.
If
it's,
if
it's
going
to
be
a
new
api,
then
you
know
if
the
type
of
the
napi
value
that
you
wish
to
persist
is
object.
H
Well,
okay,
fine,
no,
no
yeah!
Okay!
You
do
need
a
flag
because
you
don't
want
to
fall
back
to
creating
a
regular
reference.
If
it
is
an
object,
you
sometimes
want
a
persistent
reference,
or
rather
a
reference
without
weak
semantics,
even
for
an
object
right,
because
I
was
thinking
you
could
detect
the
type
right
from
from
the
object
and
then
you
use
old
style
references
for
objects
and
then
new
style
references
for
for
integers,
but
no,
no,
even
with
a
new
api,
you
still
need
the
flag
right.
C
A
D
D
We
want
to
explicitly
say
no
weak
semantics
yeah.
I.
A
Know,
but
I
guess
I
was
like
could
in
c
plus
plus,
I
think
we
could
have
that
automatically
filled
in
without
actually
having
to
even
create
a
new
api,
like
I
guess,
right
anyway,
we're
in
c,
so
it
doesn't
matter
yeah,
yeah
yeah.
We
need
a
new
api,
specifically
that
has
the
the
that
particular
extra
option,
and
we
can
do
this.
We
do
the
same
deprecation
of
the
version
that
doesn't
have
it
right.
Yep.
H
C
In
some
cases,
remember
like
we
just
discussed
this
analyzer
behavior,
so
I
think
that
some
of
these
functions
also
will
also
will
have
like
another
flag.
Pretty
much
is
the
same
same
same
parameter,
which
will
control
this
npif
behavior.
H
So
so
wait
a
second.
Why
don't
we
can't
we
flip
this
around?
Like
can't,
we
say
that
we
relax
the
acceptance
criteria
for
an
api
ref
or
like
for
network
for
create
reference.
We
we
relax
the
criteria
saying
it
is
able
to
accept
any
value
now,
not
just
object
and
symbol.
H
I
think
we
extended
that
to
symbol,
but
if
you
do
pass
in
this
ref,
if
you
do
pass
in
a
primitive
value,
then
you
get
you
don't
get
the
weak
semantics
right,
and
so
we
get
we
get
everything
we
want,
except
for
the
explicit
non-weak
semantics
for
objects
using
existing
apis,
no
need
to
change
the
surface
at
all,
and
then
the
new
api
covers
only
the
situation
where,
yes,
I
want
a
reference
to
an
object,
but
I
don't
want
the
weak
semantics,
and
so
the
newer
api
has
a
smaller
scope
and-
and
we
use
the
existing
a,
we
widen
the
scope
of
the
existing
api
because
you
only
need
the
flag.
H
You
only
need
the
flag
if
you
want
to
avoid
the
weak
semantics
right
and
you
semantics
are
only
relevant
to
objects
and
object-like
things
right.
So
so
why?
So?
Why
don't
we
just
use
the
existing
api
to
cover
everything
that
we
can
right,
including
primitives
and
and
use
the
new
api
only
for
those
instances
where
you
want
a
persistent
reference
to
an
object,
but
you
don't
want
weak
semantics.
A
A
H
H
Today,
today
it
is
today,
if
you
pass
a
primitive
to
create
reference,
you
get
you
get
an
error
right,
so
nobody
is
passing
primitives
to
get
reference
because
they've
been
getting
errors
all
this
time.
A
H
Well,
for
what
it's
worth,
I
I,
if
I
remember
correctly,
with
threat
sake,
function
we
made
a.
We
made
a
change
like
this
in
behavior.
That
was
not
explicitly
marked
by
an
outside
api
change,
which
I
which,
if
I
remember
we
made
something
optional.
H
That
was
not
optional
before
I
forget
what
it
was,
but
we
made
it
optional
and
it
didn't
break
anyone
because
everyone
was
required
to
provide
it,
and
so
they
provided
it
because
otherwise
they
well
the
code
wouldn't
run,
and
so
now
that
we
made
it
optional,
people
started
changing
code
such
that.
Sometimes
they
didn't
provide
it
and
now
there's
no
going
back,
but
that's
okay,
we're
not
planning
on
going
back.
But
if.
A
D
A
H
D
A
Okay,
anything
else
on
this
one.
A
Okay,
we
are
12
minutes,
so
I
think
I'll
I'll
say
we
should
close
out
unless
there's
something
we
should
talk
about.
H
G
Time
you
said
that
there
was
that
that
hanging
test
for
thread
safe
functions,
and
it
appears
that
that
one
has
also
hung
in
the
formatting
pr
that
I
had.
Okay,
didn't
you
say
before
it
was
only
for
deviant
debian
that
was
causing
the
group
no.