►
From YouTube: 2020-02-19-Node.js N-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
napi
team
meeting
for
february
19th
2020.
we'll
follow
our
standard
approach
of
looking.
What
what's
on
the
issue,
the
issues
tagged
for
milestone
11.
before
we
get
started.
Does
anybody
have
any
announcements
they'd
like
to.
A
Okay,
so
this
one,
let's
see
open
this
one
discuss
3263.
A
All
right,
so
this
is
the
one
that
I
mentioned
last
time
legendarcast
and
we
we
talked
a
little
bit
about
you,
said:
hey,
let's
share
some
information,
so
I
did.
I
did
do
some
additional
investigation
and
think
what
I
I
could
be
effects,
although
you
know
not
being
the
maintainer
and
being
that
familiar
with
the
project,
I'm
not
sure.
If
that's
the
way,
they'd
want
to
fix
things,
but
I
at
least
found
something
that
did
resolve
the
issue
that
was
being
seen.
A
A
If
that
makes
sense,
there
was
already
there's
already
code
that
made
a
reference
like
sort
of
link
the
two
objects,
so
that
one
one
could
only
be
collected
after
the
other
one
like
at
the
same
time
as
the
other
one.
But
I
think
the
problem
is:
is
that
because
they
were,
it
was
a
javascript
level
reference
as
soon
as
one
became
collectible,
they
were
both
collectible
and
there
was
no
guarantee
that
the
finalizers
for
one
would
be
run
before
the
other
one
was
collected
and
that's
what
was
causing
the
problem.
C
B
What
ends
up?
Oh,
I
see
the
deletion
365.,
sorry
yeah.
A
A
B
Package
and
then
just
for.
A
B
A
D
A
B
A
Otherwise,
it
throws
a
throws,
a
an
assertion,
saying:
hey
you're
not
allowed
to
do
that,
and
so
you
know,
there's
a
bunch
of
extra
logic
added
to
the
to
the
to
this
module
to
try
and
keep
track
of
the
buffers
that
were
being
created,
and
all
that
but
and
part
of
that
is
to
you
know,
is
to
keep
things
alive
and
keep
them
actually
in
lists
that
say:
okay,
well,
I've
already
created
a
pointer.
I've
already
created
a
buffer
which
covers
this
area,
so
don't
create
a
new
one
and
that
kind
of
stuff
gotcha.
E
A
Okay,
so
I
will
I'll
leave
that
on
there
just
to
see
if
we
it's
until
it
closes
out,
but
there's
the
issues:
okay,
submission
open.js
world.
A
F
A
F
D
F
F
A
F
F
A
F
Okay,
so
I've
got
a
pr
going
on
the
examples,
repo
and
there's
a
comment
on
my
pr
that
we
might
want
to
talk
about
as
talk
about
as
a
group.
F
A
F
So
the
comment
essentially
says
that
we
sh
we
should
at
least
maybe
once
mentioned
that
node
api
was
formerly
previously
known
as
napi.
Does
that
make
sense,
or
do
we
just
want
to.
E
G
Yep
yep
yep
this
this
is
this
is
pretty
prominent
right,
so
so,
like
a
c
based
api
guaranteeing
abi
stability
across
different
node
versions
was
javascript
engines
and
then,
before
the
period
you
could
put
in
brackets,
like
formerly
known
as
an
api,
because
it
is
pretty
prominent
because
it's
it's
like
it's.
It's
like
a
like
a
bullet
bulleted
list
right
at
the
top,
so
people
are
gonna,
see
that.
F
F
C
A
F
And
then,
as
I
was
looking
around,
I
noticed
we
also
have
the
abi
stable,
node
repo.
A
F
F
Correct-
and
we
might
want
to
look
at
the
readme
there,
because
I
had
some
questions
there.
I
actually
have
a
pr
in.
F
Progress
so
you
know
I
could
do
the
same
thing
and
and
do
the
one-time
call
out
that
it
was
previously
known
as
napi.
But
if
we
scroll
down,
we
have
badges
right,
and
so
we
do.
We
want
to
update
those
badges.
D
F
Now,
if
we
look
at
the
assets
directory,
we'll
see
that
there
are
all
of
these
badges
are
in
the
assets
directory.
A
F
Right
exactly
so,
one
idea
would
be
to
create
a
whole
new
set
called
or
we
could
keep
the
name
again.
This
is
all
part
of
the
discussion
yeah.
What
we
want
to
do
here.
A
A
F
Yeah,
I
think
it
does,
because
again
it's
it's
under
the
hoods,
it's
not
out
where
everybody's
viewing
the
documentation,
yeah.
Okay,
I
will
do
that
and
then
there's
one
other
thing
on
the
readme.
F
So
that's.
F
Okay,
okay,
okay,
that's
everything
I'll
get
an
I'll
get
a
prn
on
api,
stable
node!
Also,
oh,
and
I
think
I
think
the
readme
even
says
it's
a
proof
of
concept.
If
you
look
closely,
I
mean
we
don't
leave
it,
but
we
should
definitely
change
that.
A
A
G
A
A
G
A
reasonable
thought:
well,
an
object
has
has
keys
and
values
right.
So
so
I
mean
so
does
an
array
right.
Then
you
can
actually
treat
it
as
an
object
and
get
get
the
zero
and
the
one
and
the
two
as
strings,
but
I
mean
which
one
do
we
choose
right
because,
like
once,
we
do
we're
kind
of
stuck
with
it.
G
That's
you
know
like
if
we
go.
If
we
do
it
for
an
array
and
only
an
array,
then
then
it
would
be
like
you,
you
can
you
can
forego
the
well
actually
can
you
because
there
are
such
things
as
sparse
to
raise
in
javascript
right
like
you
can
have
like
0,
1,
2
and
957
set
and
and
everything
in
between
is
undefined
right.
G
G
B
Maybe
we
can
look
and
see
how,
if
we
treat
arrays
as
vectors
and
objects
as
maps
like
they
like
that
one
comma
suggested,
we
can
see
how
how
that
plays
out,
maybe
because
I
think
that
would
be
a
reasonable
thing
like
if
you
iterate
over
array,
you
would
get
its
elements,
but
then,
if
you.
G
Yeah,
that's
that's
that
that
makes
sense
right,
because
we
we
already
we
already
kind
of
support
conveniences
like
that
right,
like
we
have
like
the
square
bracket
operator
for
assigning
a
property
right,
and
so
so
that
kind
of
puts
us
in
that
that
sort
of
territory.
You
know
where
okay,
well,
if
you
can
access
it
randomly
you
know,
then
why
can't
you
iterate
over
it?
You
know,
like
you,
can
over
such
things
that
that
also
have
these
square
bracket
operators,
so
yeah
yeah.
D
A
And
then,
let's
go
back
up
to
because
I
think
that
was
the
only
new
one.
This
one
is
closed.
Okay,
so
we
talked
about
this
last
time
when
we
we
sort
of
yeah
we're
saying
we're,
not
sure
it
belongs
in
any
in
into
the
node
add-on
api
itself.
But
you
know
we
had
some
ideas,
but
it
sounds
like
the
the
original
poster
is
won't
necessarily
have
time
to
to
think
about
it.
So
he
closed
it
out
I'll.
Take
it
off
our
list.
A
E
I
have
digging
into
the
the
copyable
persistent
matrix
taking
intake
into
that,
but
I
found
that
there
is
semantics
difference
from
the
reference
itself,
since
we,
if
we
cannot
technically,
we
are
all
the
node
api
and
the.
E
E
Npm
value
that
you
say
every
other
npi
value
it
is
copio
and
on
the
node,
an
app
nappy
reference
is
not
copyable,
but
if
we
make
an
app
reference
copy
of
or
add
a
new
class
describing
a
copyable
reference,
I
found
it.
It
is
very
easy
to
move
the
copy,
the
reference
to
another
and
it
might
be
released.
E
G
And
not
just
not
just
for
threads
right
like
like,
if
you
create
some,
if
you
create
a
copyable
reference,
that's
essentially
an
api
reference,
get
value
and
an
api
create
reference
right.
So
so
so
then
so
then
you
can.
You
can
quite
liberally
and
inadvertently
create
a
whole
pile
of
references
right.
E
E
G
D
G
Like
ref
and
unref,
but
but
still
still,
it's
very
easy
to
lose
track
of
the
of
the
ref
count.
You
know,
and
and
basically
you
can
accomplish
the
same
thing
by
just
by
just
just
reffing
it
I
mean
we
do
have
like
a
ref
method
to
increase
the
reference.
So
so,
basically
the
the
copy
assignment
would
be
like,
like
ref
and
the
sign
right
yeah.
So
so
I
mean
in
that
sense
we
could.
G
We
could
do
it
as
as
like
as
a
convenience,
because
we
already
have
ref
and
so
for
for
the
few
people
who
need
to
call
ref.
They
can
just
now
do
a
copy
assignment.
G
G
Well,
there
would
well,
let's
find
out,
what's
what's
going
on,
I'm.
G
Well,
we
just
say
an
api
delete
reference,
that's
what
we
do.
So
if
the
reference
is
not
null
and
if
suppress
destruct
was
not
set,
then
an
api
delete
reference.
That's
all
we
do
right,
but
the.
G
Actually,
okay,
when
you
reset
you
there's
a
reset,
and
so
so
then,
okay,
you
can.
You
can
actually
call
an
api
delete
reference
from
reset,
so
if
you
like,
set
it
to
something
else,
okay,
so
I
mean.
G
To
zero,
yes,
I
think
so
it
deletes
the
reference
that
was
stored
inside
the
the
c
plus
plus
object,
and
then
that
c
plus
plus
object
becomes
empty.
So
I
think
reset
is
basically
like:
okay,
you
you
it
hollows
it
out.
Basically,
and
then
you
can.
A
G
So
we
do
ref
but
explicitly,
and
we
do
unref
explicitly.
So
I
guess
what
I
I
guess.
What
this
looks
like
is
that
our
wrapper
is
very,
very,
very,
very
thin
right,
so
it
doesn't
add
any
sort
of
like
it
doesn't
map
the
the
c
api
to
any
sort
of
you
know
c,
plus
plus
level
copying
or
anything
like
you
have
to
explicitly
ref
things
and
but
yeah
so,
but
then,
basically
yeah.
This
can
be
implemented
on
top
of
this
class,
meaning
that
it's
not
immediately
necessary
for
us
to
implement
right.
A
G
D
G
G
G
Yeah
exactly
yeah
and
and
yeah
I
I
don't
think
we
can
do
that.
G
I
mean
yeah,
you
can
you
can
still
well,
I
mean
yeah
yeah.
If
you
abuse
it
then
it'll
crash
right,
I
mean
you
can
do
you
can
do
a
ref
from
a
secondary
thread
and
then
that's
game
over
but
but
yeah.
I
guess
you're
right.
It's
pretty
good
right
now,
so
yeah
it
may
make
sense
to
just
leave
it.
On
the
other
hand,
you
know
in
the
in
the
c
api,
if
you,
if
you
don't
use,
know
that
on
api,
then
then
there
is
nothing
preventing
you
from
making
a
copy
of
it.
G
Right
like
like
it's
just
a
it's
just
an
napi,
ref
right,
that's
what
you
have
and
you
can
you
can
copy
that
variable,
because
it's
really
just
a
pointer.
You
can
copy
it
any
number
of
times
right
and
you
can
pass
it
into
any
number
of
threads
as
long
as
the
threads
themselves.
Don't
make
any
c
api
calls
involving
that
value
right
or
that
pointer.
G
So
so,
but
while
you've
passed
it
to
a
thread-
and
you
may
expect
it
back
at
some
future
time-
you
can
also
use
it
on
the
main
thread
in
the
meantime,
like
you
can
increment
the
the
reference.
So
you
can
say
something
like
you
know,
an
api
create
reference
and
then
you
know
start
the
thread
pass
the
reference
into
the
thread
and
after
the
thread
is
started,
you
can
say
an
api
reference,
ref,
that's
perfectly
fine
and
then
there's
there's
a
value,
there's
a
copy
of
it
on
the
thread.
G
But
you
know
the
the
the
maintainer
understands
that
that
that
is
there
only
for
the
purposes
of
passing
it
back
later.
So,
for
example,
if
they
do
if
they
use
a
threat,
safe
function
and
they
pass
the
reference
back
as
a
piece
of
data,
then
the
reference
is
once
again
on
the
on
the
on
the
main
thread
and
it's
safe
to
to
make
api
calls
to
it,
and
it
is
a
copy
of
the
reference
right.
So.
E
I
I
I'm
hesitant
on
calling
this
operation
like,
say,
copy
semantics.
It
seems
like
we
are
treating
the
nappy
ref,
the
value
being
a
like
say.
The
ownership
is
still
unique
and
we
are
going
we
in
the
cases
you
imagine
it's
like.
We
moved
the
ownership
to
another
and
then
moved
back
to
the
function
so
and
in
the
others
the
on
the
top
of
the
issue.
That
is
a
example.
E
E
G
Well,
okay,
I
mean
if,
if,
if
you're
uncomfortable
with
this,
then
then
I
I'm
fine
with
that
like
what
we
have
now
is
okay
by
me,
so
we
can
just.
We
can
just
conclude
that
yeah.
I
would,
I
would
say.
A
E
A
G
A
G
D
G
A
F
D
D
A
A
A
In
terms
of
issues,
so
let's
look
at
there
any
issues.
People
want
to
bring
forward.
A
E
Comment:
it's
it's.
The
reddit
confirmed
back
label
in
this
one.
E
I
have
updated
the
reproduction
to
reflect
the
weak
reference
crash
on
the
weekly
reference,
that
is
to
say,
we
have
it's
not
like
a
ver,
very
identical
to
the
blacky
test
case
or
my
internal
observation,
but
it's
quite
it's
quite
similar
in
the
case
there
is
the
difference.
Is
that
how
the
risk
connection
between
the
rough
space
finalized
and,
let
us
say
another
in
not
environment,
teardown
and
the
cabbage
collection
on
the
reference
deletion.
G
Yeah,
I'm
trying
I'm
trying
to
reproduce
it
locally
right
now,
I'm
building
node.js
with
with
like
debug
symbols
and
stuff,
so
I've
I've,
I'm
ready
to
reproduce
this
like
soonish,
okay,.
E
G
E
Test
case
for
the
add-on
api
just
making
the
crash
much
more
harder
to
for
developer
developers
to
figure
out.
What's
what's
happening,
it's
so
it
it
can
be
implemented
in
the
pure
c
api.
E
E
It's
very
similar.
Okay,
the
you
know
the
gc
is
hard
to
determine
when
it
will
happen.
So
I
just
crafted
a
case
that
forced
the
gc
to
happen
in
time.
G
Yeah,
okay,
yeah,
that's
good,
yeah
I'll
I'll!
Try
to
I'll
try
to
whittle
this
down
to
like
something
that
we
can
add
to
the
test
and-
and
it's
probably
going
to
end
up
have
being
in
like
node
api,
not
js
native
api,
because
I
don't
think
we
can
use
like
the
gc
and
js
native
api
because
it's
supposed
to
be
like
you
know,
engine
agnostic,
so
I'll
I'll,
see
where
I'll
add
the
test
case.
But
I'll
try
to
whittle
it
down.
G
Sounds
good,
so
you
know
I.
I
also
had
one
thing:
we
have
enough
material
for
an
napi
or
node
api
in
this
case
version
eight,
because
we,
if
you
look
at
abi
stable
note,
I
think
it's.
I
have
that
tracking
issue.
Sure
it's
406
in
abi,
stable,
node.
G
Yeah
that
one
no
yeah,
that's
one
yeah,
so
so
all
of
these
things
are
complete.
Now,
right,
like
we
have
free
seal,
we
have
more
property
defaults.
We
have
type
tagging
acing
cleanup
hooks.
This
is
a
lot
of
material
right
yeah.
So
you
know
none
of
this
is
going
to
go
into
10.
So
then,
so
then
it's
it's
a
question
of.
A
G
Yeah
exactly
so
so
yeah.
I
just
wanted
to
bring
this
up,
because
I
think
I
think
it's
we
have
a
good
accumulation
and,
and
a
lot
of
these
things
have
been
there
for
a
while.
So
you
know
the
the
the
most
recent
one
is
this:
is
this
file
name
thing
and
and
and
that
one's
probably
not
gonna
make
it
into
into
eight,
but
but
all
the
others,
I
think,
are
plenty
good.
You
know
to
land
as
a
as
a
version.
Eight,
okay,
so.
G
E
By
mentioning
the
major
versions,
I
just
come
up
with
that:
the
uncle
exception
behavior
we
didn't
have
a.
We
have
a
question,
didn't
come
to
a
conclusion.
E
That,
in
note
of
just
call
3
65
and
one
zero.
A
A
D
Here
we
go:
okay,
oh
yeah.
This
one.
E
A
G
Yes,
yes,
that
would
be
better
yeah
and
then
have
a
have
a
default
value.
Yeah
yeah,
having
no
having
no
in
the
in
the
in
the
name
of
the
option,
just
kind
of
makes
it
more
complicated
to
think
about
what
what
it
means
for
it
to
be
there
or
not.
If
it's
just
true
or
false,
then
it's
that's
pretty
clear.
A
G
A
G
C
Yeah
that.
C
A
G
Yeah,
actually,
I've
kind
of
reproduced
it
locally,
but.
G
Is
what
I'm
seeing
is
that
that,
like
the
the
tests
are
saying
that
they
execute
it
successfully,
but
then
I
get
a
notification
saying
you
know
oops
node.js,
exited
unexpectedly,
or
something
like
that
and
and
so
what
I've.
What
I've
seen
is
that
in
a
lot
of
our
tests,
we
we
spawn
like
child
processes,
and
I
I
suspect
that
we
do
them
inconsistently
and
in
some
places
we
don't
check
for
a
clean
exit.
D
G
Crashing
in
some
places,
and
so
what
I'm
hoping
to
do
is
to
sort
of
just
like
I
grepped,
I
prepped
all
the
tests
for
for
like
spawn
sync
and
and
a
lot
of
them
are
doing
it.
And
so
what
I'm
hoping
to
do
is
to
just
have
one
facility
that
that
correctly
spawns
synchronously
and
correctly
checks
for
a
clean
exit.
Right.
D
G
Just
use
that
facility
in
all
the
tests
and
and
then
we'll
see
which
one
crashes
and
so
I'm
thinking
submit
a
pr
that
does
that.
I
find
that
the
tests
don't
pass,
and
so
I
raised
an
issue
to
fix
the
test
and
then
and
then
the
solution
to
that
issue
would
be
would
be
a
prerequisite
for
landing
the
pr
that
fixes
or
that
introduces
this
consistent
checking
for
child
process
exit
and
then
and
then
we'll
have
it
narrowed
down.
Hopefully,
yeah.
It
makes
sense.
A
G
Yeah
yeah,
I
mean
that's,
that's
a
reference
issue,
not
not
a
threat,
safe
issue.
So
unless,
unless
the
threat
say
function
test
is
making
use
of
of
references
in
exact
in
exactly
that
way,
then
then
they
may
or
may
not
be
related
right
right,
okay,
so
so
yeah
I
mean,
let's
just
tackle
all
the
crashes.
A
E
We
didn't
we
just
using
the
using
statements
in
no
that
only
already.
G
G
A
A
This
is
another
one.
I
know
kevin
you've
been
involved
in
that
one.
B
G
The
the
the
the
knowledge
one
yeah,
it's
actually
more
than
just
convenience
right,
because
if
you
want
to
check
for
null
or
undefined
you
have
to,
you
have
to
call
an
api,
a
type
of
twa
right,
because
that's
what
ends
up
happening,
if
you,
if
you
say,
is
null
that
that
calls
type
of
and
if
you
say,
is
undefined,
it
calls
type
of
again
so
in
terms
of
performance,
this
would
be
better
because
then
you
can.
You
can
check
the
resulting
value
of
a
single,
an
api
type
of
call
for
both.
D
G
That
that
they
that
they
call
an
api
type
of
and
yeah
exactly.
A
G
B
G
Unless
unless
the
compiler
optimizes
it
behind
our
backs,
I
I'm
not
100
sure,
but
if
we
want
to
be
100
sure
we
should
just
store
the
value
and
and
then
just
you
know,
compare
ourselves
that
would
be
100
sure.
A
Like
it
has
to
do
with
worker
termination
and
there's
a
case
where,
like
we
have,
we
have
code
that
basically
says
throws
a
fatal
exception.
If
it
can't
do
what
it
needs
to
do,
because
our
and
I'm
pretty
sure
a
rush
now.
A
But
it
sounds
like
there's
a
case
where
in
termination
you
know
it's
the
throw
we're
doing
we're
during
termination.
So
we're
already
shutting
down
and
the
throw
basically
says.
Well,
you
can't
call
into
javascript
and
we've
overloaded
exception,
the
like
pending
exception,
which
confuses
me
a
little
bit,
but
that's
sort
of
independent.
I
think
because
I
you
know,
having
thought
about
a
little
bit,
it
almost
seems
to
me
like.
A
Well,
we
probably
still
do
want
to
be
crashing
because
you
know
you're
trying
to
set
an
exception,
and
maybe
there's
some
cleanup
or
something
like
that.
What
I
don't
know
is-
and
maybe
you
know
gabriel-
is
these-
the
environment
cleanup
hooks.
G
The
the
cleanup
hook,
the
the
function,
signature
for
a
cleanup
hook.
Let
me
just
double
check.
Yeah
the
the
function.
Signature
for
cleanup
hook
is
simply
a
return
value
of
void
and
it
accepts
a
void
star.
So
there
is
no
more
environment,
it
doesn't,
it
doesn't
receive
an
environment,
therefore,
it
cannot
use
the
environment
and
so
so
by
by
then.
This
is
just
a
matter
of
just
freeing
a
pointer.
That's
about
all.
You
can
do,
there's
no
calling
into
anything
anymore
during
a
clean
up
hook.
A
A
E
A
E
E
G
A
Oh
right,
okay,
so
you're
thinking
that
one
will
be
called
when
the
termination
method
is
triggered
as
hey
the
environment's
shutting
down
and
once
that
runs
that
finalizer
runs
the
add-on
better
make
sure
it
doesn't
do
anything
else,
yeah,
exactly
yeah
yeah.
That's.
G
Yeah
I
mean
you
know,
this
was
kind
of
the
point
of
of
an
of
an
add-on.
Class
right
is,
is
to
to
to
have
proper
construction
and
destruction
so
basically
map
the
maybe
map
the
add-on
to
the
live
cycle
of
a
c
plus
class
instance
right,
and
so
so
you
know
either
you
use
set
instance
data
directly
or
you
use
the
add-on
class
and
then
and
then
all
your
data
will
be
destroyed.
G
G
During
during
add-on
finalization
right,
let
me
just
double
check
that
js
native
api
h,
so
set
instance
data.
Yes,
it's
a
it's
a
it's
an
api
finalize,
so
the
so
the
function
pointer
type
is
napi,
finalized,
meaning
and
void.
Star
void
star.
So,
yes,
you
can
still
call
into
the
environment.
It
gets
called
earlier
than
the
cleanup
hook.
A
E
Recently,
since
I
have
been
testing
the
finances,
so
even
though
we
can
call
into
the
javascript,
those
javascript
cannot
create
any
timers
or
any
other
async
function
asynchronous
those
editing
will
be
will
be
closed
immediately
after
the
javascript
execution
ended,
so
it
it's
rather
meaningless
in
this.
That.
A
G
G
So
then
how
do
you
you
know
you're,
throwing
an
exception
for
a
very
good
reason.
You
know:
how
else
are
you
gonna
indicate
to
the
user
that
they're
supposed
to
be
an
exceptional
condition
right?
You
can't
throw
an
exception
anymore,
because
javascript
is,
you
know,
shutting
down
right.
So
then,
what
isn't
the
fatal.
A
G
G
That's
an
interesting
I
mean,
even
even
in
pure
javascript,
it's
an
interesting
question
right.
If
the
if
the
environment
is
shutting
down,
and
you
want
to
throw
an
exception,
you
know
who's
going
to
who's
going
to
hear
it.
You
know
what
it's
going
to
prevent
it
from
turning
into
like
an
unhandled
fatal
error.
G
Know
ideally,
you'd
want
to
communicate
to
some
parent
thread.
Saying:
hey
it's
you
know
an
exception
has
happened,
but
but
I
think
that
I
think
that's
application
specific,
because
I
was
just
thinking
like
couldn't
we
couldn't
we
handle
this
internally.
Like
you
know,
if
you
you
know
like
this
converting
automatically
to
to
to
to
like
to
a
javascript
exception
from
from
like
a
c
plus
exception,
you
know
this
automatic
conversion.
G
Couldn't
we,
you
know,
make
that
conversion
a
function
of
of
whether
set
instance
that
that
was
our
recall
or
or
the
finalizer
for
set
instance
that
was
already
called
and
not,
but
no,
I
don't
think
we
can,
because
we
also
don't
know
what
to
do
if
it's
already
been
called.
That's
that's
something.
The
application
needs
to
decide.
A
Right
that
that's
yeah,
exactly
like
that's
sort
of
where
I
was
my
thought
process
was
like
we,
we,
you
know,
without
the
application
figuring
out
that
it's
okay,
it
really
should
be
like
no.
An
exceptional
thing
happened.
We
have
no
other
way
to
communicate.
It
should,
as
long
as
there's
a
way
for
for
the
application
to
know
they're
shutting
down
and
do
and
sort
of
override
that,
then
that's,
probably
all
we
should
think
about
yeah.
I'm.
G
Just
thinking
like
I
mean
at
the
at
sort
of
the
the
node
core
level
right,
you
know
our
our
workers,
I
don't
I
don't
know
if
they
have
like
an
exit
code
right,
because
because
that
would
be
the
way
to
go
right,
like
a
process,
has
an
exit
code
and
that's
a
pretty
unambiguous
indication
that
something
went
wrong.
If
that's
not
zero
right,
I
don't
know
if
a
thread
has
like
a
or
if
a
worker
has
an
exit
code.
G
A
A
That's
what
I
was
trying
to
figure
out
like
how
you
know.
I
don't
think
we
should
necessarily
you
know,
change
things
automatically,
but
can
the
can
the
add-on
know
that
it's
termination
has
been
called
and
say?
Well,
okay
termination
has
been
called,
therefore
I'm
I'm
just
you
know.
If
something
goes
wrong,
I
don't
care,
I'm
not
going
to
try
and
throw
an
exceptional
just
yeah.
A
Data,
okay,
okay,
I'll,
add
that
in
there
and
we
are
10
minutes
after
so
I
think
we
should
close
out
for
today
anything
else.
We
should.
We
absolutely
have
to
talk
about
before
we
finish.