►
A
You
can
all
hear
me
wherever
you
are
wherever
you
are
at
the
very
least
alice.
So
what
are
we
doing?
Let's
remember
we
are
doing
our
extension.
We're
going
down
the
dependency
rabbit
hole
again
and
we
are
going
to
generate
some
models
for
saturday,
so
so
we're
going
to
patch
cv
bentool
and
that's
where
we're
at
so,
let's
see
so
we're
creating
our
system
context
right
so
and
within
that
we
were
taking.
I
think
we
were
taking
a
git
repo.
A
So
if
we
look
at
the
top
left
or
top
right,
my
bad
so
we're
going
to
take
a
git
repo.
Oh
I've
realized
there
is
so
much
fun
stuff.
We
can
do
with
this.
Oh
boy!
This
is
going
to
be
great.
So
so
imagine
you
wanted
to
scan
binaries
within
a
ci
job,
and
so
you
could
create
the
repo
add
the
ci
job
inject
the
flow
which
then
either
does
the
scanning
or
pumps
out
the
output
and
then
scans
somewhere
else.
So
this
will
be
nice
and
fun.
A
So
nice,
nice
little
nice
little
expel
there.
So
let's
do
this
collector,
dataflow
cv,
control,
equals
system
context,
dfml.system
context,
all
right.
So,
let's
give
it
the
upstream
the
overlay
in
the
orchestrator:
okay,
just
the
upstream
stream
equals
collector
dataflow
all
right.
Okay,
so
there
we
go
and
there
we
go
and
we
want
a
dot
deployment.
So
so
we've
been
tooled
data
flow,
so
tcp
bend
tool
equals
so
see
so.
A
I
can't
remember
what
we
did
for
deployment.
I
think
we're
just
going
to
go
ahead
and
make
it
blank,
so
let's
call
scanner
all
right
so
for
results
in
scanner.
Print
results,
fantastic,
okay,
so,
let's
see
what
kind
of
operations
do
we
want
in
this
thing?
Is
this
re-running
on
command?
No,
it's
not!
Okay!
Where
are
we?
A
So
bang
minus
two
will
give
us
the
second
to
last
command,
so
do
clear,
bang,
minus
two
and
then
test
one
there.
We
go
so
now
just
reload
on
save
if
it
wants
to
go
at
all
computers,
computers,
computers,
okay,
so
it
should
throw
an
error
about
that.
It's
fantastic!
Okay!
So
remember
we
want
to
create
this.
We
want
to
create
a
draft-
I
told
terry,
so
yeah
and
what
were
we
doing
here?
So
we
wanted
to
take
a
repo.
A
We
wanted
to
take
a
git
repository,
so
inputs
and
I
think
we've
already
most
of
this
stuff
up.
You
know
what
that,
let's
just
just
do
this
so
from
typing
import
new
type.
A
A
A
A
And
this
is
not
ergonomic,
okay,
not
the
code.
Hopefully
the
code
is
ergonomic,
my
actual
economics,
okay,
so
I'm
check
24.
okay.
So
so
we
take
a
repo,
we
turn
it
into
a
directory.
What
do
we
want
to
do?
Well,
we
want
to
scan
it.
Let's
go
ahead
and
grab
in
our
overlay.
A
For,
let's
see
so,
we
would
like
to
let's
go
ahead
and
throw
in
our
should
I
overlay
on
this
one
and
we'll
do
both.
Should
I
and
cv
event
tool
so
so
scan
repo
to
directory,
let's
say,
create
a
new
type.
A
A
Just
throw
this
in
try
except
block
all
right,
so
this
is
a
new
code
that
we
know
wrote
to
create
a
new
primitive,
so
we
say
pass
reception
as
e
or
we'll
actually
say
raise
so
we'll
raise
the
exception.
But
first
we
want
to
say
where
what
is
this
definition.
A
A
A
A
Oh
I'm
like
lethargic
all
of
a
sudden
holy
okay,
just
like
out
of
nowhere.
Okay,
come
on
so
that
one's
when
you
quit
caffeine,.
A
Ctx
results,
and
so
what's
nice
about
this.
Well
we're
going
to
bubble
up.
You
know
we're
going
to
bubble
up
anytime.
We
have
like
a
directory
or
something,
and
we
can
make
that
a
new
context
that
we
are
a
new
extractable
thing
right.
So
right
now
the
extractables
we
had
that
whole
thing.
Okay,
so
this
is
now
now
now
we
is
cv
bentool.
A
So
we
had
this
whole
thing
where,
when
we
went
to
do
the
extraction
we
had
to
preserve
the
paths
and
the
logs
and
I
believe,
anthony-
and
I
can't
remember
who
else
was
looking
at
that,
but
yeah
so
anyways.
So
we
will
we'll
bubble
them
up
in
the
context
and
that
way,
that'll
it'll
all
be
preserved
right,
and
so
because
our
contexts
are
linked,
then
we
always
maintain
context.
A
A
So
what
am
I
doing
here?
Well,
I
am
creating.
A
I
know
I
know
I
write
out
of
order.
Okay,
so.
A
A
All
right,
so
what
did
we
do
so
we
created
basically
we're
gonna,
go
through
all
the
arguments.
A
Now,
let's
see
what's
up
my
hard
disk
appears
to
be
all
right.
There
we
go
okay,
so
that's
what
we
want
to
create
an
input
for
so
let's
create
an
input
for
it,
and
this
doesn't
exist,
discover
input,
type
right,
but
we'll
make
it
exist.
So
we
can
do
that
and
we
can
make
it
exist,
all
right,
so
discovery,
input
type
and
it's
a
our
unknown
input.
Input
of
unknown.
A
You
know
I'm
also
realizing
that
we
should
prefix
these
new
types
with
the
module
that
we
find
them
in.
So
somebody
please
please
please
remember
that,
because
that
would
really
help
we're
going
to
get
all
sorts
of
mixed
masters
context
on
things.
A
Unless
we've
already
done
that-
and
I
don't
remember
so-
it's
quite
possible-
let's
see
so
I'll-
do
another
one
yeah
I'd.
Probably
we
may
have
done
that.
Actually,
no,
but
you
know,
let's
double
check
right,
so
input
of
unknown
type,
all
right,
fantastic
right,
so
that
goes
nowhere
overlay
class,
it's
not
defined
hey.
We
found
a
bug,
we
created
a
bug
and
then
we
found
it
right.
Isn't
that
the
way
to
go.