►
From YouTube: 2022-07-29-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
api
team
meeting
for
july
29
2022
we'll
follow
the
the
approach
of
looking
at
the
issues.
We
have
tagged
for
milestone
11.
before
we
get
started.
Does
anybody
have
any
announcements
they'd
like
to
share.
A
If
not,
okay,
let's
launch
into
what
we've
got.
A
Okay,
so
here's
our
list
first
one
drive
towards
full
coverage.
I
don't
know
if
anybody
has
any
updates
or
things
we
should
discuss
on
that
front
today.
B
Yeah,
I'm
just
like
going
through
that,
like
the
list
of
issues
I
made
and
probably
like
some
of
them
already
covered,
so
I'm
just
slowly
kind
of
checking
them.
A
A
B
A
B
C
So
should
we
kind
of,
I
think,
like
in
other
parts
of
our
node
api
node
api,
we
use
different
macros
to
enable
some
features
and
stuff
right.
Should
this
also
be
considered
as
a
new
feature
and
to
be
under
such
define
or
something.
C
So
yeah,
I'm
just
curious,
also
look
on
this
change
yeah.
I
think
he
is
removing
some
constants
for
some
methods.
I
think
we
discussed
many
times
before
with
con
stuff
and
now.
B
C
B
C
I've
seen
such
similar
warnings
in
some
cases
like,
for
example,
you
have
some
untyped,
sorry
unsigned
integer
and
we're
trying
to
convert
minus
one
and
many
compilers,
giving
a
warning
because
that's
yeah.
It
thinks
that
you
have
some
signed
integer
and
it
will
convert
to
some
consigned.
But.
B
C
There
is
a
better
way
to
kind
of
to
do
this
conversion
without
causing
this
warning.
B
B
B
C
Should
we
just
instead,
if
you
introduce
a
new
type,
I
just
use
one
of
this
like
unsigned
integer,
8
or
just
int
8
array.
A
B
B
B
C
I
guess
maybe
with
what
pr
does
like
what,
if
we,
if
we're
facing
some
kind
of
a
unknown
type.
So
should
we
just
simply
throw
exception
like
a
compile
time
error,
because,
especially
if
we
do
with
constant
expression,
stuff.
B
Is
it
avoid
options
in
terms
of
standard
javascript
standard?
So
this
is
a
my
doubts
right.
B
Fulfill
or
the
the
the
javascript
standard
that
must
standard,
and
then
we
use
the
the
unknown
type
in
the
wrap
here.
C
I
would
prefer
to
kind
of
look
at
this
a
little
bit
deeper,
but
I
I
agree.
I
agree
that
it
sounds
like
we
should
avoid
using
this
unknown
type
all
together.
C
D
C
A
C
This
and
this
pr
addresses
differently
still
keeps
the
concept
of
unknown
type,
but
rather
kind
of
making
it
part
of
this
enum,
the
introducing
kind
of
boolean
variable,
and
now,
like
this
concept
of
unknown
type,
propagate
all
over
the
place,
I
think
in
reality
we
should
just
kill
it
all
together
and
not.
A
C
Yeah,
this
constant
expression
function,
which
responsible
for
determining
this
type.
We
should
just
see
instead
of
returning
this
random
unknown
minus
one
value
kind
of
screwing
up
the
rest
of
your
code,
some
somewhere
down
down
the
road.
Maybe
you
can
just
simply
pro
right
away
that
we
don't
know
what
is
this
function
just
fails.
C
So
what
do
you
guys
think
like?
I
will
propose
to
to
fail
immediately
if
we
don't
know
what
the
type
is.
B
You
have
to
to
to
choice
or
fail
immediately
or
try
to.
B
In
this
case,
I
think
that
er.
A
So
it
sounds
like
still
still
going
trending
towards
the
it's
just
like
we
shouldn't
have
the
concept
of
unknown
type
fail
earlier
or.
C
Well,
like
just
nicolas
says,
like
return
like
in
eight
or
something
by
default,
which
is
like
what.
B
C
B
C
We
have
very
first
constructor,
like
you
see
it's
we.
C
Sorry,
which
line,
if
you
look
on
this
line
up
to
2008.
B
C
B
C
And
if,
in
this
c,
plus
plus
api,
we
want
to
assume
some
some
defaults,
a
reasonable
default
will
be
single
byte,
single
byte
array,
I'm
just
not
sure
which
one
the
correct
choice
here,
and
science
or
science.
A
B
A
C
A
C
A
It
seemed:
why
is
my
search
not
working
in
the
wrong
file.
B
We
create
an
empty
buffer,
essentially.
A
Yeah,
I
think
it's
like
it
lets
you
create
the
wrapper
without
knowing
the
type
of
what
you're
wrapping
necessarily
and
then
so.
This
says:
okay,
I'm
going
to
create
it
like
this,
this
typed
array,
I
give
it
the
m.
If
I
give
it
the
not
b
value,
but
I
don't
tell
it
what
the
type
is,
and
so
it's
unknown
until
like
in
here,
it's
actually
saying.
Well,
I
don't
know
the
wrapper
doesn't
know
what
it
is.
So
when
I
do
this
typed
array
type,
if
it's
unknown,
I
actually
go
to,
I
make
the
c
call.
C
A
A
C
So,
but
I
would
say
assume
in
this
case
we
have
some
kind
of
wrapper
right
like
we
need
to
wrap
up
this
type
and
I'm
not
sure
what
in
context
of
default
contract
does
not
make
sense.
But
the
second
constructor
we're
saying,
is
an
api
value
right,
but
nobody
stops
us
at
this
point.
Just
simply
ask
just
call
this
c
function
and
find
out.
What's
this.
A
C
So
unknown
was
really
kind
of
for
just
the
artifact
of
our
c
plus
plus
rapper,
for
the
cases,
and
we
don't
know
right.
C
A
Where
it's
not
passed
in,
we
do
the
look
up
immediately.
Maybe
that's
the
right
and
the
better
answer.
C
It's
one
solution
and
it
sounds
like
what
pr
submitted
pr
did.
They
introduce
additional
boolean
variable
for.
A
C
C
B
C
A
C
A
However,
like
I
don't
think
I
don't
think
from
what
we've
looked
like
looked
at,
there's
any
reason
to
believe
that
we'll
ever
get
an
unknown
type
like
if
we
call
back
on
the
nappy
value.
If
it's
an
actual
nappy
value,
we
will
get
something
which
is
one
of
those
types
I'm
just
like,
and
no
existing
code
should
be
working
properly
or
working
at
all
and
be
affected
by
that
change
is
where
I'm
going,
even
though
technically
it
would
be
potentially
like.
C
Can
we
can
we
just
write
something
on
this
decision
and
kind
of
get
back
to
it
and.
C
C
C
A
Example,
but
but
if
there's
no
m
like
if
there's
no
actual
object
on
the
back
end
like
on
in
no
tape
in
the
c
side,
for
it
like
just
setting
it
to
some
value,
doesn't
help,
I
guess
unless
maybe
in
maybe
later
on
in
the
new,
it
will
create
one
of
that
type.
Maybe
okay.
B
A
B
B
A
I'm
just
going
to
quickly
look
like
that.
That
was
the
newest
one.
Maybe
I'd
suggest,
like
you
know,
as
limitless
suggesting
unless
somebody
thinks
otherwise,
why
don't
we
just
flip
over
to
the
document
and
spend
the
rest
of
the
time
on
that.
B
D
D
D
So
this
document
describes
a
solutions
for
it
and
about
the
possible
short-term
cleanups
and
how
to
tackle
it
with
a
more
cleaner
solution
and-
and
I
have
a
described
the
problems
about
when
we
are
children,
if
it's
possible
to
like
promote
the
it's
the
problem
about
if
a
finalizer
could
call
into
javascript-
and
I
believe
vladimir
is
working
with
a
but
vladimir-
is
working
on
solution
with,
and
I'm
just
describing
the
problem
here
and
trying
to
find
if
we
can
coordinate
vladimir's
work
into
knowledge
score
and
to
see
if
there
is
another
solution
to
it.
D
So
users
don't
have
to
change
their
code
if
they're
to
explore
if
there
is
any
possibility
with
if
there
is
any
possibility
around
on
the
on
the
solution.
So
that's
that's
the
other
part
and
I
have
a
part
of
for
the
testing
function.
As
you
can
see,
the
classic
function
have
analyzed,
but
the
information
implementation
of
the
function
is
not
in
not
the
same.
D
D
Yet
I
will
continue
to
explore
if
we
have
a
non-breaking
solution
for
this
problem
and
if
it
and
if
the
solution
is
cannot
be
done
in
a
non-frequently
and
I
I
will
describe
how
we
can
do
it
in
a
with
a
new
api
chips
and
the
environment
shadow
is
oh,
it's
meaning
about,
and
the
problem
like
say
when
the
environment
is
tracking
down
the
callbacks
and
the
api
callbacks
cannot
according
to
javascript,
and
there
is
a
ongoing
discussion
on
it
and
on
how
we
handle
this
and
whether
or
not
we
can
make
the
environment
shut
down
earlier,
so
that
we
can
allow
the
add-ons
to
according
to
javascript
in
their
callbacks
and
also
there
is
a
selection
describing
referencing,
primitive
values,
and
I
have
digging
to
the.
D
There
are
engines
like
javascript
implementation
on
the
api,
and
I
blew
right
may
also
have
a
work
on
around
this.
So
and
maybe
very
new
feedback
on
this
section
will
be
very
helpful.
So
we
can
see
if
we
can
learn.
Vladimir's
coordinate
values,
work
into
the
core,
and
the
notable
thing
is
that
in
the
information
implementation
of
javascript
of
node
api,
we
don't
have
weak
reference
around
even
with
the
javascript
object.
D
D
I
believe
vladimir's
feedback
on
this
section
will
be
very
helpful
and
there
is
a
opening
issue
on
the
issue
like
say:
a
object
with
a
tight
loop
object
is
not
garbage
collected
with
no
node
references.
I
need
to
continue
to
investigate
on
this
problem
and
find
out
what
what
we
can
do
for
this
with
a
better.
D
D
D
Yes
and
I
I
would
like
to
say
that
anna's
request
on
the
complex
scope
is
that
she
wants
the
finalizers
to
be
able
to
facilitate
the
async
hooks
mechanism.
That's
the
problem
that
we
and
the
problem
is
that
if
we
don't
allow
the
finalizer
to
be
to
call
into
the
javascript
land,
we
don't
have
to
create
a
quebec
quebec
scope
for
the
analyzers.
Since
right
when
the
finalizers
are
run,
we
have
already
lost
the
reference
to
the
let's
say
asking
resource,
so
we
cannot.
D
A
D
C
I
guess
my
question
is
so
document
says
like
we
we're
not
going
we're
not
doing
exactly
the
same
as
the
rest
of
node.js.
I
just
trying
to
understand
for
myself.
What's
node.js
kind
of
what
this
requirement
are
like
what
what
current
and
node.js
standard
approach
to
finalizers
supposed
to
be.
D
I
don't
believe
we
have
a
written
document
for
this,
but
no
in
no
decor
we
don't
allow
calling,
since
they
are
primarily
using
the
weak,
weak
callbacks.
So
they
are
not
calling
into
javascript
and
they
are
not
using
the
second
pass
callback.
Then
so
they
don't
have
the
problem
around.
D
A
C
A
The
other
one
is
like
the
original
id.
If
it's
gone,
there's
nothing
really
that
can
be
tracing
usefully
like
are
we
breaking
context
and
the
answer
is,
I
don't
think,
there's
any
useful
way,
we're
breaking
context.
So
maybe
like
a
dummy
id
or
something
might
let
us
share
the
code
without
actually
breaking
anything
or.
D
And
towards
them
to
my
understanding
that
the
id
is
used
in,
I
think
hooks
api,
but
the
more
significant
part
is
the
javascript
object
relevant
to
the
idea,
as
the
javascript
object
in
is
being
used
as
the
storage
for
the
ac
clock,
storage.
So
yeah
local
storage
is
a
stable
api,
so
I
believe
that's
the
most
most
significant
part.
We
should
consider,
rather
than
the
asynchronous
callbacks.
B
A
D
A
Just
you
know
like
I,
I
have
to
think
about
it
more
but,
like
my,
my
gut
feeling
is
like
stuff
that
that's
happening
in
finalization
is,
after
you've,
already
gotten
rid
of
everything
else
like
you're,
basically
just
cleaning
up,
so
that
context
may
not
like.
It
may
not
be
useful
to
try
and
tie
it
back
to
the
original
context,
or
it
may
not
make
sense
or
something
I
I
could
be
totally
wrong.
But
that's
kind
of
my
initial
thought.
A
Okay,
well,
I
do
see
we're
we're
like
five
minutes
after,
but
I
think
this
is
a
great
dock
and
let's
make
sure
to
to
sort
of
sink
on
into
each
week
as
well,
to
see
where
people
have
looked
and
and
how
we
can
progress
the
different
things,
any
other
things
we
should.
We
should
touch
on
before
we
close
out
for
this
week.