►
From YouTube: 2021-07-16-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
A
C
B
A
A
Okay,
so
that
one's
worth
having
the
on
our
non-stale
list,
I
assume
you
removed
the
stale
tag
as
well.
Did
you
or.
C
D
Here,
oh,
it's,
it's
open
and
it's
our
raspberry
pi
fee.
D
D
But
I
don't
understand
if
they
already
solved
the
problem
or
not.
A
E
But
there
seems
to
be
some
some
merged
change
there
that
addresses
a
use
after
free,
so
that
might
have
solved
it
for
them
right.
I
don't
know
if
yeah
so
yeah,
if
yeah
here
there's
like
a
merged
change
on
zero
mq.
B
A
Okay,
so
you
we,
that
was
965,
which
we
just
looked
at
right
and
then
we
had
912.
A
A
Okay,
sounds
good,
okay,
so
that's
the
stale
issues
modules
that
are
reported.
I
don't
think
I
s
nothing.
Recent
there,
oh,
I
haven't
enabled
debug
testing
for
add-ons
creating
the
the
matrix
of
tested
add-ons
this.
This
might
be
a
good
place
just
to
ask
you
know
jack
and
deepak
how
things
are
going
on
that
front
in
terms
of
adding
new
tests,
if
there's
any
blockers
or
questions
that
kind
of
stuff.
H
It
was
created
by
kevin
one
second,.
A
Okay,
jacks
or
would
which
one
should
we
discuss.
B
That
was
the
test,
the
modules,
the
one
that
you
were
just
looking
at
tracking
or
no
like,
were
we
not.
A
G
I
think
for
like,
in
terms
of
like
the
existing
coverage,
I
think
we
have
most
of
the
matrix
filled
out.
I
think
there's
a
few
like
functions
and
to
look
over
but
yeah
I'll,
probably
get
on
this
weekend,
because
I
was
just
finishing
my
midterms.
A
G
It
was,
it
was
like
I
think
we
decided
to
go
with
like
issues
like
it's
attack
them
under
issues.
It's
like
type
like
there's
a
tag
under
testing.
If
you
go
to
know
that
on
issues,
if
you
have.
D
Types
that
we
yeah,
I
need
yeah
right
to
call
it.
So
I
saw
that
jack
closed
the
same
ball
and
then
I
don't
know.
D
B
A
E
B
And
it's
a
problem
if,
when
we
want
to
do
rapid
development.
A
H
Yeah,
I
guess
I
have
my
friends.
I
just
worked
in
a
couple
of
sure
hours
on
this.
H
And
here
I
am
so
this
is
what
I
was
working
on
so.
H
Yeah
I
hooked
in
a
you,
know
a
script
for
I
called
it
as
unit
right,
so
we
can
just
do
a
run.
Npm
run
a
run
unit
and
do
a
filter
with
a
filter
condition.
Something
like
this
right.
H
Look
at
the
terminal.
If
you're
able
to
look
at
the
terminal,
it
would
be
something
like
this
right
unit
and
then
filter
and
then
say:
name
dot
cc,
something
like
that
which
file
we
want
to
run
right
and
there's
a
way
of
once.
You
pass
the
parameter
in
npm
script.
You
have
a
way
of
getting
that
into
the
you
know
as
a
as
a
variable
as
a
param
argument.
H
So
you
can
take
this
an
argument
and
pass
into
your
test,
and
I
I
propose
creating
a
separate
unit
test
folder,
because
this
we
have
to
just
like
your
test.
We
can
create
a
unit
to
have
a
unit
test
folder
under
which
we
can
have
a
you
know,
another
binding.jyp.
H
So
so
there's
an
index.js
under
that
unit
test,
which
can
you
know
which
can
get
the
passed
in
arguments
right?
It
can
type
in
the
passion
arguments
it
can
get
all
parse
the
power
of
passion
arguments
and
then
we
can
spawn
a
node
build
rebuild
from
there
with
the
you
know,
in
that
current
folder,
with
with
all
the
files
that
we
have
created.
H
I
I
have
the
sources
hardcoded
here,
but
I
was
trying
to
get
in
the
you
know
the
argument
that
we
passed
from
the
script
here,
the
filter
argument
the
filter
argument
for
that
particular
running
that
one
particular
file
I
was
trying
to
bring
in
here.
So
I'm
still
working
on
that.
So
if
I
am
able
to
bring
that
here,
it
obviously
comes
here
as
a
you
know
in
the
process.rt
as
an
argument,
if
I'm
able
to
pass
into
the
node
here
and
then
get
it
into
the
binding
dot
ui
the
technique.
H
The
thing
is
that
the
variable
expansion
I
have
I'm
still
tweaking
the
variable
expansion
in
process.gyp
binding.jyp.
So
if
I'm
able
to
bring
it
here
hook
it
in
here,
then
this
becomes
a
template
into
which
we
can.
You
know
inject
the
file
names
that
we
want
to
run
and
then
we
can
run
it
from
here.
H
The
only
thing
is
like
we
have
to
prepend.
You
know
the
folder,
the
actual
test,
folder
a
relative
path
and
then
add
the
file
that
we
want
to
actually
run
this
works.
Actually
I
tried
running
this.
H
If
you
look
at
it,
so
it
it,
this
index.js
is
able
to
get
to
the
filter
argument
and
build,
and
you
know,
get
the
filter
argument,
I'm
just
still
working
on
passing
that
into
the
variable
expansion
for
the
binding
jyp.
If
you
guys
any,
have
any
any
other
better
ways
of
doing
this,
let
me
know,
but
this
is
where
I
am.
E
I
think
I
I
I
think
you
don't
need
all
this
infrastructure
like.
I
think
you
can
just
do
this
with
npm
test,
because
because,
if
you
say
npn
test
minus
minus
filter
right,
then
then
the
this
npm
config
filter
will
will
be
available
in
like
the
index.js
right,
and
so
while
that
does
not
fix
your
your
your
compilation,
so
it
doesn't
reduce
the
number
of
files
that
that
it
compiles.
E
It
does
reduce
the
number
of
tests
that
it
runs
so
and
for
for
speeding
up
the
the
building
of
the
tests
you
can
you
can
build
them
in
parallel
with
the
following
command
line.
So
if
you
look
at,
if
you
look
at
the
chat,
you
can
say
like
make
flags
equals
minus.
However
many
processors,
you
have
times
two
and
I
don't
know
if
it's
make
flags
or
make
ops,
so
I
always
just
add
them
both
and
then,
if
you
run
npm
test
with
these
flags,
then
it'll
build
that
many
at
a
time.
E
H
E
Yeah
yeah,
if
you
have
like
whatever
whatever
16
hardware
threads
right
or
actually,
if
you
have
eight
hardware
threads,
you
would
say
something
like
16.
If
you
have
16,
you
would
say
32
right
because
you
won't
always
want
to
have
you
always
want
to
have
a
bunch
of
them
standing
by
to
launch
right
and
so
to
to
maximize
cpu
utilization.
E
E
This
work
of
trying
to
you
know
build
up
this
whole
infrastructure
of
a
second
binding.jib
and
all
that,
if,
if
we
find
that
it's
slow
even
after
that,
then
we
can
start
looking
at
at
at
filtering
the
the
the
sources
and,
honestly,
I
think
filtering.
The
sources
should
also
work
with
the
existing
binding.js
though
it
may
be.
It
may
be
quite
a
quite
quite
like
like
an
exercise
in
in
in
circumventing
jip.
At
that
point,.
B
B
Like
we
had
a
meeting
deepak
and
I
we
had
a
meeting
just
sort
of
go
through
the
whole
testing
infrastructure.
B
Everything
works
and
whatnot
so,
like
the
end
goal
of
this
was
to
be
to
only
compile
the
individual
cc
for
the
test,
as
well
as
construct
a
binding.
That's
only
needed
for
that
one
test:
right
yeah.
I
guess
it
is
very.
B
Optimal,
I,
I
can't
think
of
the
word
that
I'm
looking
for
like
it's
wishful
thinking,
I
guess
there
may
be
a
lot
of
infrastructure
change.
That
would
be
necessary
in
order
to
do
that.
But
I
do
know
that,
like
when
I'm
running
like
when
I'm
developing
a
lot
of
times,
I'm
changing
my
package
json
and
my
index
js
and
my
binding
cc
just
so.
E
Yeah
agreed
yeah
yeah.
I
I
I
found
that
an
acceptable
way
around
it
is
is
to
use
this
this
make
flags
and,
if
you're,
if
you're
working
on
tests,
only
then
another
good
good
thing
to
have
is
c
cash.
So
if
you,
if
you
do
see
cash
and
you
change
a
test,
it'll
only
recompile
that
test,
because
the
header
hasn't
changed
and
so
for
all
other
tests.
E
So
so,
when
it
does
that,
then
inside
index.js
you
can,
you
can
grab
the
the
the
npm
config
filter
environment
variable
and
you
can
decide
on
the
final
list
of
tests
yeah,
yes,
so
so
so
I
guess
what
I'm
saying
is
you
for
this
particular
like
for
for
the
index.js
alone?
You
don't
need
this
like
extra
directory
with
that
with
another
binding
chip
and
all
that
and.
E
Yeah,
I
understand
I
understand
yes,
what
I'm
trying
to
say
is
that
as
a
first
step,
I
think
we
should.
We
should
do
the
thing
where
it.
Yes,
it
builds
all
the
bindings,
even
though
that's
not
our
final
goal,
and
but
it
only
runs
the
ones
that
are
chosen
and
then,
as
a
second
step,
we
we
try
to.
We
try
to
limit
the
the
bindings
that
we
build,
and
then
we
take
this
like
stepwise
approach
instead
of
like
trying
to
just
go
at
it.
H
Yes,
so
yeah,
we
already
know
that
there
are
two
steps
right.
I
was
when
we
had
discussion
with
kevin,
so
we
know
that
there
are.
There
are
two
steps
right,
one
is
the
test
and
another
one
is
a
compilation
right
so
yeah.
The
test
step
is.
We
know
that
that
is
easier
because
we
have
written
a
test
script
in
the
index.js,
so
we
can
modify
it
to
just
filter
out
and
run
that
one
particular
test.
But
the
compilation
is
what
we
are
had
like.
Yeah
and.
A
So
since
you
know
deepak's
halfway
through
this
one,
I
think
it'd
be
interesting
just
to
see
where
we
get,
because
it
I
I
think
I
can
see
like
it's
basically
like
a
lot
of
times.
I
want
to
like
not
build
it
all,
but
that's
kind
of
separate,
but
but
if
you
are
going
to
build,
I
can't
see
the
use
case
where
it's
like
yeah.
A
I
only
want
to
build
the
one
test
that
I'm
working
on
and
if
you
could
just
you
know,
kind
of
like
today,
I
can
go
in
and
easily
edit
the
index.js
to
splice
things
and
stuff,
and
that's
where
we
could
do
a
better
job
of
having
options
to
let
you
not
have
to
edit
and
but
I
think
it
would
be
interesting
to
have
the
similar
ability
to
say
I
want
to
splice
down
that
by.
I
guess
it's
the
binding.jip.
A
A
E
Yeah
yeah
yeah.
Okay,
honestly,
I
think
the
the
the
ideal
situation
would
be
if
we
didn't
have
files
which
contain
references
to
other
files.
So
ideally
we
would
have
a
we
could.
We
could
decide,
we
could
have
like
the
directory
structure
alone.
E
Binding
dot
cc
right
so
ideally,
we'd
have
neither
of
those
right
because,
like
for
example,
let's
say
I
want
to
build
three
things
right
now
you
need
to
now.
You
need
to
construct
a
a
custom
binding.cc
right
because
it
should
have
like
in
it
this
in
it
that
in
it,
the
other
thing
and
nothing
else
right
so.
E
A
E
Oh
so
so,
and
there
might
be,
there
might
be
platform
implications
for
that
right,
because
if
you
forward
declare
like
init
abracadabra
right,
but
then
you
don't
provide
init
abracadabra
anywhere,
you
know.
Linux
may
not
complain
because
linux
has
lazy
symbol.
Resolution,
but
windows
might
complain,
it
might
say,
cannot
build
binding
dot
node,
because
init
abracadabra
is
undefined
right.
E
We
should
not
have
this
like
in
it
in
it
this
and
in
it
that
and
in
it
the
other
thing
you
know,
but
that
may
be
difficult
because
well,
you
know,
aside
from
creating
like
a
shared
object
for
each
test,
if
we
want
to
have
all
the
tests
in
one
shared
object
that
may
not
work,
you
know
so
so
I
I
I
don't
know
the
whole
story,
but
you
know
one
of
the
implications
of
trying
to
do
one
at
a
time
might
be
that
each
one
will
have
to
be
like
its
own
binding
dot.
A
E
Yeah
for
sure
yeah
yeah.
Yes,
that's
a
good
point,
because
if
we
have
like
a
binding.jib
for
each
test
and
there's
no
way,
you
can
say
make
flags
because
it
always
only
compiles
one
file
and
and
and
you'd
have
to
have
like,
like
an
overarching
make
job
that
that
runs
like
you
know:
16
directories
at
the
same
time,
but
now
you're
talking
about
like
custom,
make
files
and
stuff
so
so
yeah
yeah.
That
may
not
be
the
solution.
E
On
the
other
hand,
the
the
since
the
binding.jib
already
lists
all
the
files
right
you
know.
Instead
of
having,
like
you
know,
binding
dot.
Node
sources
equals
long
list
of
files.
Right,
we
could
have
like
you
know,
object,
dot,
node
and
and
typed
array,
dot
node,
but
we
we
have
them
all
in
one
zip
file
right,
because
if
we
do
then-
and
I
might
be
wrong
about
this-
it's
worth
an
experiment-
perhaps
one
then
then.
E
A
I
wonder
if
there's
something
in
between
like
if
we
structured
it
so
that
every
test
had
its
own
directory
and
had
which
files
it
needed.
But
then
there
was
a
step
that
actually,
like
you
know,
kind
of
like
we
have
for.
We
now
have
for
the
index,
which
basically
goes
through
and
builds.
The
you
know
builds
up
what's
going
to
be
run
automatically.
C
E
A
B
I
don't
think
you
would
need
to
dynamically
generate
binding.jip,
because
you
could
use
some
process
expression
to
generate
the
build
sources.
E
B
E
That's
yeah,
that's
a
good
point.
So,
for
example,
let
me
think
okay,
but
how
do
you
deal
with
binding.cc
then.
E
That
has
yeah.
That's
right!
That's
that's
an
excellent
point.
That's
an
excellent
point!
Yes,
I
I
think
kevin.
I
think
you
you
nailed
it
so
so!
Okay,
so
you
have
the
environment
variable
right.
The
environment
variable
can
be
used
as
the
as
the
value
of
the
sources
thing
right,
assumedly,
I'm
not
100
sure
right.
B
A
E
Sources
and
you
can
use
the
same
npm
config
filter
thing
to
also
pass
into
index.js.
E
Yeah
and
in
fact,
since
since
the
since
the
the
filter
thing,
since
the
filter
thing
is
coming
in
from
the
environment
anyway,
its
default
value
might
just
be
like
you
know,
ls
tests,
you
know
as
a
list
and
then
and
then
you
know
the
having
a
filter
specified.
You
know
like
if
filter
is
not
specified,
then
filter
is
equal
to
back,
quote
ls
tests,
you
know
and
then
and
then
the
list
comes
from
tests,
if
not
specified
otherwise
by
the
user.
C
E
A
H
Yes,
one
of
the
things
I
heard
is
that,
like,
I
think,
even
kevin
brought
this
up
previously,
the
binding.cc
is
something
that
we
should
be
templating
in
case
we
are
trying
to
you
know.
We
cannot
include
this
binding.cc,
which
is
there
originally,
because
it
would
miss
symbols
right,
so
we
have
to
have
a
custom
binding.cc.
H
E
Yes,
yes,
yes,
so
so,
basically,
when
you're
building
a
target
with
jip,
some
of
the
source
files
for
that
target
can
be
generated
right.
So
you
you,
you
can
create
a
target
that
that
is
not
like
a
c
plus
plus
target.
It's
a
it's
a
target
of
type,
none.
H
H
E
A
E
Ready
to
share,
let
me
let
me
just
grab
the
binding.jip
put
that
on
screen
and
now
I
think
I'm
ready
to
share.
Let's
see
if
I
may
share
screen
entire
screen
share.
Okay,
so
now
y'all
can
see
this
hopefully,
and
you
go
to
here,
and
so
this
is
by
this
is
iotivity
node,
zip
file.
So
let's
see
no
target
defaults
doesn't
matter
target
conditions.
Doesn't
matter
targets
right
so
so
this
is
this.
The
name
of
this
target
is
csdk
right.
E
This
target
builds
like
a
c
library
right
using
like
a
completely
different,
build
system
right.
So
so
so
you
can
see
that
the
type
is
none.
Even
though
the
result
is
a
shared
library.
I
said
that
the
type
is
none
and
then
instead
of
having
sources,
it
has
actions
see
and
then
the
action
is
like
build
scripts,
build
c,
csdk.js
right,
and
so
the
only
the
only
way
you
you
can,
you
can
tell
it.
E
What
to
expect
is
is
via
this
inputs
and
outputs,
and
this
is
all
like
the
outputs
is
a
directory
called
iotivity
installed
right.
So
basically,
what
you're
saying
here
is
that
there's
a
target
by
the
name
of
csdk
right
and
in
order
to
create
this
target,
you
perform
this
action
right
here,
the
and-
and
you
know
that
this
action
has
completed
successfully.
E
When
this
file
appears
right.
This
file
can
be
a
directory,
it
can
be
whatever
and
in
order
to
complete
that
action,
you
run
this
script.
So
this
is
like
a
like
a
custom,
build
step
right,
and
so
so
so
so
then
you
go
to
see.
These
are
other.
This
is
this,
for
example,
generates
source
files.
This
is
another
sort
of
supporting
target
right,
you
have
generate
constants
and
what
does
it
do
see
it
again?
It
doesn't
have
sources,
but
it
does
have
outputs
and
the
output
is
generated.
E
Constants
dot
cc
right,
and
so
so
how
do
you
generate
this
file?
Well,
you
have
you
have
like
two
actions
right.
E
First,
you
you
need
to
have
iotivity
installed
present,
so
it
depends
on
the
presence
of
that
directory
and,
second
of
all,
you
run
this
generateconstance.js
script,
which
will
ultimately
create
this
file
right
and
then,
finally,
you
have
another
one
of
these
for
generate
enums,
see
and
and
notice
how
these
depend
on
csdk
right,
because
because
these
this
command
here,
this
command
here
needs
files
from
iotivity
installed
right,
and
so
you
have
to
declare
that
as
a
dependency,
and
so
these
two
things
depend
on
csdk
and
then
this
thing
also
depends
on
csdk,
so
you
have
three
dependencies
on
csdk
and
finally,
this
is
your
target.
E
You
have
the
sources
right
and
then
you
have
these
dependencies
right,
and
so
you
know
that
when
these
sources
get
created
see
see,
the
sources
here
listed
are
generated.
Constants.Cc
this
file
doesn't
exist.
This
file
is
not
part
of
the
repository.
It
is
generated
by
one
of
these
previous
targets
right,
so
you
have
generated
constant
cc
generated
enum
cc
and
generated
function
cc
right.
E
So
in
our
case,
this
here
would
be
would
be
binding.node,
and
then
you
would
have
like
a
generated
binding.cc,
which
is
created
by
a
target
that
binding.node
depends
on
it,
so
it's
listed
in
its
dependencies,
so
it
wouldn't
be
as
complicated
as
this,
but
it
would
have
at
least
one
dependency,
which
has
one
of
these
like
actions
instead
of
sources
and
stuff
and
and
flags,
and
all
that
it
would
be
a
target
of
type,
none
which
has
actions,
inputs
and
outputs
right.
A
A
A
E
And
bug
that
jip
has
so
yeah
it's
it's
do.
B
E
E
A
A
A
So
over
the
last
month,
three
or
four
failures
that
looked
pretty
consistent,
you
know
different
platforms,
this
one-
I
think
here
this
this
one
I
think,
was
related
to
an
issue
that
was
in
core
and
v8
this
new
no-op
thing.
I
found
another
issue,
but
these
three,
you
know
we
see
failing
tests
running
after
that
particular
test.
A
A
If
you
just
run
that
the
the
the
so
I'd
say
function,
I
can't
recreate
it,
but
it's
kind
of
one
of
those
ones
where
like
and
similarly,
if
I,
if
I
chop
through
the
list-
and
I
remove
enough-
it
doesn't
happen,
but
then,
if
I
put
back
the
ones
I've
removed
and
chop
out
a
different
set,
it's
like
I
can't
say
removing
any
particular
tests
in
particular
removes
the
problem
right
because
I
say:
oh
okay,
I
removed
this
test.
It
it
didn't
happen.
A
So
then
I
add
some
other
tests
back
and
don't
include
that
test
and
it
still
happens
right
like
so.
I
you
know
it's
kind
of
like
yeah.
I
can
remove
a
test,
it
doesn't
happen,
but
then
I
can
also
see
it
happen
without
that
test
through
other
combinations.
E
Test
and
then,
if
that
fails,
then
then,
then
you
crash
during
a
subsequent
test
and
all
that
like
right,
like
we,
we
did.
We
did
do
this
like
promise
thing,
I
think
I
think
we've
got
that
by
now
right,
where,
where
you
wait
for
one
test
to
finish
before
you
start
another
test
right
and
then
we
did
get
some
kind
of
sort
of
determinism
that
way,
but
it's
still
not
a
hundred
percent,
because
the
garbage
collector
can
run
any
time
and
it
is
only
one
process
that
runs.
A
E
A
E
That
the
height
symbols,
though,
right
like
we,
did
that
the
visibility
equals
hidden.
Didn't
we
to
our
so.
A
A
Place
in
the
symbol
test
where
we
weren't
using
the
test
runner,
but
that
didn't
seem
to
make
a
difference
either.
I
I
did.
I
turned
on
verbose,
gc
to
see
if
anything
like
jumped
out
as
being
different,
but
that
kind
of
looked
the
same.
We've
got
some
extra
flags
like
don't
do
concurrent
sweeping.
I
figured
well,
maybe
that's
an
option
not
tested
as
well
by
veets,
but
I
turned
that
off
that
didn't
make
any
difference.
So
I'm
I'm
trying
I've
tried
all
sorts
of
things
to
try
and
get
that
sort
of.
A
C
A
Is
is
I
tried?
No,
you
know
before
from
the
last
one
I
ran
with
valgrind
and,
like
part
of
the
problem,
is
the
thread
say,
function
test
hangs,
but
I
I
basically
what
I.
C
E
A
A
E
A
A
E
Yeah
yeah
doing
that
with
valgrind
yeah
that'll
be
that'll,
be
a
career
right.
There.
A
E
A
And
that
might
actually
do
it.
I
had
scripts
which
basically
ran
and-
and
I
could
just
let
that
run
over
the
weekend
or
something.
E
E
E
You
know
how,
before
you
had
to
what
is
it
you
had
to
do
in
the
destructor
you
had
to
like
reset
that's
right.
You
had
to
reset
in
the
destructor
right
like
if
you,
if
you
store
the
persistent
as
a
as
an
instance
member
of
a
larger
class,
then
you
always
had
to
write
a
destructor
that
would
like
reset
it,
but
with
globals.
E
You
don't
have
to
do
that
because
it
does
it
for
you
and-
and
it's
like
the
99.9999
use
case-
is
where
you
want
it
gone
and
reset
when,
when
the
when
it
gets
destructed,
and
so
I
believe
at
some
point
in
court,
we
switched
to
using
globals,
and
so
that's
probably
why
it's
it's
in
v8.
Is
that
a
recent
change
not
so
recent?
I
I
don't
know
honestly
what
the
timeline
is,
but
I
do
believe
we
made
that
like
within,
like
the
last
two
years.
Okay,
well,
two
years.
A
A
A
That
common
right,
like
we're
talking
three
times
in
almost
a
month
right,
but
but
it
is
fairly
repeatable
in
in
the
you
know,
if
you
run,
if
you
run
10
000
runs,
you
know
it
pretty
much
happens
for
sure
right.
E
So
so
wait
when
you
run
this,
do
you
just
run
with
like
latest
16
point
accent
and
you're,
just
like
basically,
while
true
semicolon
do
npm
test
semicolon
done.
A
E
It
may
make
a
difference
right,
because
if
your
cpu
is
at
a
hundred
percent,
the
the
threat
timings
might
be
different
than
if
you
just
run
a
single
process
right.
So
so
like
under
cpu
pressure,
the
the
threat
say
function
may
behave
like
in
in
some
unexpected
way,
because
because
it
cannot
schedule
the
threads
as
it
would,
when
there's
no
pressure
on
the
cpu,
so
the
fact
that
you're
running
it
in
parallel
may
actually
be.
A
A
I
I
you
know
it
might
still
be
somehow
related
to
that,
because
you
know
sometimes
other
people
run
things
on
machines
and
this
seems
to
come
in
sometimes
seem
more
frequent,
although
that
could
just
be
bad
luck
or
good
luck
or
whatever
right
so
yeah
yeah
yeah
wrong
phase
of
the
moon
exactly
like
today,
because
sometimes
you
know
sometimes
like
within
the
first
thousand,
you
get
one.
Sometimes
it
seems
to
take
much
longer.
But
okay
anyway,
I
thought
I'd.
A
One
we
don't
have
too
much
more
time,
but
if
you
have
thoughts,
get
I'll
get
people
thinking
about
it.
If
you
have
any
suggestions
of
what
to
try.
E
Let
me
know,
another
thought
is,
you
know,
try
to
maybe
maybe
try
to
like
remove
some
of
the
rappers
like
I.
I
know
it's
pretty
vague,
but
I
mean
if
you,
if
you
just
run
the
core
tests,
you
know
do
those
ever
fail,
like
you
know
like
if
you
just
run
like
the
node
cortes,
because
if
it
is
threat
safe
function,
then
we
have
pretty
much
the
same
tests
in
core,
but
without
the
the
extra
c-plus
plus
code
right
right.
E
Be
that
might
be
sort
of
like
an
indicator
that
you
know
it's
also
happening
in
core,
though
because
I
mean
core
tests
are
flaky
too
right.
It's
just.
E
I
don't
know
if
these
are
so,
if
you,
if
you
run
like
like
like
make
test
js
native
api
and
make
test
node
api,
you
know,
then
you
know
if,
if
those
ever
crash,
then
that's
a
good
indication
that
it
isn't
an
api
and
it
may
or
may.
D
E
A
Running
the
I
could
try
running
the
core
ones
to
see
if
that's
yeah
yeah,
it
goes
deeper
than
that
yeah.
Now,
that's
that's
good
idea,
and
I
was
also
thinking
maybe
trying
like
an
earlier
version
like.
Is
it
something
we've
added
in
the
test
lately,
although
that
could
just
be
hey,
we
added
some
something
that
then
caused
it
to
hit
the
the
area.
A
G
B
A
D
Made
some
more,
we
made
the
last
race
one
month
ago:
okay,.
A
D
Yeah
we
had
some
fixer
now
and
yeah.
I
think
that
we
can
prepare
for
these
new
orders.
A
D
D
Yeah
I
saw
on
the
node
repo
so
like
asked
about
promises
them
and
someone
that
argued
that
I
maybe
it's
not
a
necessary
feature,
so
I
don't
know.
Maybe
we
need
to
discuss
about
these.
I
I
don't
know
what
what
is
your
your
answer.
D
We
have
two
two
paragas:
okay,
yeah
yeah.
A
B
B
Understanding-
and
I
think
it's
I
think
it's
kind
of
weird-
I
don't-
I
don't
necessarily
think
it
needs
to
be
an
actual
api
function,
just
yeah,
because
it
calls
the
I
think
it
might
be
better
if
you
go
to
the
files
changed,
maybe
the
readme
to
show
how
he
documented
it,
but
we
are
almost
out
of
time
but
yeah
this
one
can
be.
I
I
I
share
this
last
opinion
here
that
it
should
be
a
userland
code,
like
you
can
make
a
userland
library
to
do
this.
A
E
Yeah
yeah
exactly,
I
think
I
think
I
think
anna
says
it
best.
I
mean
you
can
just
retrieve
like
the
then
property
of
the
promise
and
and
that's
it
so
and
then
you
know
and
then
just
call
it
and
then
pass
it
a
function.
Yeah,
there's
no
reason
to
this
is
not.
This
is
not
something
you
cannot
do
without
api,
so
I
mean
yeah
user
land
definitely
like
if
somebody
wants
to
make
a
library
for
that,
then
so
be
it.
But
I
don't
think
this
needs
to
go
into
core.
F
One
than
from
my
previously
changed
request
is
that
current
implementation
requires
the
promise
to
be
native
promised
from
the
v8
implementation.
But
if
we
are
going,
if
we
are
going
to
implement
an
external
api
promise,
then
I
would
agree
with
it
will
be
have
to
be
worked
with
user
lender
from
new
zealanders
durable
likes
to
say.
F
E
E
Oh,
that's
a
good
point.
Yeah!
That's
that's
true!
Yeah,
that's
yeah!
Yeah!
I
mean
at
that
point
you're!
Absolutely
right!
I
mean
if,
if
we,
if
we
make
this
like
promise
specific,
then
you
know
javascript.
The
javascript
world
is
full
of
implementations
of
what
happens
when
you
call
dot,
then
right
and
and
not
all
of
them
are-
are
made
by
the
engine
right,
yeah,
so
yeah.
So
this
this
then
able
is
much
larger,
much
larger
than
just
a
native
promise.