►
From YouTube: Node.js Loaders team
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
All
right,
so
our
agenda
for
today,
first
up
is
the
pr
that
jacob's
been
working
on.
So
why
don't
we
start
with
that
and
jacob?
Do
you
want
to
tell
us?
A
B
I
believe
it's
done
the
only
thing
blocking
it
is
derek's
blocking
review
from
like
several
weeks
ago.
He
had
mark,
he
had
blocked
it,
thinking
that
it
also
included
phase
two,
and
he
had
some
like
concerns
about
how
phase
two
would
be
done,
and
then
his
blocking
review
was
just
never
removed.
A
Okay,
well,
let's
see
if
he
comes
today,
I
looked
at
it.
I
haven't
looked
at
it
today.
Let
me
open
it
up,
but
I
looked
at
it
like
earlier
in
the
week
and
I
thought
there
were
a
lot
of
comments
from.
I
don't
know
their
name
ada95
antoine
have
all
of
those
been
resolved.
B
B
B
B
A
C
B
Just
took
his,
he
did
it
as
a
suggestion
in
the
pr,
and
I
accepted
the
suggestion,
thinking
that
it
would
be
fine,
because
I'm
like
okay,
this
is
just
words,
but
then
it
was
like.
The
error
message
was
like
probably.
B
Length,
it
was
complaining
that,
like
there
was
a
disagreement
in
columns
or
something-
and
I
so
I
thought
it
was
too
long
and
I
was
like
oh
no,
it's
only
66
characters.
So
half
an
hour
later
I
found
figured
out.
I
didn't
like
the
colon.
A
So
all
right,
I
will,
if
that,
if
so
we'll
try
to
track
down
derek,
I
will
try
to
find
time
soon
to
review
this.
Hopefully
this
weekend,
I
I
want
to
get
guy
to
to
say
where
he
stands
on
it,
because
it's
been
several
weeks
since
he
looked
at
it,
and
this
is
a
lot
of
his
code.
A
So
I
want
to
make
sure
he's
approving
this
before
we
merge
it
in
so
if
we
can
I'll
try
to
reach
out
to
him
but
yeah
other
than
that,
can
you
summarize
what
this
does
in
the
end
like?
Did
it
go
a
little
any
beyond
what
we
were
initially
talking
about
as
the
kind
of
merging
a
couple.
B
Hooks
only
ever
so
slightly
the
only
additional
thing
that
it
does
that
beyond
what
we
originally
talked
about
was
optionally,
allowing
format
in
the
resolve
as
a
return
from
the
result
book.
A
Merge
completes
merging
the
hooks
into
resolve
and
load
and
and
still
global
reload
code.
I
guess
yeah
and
then
format
can
optionally
be
returned
from
resolve
yeah
and
that's
nothing.
B
To
do
essentially
yeah
and
it
included
test
cases
for
both
when
format
is
included
and
when
it's
not
included.
So
it
all
checks
out.
A
All
right:
well,
this
is
fabulous.
So
let
me
yeah
congratulations
here.
Does
anyone
else
have
any
thoughts
on
that
or
notes
on
it.
A
Let's
see
okay,
so
here
we
so
this
is
where
we
are
then
wait,
which
one
is
yours.
This
one.
A
B
Yes,
actually
should
I
put
that
as
a
comment
or
in
the
body
of
my
pull
request,
and
then
it
will
automatically
close
this
one
when
mine
gets
merged.
Sure.
A
Okay,
I
mean
whether
or
not
it
does
it
automatically.
We
can
follow
up
and
and
do
it
but
yeah
it
would
be
good
to
link
them
somehow,
maybe
put
it
in
the
top
comment
on
yours
so
that
it's
like
really
it's
pretty
prominent
okay.
So
then.
A
So,
okay,
so
this
part,
did
you?
Did
you
potentially
already
do
this
too?.
B
Yeah
so
that
pull
request
that
I
opened
and
then
you
were
like
that
the
pull
request
I
opened.
I
think
it
was
like
a
few
days
ago
and
you
commented
saying
it's
not
done
yet,
because
the
the
68
pull
request
needs
to
go
first
right,
and
I
said
yes,
so
that
pull
request
is
the
one
that
updates
this
list.
That
says
what
the
remaining
work
is.
A
D
A
A
And
it
does
this
of
the
exception
on
unknown
file.
Types
is
now
thrown
in
and
load
yes,
okay.
Here,
I'm
going
to
add
this
to
the
let's
see
the.
A
To
the
other
thing,
so
here
I'll
just
copy
this.
A
Yeah
we
should,
if
it
doesn't
say
all
this
in
the
like,
if
these,
if
these
things
aren't
mentioned
in
the
description
at
the
top,
we
should
probably
add
it
so
that.
B
A
Okay,
I
added
it
to
the
google
doc
too
all
right.
So
then,
this
pr
is
huge
or
at
least
covers
a
lot
of
ground
yeah.
So,
okay,
so
once
we
land
it
so
yeah
bradley.
If
you
have
time
to
review
it
too,
we
should
get
a
lot
of
eyes
on
this
because
it
gets
us
three-fifths
of
the
way
to
finishing
this
list
and
then
the
next
and
then
then
we're
right
up
at
the
cusp,
then
of
of
chaining
all
right
so
and
which
I
think
is
the
other.
A
A
This
pr
spr,
oh.
A
I
mean
this
is
this
is
why
I
split
this
into
you
know.
I
was
suggesting
that
this
be
at
least
three
pr's,
because
yeah
it
can
and
the
other
thing
is
like
big
prs.
Just
it
almost
gets
exponentially
more
difficult,
because
then
it's
like
it's
hard
to
get
people
to
review
them,
because
it's
such
an
investment
to
review
all
that
code
yeah.
So.
B
I
think
consolidated
methods
was
ended
up
being
a
necessity
and
that's
why
that
ended
up
getting
incorporated.
E
B
It
seems
like
there
are
quite
a
lot
of
like
use
cases
to
consider
for
training,
and
happily
people
have
started
to
chain
in
on
what
their
use
cases.
B
A
I
mentioned
just
this
morning:
there
are
these
other
documents
in
this
repo,
so
like
resources,
so
that
I
suggested
that
whoever
started
that
issue
with
the
other
loaders
just
open
a
pr
to
add
them
to
this,
and
it's
a
little
easier
to
follow
than
like
comments
on
an
issue
thread,
and
we
have
this
use
cases
this.
A
I
copied
this
from
something
I
forget
what
it
was.
I
think
the
oh
there
was
a
use
cases
thread
I
think
in
as
part
of
the
loader's
next
steps.
I
think
people
yeah
in
loader's
next
steps
that
humongous
thread.
That's
got
like
300
comments.
Now
at
one
point,
people
were
talking
about
their
use
cases,
so
I
just
kind
of
skimmed
through
the
whole
thread,
picked
out
the
comments
that
mentioned
use
cases
and
consolidated
them
into
this.
So
the
idea
was
to
try
to
make
this
stuff
easier
to
find.
So
you
don't
have
to
read.
A
You
know
40
pages
of
comments
to
find
what
you're
looking
for
but
yeah
these
are.
You
know
these
are
just
markdown
files
in
this
repo.
So
if
anyone
can
feel
free
to
open
a
pr
and
then
we
can
just
approve
it
at
a
meeting,
speaking
of
which
yeah,
if
people
don't
mind
giving
approvals
to
these,
I
don't
know
if
they
need
to
or
what
but
so
yeah.
These
are
just
the
minutes
for
last
time.
So
unless
there
are
any
other
notes,
I'll
merge
this
in.
B
A
Name:
okay,
we'll
deal
with
this
later
after
the
meeting,
but
yeah
sure,
or
you
could
submit
a
suggestion
on
here
and
I'll
click.
I
do
I
don't
know
about
it
right,
oh
anyway.
Yes
I
mean
we
can.
There
can
always
be
pr's
afterwards
too,
but
all
right
so
moving
on
the.
Let
me
open
the
other.
B
Sure
so,
basically,
there
are
two
kind
of
leading
approaches
for
how
to
tackle
chaining
the
first
one
recall
I
called
it
the
next
one,
because
that
seems
to
be
the
most
important
thing
about
it,
whereby
next
is
an
alias
to
the
next
loader
and
then
the
other
one
uses
a
done
to
say
stop
so
for
the
next
one.
It
is
potentially
a
little
bit
more
robust
than
the
done
one,
but
I
believe
that
the
next
one
comes
with
a
lot
more
gotcha
kind
of
complexity
than
the
done
one.
B
I
think
for
the
next
one.
You
must
call
next
and
if
you
don't
things
fail
in
a
very
weird
way,
so
there's
some
extra
handholding
that
we
could
potentially
do.
But
when
I
was
implementing
the
current
stuff
which
basically
uses
next,
I
even
ran
a
foul
of
some
of
the
gotcha
complexity
stuff
and
I'm
like
okay.
I
wrote
this
then
if
anybody
should
be
okay
with
it.
B
D
E
D
B
E
B
Cool
so
yeah
with
the
next
kind
of
approach.
It's
the
design
of
it
is
a
bit
bespoke
so
for
very
pervasive
patterns
that
you
use
next.
This
is
basically
this
behaves,
basically
the
opposite
of
how
those
work,
which
I
believe
many
users
will
find
very
counter-intuitive
and
be
quite
confused,
because
they
will
expect
it
to
behave
like
how
most
other
things
that
this
appears
to
be
similar
to
behave
and.
A
B
B
A
generator
express,
I
believe,
those
are
the
two
examples
that
I
have
so.
E
A
D
A
D
B
D
B
Used
express,
admittedly,
in
a
couple
years,
because
it's
kind
of
died,
but
from
what
I
remember,
if
you
didn't,
maybe
it
was
an
older
version.
It
was.
It
worked
exactly
as
you
expected
when
you
didn't
call
next
and
you
only
needed
to
call
next
explicitly
with
an
error.
If
you
were
trying
to
opt
into
the
error
handling,
I
think
you're.
A
So
I
think
you're
thinking
of
handlers
for
particular
routes
like
if
you
have
like
you,
know,
app.get
slash
foo.
You
don't
need
to
call
next
unless
you're
gonna,
unless
you're
throwing
an
error
from.
A
But
if
you're
creating
middleware
like
something
that
parses.
C
A
The
middleware
function
that
gets
called
like
you
know
the
name
comes
from
it
gets
called
in
between
express,
receives
the
request,
but
before
it
gets
sent
to
that
function,
that
does
the
like
slash
foo,
it
express
will
run
every
middleware
function
that
is
registered
with
express,
and
so
each
middleware
function
has
to
call
next
so
that
it
goes
to
the
next
middleware
function
and
eventually
to
the
final
function,
which
is
the
handler
for
responding
to
slash
foo.
So
we.
E
C
A
Like
send
the
html
back
to
the
user,
and
if
that's
all
you
want
to
do,
then
you
don't
need
to
call
next
and
it's
not
like
anything's
hung
it's
just
like
the
function
executed
finish
what
it's
doing
and
like
any
other
function
that
finish
what
it's
doing
it
gets
whatever
you
talked
it
or
something.
So
if
you
know
that
you
don't
need
any,
you
know
if
you've
already
returned
the
html
to
the
user.
You
know
you
don't
need
express
to
do
anything
else.
A
B
I
see
how
like
these
loaders
are
more
analogous
to
the
middleware
and
how
you,
if
you
are
aware
of
that,
that
it
would
make
more
sense
for
you
to
expect
it
to
behave
like
that.
But
I
think
the
vast
majority
of
users
will
be
more
familiar
with
the
route
handler
part
of
expect
of
express
and
if
they
haven't
touched
like
a
custom
middleware
thing
before,
then
they
will
not
be
familiar
with
that,
and
so
I
think
that's
probably.
C
A
That's
a
fair
point.
I
I
think
one
other
thing
we
have
to
keep
in
mind
is
like
something
that
was
said
a
long
time
ago
is
like
there
are
not
going
to
be
that
many
people
writing
loaders.
You
know
like
we
saw
with
that
list
of
like
loaders
out
in
the
wild.
I
mean
yeah,
there's
whatever
a
dozen
or
something
but
but
like
most
typical
apps
aren't
gonna
have
a
custom
loader
there's
like
someone's
gonna
write
a
typescript
loader.
A
You
know
like
there's
gonna,
be
whatever
a
few
dozen
loaders
written
and
on
mpm,
but
that's
it
like
the
average
application.
Developer
isn't
going
to
be
doing
this,
so
you
know
that's
just
something
to
keep
in
mind.
It's
like
we
don't
have
to
bend
over
too
far
backwards,
because
this
is
very
much
like
a
power
user
feature.
B
Yeah,
I
just
am
concerned
that,
like
for
probably
what
I
think
most
users
will
need,
it
is
not
that
advanced
like
they
just
want
to
do
some
like
live
transpiling
of
typescript,
or
they
just
want
to.
B
Fix
a
path
in
in
some
simple
way,
maybe
like
an
alias,
but
now
we
have
import
maps
and
stuff.
So,
like
my
main
concern
is
like
don't
make
easy
things
difficult
but
like
if
we
have.
C
A
That
that's
kind
of
that's
kind
of
what
I'm
getting
at
is
that
like
we
don't,
I
think,
what
because
remember,
the
user
base
of
people
using
loaders
is
going
to
be
high,
but
the
user
base
of
people
writing
loaders
is
going
to
be
small,
so
the
the
the
writing
loaders
users,
probably
want
the
most
powerful
thing
we
can
supply
to
them.
Even
if
it's
slightly
more
complex,
you
know,
but
these
are
all
subjective
targets,
I'm
not
saying
that
next
are
done
or
one's
better
or
easier
than
the
other.
A
F
A
B
Sorry
I
had
to
go
to
the
bottom
of
the
sea
before
I
could
move
on
so
yeah
for
done
how
that
works
is.
If
you
need
to
short
circuit
and
say
like
stop,
we
have
finished
what
we're
doing.
Maybe
there's
50
more
loaders
ignore
them.
We're
done
that's
when
you
call
dutton
aside
from
that.
If
you
are
continuing
the
chain,
if
your
loader
is
kind
of
like
opting
out
and
saying,
I
have
nothing
to
do
ignore
me.
Then
it
returns,
I
think
nullish.
B
Yes,
it
would
return
knowledge.
So
it's
saying
I
have.
I
have
nothing
for
you
if
it
returns
a
valid
or
invalid
value
that
gets
accepted
and
passed
along
to
the
next
loader.
Sorry,
the
next
hook
in
the
chain
and
at
some
point
that
value
needs
to
eventually
be
a
valid
value,
but
anything
in
between
start
and
finish
is
fine
and
then,
if
it
explicitly
calls
fault
sorry,
if
it
explicitly
returns,
say
false
skip
this
file.
B
So
basically
it
uses
these
very
specific
kinds
of
returns
as
flags
about
what
to
do.
Probably
most
of
the
time
you
will
only
be
returning
some
kind
of
string,
value
or
opting
out,
and
the
I
think,
probably
more
rare
cases
or
the
rarest
of
cases
is
when
you'll
short
circuit,
because
otherwise
most
loaders
would
behave
like
in
the
opt
out
fashion
of
I
don't
know
what
this
is
continue
so
for
whoever's
question
about
what
the
differences
are
between
next
and
done,
where
the
functionality
next
provide.
B
There's
facilitate
that
done.
Doesn't
the
only
one
that
I've
seen
so
far
is
to
dynamically
manipulate
the
sequence
of
hooks,
so
someone
posted
early
this
morning
potentially
needing
to
do
some
kind
of
detection
and
then
next
call
next
some
number
of
times
or
something
and
then
influence
the
sequence
of
the
load
hook.
Order
with
next,
you
can
do
that.
B
I
don't.
I
wasn't
really
sure
why
this
user
was
saying
that
they
needed
to
do
that.
But
if
that
is
an
I
think,
yes,
yeah.
E
E
E
Oh
yeah,
it's
only
calling
the
next
loader
saying.
Please
return
me
what
you
would
get
you
could
call
it
as
many
times
as
you
want.
You
can
call
it
preemptively.
So
you
see
hey
you're,
gonna
transpile,
this
typescript
file,
the
typescript
files
importing
other
things,
like
definition
files.
F
I
even
remember
exact
details,
but
we
actually
could
not
go
that
route.
We
actually
had
to
duplicate
the
source
code
of
node's
internal
resolver,
because
we
we
couldn't
do
something
as
simple
as
like
find
this
file.
If
it
has,
the
js
extension
then
find
it
if
it
has
the
ts
extension,
because
intermediate
directories,
and
things
I
think
would
be,
would
be
skipped
over
by
the
first
resolution.
C
F
C
F
E
So
without
the
ability
to
send
extra
data,
essentially
to
the
loader
you're.
Delegating
to
you
can't
tell
it
hey,
also
look
for
these
extra
file,
extensions
and
stuff.
B
Oh
yeah
you're
not
passing
it
as
like
an
argument
in
the
the
in
the
hook
function
and
it's
not
like
a
command
line
argument.
It's.
A
A
A
Basically
any
any
loader
that
just
wants
to
do
something
with
the
file
loaded
off
disk,
so
like
resolve,
tells
node
where
to
find
the
file
on
disk,
and
then
you
know
it
just
needs
to
get
loaded
and
then
we're
going
to
do
something
with
it
before
returning
it
like,
for
example,
transpiling
it
or
adding
instrumentation
to
it.
You
know
who
knows
what
mocking
part
of
it,
whatever
the
the
way
that
this
example
is
written,
is
that
like
in
this
case
next
is
nodes?
A
Well,
say
that
say
that
http
isn't
here
say
it's
just
this
loader
that
you're
working
with
okay
so
then,
and
we're
just
loading
a
coffee
file?
Okay!
So
then,
this
this
next
call
is
just
that's:
node's,
internal
load
hook,
saying
which
will
you
know
given
a
path
on
disk?
Just
read:
it
return
the
string,
nothing
else,
it's
not
going
to
validate
that.
It's
a
known
file,
format
or
anything
like
that.
A
Not
yet
so
we're
calling
next
in
order
to
you
know
like
in
the
current
the
current
examples
for
like
default
default
load
or
whatever
it's
called
default,
get
format
etc
default
at
source.
We're
calling
like
the
default
one
or
the
node
one
to
get
the
the
source
or
whatever
source
would
have
been
like.
Maybe
there's
some
other
transpiler
in
between
this
one,
and
that
one
that
like
say
this
is
the
they
say:
you're
writing
a
battle
loader.
So
there's
a
battle
loader
and
a
copy
script
loader.
A
So
the
coffeescript
loader
calls
node
to
get
the
source
converts
it
to
javascript.
The
babel
loader
gets
coffeescript's
output
and
then
converts
it
to
more
javascript.
But
anyway,
that's
that's.
The
idea
here
is
like
this
can
call
nodes.
So
in
the
in
the
next
approach,
that's
possible
because
it's
like
the
loader
can
decide
whether
like
will
node
blow
up.
A
If
it
tries
to,
you
know,
do
the
default
case
like
if
the
loader
knows
that
it's
got
an
http
url,
then
it
shouldn't
be
calling
next
with
that,
because
that'll,
like
node,
won't,
will
error
on
that.
Is
this
kind
of
thing
possible
in
the
in
the
don
approach
and
how
would
that
work?
A
B
Yes,
because
all
that
has
to
happen
between
start
and
finish
is
do
whatever
needs
to
be
done
so
that
node
understands
the
final
output.
B
A
Like
you
know,
this
is
the
first
function,
that's
run,
but
then
it
calls
nodes,
loader
node's
default
loader
inside
of
it
which
makes
nodes
loader
the
second
function,
that's
run,
you
know,
and
then
it
returns
back
to
the
first
one,
which
then
returns
to
the
other.
You
know
esm,
loader,
the
the
thing
that's
gonna
actually
execute,
whatever
the
final
format
and
source
are
right,
so.
B
So
yeah
this
is,
I
think,
what
I
was
talking
about
earlier
about
dynamically,
manipulating
the
sequence
that
the
hooks
run
so
next
supports
that,
but
done
does
not.
So
if
you
have
different
different
orders
that
the
hooks
need
to
be
called
in,
then
you
probably
can't
really
do
that
with
them.
Go
ahead.
E
B
E
Mean
has
to
get
a
value
from
ron,
so,
let's,
let's
go
back
to
the
coffeescript
loader,
for
example.
We're
saying
that,
in
order
for
the
coffeescript
loader
to
work
in
the
done
model,
the
default
must
always
run
so
essentially,
instead
of
having
parameters
url
context.
Next,
you
just
have
a
single
result
parameter
and
it's
the
result
of
whatever
the
thing
that
ran
before
you
yeah.
E
This
means
that
node's
default
hook
always
runs
like
you
were
saying.
This
also
means
that
if
I
don't
want
to
use
the
result
of
node's
default
hook,
nodes
default
hook
always
runs
yes,
so.
A
Doesn't
know
it's,
we
can't
always
go
to
node's
default
because
it's
like
just
not
going
to
know
what
to
do
with
some
things.
It's
not
going
to
know
what
to
do
with
an
http,
url,
etc.
It's
not
going
to
know
what
to
do
with
json
source,
etc.
So
we
need
to
be
able
to
short
circuit
so
that
we
can,
you
know,
not
be
limited
to
what
node
like
if
we're
limiting
ourselves
to
what
node
already
knows
what
to
do
with,
then
we
kind
of
don't
need
loaders.
A
B
And
done
is
the
short
circuit,
so
if
you
say
like
stop
propagation
like
event,
stop
propagation
stop,
stop
doing
anything
that
says
like
this
is
handled.
F
E
E
A
Yeah,
I
was
gonna
say
like
it
would
almost
be
useful
to
help
illustrate
your
proposal
would
be
like
take
these
two
loaders.
Take
this
whole
example
of
just
not
forget
the
other
one,
because
the
other
ones
are
resolved.
So
that's
kind
of
simpler.
This
one
is
an
example
of
chained
load.
Hooks,
there's
only
two,
so
the
idea
is
like
make
it
so
that
you
can,
where
is
it
yeah,
example.com,
https,
example.com
module.coffee?
A
A
B
You'd,
have
your
http
s
loader.
That
would
return.
Some
value
that
returned
value
would
then
get
passed
to
the
next
load
hook
in
the
chain
which
you
have.
You
have
control
over
the
sequence,
a
static
sequence,
but
you
can
still
control.
C
B
B
B
If
it's
a
file,
url,
then
https
loader
should
ignore
that
you
would
probably
want
to
put
those
sorts
of
like
reading
type
loaders
rather
than
trans
transforming
loaders.
You
run
them
for
the
reading
ones.
Up
at
the
start
of
your
list,
so
https
loader
says
I
don't.
B
Next
next
and
then
whatever
the
next
quote,
is
says,.
B
E
B
E
B
B
A
Arguments
there
would
have
to
be,
in
addition
to
done,
there
would
have
to
be
like
default
load
or
something
like
that
like
we
currently
have
like
default,
get
source
or
something,
and
that
way
you
could
call
into
the
no
default
version
of
that
hook
anywhere
in
the
chain
and
get
its
results.
And
you
know
then
you'd
still
be
able
to
get
this
line,
because
you'd
be
able
to
call
nodes.
B
E
B
A
You
know
so
that
we
know
like
because
we're
going
to
need
to
do
things
like
this.
Yes,
whether
or
not
there's
a
result
from
previous
and
then
result
like
which
may
be
undefined,
because
this
isn't
the
first
it
you
know,
may
or
may
not
be
the
first
loader
because
you're,
because
it
sounds
like
you're
saying
that
the
node
the
node
default
is
always
last
in
the
chain.
So
we
can't
assume
that
there's
always
some
result
before
this,
because
this
could
literally
be
first
because
node
is
last.
A
So
I
would
say
like
take
this
example
of
these
two:
well,
maybe
these
two
and
these
three
and
rewrite
them
with
with
done
like
how
would
you
implement
these
two
examples
in
done,
and
I
think
that
would
clarify
a
lot
of
these
questions
that
people
are
asking,
because
then
we
would
see
what
the
api
is.
Okay,
cool.
F
I
think
also
one
thing
we
might
need
is
an
ability
not
just
to
call
next,
but
to
call
from
the
top
and
correct
me
if
I'm
I'm
missing
something
here,
but
supposing
that
you
want
to
know
how
to
load
a
file
pulled
from
a
web
server,
so
you're
you're
trusting
a
loader
to
pull
it
from
the
web
server,
but
then
to
figure
out
how
to
treat
that
file.
You
need
to
pull
other
files
from
the
web
server
in
the
same
directory.
E
C
E
C
Think
of
an
example
right
now,
but
there
could
be
a
case
where
the
files
are
not
one-to-one
with
modules
right,
where
there
may
be
multiple
files
to
constitute
a
single
like
esm
module.
I
I
can't
think
of
an
example,
but
that'll
be
one
reason
why
you'd
want
to
end
up
going
through
the
stack
twice
potentially.
A
B
I
think
this
touches
on.
I
think
it
was
an
issue
a
couple
days
ago,
where
they
wanted
to
be
able
to
configure
the
loaders
sort
of
dynamically
to
inject.
That
kind
of
behavior.
F
F
I
said
it's
okay,
I
didn't
introduce
myself,
it's
fine
yeah,
but
I
also
I
realize
that,
like
dynamically
configuring,
the
loader
stack
is
perhaps
a
different
concern
than
just
given
that
we
have
a
loader
stack.
How
do
the
loaders
invoke
each
other.
B
Well,
I
think
you
were
saying
you
wanted
to
be
able
to
like
add
extra
loaders
and
like
configure
how
they
configure
how
they
behave
right
and
because
those
query
parameter
stuff
right.
F
Yeah
that
mostly
the
the
the
use
case
was
just
the
node
process
has
already
booted
we
already
have
code
running
and
that
code
that's
running
is
some
sort
of
command
line
tool
that
realizes
after
the
fact
hey
now,
I
need,
to
dynamically
add
a
loader.
You
know
to
to
serve
this
command
line
use
case.
It
is
okay
that
the
code
that
I've
already
loaded
has
not
been
instrumented
or
transformed
or
loaded,
that's
fine,
but
in
order
to
load
this
next
plugin
or
file
or
asset
or
whatever,
I
will
need
this
extra
loader
functionality.
E
Banned
in
designs
previously
due
to
problems.
So
if
you
look
at
node
source
code,
we
actually
maintain
two
module
registries,
one
for
loaders
one
for
app
code,
and
we
did
that
after
bugs
showed
up
of
doing
what
you're
asking
to
do
like
modules,
don't
actually
like
being
loaded
in
partially
instrumented
states.
F
Well,
we're
not
talking
about
instrumented
we're
talking
about
something
that
node
cannot
load
at
all
until
it
gets
this
additional
loader.
So
the
the
and
I
I
I
do
under
I
do
under
understand
the
the
the
concerns,
but,
but
in
this
case
it's
you
so
you've
node
has
done
its
initial
static,
traversal
of
all
esm
modules,
they've
all
been
resolved
and
linked
and
everything
and
it
boots
up
and
now
you're
running
this
command
line
tool
and
this
command
line
tool
discovers.
E
E
I
understand
I'm
I'm
just
stating
that,
like
this
we've
had
a
similar
thing
in
the
past,
it
was
really
bad.
We
did
something
equally
bad
to
mitigate
it
basically
and
it
solved
it.
I
am
skeptical
of
this
use
case
being
more
than
a
special
case
of
a
more
general
problem.
B
I'm
thinking
if
we
were
to
address
that
use
case,
you
would
probably
need
to
have
a
loader
that
just
is
in
the
queue
before
these
things
and
it
somehow
needs
to
publicize
under
these
conditions.
You
need
to
do
this
stuff
and
I
believe
that
would
be
possible
because
of
exactly
what
bradley
said
that
nodeland
has
its
own
special
cache
and
various
things
like
that.
B
F
F
The
question
is
like
essentially
we're
telling
consumers
of
these
command
line
tools.
Look
we've
written
this
command
line
tool
to
behave
in
a
certain
way
and
to
give
you
this
functionality.
Unfortunately,
you
must
set
the
node
options.
Environment
variable
to
install.
D
E
D
E
I
don't
know
since,
since
the
issue
really
is
about
injecting
these
load
hooks,
not
about
specific
import
sites,.
B
Sorry
yeah,
so
what
I'm
saying
is
I'm
thinking
that
results
can
come
directly
from
the
previous
hook
and
then
in
context.
Potentially
we
could
have
that
be
mutable
by
the
previous
hook.
You
could
have
your
original
context
and
then
you
could
have
your
mutated
context.
B
No?
Well?
No,
and
you
could
have
your
mutated
context,
so
that's
how
you
could
kind
of
communicate
these
conditions
from
one
hook
to
another
and
the
change
in
conditions
of
the
the
former
hook
could
say.
I
know
that
this
is
going
to
be
needed.
A
We're
we're
going
to
start
to
get
kicked
out
by
the
next
group
who's
going
to
come
in
any
minute,
so
I
would
encourage
you
guys
to
wrap
this
up.
I
will
take
a
look
at
that
pr,
I'll
ping
guy
bradley.
Let
me
know
if
there's
anything
else
that
need
that
you
can
think
of
that
needs
to
happen
without
pr,
and
if
you,
if
you
just
look
at
it,
please
please
do
so
anything
else
we
should
cover
before
we
get
booted.
B
Just
a
quick
note
on
that:
if
we
can
leverage
this,
then
I
think
we
should
probably
be
okay
to
potentially
address
andrew's
potential.
Ed
edge
case
is
a
subsequent
thing
if
it's
a
smaller
subset,
because
we
won't
be
breaking
anything.