►
From YouTube: Node.js N-API Team meeting - Feb 25 2019
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
B
B
B
B
B
B
A
C
A
C
A
C
A
A
A
A
A
A
D
B
A
A
A
D
B
D
Yeah
so
I
was
I
was
just
thinking
that,
after
having
spoken
about
this
at
length
with
with
Rafaela
I
was
thinking
that
I'm
not
sure.
If
this
is
within
scope
right
because
we
dropped,
we
dropped
the
module
for
for
a
very
good
reason
right,
because
we
kind
of
assumed
that
that
no
native
add-ons
would
be
fronted
by
by
index
JSS
right.
But
but
if
he,
if
his
is
not,
then
then
you
know
this
kind
of
configuration
management.
You
know
where
is
my
config
file?
You.
D
This
to
be
to
be
within
scope
for
native
modules.
Right
is
what
I
was
thinking,
because
you
know
there
there
are
ample
ways
of
locating
past
config
files,
and
JavaScript
is
the
best
way
to
do
that
right.
The
purpose
of
a
native
module
is
to
expose
functionality
that
is
otherwise
unavailable
right
roles,
I
think
it's
like
ma'am
yeah.
No,
no
go
go
ahead.
That
that's
my
basic
point
like
we
really
want
to
take
this
on
and
I
understand
that
it
was
available
before,
but
that's.
A
D
A
D
I
mean
look,
look,
look
a
look
at
it.
This
way
right!
So
all
there
all
the
stuff
that
you
write
in
the
body
of
the
unit
function
right,
it's
basically
just
stuff
to
decorate
the
export
right
now
now,
if,
instead
of
doing
that,
you
you
just
you
put
a
single
binding
on
the
export
subject
in
your
init
function
and
I
do
all
your
decorating.
When
somebody
calls
that
binding
right,
then
then
you
can
pass
the
config
file
into
that
binding
and
then
it'll
decorate
it
accordingly.
E
E
A
A
D
D
So
all
right,
so--okay
so
again
you
create
a
function
called
initialize
right.
It's
accepts
two
arguments,
yeah
airports
and
a
path
I
don't
and
it
returns
the
exports
back.
But
now
the
exports
are
properly
decorated,
as
they
would
have
been
in
a
normal
add-on
in
response
to
to
just
initializing
the
atom.
A
D
Yeah
and
I
mean
I
mean
Rafaela
did
say
that
that
he
is
providing
his
add-on
as
an
NPM
package
right
right.
So
so
so
you
know
he
can.
Just
you
know,
do
like
start
equals
index
RJ,
and
all
that
right.
I
mean
I,
understand
that
his
his
those
consuming
his
module
may
be
loading
the
the
add-on
direct
right
and-
and
so
that's
why
he
he
doesn't
want
this.
This
in-between
index
dot
JSP,
but
okay.
Yes,
he
has
lost
that
ability.
A
D
A
D
Of
the
bindings
of
the
add-on
could
be
a
function
called
initialize
which
which
accepts
the
exports
and
then
just
adds
all
the
other
stuff,
and
it
can
also
set
the
config
pilot.
Why
does
it
get
the
pass
well
from
from
from
Java
stuff
like
okay,
the
JavaScript
looks
like
this
con
something
equals
require
my
add
right.
D
Yeah
then
you
say,
and
then
you
say:
add-on
dot,
initialize
bracket,
add-on,
comma
underscore
underscore
dear
name
and
then
okay,
sorry
add-on
equals
add-on,
not
initialized
bracket,
add-on,
comma
underscore
underscore
dear
name,
so
in
effect,
you're
calling
back
into
the
add-on
passing
the
add-on
itself
back
into
the
add-on
and
the
path.
And
so
now
the
add-on
on
the
native
side
has
everything
it
needs
to,
but
to
take
into
account
that.
D
A
D
So
that's,
but
at
that
point
since,
since
you're
passing
the
journey
from
JavaScript
right,
they
don't
can
you
can
do
any
any
kind
of
like
path
management.
You
feel
like
path
or
join,
build
release.
You
know
you
can
search,
you
can
do
whatever
you
want
and
then
pass
pass.
What
you
what
you
know
to
be
a
correct
path
into
the
module,
whereas
on
the
native
side
you
have
very
limited
resources,
because
you
know
I
mean
Rafaela.
Right
now
is
doing
some.
Some
super
expensive,
like
path
traversal
and
all
that,
but
I
mean.
D
So,
okay,
the
only
thing
is
and
and
and
I
think
this
is
what
what
what
what
is
what
his
objection
is,
is
that
if
you,
instead
of
requiring
their
native
modules,
udl
open
your
native
module,
then
then
it's
not
going
to
pass
through
the
index
J
yet
right,
and
so
it
won't
be
properly
initialized
right,
but
like
you're
not
supposed
to
DL
open
a
native
module
you're
supposed
to
require
a
native
module
right.
You
know
and
okay,
fine
segi
we're
even.
D
Like
okay,
so
so,
even
if
you
require
the
dot
node
file,
even
then
it
going
you're
only
going
to
get
the
one
binding,
which
is
initialized,
which
you
then
have
to
call
right.
So
so
it's
going
to
change
the
way
like
if
his
consumers
are
not
saying
like
require
package
name
but
they're
saying
require
package
name,
slash,
build
slash,
release,
flash
his
module
dot
node.
If
they
say
that,
then
this
won't
work
right
because
they're
bypassing
the
whole,
the
whole
NPM
packaging
system
and
just
loading,
the
add-on
direct.
D
B
D
So
that's
one
one
scenario
under
which
it
was
failed.
The
other
one
is
if,
if,
if
as
he
puts
it,
they
they
require
the
module
from
the
native
side
of
their
own
native
module
right,
but
but
even
even
then,
if
they,
if
they
acquire
the
global,
require
function
from
JavaScript
and
then
they
say
require
packaging.
It
should
still
work.
We
can
write,
the
node
will
do
all
the
resolution
and
everything
so
like
I
would
really
have
to
see
the
the
the
use
case
where,
where
it
is
impossible
to
go
through
Java,
you
know
so.
A
I
think
IO,
like
they
work
around
I,
have
no
question
that
there's
you
know
this
is
kind
of
what
I
was
thinking
that
you
should
be
able
to
get
it
from
JavaScript
is
that
is
it
is,
is
the
use
cases
you
know?
Is
it
nice
enough
not
to
have
to
do
that
to
add
in
something
like
a
get
path?
You
know,
Nappi
get
back,
yeah.
D
Yes,
and
no
right,
because,
like
okay,
the
past
that
we
do
get
and
the
past
that
the
module
did
have
so
far
right
that
he
was
using
his
is
probably
correct.
You
know,
but
you
know
there
are
like,
as
I
said
in
the
comments,
there
are
such
things
as
sibling
right,
and
so
so
you
know
the
things
that
that
DL
open
does
to
actually
to
turn
the
past.
D
Let
you
give
it
into
like
an
actual
inode
from
which
it
can
M
map
you
know
is
something
that
is
internal
to
DL,
open
and,
and
it
may
be
highly
platform
specific
and
so
on
and
so
forth.
The
best
we
can
do
is
is
is
to
provide
whatever
path
we
were
given
as
to
which
which
which
was
the
result
of
our
own
path
resolution.
You
know
turning
turning
there,
the
require
parameter
into
like
an
actual
path
on
the
file
system,
because
we
do
some
of
that
right.
All
right
it.
D
You
know
I
mean
99%
of
the
time,
it's
correct,
precisely
because
we
have
pretty
pretty
standard
package
structure
right.
So
so
you
know
symlinks
shouldn't
be
a
problem.
Like
you
know,
the
the
Maya
donk
node
inside
build
release
should
be
an
actual
file
like
99.99%
of
the
time
it
should
not
be
assimilated,
okay
and
and
if
so
far
it
has
not
been,
and
that's
why
it
has
worked
for
for
fil-a
right.
D
So
you
know
his
use
case
would
be
addressed
if,
if
we
were
to
to
provide
such
meta
data-
but
you
know
not
so
many
people
need
it,
nobody
nobody's
coming
come
up
so
far.
Saying
that
you
know
I
need
it.
You
know
the
big
people
have
had
many
questions
about,
know
that
on
API,
but
this
has
never
been
one.
You
know,
and
we
we've
been
out
there
for,
like
it's
still
possible,
is
the.
A
First,
dive
more
like
do:
we
think
that,
like
gloating
and
like
is
loading
a
config
file,
something
that's
typical.
D
Well,
yeah
I
mean
sure.
Ok,
that's
it
I
mean
that's
what
I'm
p.m.
packages
are
for
right.
You
have
an
index
dot,
j,
s8,
x,
GS
knows
its
own
path
right
because
no
gives
it
to
it.
Yeah
yeah
file,
name
and
your
name,
and
then
it
can
build
paths
off
of
that
which
are
which
are
part
of
the
package
and
and
access
any
any
files
that
it
beings
appropriate
from
from
from
its
own
package
right
and
provide
absolute
path
to
those
files
to
whoever
whoever
requires
it
right.
But
it's
all
done
from
JavaScript.
A
D
Yeah
there
were
two:
there
were
two:
there
were
two
arguments
in
favor
throughout
from
the
module.
One
was
that
most
modules
are
fronted
by
an
index
J
s
and
then
they
internally
they
load
the
native
add-on
and
and
then
you
know
they
massage
it
and
whatever
and
present
a
nice
JavaScript
friendly
interface
via
their
index,
dot
JSON
require,
and
the
other
one
was
that
if
we
keep
the
module
parameter,
then
then
we're
we're,
throwing
us
in
throwing
ourselves
into
the
fray
regarding
the
SM
module
right,
because
now
we
are,
we
are.
D
We
are
sort
of
providing
the
common
j/s
formats
except
its
native,
not
JavaScript,
and
so
we
were
at
that
point.
The
discussion
around
the
SM
was
still
pretty
fresh
and,
and
we
were
afraid
that
okay,
we're
going
to
publish
an
API
and
now
we're
going
to
have
to
support
yes,
I'm
explicitly,
because
our
format
is
now
essentially
commonjs,
because
we
have
the
module
area
of
the
module
dot
export.
D
And
so
so
we
said
that
because
because
most
modules
are
funded
by
index.js
file
yeah
and
we
can
just-
we
can
just
do
the
lowest
common
denominator,
which
is
take.
These
functions,
dump
them
into
JavaScript
land
and
let
JavaScript
plant
worry
about
turning
that
into
an
ESN
module
or
a
common
J's
module
or
whatever
that.
That
was
basically
the
rationale,
and
so
we
went
with
the
absolute
lowest
common
denominator,
which
is
take.
This
exports
object,
decorate
it
and
give
it
back
to
JavaScript
yeah.
D
D
I
mean
that's
what
the
gist
does
that
I
pasted
into
the
issue
yeah,
so
it
basically,
it
basically
does
what
every
other
example
does,
except
the
binding
that
that
that
is
thrown
back
into
JavaScript
there's
only
one
binding,
not
the
actual
bindings,
that
that
do
the
useful
work.
It's
just
one
binding,
which
you
can
call
with
the
path
and
with
the
export,
and
then
when
that
binding
run
it
takes
the
path
it
takes
the
exports
and
it
decorates
the
exports
and
gives
it
back
so
so
so
then
it's
like
a
two
step.
I'm.
A
A
Create
the
object
because
I
mean
the
whole
thing
we
need
to
show
is
simply
that
you
can
get
the
path
in
the
add-on
right
like
in
this
year.
So
it's
like
whether
you
within
what
you
go
on
to
use
it
for
doesn't
matter
as
much
as
the
oh
yeah.
Okay,
I
can
get
a
path
because
you
know
I
got
it
from
javis
I
got
into
JavaScript
I
added
int,
I
added
it
in
so
now
it's
available
to
my
module
and
the
module
yeah.
D
D
But
but
anyway,
III
saw
saw,
saw
my
gist
and
he
said
that
that's
great,
but
I
can't
use
that.
So
so
then
I
don't
have
another
solution
for
him,
except
if
we
start
brainstorming,
you
know
what
kind
of
method
that
a
module
might
need,
and
at
that
point
I'm
thinking
that
you
know
configuration
data
management
is
not
something
that
native
modules
should
be
doing.
I
do
that
on
the
JavaScript
side
and
just
take
all
the
stuff
that
you
can't
do
on
the
JavaScript
side.
D
Like
oh
I,
don't
know
a
high
high
high
efficiency
system
logging
you
know,
and
and
and
do
that
on
the
native
side,
but
you
know
the
where
to
log
to
and
what
the
address
is
of
the
various
servers
are
and
stuff
like
that
that
doesn't
belong
in
a
native
module,
except
as
a
parameter
received
from
JavaScript.
You
know
figuring
out
where
you
are
on
the
file
system.
Yes,
you
can
do
it
on
the
native
side,
but
it's
a
thousand
times
easier
in
JavaScript.
Well,
yes,
I'm.
A
More
from
the,
if
know,
if
you
know
99%
of
modules
didn't
have
a
file
that
could
grab
the
pass
yeah
and
you
know,
then
maybe
we
should
have
a
method
if
they,
if
99
percent
are
gonna,
have
that
then
simply
documenting
to
show
you
know
and
how
you
do
it?
If
you
how
you
do,
it
is
probably
good
enough
because
what'swhat's
the
yeah,
you
know
I
guess,
what's
the
fundamental
objection,
then
to
doing
what's
listed
there
what's
listed
where
well
like
you
said
he
said
he
can.
You
know
the
your
example.
Isn't
gonna
work.
A
D
Yeah
because
he
doesn't
want
to
go
through
JavaScript,
he
he
wants,
I
I
guess
what
he
wants
is
is
for
people
to
be
able
to
load
his
dot
note
file
directly
and
then
and
then
there
is
no
index
J
s
in
between
that
that
will
that
will
basically
forward
like
set
its
own
module
dot
exports
to
be
equal
to
the
add-on
after
having
properly
initialized
the
add-on
with
a
path
and
everything.
So
so
so
then,
at
that
point
he's
he's
sort
of
out
of
the
loop.
D
The
actually
you
know
what
he's
not
because
because
he
does
say
that
that
he
does
acquire
the
global
require
function
for
Mike
from
library,
from
the
the
the
main
module
M
and
then
and
then
he
can
do
like
a
require
dot
resolve
you
know
of
his
own
package
and
then
he'll
get
the
path.
So
you
know,
as
long
as
he
provides
an
NPM
package
that
that
node
can
resolve.
D
Then
he
can
just
say:
okay
from
the
native
side,
he
can
say:
okay,
you
know,
nappy
call
function
require
comma,
my
package
name
right
and
then
she
gets
back
or
require
dot
result
right.
So
so
they're
like
get
resolved
from
required,
then
call
resolved
with
my
package
name
and
he
gets
back
an
absolute
path
and
he
can
work
with
that.
Okay,.
B
E
D
A
D
Yeah
yeah
I,
think
I
think
he's
mostly
concerned
about
about
his
dependents,
like
he
doesn't
want
his
dependents
to
have
to
change
their
code
in
the
way
they
load
his
add-on
and
right.
This
may
be.
This
may
be
able
to
give
him
that
and
I'm
gonna
I'm
gonna
change
the
example
to
to
try
and
do
that
and
see
if
that
works,
if
he
can
get
back
to
where
various
package
is
located
and
then
start,
you
know
dealing
with
his
own
directory
structure
rather
than
having
to
traverse
directories
at
depth.
A
D
A
D
Well,
you
know
it's
it's
it's
nothing
fundamental
right.
It
can
be
done
just
by
retrieving
a
global
global
and
then
retrieving
a
property
of
that
global,
which
is
a
function
that
you're
calling
the
function.
You
know
it,
it's
a
note
specific
thing.
So
if
we
were
to
add
it
I
mean
we
can
add
it
as
deeply
as
we
want,
but
but
it's
nothing
fundamental
right,
so
so
I'm
not
sure
if
we
should
add
it
to
core
I.
Don't
think
we
should
add
that
to
core,
because
notably.
A
D
B
D
A
D
E
D
Yeah,
so
it's
also
starting
starting
to
go
down
this
path
of
providing
information
about
the
module
from
from
core
is,
is
something
that
I
would
I
would
be
very,
very
cautious
with.
On
the
other
hand,
one
can
argue
that
that
you
know
if
we
want
native
add-ons
to
be
on
par
with
Java,
Script
add-on
and
sooner
or
later,
we'll
want
them
to
have
your
name
and
file
name
and
all
these
things,
because
JavaScript
packages
have
that
every
single
Java
rendered
or
common
J's
module
has
a
dear
name
and
a
file
name.
So.
A
That's
why
I
thought
those
two
like
I
wouldn't
want
to
add
the
module
back
in,
because
the
structure
of
that
you
know
will
vary
against
implementation.
Yet
what
you
can
you
can
imagine
that
if
you
have
a
native
module,
you're
likely
always
gonna
have
a
name
and
you're
always
gonna
pass.
Now
you
can
think
of
dynamically
ones
that
aren't
loaded
off
the
file
system,
maybe
the
past
or
something
different,
but
yeah.
B
B
D
A
D
A
D
A
D
So
that
that
can
get
rather
fat,
oh
and
it
would
it
would.
It
would
also
one
oh
I,
guess
it
wouldn't:
yeah
yeah
you'd
have
to
have
the
hash
and
then
an
API
to
access
the
hash.
Okay,
that's
that
that's!
If
we
were
to
do
this
and
that's
probably
how
we
would
do
this,
but
the
thing
is:
we
already
have
a
hash
of
modules
out
there.
So
let's
not
have
another
one
kind
of
thing
right.
D
D
D
Yeah,
because
because
yeah
each
worker
has
its
own
has
its
own
isolate,
so
so
you
know
we
we
will
not
find
okay,
no
every
time
you
have
every
time
you
have
a
global,
we
stash
the
end
in
a
private
property
of
the
global
right.
So
you
know
our
worker
will
certainly
have
a
new
global
because
it
really
isolates,
and
so
it
will
not
find
the
end
vanilla
created
laser
there.
So
yes,
Fred,
okay
and.
E
A
B
A
A
A
D
A
D
A
A
D
I
I
haven't
gotten
around
to
trying
to
land
my
PR
again,
but
I
think
it's
green.
Now
that
I
figured
out
that
that
on
OS
10
you
always
have
to
compile
with
with
hidden
visibility.
Otherwise
you
get
really
weird
symbol
interactions.
If
you
have
two
2's
OSS
have
all
the
same
symbols.
It
doesn't
seem
to
know
how
to
properly
isolate
them
from
one
another
and
how
to
properly
resolve
like
it
was
insane.
D
I
was
looking
at
the
gdb
back-trace
and
it
was
like
finding
underscore
no
except
binding
underscore
no,
except
in
terms
of
the
frame
sequence
and
then
binding
and
then
binding
underscore
no
accept
and
I'm
like.
Are
you
insane?
How
can
you
jump
from
one
SL
to
the
other
in
a
single
code?
Call
stack
like
they
should
really
be
aware
of
each
other
and,
and
so
I
was
like.
Okay,
that's
it
disability.
Hidden
I
took
me
about
a
week
to
figure
that
out
so
yeah
I'm,
not
sure
you
know
it.
D
The
only
thing
that
that
that
I
can
take
away
from
that
is
I'm,
not
sure.
If
we
should
maybe
document
that
for
OS
10
people
should
add
visibility:hidden,
because
you
know
if
you
have,
if
you
have
well
I
guess
yeah,
if
you
have
workers
and
the
module
will
be
initialized
multiple
times,
but
the
handles
will
not
be.
D
On
the
other
hand,
it
okay,
if
you're,
looking
at
a
large
project
right
and-
and
you
have
two
different
dependencies
somewhere
deep
down
the
tree-
that
both
use
the
same
native
addon
right,
but
they
use
different
versions
of
the
native
add-on.
Then
on
OS
10
you
might
get
into
clashes
like
I.
Did
you.
D
Because
you
have
two
different
shared
objects,
loaded
into
the
same
process,
and
now,
if
OS
10
does
this
as
this,
this
improper
boundary
you
set
up
and
and
then
the
codes
are
start
hopping
between
the
two
mehrabad
ons,
because
the
symbol
just
happened
to
resolve
that
way,
then
you
know
we
may
want
to
recommend
that
that,
for
the
sake
of
OS
10
people
build
with
with
visibility
equals
hit.
Are
things
are
same?
Some
are.
D
Believe
Linux
Linux
does
a
very
good
job
of
scoping.
Scoping
shared
object,
so
so,
okay,
so
the
primary
symptom
that
that
I
noticed
was
that
if
you
have
a,
if
you
have
a
global
static
variable
inside
there's,
like
a
class
like
you
have
like
static
something
equal
or
static
in
something
equals
five
all
right.
Well,
you
can't
initialize
it,
but
whatever
and
and
that
class
is,
is
declared
inside
a
header
file
right,
which
is
included
from
from
from
two
different
versions
of
the
code.
Right
because
in
I
know
that
on
API
we
build
two
module.
D
A
D
So
because
they're
not
templated,
they
are
declared
global
and
they
become
symbols
in
all
the
modules
that
include
matthew,
dot,
h,
right,
and
so
what
I
noticed
was
when,
when,
when
I,
when
I,
when
I
add
such
as
a
static,
integer
and
and
I
take
the
pointer
of
it
on
Linux
and
I
print
out,
the
pointer
value
on
Linux
I
get
two
different
values.
I
know
what
and
I
get
the
same
value
I
get
the
same
value
twice
and
that's
impossible,
because
these
should
be
located
at
different
addresses.
C
D
Then
that's
why
I'm
getting
an
address,
but
it's
replacing
it
with
the
same
address
for
the
two
different
modules.
So
I
don't
know
what
what
algorithm
the
linker
is
using
to
to
resolve
the
addresses,
but
it
is
wrong
and
it's
only
wrong
on
the
West
10,
because
it
works
fine
on
AIX.
It
works
fine
on
every
other
unit,
okay,
except
for
OS
10.
It
even
works.
Fine
on
FreeBSD,
upon
which
it
was
ten,
is
based.
It.
D
E
D
A
E
D
You
know
it's
the
same
code.
Realistically,
if
the
symbol
name
is
the
same,
that
chances
are
it's
the
same
code
right,
but
sometimes
just
sometimes
you
know
you
get
an
object,
especially
if
it's
references
right.
You
get
a
reference
there
what's
needed
in
in
one
module
in
one
shared
object
and
you're
using
it
in
the
other
shared
object.
So.
E
A
A
D
And
then
you
will
not
have
name
class
name
clashes,
because
you
know
chances
are
you
will
instantiate
or
you
will
create
a
specification
or
whatever
that's
called
in
people
plus.
When
you
actually
declare
the
symbols,
you
would
do
that
inside
an
anonymous
namespace
and
then
and
then
the
unique
symbol.
Value
for
for
each
use
of
the
class
will
be
different,
and
so
you.
D
This
problem,
but
we
don't
have
that
we
have
classes
which
are
just
declared
just
like
that
and
and
like
you
know
more
and
more
I'm,
beginning
to
see
that
we
are
not
just
purely
in
line,
because
we
are
adding
symbols
to
people's
add
on
you
know,
because
we
don't
have
these
templated
classes.
So
order
is.
B
D
All
our
classes
are
templated,
we
are
adding
symbols
to
people
people's
add
on,
and
so
so
all
these
add-ons
written
know
that
on
API
will
have
all
these
symbols
right.
No,
so
so
you
know
on
OS
10.
This
is
kind
of
dicey
right,
because
now,
if
you
have
two
different
add-ons
written
and
know
that
on
API,
they
both
have
certain
symbol
and.
A
D
E
D
D
A
I
think
production
is
mass,
is
mostly
Linux
and
probably
then
followed
by
Windows,
but
still
yeah.
It's.
We
definitely
need
to
figure
out,
because
this
is
the
first
time
I
mean
we.
We've
been
running
those
tests
and
I
I'm,
hoping
it's
not
just
that
any
one
of
our
tests
could
have
crashed
like
we
added
a
new
tat,
you've
added
something
new
that
caused
it
to
crash
right,
yeah.
D
Well,
well,
let
me
think
so:
yeah
I,
specifically
I
specifically
added
a
new
class
and
I
added
it
to
to
both
add
on,
and
they
are
the
symbol
overlap.
So
so
you
know
oh
and
and
then
I
and
then
I
did
the
same
thing
with
with
just
just
a
plain
v8,
a
dog
and
they're.
The
symbol
overlap
too,
but
but
because
the
code
is
the
same
in
both
cases
you
know
in
in
in
the
case
of
the
simple
v8
add-on,
I
couldn't
get
it
to
crash,
because
the
code
was
too
simple
right.
B
B
D
So
you
know
I
can
I
can
keep
I
can
keep
investigating,
but
but
the
immediate
solution
is
to
protect
your
symbols
on
on
the
on
the
OS
pen
side,
with
with
visibility:hidden
okay.
So
now
that
I
know
that
I
think
about
that
one
thing
we
might
want
to
do
is
so
so
that
we
don't
have
people
who
change
their
config
files
when
they
build
this.
Is
you
know
we
can?
D
We
can,
just
you
know,
add
some
macros
at
the
top
of
map
pH,
which
is
define
visibility
hidden
by
default
and
then
and
then
just
add,
or
in
every
single
global
static
as
a
symbol
that
we
create
with
with
this
visibility
hidden.
So
you
know
I
need
that.
That's
good
practice
right,
like
you,
want
to
limit
the
symbols.
You're
exposing
right.
D
Like
but
one
thing
I
I'm
kind
of
hazy
about
this
in
node,
we
have
this.
We
have
this
definition
called
node
module,
export
right
and-
and
so
you
could
mark
one
of
your
symbols
as
an
add-on
maintainer,
you
can
mark
one
of
your
symbols
as
node
module
export,
meaning
that
okay,
please
exclusively
export
this
symbol,
but
if
we
have
that,
then
isn't
that,
because
we're
already
building
with
visit
with
default
visibility
hidden.
D
E
D
D
A
D
Yeah
exactly
why,
whatever
whatever
we
provide
that
that
people
don't
realize,
may
adds
to
their
symbol
table,
we
should
no
longer
add
to
their
symbol,
table
exactly
okay,
all
right
so
so
yeah,
so
that
that
that
could
be
another
to-do
list
is
to
mark
all
our
symbols
as
hidden
and
I'm.
Okay,
yeah
I
know.
This
is
something
we
do
in
nodes
periodically.
You
know
we
go
through.
We
go
through
the
the
binary
using
nm-,
saying
that
hey
what
here
and
then
modulus
it
yeah.