►
From YouTube: 2022-05-06-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
noted
api
team
meeting
for
may
6
2020
22
we'll
follow
our
standard
approach
of
looking
at
issues
that
were
tagged
for
milestone
11.
before
we
get
started.
Does
anybody
have
any
announcements
that
they'd
like
to
share.
B
No
okay,
I
I
have
one:
we
released
the
version
five
for
not
the
done
api.
Then
we
dropped
the
support
for
node
12.
We
added
some
new
new
things
and
fix
on
documentation.
So
yeah,
let's
see
and
that's
it.
A
Great
yeah,
no,
and
thanks
for
doing
that
that
release
well,
it's
good
to
see
that
get
that
out
any
other
announcements
before
we
get
started.
A
Hide
that
okay
right
so
first
of
all,
we
have
stale
issues
noted
on
stale
issues.
So
let
me
just
open
that
up
we'll
go
down
to
the
bottom.
A
So
this
one,
I
guess,
was
mark
stale,
so
they
added
it
in.
Let's
see
this
is
a
duplicate
of
669.
So
what
was.
C
A
C
C
A
C
E
A
At
the
drive
towards
full
coverage,
I
don't
know
jack
if
there's
anything
that
you
have
to
mention
on
that
front.
A
Sounds
good
okay
and
then
there
are
just
as
a
note
for
anybody
who
might
be
watching.
There's
lots
of
sort
of
good
first
issue
issues
tagged
there
if
anybody
wants
a
sort
of
place
or
figure
out
how
to
get
how
to
get
started.
Helping
out
on
the
add-on
note
on
note,
add-on
api
side
of
things
in
terms
of
enabling
debug
testing
still
haven't
done
that
so
then
we're
back
to
looking
at
the
issues
raised
by
emit
module
owners
or
somewhat.
So.
C
D
A
Basically,
you
know
the
comment
was
that,
like
they
created
an
object
through
an
api
or
node
api
and
the
things
like
the
spreader
operator
didn't
work
nope,
and
I
think
you
know
having
looked
at
it.
What
I
think
I
figured
out
is
that
you
know
when
we
have
this
instance
accessor,
which
we've
created.
A
So
you
know
some
of
the
examples
we
have
show
creating
like
defining
a
class
and
using
that
to
then
create
the
constructor
for
object
wraps,
and
what
that
does,
though,
is
that
creates
properties
and
accessors
on
the
prototype
and
things
like
keys
and
object,
spread
only
work
on
own
properties,
not
things
you
inherit
from
the
prototype
and
that's
why
those
properties
weren't
showing
up
in
like
the
spread
or
if
you
did
keys
and
stuff
like
that,
we
we
can
actually
add
if
we
define
properties
instead
using
you
know
a
defined
properties
call
in
the
constructor,
for
you
know,
we
get
a,
we
get
a
callback
when
an
object
and
a
wrapped
object
is
created.
G
So
what
does
javascript
do
right
like
in
javascript,
if
you
create
the
class
and
the
classes
properties,
those
are
not
spreadable
either
right.
A
I
I
think
that
would
be
the
the
case.
I'd
have
to
look
back
at
their
sample
code.
They
had
they
had
some
sample
code
which
says
hey.
I
do
this
with
a
normal
object,
but
you
can
see
this
is.
This
is
know
that
on
node
add
on
api
code,
but
I
I
have
to
go
back
actually.
I
can
go
look
at
it
right
here.
So
here's
the
nap
implementation.
E
E
A
A
Right
like
in
here,
they're
just
creating
an
object
and
adding
some
properties
as
opposed
to
creating
a
constructor
and
constructing
it
from
those
properties.
So
I
think
the
answer
to
your
question,
gabriel
is
yeah.
Javascript
will
do
the
same
thing.
We're
doing
it
just
may
not
be
obvious
that
that's
what
people
should
expect.
G
A
Yeah,
like
I
can
kind
of
see,
though,
that,
like
you
know
because
they're
not
creating
like,
if
you
just
follow
our
instructions
and
our
doc,
you
know
you're,
basically
creating
a
wrapper
object,
and
you
do
you
say
new
on
the
wrapper
object
right,
yeah,
and
so
it
might
not.
I
like
that's
where
yeah,
I
think,
I'm
kind
of
I
agree
that
there's
probably
nothing
we
should
do,
but
in
the
documentation
we
might
want
to
explain
it
a
bit
better
because
it's
probably
not
as
obvious
as
it
could
be,
that
it's
like.
A
A
Exactly
like
sort
of
you
know
the
instance
accessor
name
even
kind
of
makes
me
think
like.
Oh,
this
is
how
I
set
up
accesses
to
instances
like
properties
on
my
instance
versus
on
the
you
know,
true,
so
so
yeah,
I
thought
you
know,
I
think
you're,
probably
confirming
what
I
was
thinking
is
like
code
wise.
A
Right
all
right:
okay,
that's
all!
If
anybody
else
has
any
other
comments
or
suggestions
in
terms
of
what
we
should
do
going
forward.
You
can
comment
in
on
that
issue,
but
I
thought
that
was
interesting.
Having
looked
at
it
because
it
was
like,
it
wasn't
necessarily
immediately
obvious
to
me
either
I'm
just
like
yeah.
Why
are
we
getting
spread
properties
like
okay?
It's
it's
because
of
the
the
prototype
versus
non-prototype
thing.
A
B
This
one
okay,
yup
yeah,
you
you,
you
reacted
and
yeah,
but
essentially
we
have
these
function
under
experimental
flag
and
if
we
want
to
promote.
B
We
can
I
I,
I
think
that
node
api
creates
syntax
or
intro
syntax
error.
I
think
that
could
be
could
be
stable.
Now.
B
B
Okay,
create
syntax
error,
was
added
in.
C
E
Okay,
well,
it
was
over
two
months
ago,
but
it's
it's
a
reformat
code.
A
E
A
A
B
E
E
B
A
policy,
oh
that
we
need
to
to
follow.
No
in
terms
of
time,
no.
B
But
yeah,
I'm
I'm
okay!
If
you
want
to
to
wait
because
maybe
we
need
to
to
to
change,
you
know
something.
A
A
A
A
That's
just
another
thing:
you
know
that
we
might
want
to
do,
but
I'm
not
I'm
not
saying
in
this
case,
like
I
guess
it's
like.
Do
we
have
a
bunch
of
do.
We
have
other
experimental
things
that
if
we
waited
a
little
bit
longer,
we
might
want
to
promote
soon
and
to
do
them
all
together
would
be
the
only
other
would
be
the
other
thing.
That
kind
of
I
would
think
about.
B
Yeah,
so
when
you
are
saying
that
we
need
to
wait,
for
example,
the
19
rarities
for
to
to
to
reason
the
dpi
version.
Is
it
driving.
A
No,
no,
like
I'm
just
saying
we
can,
that
might
be.
We
might
think
about
that
like
is
there
any
reason
to
wait
till
closer
to
a
major
release
like
in
this
case?
I
I'm
not,
I'm
not
thinking
that.
Necessarily
I'm
just
mentioning
that
as
like
things
that
might
we
might
think
about
doing
or
if
there
were.
A
B
I
I
think
that
we
we
can,
that
that
everyone
can
can
think
to
to
this,
and
maybe
we
can
decide
next
week,
yeah,
it's
not
so
yeah
yeah.
A
B
E
C
C
A
E
A
A
A
A
Yep,
no,
that's
always
good
you're,
seeing.
A
D
Yeah,
no,
it's
still
there
like
get
all
property
names.
It's
a
little
bit
below.
E
A
D
A
A
D
I
have
right
not
not
related
but
kind
of
generic
question
if
yep
anything
else.
So
my
question
like
I
was
looking
for
some
different
documentation
and
I
wonder
what
what's
the
general
ideas
about
node.js
to
be
distributed
as
dll
and
have
an
api
safe
api
for
the
node.js
dll?
D
Like
to
have
node.js,
be
embedded,
no.js,
dojo,
being
embedded
inside
of
three
native
applications
right.
A
Right
so
there
there's
been
long-standing
discussion
of
that.
I
I
personally
think
that
would
be
a
benefit
to
node,
getting
it
to
the
point
where
we
like
ship.
Another
binary.
That's
that's
a
that's.
The
potential
challenging
part
in
that
like
it,
takes
us
overhead
in
time
to
ship
and
keep
every
binary
like
so
there's
been
many
suggestions
like
I
would
personally
like
us
to
have
like
a
development
binary
and
a
runtime
barnary
kind
of
like
you
know,
java
has
because
then
you
can
have
like
a
smaller
one.
A
That
is
the
smallest
that
you
need
just
to
run
things,
and
then
you
can
have
a
bigger
one
that
can
have
more
tools,
but
every
time
we
get
into
those
discussions,
it's
like
a
whole
nother
set
of
things
to
sort
of
package
and
ship,
or
it's
painful.
So
there's
that
there's
a
challenge
on
that
front.
There
is
already
work
to
like
you,
there's
options
to
build
known
as
a
shared
library
and
actually
there's
a
pr.
A
I've
been
doing
some
work
with
to
try
and
help
get
landed,
because
one
of
the
teams
at
ibm
actually
ships
it
that
way
as
part
of
one
of
their
products
across
a
number
of
platforms.
D
H
D
A
A
I
I
think
you
know
we
need
a
broader
discussion
in
the
project
because
there's
you
know,
there's
different
people
who
are
doing
embedding
today
different
ways,
and
but
if
we
had
a
champion
to
to
sort
of
push
that
forward
and
lead
the
discussion,
it's
something
I
would
definitely
support,
because
I
think
it's
it.
It
would
be
good
to
have
that.
A
What
I
can't
say
to
you
is
whether
we'll
have
you
know:
there'll
be
people
who
say
no,
it's
too
early,
still
or
or
whether
it'll
be
the
point
where
people
are
like
yeah.
Okay,
we
should
actually
start
to.
You
know,
standardize
the
api
at
this
point.
A
D
Okay,
let
me
explore
it
a
little
bit
so
you
you
already
said
there
are
some
pr's
and
works
I
want
to.
I
want
to
do
some
kind
of
more
research
about
existing
state
of
art
and
understand
a
little
bit
deeper
before
yeah.
D
But
I
believe
it
will
be
greatly
beneficial
like
so,
for
example,
for
electron
projects
or
like
what
we're
doing
with
native
that's.
A
Yeah
I
like
the
yeah
so
and
that's
where,
like
they
have
been
involved
in
in
in
in
some
of
the
discussions,
but
like
not
actively
pushing
it
enough
to
say
hey,
we
absolutely
need
it
to
be
standardized
or
whatever,
but
yeah.
I
I
think
like
they
should
also
be
interested
in
that.
To
be
honest,.
H
A
So
that's
the
pr2
to
kind
of
fix
it,
and
then
this
pr
based
on
that,
I
was
working
to
pr
in
some
doc
into
our
like
maintaining
guides,
which
is
here
it's
a
little
bit
of
out
of
date,
because
it
doesn't
reflect
some
updates
and
discussion.
We've
had
in
the
other
pr
about
how
to
improve.
You
know
fix
up
the
support,
but
those
are
probably
the
two
you'd
want
to
read
up
on
in
terms
of
the
best
the
best
discussion.
That's
going
on
on
that
front
right
now,.
D
I'm
also
kind
of
curious
today
in
node
api
we
have
api
to
evaluate
javascript
if
I
could
just
run
run
script.
I
think
like
this,
I'm
curious.
Is
there
any
interest
for
us
to
make
this
whole
this
evaluation
javascript
to
be
a
little
bit
more
extended
like,
for
example,
creating
bytecode
and
running
byte
code
and
so
on?
It's
is
a
kind
of
any
general
interest
in
such
type
of
apis.
A
I'm
wondering
if
this
is
related
to
snapshots,
so
I
know
joey
is
working
on
snapshots
where
and
she's
got
it
to
the
point
where,
like
we
generate
some
snapshots
to
have
like
pre-generated
code
v8
code,
that
you
can
just
load-
and
I
know
she's
working
on
something
similar
for
user
snapshots.
So
like
you
could,
I
guess
somehow
run
your
code
to
a
certain
point.
A
Take
a
snapshot
and
then
reload
that
I
don't.
D
No,
it's
different
snapshots,
effectively
kind
of
taking
the
whole
heap.
I
actually
don't
know
how
snapshot
is
gonna
work
with
native
modules
at
all,
I'm
pretty
much
more
talking
about
like
each,
maybe
module
being
able
to
take,
for
example,
javascript
create
byte
code
that
is
out
of
his
javascript
and
actually
execute
by
code,
so
think
it
makes
the
whole
execution
of
a
big
javascript
kind
of
scripts
faster,
because
we
don't
need
to
prepare
them.
A
Right,
okay,
so
it's
like
is
that
related
to
native,
so
go
ahead.
C
A
D
No,
no,
you!
You
can't
do
it
for
javascript
it's
but
most
javascript
engines.
They
always
have
like
source
code
and
converting
to
bytecode
and
then
in
fact,
executed
by
code
inside
even
like,
for
example,
hermes,
javascript
engine.
They
even
say
that
they
can
execute
bytecode
without
source
code.
So,
thankfully,
the
whole
idea
about
how
hermes
interpreter
for
javascript
is
faster,
that
in
production
they
never
use
source
code
at
all.
We're
just
using
bytecode,
so
think.
D
C
The
hermes
does
is
that
v8
doesn't
allow
the
source
code
to
be
absent
from
the
execution
since
the
it
might
be
deoptimize
the
whole
thing
and
get
back
to
replacing
the
source
code,
and
there
might
be
possibilities
that
the
developer
tools
might
need
to
fetch
the
source
code.
To
enable
like
say,
step
into
the
source
code
like
something
like
that.
D
Yeah,
there
are
two
functions
which
usually
kind
of
prevent
from
from
doing
it,
one
of
them
is
being
able
to
get
source
code
as
a
function.
Another
eval
functions
actually
two
of
these
functions,
which
require
source
code,
but
my
question
is
more
generic:
are
we
interested
in
api
to
add
factory,
creating
this
bytecode
and.
A
G
Yeah,
that's
that's
that's
my
instinct
too,
like
node
api
is
supposed
to
basically
follow
the
the
ecma
script
spec
and
provide
a
native
interface
for
that
spec
right,
and
this
is
kind
of
this
kind
of
assumes
that
all
engines
are
implemented
such
that
there's,
this
intermediate
representation,
which
is
probably
true,
but
I
mean
I
I
don't
know,
does
jerry's
script,
have
an
intermediate
representation.
G
You
know
so
these
apis.
I
don't
know
if
they
can
be
implemented
on
on
on
all
engines.
I
mean
they
can
be
implemented
on
on
most
of
the
major
ones,
but
I
don't
know
that
we
should
do
that
honestly
and
then
you
know
if
it's
outside
of
node
api,
do
we
care
about
api
stability
or
or
what?
What
is?
What
is
the
intention
there.
D
Yeah
my
main
scenario:
I'm
using
this
node
api,
is
a
abi,
safe
parent
of
javascript
engines
and
these
javascript
engines
being
used
inside
of
react
native
applications.
D
So
I
think
we
effectively
start
up
time
for
react,
notifications,
very
kind
of
critical
and
using
byte
code
as
something
called
how
we
improve
in
this
startup
time.
So
my
I
guess
my
question
was
mostly
along
the
lines.
It
is
something
which
we
want
to
see
in
the
core
of
node
api,
or
it
should
be
actually
kind
of
engine
specific
extensions,
if
you
like.
A
A
Right
so
like
what
I
wouldn't,
I
guess
like.
Could
you
implement
it
behind
the
scenes
on
that,
like
basically
just
say,
hey?
Well,
I'm
gonna
cache
somewhere
and
if
I,
if
I
basically
get
a
script,
somebody
passes
me
a
script,
and
I
can
tell
that
that
script
is
the
same
as
one
that
I
already
have.
The
byte
code
for
I'll
just
run
the
byte
code
right.
D
It
should
be
possible,
but
this
function
is
very,
very
kind
of
rudimentary
because
it
only
accepts
string
right.
I
don't
even
have
id,
which
I
can
use.
For
example,
debugging
information,
like
I
mean.
H
D
H
G
What
about
check
summing,
like
you,
get
to
you,
you
get
the
string
you
check
some
and
if
it
matches
you
load
is,
is,
is
the
check
summing,
plus
the
loading
slower
than
actually
executing
the
script.
A
D
Nice
for
scripts
to
have
to
have
some
name
like
it
would
be
nice,
so.
A
But
that
that's
the
case
where,
like
I
wouldn't
I
don't
see
it
as
big
an
issue
if
we
said
well,
okay,
you're
gonna
have
we're
gonna
extend
run
script
with
a
new
signature
or
whatever
that
lets
extra
information
be
passed
that,
like
other
engines,
could
just
throw
away
or
you
don't
need
to
use.
But
you
know
if
they're
basically
hints
that
the
engine
can
use
for
optimization
that
that
seems
like
a
reasonable
extension
to
me.
D
Okay
sounds
good,
so,
for
example,
in
hermes,
then
we're
given
buffer
with
with
a
kind
of
javascript
string.
They
usually
check
first
few
bytes
and
see
if
this
field
question
buys
a
special
signature.
Then
they
interpret
that
as
a
byte
code,
if
it
doesn't
have
the
signature
interpreters
as
a
just
javascript
string.
G
Yeah
these
magic
bytes
are
another
way
forward.
Yeah
I
mean
you
know
also,
you
know
if
if
the
string
starts
with
a
pattern
that
cannot
be
valid
javascript,
then
you
know
we
can.
We
can
maybe
add
some
logic
that
says:
oh
wait.
This
can't
be
javascript.
So,
let's
see,
if
it's
you
know,
byte
code.
A
A
However,
you
could
come
up
with
some
sort
of
caching
scheme
and
if
providing
like
an
extra
optional
id
or
something
helps
the
engine
on
that
front,
like
that's
something
where
okay
yeah
you
provided
the
id
an
engine
doesn't
use
it.
That's
not
an
issue
right,
but
then,
if
it
means
that
you
can
use
that
id
to
cache
for
your
second
run
behind
the
scenes,
that
seems
useful.
A
C
How
source
map
works?
It's
just
valid,
javascript
code,
it's
commented
out
and
it
can
be,
it
can
be
data
url
or
a
ui
reference
to
another
file.
Just
a
just
a
thought.
A
A
D
Actually,
I
like
the
idea
this.
I
like
this
idea,
yes,
and
also
on
a
related
note
that
today
we're
providing
to
this
run
script.
We
were
given
as
a
factory,
an
api
value.
We
pretty
much.
We
expected
first,
this
to
be
somehow
kind
of
created
and
I'm
kind
of
interested
like
is
there
any
way
for
us
to
instead
provide
this
string
as
a
kind
of
buffer.
D
A
A
Then
other
other
implementations
would
take
that
c
string
and
convert
it
into
an
app
and
node
api
value,
but
some
could
just
execute
it
directly
right
yeah.
That
again
sounds
like
you
know.
We
would
have
to
provide
a
v8
equivalent
that
did
that
extra
wrapping,
like
maybe
just
did
the
dumb
thing
right,
converted
your
c
string
into
a
note,
ap
api
value
and
called
the
other
one,
but
like
yeah
like
that,
that
kind
of
addition
seems
like
it's
not
platforms.
You
know
you
can
implement
it
on
any
platform,
but
then
it
does.