►
From YouTube: 2021-10-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.js
node
api
team
meeting
for
october
29th
2021.
we'll
take
our
standard
approach
of
looking
at
a
few
of
the
things
that
are
tagged
for
milestone,
11
and
then
go
from
there.
So
let
me
share
my
screen
here:
yeah,
it's
being
live
streamed,
okay,.
A
So
the
first
thing
we
have
there
is
the
the
ask
for
a
review
on
node
serial
port.
I
think
nicola
you've
been
following
that.
Do
you
have
an
update
or
know
where
that's
at.
D
Basically,
they're
running
into
a
crash
because
of
reference
management,
and
I
asked
them
for
a
reproduction
so
that
I
could,
I
could
see
the
crash
and
maybe
trace
it
out
for,
but
I
I
haven't
seen
if
they've
answered
the
question
or
not
okay,
so
I,
like
I
tried
to
build,
it
run
the
tests
and
everything
worked
fine,
so
there
must
be
some
different
way
to
reproduce
it
right.
You.
A
Okay,
well,
it's
good
seems
like
we're
still
they're
still
moving
forward
and
different
people
here
are
helping.
So
that
sounds
good
okay.
So
the
next
thing
we
have
on
the
list
is
looking
at
stale
issues.
I
don't
see
that
there
were
any
added
the
one
that
we
have
on
the
list.
Is
this
one?
A
And
so
this
is
the
issue
in
the
repple.
I
know
jack
looked
a
little
bit
at
it,
and
so
kevin
also
was
going
to
look
at
it.
He
says
we're
going
to
revisit
this
once
this
lands
yeah
so
go.
E
Ahead
jack
yeah
start,
so
I
think
kevin
and
someone
else
made
a
suggestion
to
symbol
to
replace
we
used
like
a
unique
uid,
but
was
hard-coded,
so
he
recommend
using
symbol
to
sort
of
replace
that.
But
the
problem
I
found
was
for
some
reason
it
will
crash
on
the
tests.
But
I
couldn't
quite
point
pinpoint
why
that
exactly
is
I
think,
if
you
scroll
down,
you
should
be
able
to
see
yeah.
A
A
A
And,
like
I
guess,
it's
less
likely
that
somebody
would
put
in
something
which
is
a
symbol
on
an
object
versus
a
string,
but
I'm
not
sure
I
guess
I'm
not
sure
it's
massively
different,
not
disagreeing
that
a
symbol
make
like.
I
think
the
symbol
might
make
sense,
although
we
might
still
want
the
symbol.
We
use
the
string
for
to
be
that
good
or
something
like
that.
F
If
you
just
simply
go
over
properties,
regular
iteration
symbols
typically
not
included
unless
they
explicitly
asked
for
in
javascript.
So
the
only
kind
of
symbol
is
it's
much
rarer
to
to
need.
But
I
guess
it
would
be
nice
if
we
maybe
do
some
kind
of
name
spacing
like,
for
example,
let's
just
say
like
israel
object
but
saying
something
like
a
node
api
dot.
Israel
object.
So
in
this
case,
if
we
have
a
name
of
the
symbol
which
actually
somehow
like
a
name
spaced
towards
an
api
would
be.
A
But
then,
in
terms
of
the
crash,
I
don't
see
like
if
we're
simply
looking
up,
the
only
thing
I
could
see
is
if,
for
some
reason,
there's
different
m's
right,
because
we'll
get
a
different
symbol
for
each
animal.
E
A
E
That
could
be
it
because
I
think
the
the
test
that
it
crashes
on,
I
think,
spawns
a
worker.
So
maybe
that
could
potentially
be
an
issue.
A
But
right
so
that
I
mean
that's
something
to
figure
out
and
if
it
is
that
we're
doing
on
a
different
m,
then
I
think
we
need
to
to
say
should.
Should
we
be
having
multiple
m's
or
you
know,
and
if
that's
allowed,
then
again
the
symbol
isn't
going
to
be
workable
because.
A
To
be
consistent
across
them,
so
maybe
that's
the
next
thing
to
look
at
because
that's
that's
the
only
thing
that
I
would
expect
to
be
any
different
right.
A
Okay,
I
guess
not
so
that's
all
we
had
in
that
that
particular
list
in
terms
of
issues.
A
B
I
I
copy
on
the
shot,
the
okay.
Let
me.
B
I
I
don't
know
how
to
answer
and
it's
an
old
issue.
So,
okay.
B
Yeah,
usually
this
object
is
built
from
the
gis
engine.
No,
so
you
you
have
the
navi
underscore
callback.
B
It's
something
that
you
can
yeah
you
you
obtain
from
from
the
just
angie.
I
presume
that
he
won't
yeah,
emulate
and
adjust
the
energy
so
right.
A
D
So
I
think
I
think
the
solution
here
is
to
factor
out
the
body
of
the
function
that
is
requiring
him
to
pass
in
a
callback
info
and
and
then
to
just
call
that
with
different
parameters
from
wherever
he
needs
to
and
then
have
the
the
javascript
engine
called
the
same
function
using
the
callback
info
from
from
wherever
the
javascript
engine
calls
that
function.
I
think
that's
usually
the
solution
when
you,
when
you're,
trying
to
call
one
of
your
own
bindings.
A
D
A
Right,
like
we
have
a
javascript
front
bit
that
says,
do
this
and
then
it
you
know
it
triggers
some
javascript
wrappers.
That
then
call
the
methods
and-
and
I'm
just
wondering
like
why-
wouldn't
you
do
that
and
it's
sometimes
sometimes
it's
just
well.
I
didn't
think
think
of
doing
it
that
way
or
something
call
back.
D
Yeah
I
mean
you
know:
a
callback
info
can
be
constructed
using
just
an
environment
and
and
a
core
right,
an
api
callback
info
yeah
which
which
can
potentially
be
null
and
then
just
don't,
do
anything
with
it.
It'll
still
construct.
But
you
can't
do
anything
with
it,
because
it'll
crash.
A
A
So
we
get
callback
info
but
and
then
we
later
well
you'd
have
to
implement.
D
Yeah,
I
was
just
thinking,
doesn't,
doesn't
every
class
have
like
a
default
constructor
and
I
don't
think
we
delete
the
default
constructor
for
callback
info
right.
A
D
A
D
A
Because
I
think
yeah,
if
you,
if
you
basically
subclass
to
implement
everything,
so
it
returns
the
data
you
want
to
have
returned,
then
it
might
work
yeah,
but
that
seems
it
seems
like
it
would
be
a
fair
amount
of
work
versus
hey.
If
I
just
can
call
some
javascript,
that's
gonna
be
a
lot
easier.
D
Yeah
I
mean
if,
if
this
person
wants
to
call
a
binding
from
native
they're
better
off,
just
you
know
factoring
out
the
the
body
of
the
binding,
because
what
are
bindings
they're,
basically
like
you,
know,
convert
all
the
parameters
from
javascript
into
into
some
native
parameter,
call
a
function
and
return
the
return
value
of
that
function.
That's
what
a
binding
is,
if
it
doesn't.
D
A
A
Right,
like
you,
can
you
know
you
could
do
this
subclass,
but
the
chance
of
you
know
you
getting
that
subtly
different
from
what
you'll
actually
get
is
quite
high.
So,
okay,
I
think
that's
a
reasonable
answer
and
we'll
see,
maybe
maybe
they'll
explain
a
little
bit
more
of
their
context
and
that'll
help
us
understand,
but
it
seems
like
a
reasonable
answer.
A
G
B
Native
of
dependents,
no
so,
okay,
two
weeks
ago,
were
1181
and
now
yeah.
How
many
of
these
so
yeah.
We
have
little
increments
per
week
about
native
dawn,
written
using
noted
on
avi.
A
Comparison,
yeah
they're
still
waiting
yeah
still
way
ahead,
but
you
know,
I
think,
if
you
look
at
the
I'm
just
looking
at,
I
mean
we're
now.
One
it's
in
a
node
on
ap
is
now
a
third
which
is
you
know,
a
pretty
decent
number
so
versus
like
a
year
ago.
I'm
sure
it
was
much
less
than
that.
So.
B
D
B
A
A
No
doubt
no,
that
on
api
yeah,
okay,
yeah,
okay,
now
that
that's
good
okay,
so
let's
the
tested
method
so
jack,
do
you
have
an
update
discussion
on
that
front
today,.
E
Nothing
there,
but
I
have
a
question
about
like
one
of
my
prs
within
no
core
sure:
zero.
Five,
five:
two:
you
can't
talk.
E
I
noticed,
like
I,
had
like
three
consecutive
ci
failures,
so
I
was
wondering
if
that's
something
with
what
I
wrote
or
is
it
like
what.
A
I
I'm
gonna
say
it's
unlikely
to
be
yours,
like
let's
just
find
that,
though,
so
he
said,
four
zero,
five,
five
four.
A
Five:
five:
two
okay
yeah
like
I've,
I've
got
a
few
and
I've
been
like.
You
know:
they're
there's
been
a
fair
amount
of
intermittent
failures
lately,
because
if
we
look
at
what's
failed.
A
I've
tried
to
resume
build
a
few.
Let's
see
view
console
output
like.
A
A
So
there
are
14
different
pr's
where
that
was
seen
across
different
things,
and
so
I'm
gonna
try.
Let's
try
again
here
anyway,
I
may
have
tried
a
few
times
to
resume
it,
but
sometimes
like.
If
there's
fixes
we
need
to
just
actually
I'm
just
gonna
kick
off
a
whole
new
build
me.
Do
that,
but
yeah,
I
think
we'll
try
a
few
more
times
before.
You
should
worry
about
it
being
related.
A
Okay,
deepak:
do
you
have
anything
on
the
the
the
work
you're
doing
in
terms
of
making
it
easier
to
run
individual
tests.
I
Yes,
so
I
had
responded
to
the
comments
and
I
also
added
a
call.
I
had
only
one
comment
remaining
from
kevin.
I
replied
to
that
as
well.
I
can,
I
think
the
pr
is
pretty
good
to
merge.
I
To
gabriel's
comments
as
well
gabriel,
do
you
have
any
yeah
questions.
A
Right,
okay,
so
yeah,
I
think
I
can
just
see
yeah.
We
just
be
good.
If
you
could
take
another
quick
look
and
then
we
can
plan
that
before
it
becomes
too
stale.
A
Okay,
then,
down
to
if
we
look
at
github,
actually,
why
don't
I,
since
I'm
already?
No
I'm
not
there.
A
A
A
D
Oh
this
one
yeah
yeah,
yeah,
okay,
so
so
what
okay?
So
basically,
this
person
is
creating
a
buffer
right.
D
Oh
wait!
A
second
you!
I
think
I
think
I
know
why.
I'm
not
100
sure,
maybe
you
can
correct
me.
My
understanding
was
that
this
person
is
creating
a
buffer
right
and
and
then
they're
taking
a
reference
to
the
buffer
right
and
the
reference
behaves
differently
for
some
reason
than
than
it
should,
and
I.
D
Yeah
I
I
remembered
that
when
we
create
references
to
buffers
specifically,
we
don't
use
a
regular
finalizer,
the
buffer
has
its
own
buffer,
finalizer,
and-
and
so
we
use
that,
because
the
memory
for
the
buffer
has
to
be
handled
differently
than
for
a
regular
reference,
and
so
what
I
was
thinking
is
we
should
do
like
like
when,
in
in
an
api,
create
reference.
D
We
should
do
like
this
thing,
where
it
we
check
if
it's
a
buffer
and
if
it's
a
buffer,
we
create
the
reference
using
the
buffer
reference
code
path,
but
now
that
I
think
about
it,
some
more
the
buffer
created
from
javascript
is
never
an
external
buffer
right
and
we
only
need
this
for
external
buffer.
So
my
comment
may
not
actually
be
relevant.
A
F
A
Object
itself,
and
they
do
that
and
it's
in
a
loop,
so
they
continually
use
the
same
object
and
create
new
references
to
it,
and
the
thing
is
the
old
ones.
Well,
the
the
thing
is
yeah,
the
basically
they've
removed
the
the
pat
like
the
old
reference.
D
Second,
when
when,
but
they
do
call
an
api
delete
reference
in
a
tight
loop
right.
A
D
A
D
Yeah
yeah
yeah
yeah.
If
you
okay,
I
see
I
see
yeah
okay,
so
so,
oh,
my
goodness,
that's
terrible
right
because
so
they're
basically
creating
a
reference,
then
weakening
it
and
then
creating
one
and
weakening
it.
Creating
one
and
weakening.
A
D
A
D
A
H
D
You
know
why
not
just
delete
the
reference
if
it's
in
a
synchronous
loop
that
it
doesn't
make
sense
to
to
to
unrefit,
because
the
garbage
collector
presumably
doesn't
have
a
chance
to
assess
or
doesn't
have
a
chance
to
mark
the
object
as
not
used
anymore,
because
well,
it's
used
it's
in
the
loop
right
until
the
loop
exits,
the
scope
doesn't
close.
So
so
then
the
garbage
collector
will
never
mark
the
object
as
ready
for
garbage
collection
right,
and
so
so.
A
D
Oh
yeah
yeah
yeah
yeah,
normally,
yes,
but
since
you're
in
a
loop
right,
you
know
that
you're
going
to
be
creating
another
reference
to
it
before
the
loop
exits
right
and
if
the
loop
does
exit
then-
and
you
delete
references
so
right.
So
basically
before
you
start
to
loop
over
delete
the
reference,
because
you
know
the
next
iteration
of
the
loop
is
going
to
create
the
reference
right.
A
A
A
The
code
like
so
if
they
were
really
struggling
with
like
how
do
I
fix
this
in
a
real
app
I
could
see,
but
I
think
it
was.
It
was
kind
of
like
with
rust
the
rust
wrapper.
You
could
write
a
little
bit
of
code
and
yeah
okay,
these
things
you
can
make
this
happen
and
in
the
end
I
I
hope
we
explained
like
this
is
what's
going
on,
and
yes,
that's
kind
of
expected
right,
but
we
don't
think
that
you'd
ever
really
need
to
be
doing
this.
F
F
A
F
Yeah
I
mean
like
just
even
like
implementing
this
in
api,
like
using
the
same
api
in
different
contexts.
I
faced
the
same
same
issue
that
it
was
not
obvious
to
me
that
I
need
to
instead
of
saying
unref.
The
ref
count
is
one.
I
need
to
I
better
to
call
delete
reference
because
think
if
I,
if
I
put
to
zero
it's
kind
of
expensive
operation
because
internally
creates
a
deep
reference
and
it's
not
not
cheap
right.
A
F
F
Probably
yes,
especially
then
we're
saying
this
release
unref
reference
that
it's
pretty
much
then
it
goes
to
zero,
maybe
just
more
like
okay
documentation.
A
Okay,
I
don't
think
unless
there's
other
ones
is
there
any
other
ones
that
people
think
we
should
talk
about.
A
If
not,
then
I
know
vladimir,
you
mentioned
you
had
a
few
questions
that
you
wanted
to
bring
up
this
week.
F
Oh
yes,
as
I
mentioned
before,
a
record
started
like
we're
working
on
nap
implementation
for
hermes
engine
hermes
engine
is
something
that
facebook
creates,
mostly
in
context
of
react
native
main
difference
from
other
javascript
engines.
That
hermes
is
interpreter
only
because
for
some
scenarios,
which
is
not
calculation,
heavy
interpretation
can
be
more
beneficial,
especially
than
you
think
about,
like
application,
startup,
also,
memory
use
and
stuff
so
think
we
see
in
some
scenarios
when
we
want
to
have
react
native
for
ui.
F
We
see
some
clear
benefits
on
top
of
the
8
engine,
because
we
use
a
much
less
memory
and
we
use
kind
of
front
kind
of
startup
time
faster
and
so
on.
So
thankfully
we
see
at
least
in
microsoft,
office.
There
are
some
scenarios
where
we
see
benefits
of
using
hermes
engine
ui
only
scenarios,
and
we
have
some
benefits
of
using
the
eight
engine
in
like
custom,
excel
calculations
or
something
this
will
be
different
kind
of
wins
there.
F
But
anyway,
as
I
implemented
this
an
api
for
hermes,
I
have
a
few
questions
like
one
of
them
probably
easy.
One
like
there
are
some
features
which
hermes
engine
didn't
implement.
Yet,
for
example,
big
integer
and
an
api
has
apis
for
them.
So
what
will
be
kind
of
reasonable
way
to
do
like
just
simply
return
generic
failure,
or
something
in
case
of
this
function
not
implemented.
A
A
I
don't
know
if
that
works,
though,
because
there
may
be
some
features
you
do
want
to
support.
But
anyway,
that
just
came
to
mind
like
in
a
very
specific,
some
very
specific
cases
you
might
say.
Well
we
only
provide
an
earlier
one.
F
If
I'm
not
mistaken,
it
was
edited
like
version
six
or
something
like
this
beacon
support
is
edited
quite
early
because
the
it
supports
begin
for
some
time
and
right,
like
does
not
have
scenarios
at
least
no
customers
who
asking
for
this
feature.
Yet
there
are
other
features
more
important
people
asking
for
right.
B
But
the
problem-
the
node
api
version-
is
that
maybe
he
want
some
feature
that
we
added,
for
example,
in
version
8
and
the
beginner
was
added
in
version
six,
I
I
think
yeah
I
will
remember
yeah
so.
B
Maybe
yeah
you
can
throw
a
a
a
a
fail,
but
then
maybe
if
you
think
at
the
equine
standard,
you
should
say
that
that
engine
does
not
implement
that
particular
feature.
No,
because
yeah
no
dpi,
yeah,
abstract.
You
know
the
the
concept
over
the
javascript
standard.
B
D
That's
that
I
was
just
thinking
from
from
what
you
were
saying
nicola,
that
generic
error
is
kind
of
well
generic
right.
So
if
we
want
it
to
be
super
super
nice,
we
might
want
to
add
a
status
code
that
says
like
not
implemented,
and
that
that
would
be
a
lot
clearer.
You
know
yeah,
you
could
do.
D
D
It's.
It's
really,
and
I
mean
from
what
you're
saying
nobody's
nobody's
gonna
run
into
this
because
nobody's
using
bigint
right
now,
right
so
and-
and
I
understand
that
people
might
start
trying
to
use
it
because
they're
consulting
the
the
main
api
documentation
and
it's
like
ooh,
it's
got
big
ends.
Let
me
try
it
and
then
they're
like
nope.
C
D
But
if
you're
writing
an
api
add-on,
you're
also
handling
the
napi
status
right,
and
so
it
will
return
and
not
an
api,
okay,
right
and
you're
expected
to
handle
that.
So
yes,
it
behaves
differently
on
different
engines,
but
we
fail
in
in
a
way
that's
consistent
with
an
api,
and
you
should
be
expecting
those
failures
right.
A
Yeah
but
you,
but
we
don't
expect
everybody
to
check
every
call
they
make
to
see
if
it's
an
implemented
function
or
not
right
because,
like
the
whole
idea
is
like
you
know,
you
opt
into
an
api
seven
and
therefore
you
get
napi
seven
right.
So
like
it,
you
know
this
does
sound
like
a
special
case
where
every
engine
doesn't.
You
know.
A
I
think,
like
a
not
implemented,
makes
sense,
but
it's
kind
of
like
you
don't
want
that
to
be
the
regular
you
just
you,
you
potentially
lose
the
hey.
I've
got.
I've
got
something
that's
already
compiled
it
may
just.
It
won't
necessarily
run
across
the
different
engines
in
this
case,
but
I
don't
think
you
should
be
asking
people
to
write
their
write,
their
modules
to
check
and
then
cope
with
being
not
implemented
or
something.
I
guess
in
maybe
some
very
small
cases
right.
A
F
You
like
in
in
in
c
plus
plus
libraries
like
as
they
implemented
like
new
standards.
They
have
some
special
kind
of
if
there
for
different
kind
of
features,
if
you
like,
because
big
hint
is
like,
is
a
feature
right.
D
F
Clearly,
missing
from
this
specific
javascript
engine
and
the
similar
stuff,
people
do
in
c
plus
plus
libraries.
They
simply
said,
oh,
like
saying
no
except
no
was
not
supported
yet
like,
and
people
can
just
simply
use
if
they
have
to
check
this
feature.
If
it's
features
there
or
not,.
F
F
It's
not
only
like
it's
not
feature
dependent,
node
api
is
actually
kind
of
a
functionality,
it
may
add
new
functionality,
for
example,
add
finalizer
was
added.
Much
later
like.
I
would
like
to
use,
add
finalizer
right,
yeah.
F
F
One
of
the
solutions
could
be
like
similar
to
what
you
propose
that
maybe
we
can
add
some
set
of
defines
which
can
filter
out
some
non-supported
apis
right,
make
sense.
A
Yeah,
like
I
guess,
it's
the
like
in
the
compile
like
because
it's
about
people
who,
when
they
write
their
when
you
write
your
ad
on,
do
you
want
to
make
sure
it's
going
to
run
across
all
these
different
engines,
and
so
yeah,
maybe
like
even
just
in
the
include
file,
something
that
filters
out.
That
is
a
filter.
A
Yeah,
I'm
not
so,
I
think,
like
a
node,
node
add-on
api,
it
would
actually
be
a
good
place
to
put
that
where,
basically
it
says
you
know,
you
could
have
a
defined,
you
know
require
hermes
or
something
or
require
v8
like
require
hermes,
supported
by
hermes,
require
supported
by
v8
and
there
we
could
filter
out
things
in
node.
Add
on
api,
because
it's
not
you
know
what
an
api
is
a
wrapper
that
it's
not
tied
to
node
in
node
itself.
A
A
B
In
that
we
could
do
that.
B
So
if
I
were
understood
we
should
define
macro
pair.
E
A
A
I
think
the
suggestion
of
having
like
a
non-implemented
like
an
error
code
printing
that
into
core
would
make
sense
to
me
and
then
that's
just
something
you
can
return.
That's
more
specific
than
a
generic
error.
B
Yeah,
because
generic
payor
could
be
everything
and
yeah
yeah
instead,
the
the
real
reason
is
that
the
javascript
engine
does
not
support
the
value.
F
And
as
we
talk
about
this
error
messages
like
say,
for
example,
invalid
argument
right
like,
for
example,
some
people
can
pass
now
with
null
not
expected,
and
we
we
return
this
an
api
invaded
arc
yeah,
but
how
developers
would
actually
find
out
like
something
fails
right
like,
and
they
see
this
wrong
status
code,
how
they
can
find
out,
like
which
exactly
argument
was
bad.
A
F
So
I
wonder,
like
I
guess
my
question
yeah,
is
it
kind
of
any
thoughts
to
add
some
extended
extended
error
info
like,
for
example,
just
simply
maybe
providing
string,
and
this
string
would
internally
say
yes,
this
argument
foo
is
now
we.
A
Already
have
that
method.
There
is
a
like
get
extended
info
method,
and
so
it
will.
But
I
I
you
know,
I
don't
think
we
set
any
extra
info
in
terms
of
the
argument.
We
probably
could
so
that
that
that
that's
probably
we've
still
we've
we've
documented
that
as
platform
and
implementation
specific,
so.
F
F
Okay,
so
you
what
you're
saying
like
there
is
in
this
extended
air
info.
We
have
this
special
field
for
engine
specific
info,
which
is
like
probably.
D
Okay,
so
I
was
just
going
to
say,
like
the
the
status
I
think
is
better
because
it's
like,
if
we
added
hash,
defines
to
the
header
file,
then
the
compile,
but
now
you're
asking
people
to
compile
the
add-on
for
different
implementations,
which
is
what
we're
trying
to
avoid
with
an
api
right.
I
think
you
guys
came
to
the
same
conclusion.
A
It
was
more
in
my
mind
about
helping
people
like
it,
wouldn't
be
that
you
needed
to
use
any
of
these.
But
if
you
wanted
to
say
I'm
I
want
to
support
these
ones.
You
could
easily
have
stuff
filtered
out
for
you,
but
I
I'm,
but
I
don't.
I
don't
see
that
like.
I
don't
think
that
would
make
sense
and
then
the
the
ones
that
are
in
the
node
repo
at
all,
because
we
know
that
we've
implemented
them
all
in
the
shared
external
repo
with
the
headers.
A
Maybe,
but
then
that
adds
extra
extra
like
differences
between
what's
in
node
and
what's
in
the
shared
headers
right
yeah,
but
so
I
think
to
answer
the
real
question:
it's
like
yeah,
let's
adding
a
new
field
to
the
core
would
make
sense.
It
says
it's
not
implemented
and
then,
as
as
as
nikola
pointed
to
this
nappy
extended
info,
you
could
you
could
say
more,
you
know
in
there
you
have
the
engineer
code
in
the
and
a
string
that
you
can
provide.
F
Yeah,
so
it's
a
good
suggestion:
yes
I'll
use
it
and
should
we
say
not
supported
or
not
implemented.
What
would
be
better?
I
think
okay.
D
F
There
are
some
other
kind
of
things
which
just
simply
missing
difficult
to
do
in
hermes,
engine
which.
A
A
Okay,
so
I'll
make
you
the
the
the
owner
of
the
video,
the
host
and
so
it'll
keep
going
until
you
close
the
the
chat
and
I'll
drop
off.
Sorry
quietly
at
12.,
so
sorry
go
ahead.
Lumiere.
F
Okay,
so
another
question:
I
guess
for
me
it's
what
a
little
bit
stuck
with
today
finalizers
in
an
api
is
they
can
access.
F
I
think
they
allow
to
access
engine
javascript
engine
functions
and
it's
usually
it's
kind
of
done
for
a
special,
secondary
callback
in
garbage
collector,
and
currently
this
mechanism
is
missing
in
hermes
engine.
F
So
I
just
want
to
wonder,
like
what's
the
general
feeling
about
this
finalizers
being
able
to
do
with
all
this
extended
work,
how
important
it
is
for
for
an
api.
D
Yeah,
well
I
mean
it
depends
on
the
add-on,
whether
it
it
calls
into
js
or
not
right.
Some
add-ons
do
some
add-ons,
don't
it
depends
on
the
on
the
use
case.
But
the
fact
that
it's
able
to
do
that
is
is
is
another
difference
right,
so
we
we
actually
have
a
situation
that
is
kind
of
limited
right
now
in
in
a
node
which
is,
you
are
unable
to
run
javascript
from
a
finalizer
when
the
environment
is
being
destroyed
right.
D
So
if
you're
a
worker
thread-
and
you
have
weak
references
right
at
the
end
of
the
worker
thread-
we
see
what
weak
references
the
engine
has
left
us
and
then
we
and
then
we
finalize
them
all
right
in
a
loop,
a
synchronous
loop
and
during
during
the
execution
of
this
loop.
Javascript
execution
is
unavailable
right
and
right
now
we
there's
really
nothing.
We
can
do
about
that
because
I
mean
the
engine
is
gone.
There's
just
nothing.
D
You
can't
call
into
the
engine
if
the
engine
is
gone
right,
and
so
we
were
debating
as
to
whether
to
add
a
status
code.
For
that,
like
you
know,
cannot
execute
javascript,
but
you
know
there
are
some
things
that
you
can
still
do
with
the
engine
like
delete,
references
and
and
this
kind
of
stuff
which
is
which
doesn't
involve
the
execution
of
javascript.
But
it's
still
it's
still
very
sort
of
heterogeneous.
D
So
we
have
a
precedent
for
this,
where
you
just
cannot
call
into
javascript,
and
if
you
try
to
call
an
api
anything,
it
will
just
come
back
with
an
error.
So
so,
given
that
we
have
this
precedent,
it
may
not
be
the
end
of
the
world.
If
you,
if
you
just
returned
an
error
code
there,
and
you
can
check
you-
can
check
the
implementation
and
nodejs
to
see
what
error
code
we
return.
D
Oh,
no,
I
think
I
think
in
in
vladimir's
case
it's
every
case.
So,
even
even
during
normal
operations,
you
cannot
call
into
into
javascript
from
from
a
finalizer.
That
is
my
understanding.
So
yeah
it's
it's
worse,
but
at
least
it's
not
without
precedence
that
you
cannot
call
javascript
from
a
finalizer.
A
A
I've
got
to
drop
off,
but
I'll,
try
and
listen
in
and
and
see
what
I'm
sure
we'll
have
more
discussion
on
some
of
these
anyway.
So
talk
to
everybody
later,
bye.
D
D
D
We'll
return
an
api
pending
exception.
It's
just
absolutely
terrible,
but
that's
what
we
do
so
it
says
like.
If
you
call
a
function
that
has
an
napi
preample,
then
we
return
an
api
pending
exception.
If
the
last
exception
is
empty
and
okay
yeah
yeah.
If
if
if
either
the
last
exception
is
not
empty,
then
we
return
an
api
pending
exception.
That
makes
sense.
But
if
you
cannot
call
into
js,
then
we
also
return
an
api
pending
exception
and
that
is
just
terrible,
yeah,
so
yeah
and
and
we're
stuck
with
that,
because
we've
released
with
that.
D
F
Okay
and
if
we
do
with
spending
conceptions,
should
we
kind
of
somehow
yeah
there's
no
way
to
first
to
synthesize
this
exception
right.
If
people
ask
for
it,.
D
Well,
no,
no
they're,
yeah!
That's
right!
There
isn't
because
because
well
you
can't
use
the
engine
anymore
right
so
yeah
I
mean
if
you
try
to
get
the
last
exception.
That
call
would
probably
also
fail,
because
the
last
exception
is
null
so
so
yeah.
That's
a
good
point.
Let
me
see
get
what
was
it.
D
Okay,
so
let's
see
what
happens,
see:
okay,
get
and
clear.
D
Okay,
okay,
I
see
okay,
well
we're
actually
not
so
bad
because
get
and
clear
last
exception
if
and
last
exception
is
empty
return
and
api
get
undefined.
D
F
Yeah,
I
think
I
I'm
going
to
cache
and
define
failures
like
now.
I'm
defined
distinctly.
I
don't
need
to
go
to
engine
at
this
point
and
hermes
in
this
sensor
is
pretty
good
because
they're
using
this,
this
double
encoding,
double
double
kind
of
dropping.
H
D
D
One
observation
that
that
I
have
based
on
your
questions
is
that
you
know
we're
kind
of
you
know
we're
we're
kind
of
turning
into
like
this
situation,
where,
where
where
jquery
was
at
some
point
right,
different
browsers
had
different
features
and
jquery
tried
to
sort
of
unify
them.
So
now
that
we're
implementing
this
on
multiple
engines,
we're
finding
that
you
know
different
engines
have
different
features
and
sooner
or
later
we're
going
to
need
somebody
somewhere
to
like
polyfill
or
or
somehow
you
know
smooth
over
these
differences.