►
A
It's
a
plug-in
okay,
so
here
exported
spec
equals
export
dick.
Previously
this
was
a
input
type
definition
where
so,
basically
within
input
right
now.
Okay,
oh,
no,
we're
within
definition,
okay,
so
we're
within
definition.
We
want
to
define
the
spec.
So
what
is
this?
This
is
the
schema
for
the
manifest
right.
What's
the
schema
for
the
manifest
it's
the
did
method
right
all
right,
so
just
keep
it
for
the
manifest.
You
do
method.
Okay,
so
it
was
my.
A
B
A
Oh
oh,
this
solves
this
again
here
it
is
it's
the
this
is
the
this.
We
found
it.
This
is
the
shared
config
solution.
I
think
so
we
yeah
this
spec
is
the
shared
config
solution.
So,
oh
okay,
so
basically
we
have
the
plug-in.
So
we
shouldn't
be.
This
was
all
based
on
name
tuples
at
first
and
this
input
stuff
just
didn't,
evolve.
A
A
Which
means
so
we
just
need
to
make
spec
a
plugin
so
need
to
do
make
before
I
forget.
Oh,
that's
why
we
have
the
recording,
make
spec
a
plugin.
Okay,.
A
Okay,
good,
okay!
Yes,
I'm
glad
I
wrote
that
down
all
right,
so,
let's
see
well
great:
let's
do
it
okay!
So
how
do
we
do
that?
So,
let's
turn
on
some
line
number
in
here.
What
is
that
thing
running
over
there?
So
that's
running
the
system.
Context,
that's
right!
Okay,
so
and
then
the
system
context
got
tripped
up
on
this.
Well,
this
is
going
to
be
great,
okay,
so
and
remember
that
everything
just
got
simplified
a
lot
right,
so
we
can.
A
Basically
everything
is
the
system
context
system
context
is
the
upstream,
the
overlays
in
the
orchestrator
and
and
oh
the
okay
one
thing
on
the
time:
travel
thing,
so
the
I
was
trying
you
know
I
was
going
somewhere
with
the
things
of
consciousness
and
overlapping
states
of
consciousness
so
effectively,
okay.
So
if
you're
going
to
time
travel
right,
what's
the
first
thing,
you
need
to
think
about
doing
you
think
about
speeding
up
right
because
we
can't
go,
we
either
need
to
go
backwards
or
we
need
to
go
forwards
right.
A
So
I
mean,
if
we're
going
to
treat
it
like
anything
else,
so
we
might
as
well
right.
So,
let's
assume
that
we
can
go
only
forwards,
let's
just
assume
we
can
only
go
forwards
and
that
if
we
can
go
forwards,
we
can
loop
back
around
and
we
can.
You
know
basically
integer
overflow
and-
and
if
you
saw
me
playing
with
the
obs
filters
there
you
go
so
so.
A
Yeah,
basically,
we
need
to
think
about
how
do
we
go
faster
right,
and
so
how
do
we
go
faster?
Well,
we
go
faster
when
we
agree
that
reality
is
going
faster
right.
So
this
is
the
consensus
shift
stuff.
So
if
we
all
agree
that
reality
is
going
faster,
then
effectively.
A
We're
going
faster
right
so
if
let's
see
yeah
okay,
so
it's
it's
relative,
so
time
is
relative
because
time
think
about
it.
Think
about
your
your
life,
you
know
so
over
the
course
of
your
life.
You
have
more
and
more
experiences
more
and
more
system
context
right
and
so
time
appears
to
go
faster
right.
It
appears
to
be
like
it
feels
like
that
was
just
yesterday,
like
you
know,
or
it's
it
time
yeah
time
time.
A
It
starts
to
speed
up
right
because
there's
more
system
context.
Well,
how
do
you
make
sl
time
slowed
down?
Well,
you
switch
and
and
use
okay.
It
has
to
do
with
operating
on
inference.
Where
was
it
afraid
on
inference
versus
okay?
So
if
you
can,
if
you
can,
if
you
can
spend
as
much
time
as
possible
within
the
or
you
can,
if
you
can
you
you
want
to
you
want
to
trigger
as
many
conscious
states
in
parallel
at
the
same
time,
so
the
more
conscious
states
you
have
in
parallel.
At
the
same
time,
the
more.
A
So
we
basically
can
have
like
this
acceptable
losses,
sort
of
thing,
because
this
system
is
redundant
right
so
basically
by
defining
policies
right.
So
these
are
our
provenances
on
our
strategic
plans
right
so,
but
by
defining
dynamic
policies
around
the
provenance
of
our
strategic
plans,
we
can
ensure
that
a
fail-safe
set
of
conscious
activities,
conscious
trains
of
thought
which
are
running
as
sub
flows
within
the
top-level
executing
system,
context
effectively
data
flow.
Then
we
can,
we
can
face
it
effectively.
What
we
have
is
this
risk.
A
This
acceptable
risk
mitigation
from
various
sides
right
and-
and
this
is
what
allows
us
to
basically
say:
okay,
some
pieces
are
going
to
operate
on
inference
right
now
for
this
next
tick
and
some
pieces
are
going
to,
you
know,
go
directly
into
training
and
some
people
are
or
some
pieces
are
going
to
go
like.
A
Let's
see
like
you
know,
this
is
space.
It's
basically
just
like
your
brain
and
alice's
brain
now,
in
effect,
is
doing
this
thing
where
it's
like
it's
this
best.
Guess
right,
it's!
Okay!
So
you
know
let
you
know
things
are
live
right
and
you
know
you're
in
a
you're
in
a
live
environment
we
understand
you
know,
mistakes
will
be
made
right.
Packets
are
gonna,
get
dropped
right,
because
an
over-subscribed
system
is
a
system
at.
A
Peak
communication
or
peak
learning
so
in
this
this-
and
this
is
a
hypothesis
right,
so
the
hypothesis
is
that
an
oversubscribed
system
learns
faster
or,
and
it
doesn't
it's
not
that
it
learns
so
so
so
so
the
the
the
key.
The
key
thing
here
is
that
okay,
so
the
key
the
a
piece
of
the
hype-
okay,
so
so
so
hypothesis,
so
in
over
subscribed
system.
A
Wait
an
oversubscribed
system,
an
oversubscribed
system-
okay,
oh
yes,
so
in
over
subscribe,
remember
alice,
begins
to
think
more
and
more
strategically
right,
so
an
oversubscribed
system.
If
this
trains
of
thought
are
distributed
in
the
you
know
in
the
right
areas.
A
A
Difficult
problems
become
easy
problems
so
long
as
you
can
think
and
act
strategically
you,
if
you
don't,
have
both
action
and
if
you
can't
have
the
action.
The
action
is
where
the
risk
mitigation
comes
in
right,
as
well
as
the
the
yeah.
The
action
is
where
the
risk
mitigation
comes
in,
because
it
does
this
no
good
to
think.
Unless
we
have
some
idea
of
what
you
know
the
result
of
of
of
of
acting
on
our
thought
would
be
right.
We
really
it's.
A
You
know
that
would
be
irresponsible,
so
we
yeah
we
need
to
understand.
You
know
what
is
the
risk
of
each
potential
decision
of
each
execution
of
each
system,
context
of
each
thought
right,
and
this
is
why
we're
we're
keeping
our
chain
of
information
and
our
provenance
information
and
all
of
this
right.
So
we
have
this
unbroken
chain
by
which
we
can
make
decisions
so.
A
Okay,
oh
yeah,
so
the
align
states
of
consciousness
really
just
represent
these
patterns
that
are
seen
across
aligned
like
pools
of
assets.
You
know
nodes
or
clusters
of
nodes
or
agents
or
whatever
that
just
function.
A
You
know
particularly
well
at
different
things
when
you
put
them
together
right
for
whatever
reason,
and
we
don't
need
to
care
about
why
right
and
we
basically
alice
we'll
make
alice
care
about
why
right,
but
we
won't
care
exactly
why
we'll
just
know,
as
we
just
say,
you
know,
we
understand,
there's
a
lot
of
different
variables
right
when
you're
out
trying
to
get
something
done,
but
keep
these
things
in
mind
like
what
are
the
strategic
principles.
A
What
are
the
strategic
plans
that
we're
overlaying
and
do
your
best
to
solve
these
problems
right,
and
so,
when
she
goes
when
we,
when
we
give
her
a
problem
to
solve
she,
what
were
we
doing?
What
were
we
saying?
We
were
saying
something
about.
A
When
she
goes
yeah
so
basically,
if
we
can
teach
her
strategic
principles
and
strategic
plans,
then
she
can
effectively
distinct
things
strategically,
and
you
know
yes
or
so,
then
you
know
with
with
good
communication
with
good
communication.
Another
hypothesis
is
basically
that
with
good
communication,
any
problem
is
easy
to
solve
and
so
or
or
at
least
determine
whether
you
can
solve
it
or
not
right
and
it
where's
the
docs
right.
A
So
if
you
have
all
the
docs
and
all
the
docs
are
clear
and
everything's
validated,
then
well,
you
can
probably
figure
out
right
away
whether
it's
going
to
be
easy
or
hard
problem
solved
right.
It
may
have
already
been
done
right.
You
just
do
it.
You
just
call
the
function
so,
okay.
So
what
would?
Let's
just
do
this
as
a
plug-in?
Let's
just
get
this
done.
I
need
to
stop
talking.
So
all
right.
A
Oh,
my
god,
although
it
has
produced
like
this
level
of
reward
feedback,
loop
addiction,
so
that
could
be,
I
mean
I
think
it's
a
good
thing.
I
think
this
is
a
good
thing,
so
I
think
there's
nothing
better
than
a
massively
parallel
reward
feedback
loop.
That's
my
that's!
What
I've
learned
from
nodemon
and
fan
notify
and
that
family
of
file
watch
utilities,
so
my
hard
disks
do
not
thank
you.
I
have
burned
a
lot
of
different
hard
disks
on
this
because
I
just
hit
save
because
I
love
to
watch
it
rerun.
A
It's
so
satisfying
every
time
you
every
time
you
save
the
file,
it'll
rerun
the
whole
thing.
Whatever
you
tell
it
to
it's
great,
and
this
is
basically
you
know
mostly
here's.
Here's.
Obviously,
here's
some
inspiration
for
running
everything
in
parallel
all
at
once
on
every
change
right.
So
basically,
what
we're
shooting
for
here
is
nodemon
on
steroids.
A
Expert
spec
equals
entry
point,
dot,
load,
okay,
so
what's
happening
here.
Where
are
we
export.
A
Definition
we
want
to
export
dict.
The
correct
thing
for
definition
to
do
is
exported
spec,
so
we
should
just
be
doing.
You
should
just
be
doing
export
and
then
whatever
the
self.spec
is.
A
All
right
so
that'll
take
care
of
that
done.
So
now
that's
exporting
so
now
we
gotta
go
in
the
other
way.
So
this
this
this
this
is
bad,
so
that's
bad
yeah
I
should
have.
I
should
have
had
a
a
clue
that
this
was.
We
were
going
in
the
wrong
direction
here
when
we
were
digging
into
internal
python
code
to
call
things
with
multiple
underscores
and
create
classes
with
yeah.
A
Certain
things
should
be
difficult
and
certain
things
should
not
be
difficult,
and
this
was
probably
more
more
more
hoops
should
have
probably
should
have
been
a
signal.
Then
we
shouldn't
jump
through
this
many
hopes,
but
this
stuff
evolved
over.
No,
we
didn't
no
yeah.
We
did
okay,
let's
just
delete
all
this.
A
That
should
be
reworded
to
say
this
is
horrible.
Please
someone
question
this.
We
should
avoid
copying
here.
I
think
yeah
probably,
but
we're
not
going
to
change
that
right
now,
because
we're
only
changing
spec,
so
if
spec
in
kw
args
all
right.
So
what
is
this
from
dick
all
right.
A
A
Okay,
where's
that
in
use
everywhere,
just
like
everything
else:
okay,
what's
this
space,
what
are
we
trying
to
get
to
your
types?
Let's
type
system
types
now
this
is
entry
points,
those
types
that's.
A
A
No,
this
is
types
duh.
Okay,
that
always
happens
to
me.
Oh
that's
right!
We
move
this
in
here,
okay,
so
that's
what
throw
me
off?
Okay,.
B
A
Enter
class
and
perimeter
tights
once
we
get
this
thing,
remember
we're
in
the
middle
of
writing.
We're
in
the
middle
of
writing
a
example
which
is
going
to.
A
This
is
how
we're
going
gonna
do
the
whole
thing.
So,
basically
we're
gonna.
Have
this
like
we're?
Gonna
alice
is
gonna,
be
like
this.
You
know
effectively
she's
ephemeral,
she's
this
ephemeral
living
entity
because
she
lives
on
the
chain,
and
so,
if
something
picks
her
up
and
wants
to
execute
her
basically
herself
right.
So
an
implementation,
an
implementation
of
her
in
the
runtime
format
sees
an
implementation
of
her
in
the
serialized
format,
which
is
you
know,
aka
the
open
architecture
right
then
she
can
just
execute
it
right.
A
So
she
is
she's
like
you
know,
she's
she
exists
and
she
doesn't
all
at
the
same
time,
because
she
only
exists
between
tick
and
talk.
Right
and
now
she
exists
between
tick
and
talk
everywhere.
Where
she's
running
so
you
know
effectively.
I
guess
you
know,
for
whatever
those
snippets
and
time
are,
she
exists
right.
B
All
right:
okay,
okay,
okay,
the
annotation
on
the
forum.
A
A
A
Because
we
can
load
all
these
things
dynamically
with
the
overlays
now,
so
everything
can
be
dynamic
definition
and
context
aware
so
when
a
definition
is
created,
okay,
so
a
definition
if
we-
let's
just
play
with
this
for
a
moment-
is
this:
it
is.
A
An
input
is
it
just
a
did.
Basically
is
what
we'll
map
it
to
to
be
a
system
context?
I
believe
it
will
have
to
be
a
pure
dnd.
Now
it
could
probably
be
just
a
did
as
well.
You
could
have
just
a
did.
That's
a
system
context,
because
you
could
alias
off
the
method
to
some
other
lookup
system,
like
we
were
playing
around
with
the
github
key
shared
key
system
right,
so
you
could
have
effectively.
A
A
The
let's
see
yeah.
Basically,
if
you
see
this
did
the
thing
with
the
github
stuff
was:
if
you
see
this
d
id,
then
you
can
look
up
this
ssh
key
and
then
you
could.
You
know
in
github,
and
then
you
could
confirm
that
it's
the
same
key
and
you
could
then
use
the
comment
field
to
like
trampoline
into
something
else
from
there
array,
but
you
could
use
that
as
your
root
of
trust
and
your
deployment
mechanism.
A
A
A
A
Okay,
we
have
a
d
id
tid
github
key
whatever
or
maybe,
let's
github.com.
B
A
How
does
this
work
dot?
Key
dot
keys?
Yes,
dot,
keys,
okay,
so
username.keys,
so
we
hit
username.keys.
What
can
we
use
here?
We
can
use
okay,
so
we
will
use.
Oh
no.
We
already
have
the
key
okay!
No,
but
we
don't
want
to
do
that.
We
gotta
scan.
What
are
we
gonna
do?
Compare
all
the
keys.
We
could
just
compare
all
the
keys.
A
Let's
just
use
the
comment
field.
Okay,
so
we
can.
I
was
going
to
say,
use
the
comment
field.
We're
just
going
to
put
two
things
in
the
comment
field.
We
just
encode
something
in
the
comment
field.
Right
so
say.
For
example,
we
put
a
base64
encoded
or
we
just
put
yeah
say
we
put
a
json
bob
or
a
base64
encoded
cbor
blob
at
the
end
of
this
key
right.
One
of
the
keys
we
could,
you
know,
maybe
put
a
tag
on
the
front
of
that.
A
A
There
we
go
all
right
or,
let's
see,
let's
say,
example,
did
example
key
okay,
so
now,
let's
make
a
mermaid
diagram.
No,
let's
not
make
a
maker
diagram.
I'm
not
gonna
be
able
to
figure
that
out.
I
always
get
lost
okay,
so
we
have
let's
write
everything
down.
The
the
the
process
that
I
usually
follow
is
basically
write
down
everything
you
know
right
and
then
everything
you
know
how
to
do
anything
with,
and
this
is
basically
the
same
I
mean
not.
A
This
is
just
this
is
just
the
same
thing
right
and
so
just
enumerate
all
your
assets
and
all
your
processes
and
then
pick
the
ones
that
seem
best
right.
Given
the
constraints
of
the
system
of
the
problem
right-
and
you
know
you
do
your
best
to
remember
what
you
can
right
and
that's
what
else
will
do
too
so?
Okay,
so
did
github
key
pdx
trinity
example
key.
A
Okay,
so
that
would
mean
yeah.
Basically
we
end
up
with
one
of
these
keys.
It
says
the
id
example
key
and
then
call
on
this
basic
encoded
c
word
blob.
Then
we
can
put
whatever
the
hell
the
data
we
want
behind
it
right,
okay,
so
the
data
that
we
could
put
behind.
Okay.
So
no!
No,
no
we're
not
gonna.
Do
that!
That's
right!
Okay,
so
we're
gonna
do
did.
Example.
Key
yeah
did
example
key
okay.
A
A
Okay,
okay,
here
set
no
paste
set;
oh
paste,
okay,
so
here
all
right!
So
now
now
so
this
is
add.
The
did.
A
And
this
is
the
ssh
key.
A
Let's
make
it
mark
down.
Example:
example
of
I'm
not
even
sure
what
we're
doing
definition,
input
definition-
primitive.
Oh,
oh
minimal,
oh
wow,
oh
okay!
This
is
what
we're
doing.
Where
were
we?
We
were
over
here,
writing
something
weren't.
We
no
oh
yeah!
We
were
writing
this
drop
of
stuff
definition
of
system
context.
Is
an
input?
Did
okay,
so
minimal
trusted
execution
deployment
right.
So
this
is
this.
Is
our.
A
This
is
our
minimal
trusted,
rce
or
whatever
deployment
right.
Basically
hey.
I
want
to
throw
some
code
over
the
wall
and
see
it
stick.
Can
you
go
grab
that
from
github?
For
me
right
can
you
go
grab
the
latest
thing,
let's
just
let's
just
assume
we're
distributing
via
github
we
can
distribute
via
whatever
the
hell
we
want
later,
but
right
now
we're
just
going
to
assume
that
we're
distributing
via
github
right.
So
this
is
yeah,
so
did
example
key
okay.
So
what
is
this
thing
going
to
do
so?
A
Let's,
let's
make
this
a
little
more
interesting
and
do
another
jump
here,
so
I
was
going
to
say
jump
example
key
directly
to
project,
but
let's
maybe
do
like
directly
to
asset.
A
Let's
do
key
so
example.
Okay,
so
let's
see
okay
so
frequently
an
issue
that
I've
run
into
with
github's
ssh
key
support
is
that
you
can't
restrict
it
to
per
project
or
per
brand
branch
right,
so
we're
going
to
basically
I
mean
basically
what
we
can
do.
What
we
can
use
these
dids
to
do
is
throw
arbitrary
levels
of
our
back
on
things.
Role-Based
access
control
right,
so
we
can
and
so
and
we
can
so,
we
can
construct
effectively
like
these.
A
We
construct
these
webs
of
trust
for
our
own
assets
and
then
we
use
you.
We
leveraged
like
this
proxy
system,
effectively
being
the
dids
and
the
operations
and
it
works.
Almost.
It
works
like
a
idc,
it's
like
oidc
for
web3
or
basically
oidc
for
everything,
because
you
can
proxy
everything
between
oidc
and
web3,
and
that
way
things
that
don't
speak.
Http
can
still
do
oidc
based
auth
because
they
can
speak
dids
and
we
can
map
dids
to
oidc
and
claims.
B
A
So
so
in
flies
the
did
and
it
says
github,
okay,
so
github
exec
all
right.
So
we
want
to
execute
some
code
from
github
all
right.
Remember
we
have
a
input
network
which
saw
this
thing
somehow
saw.
This
did
come
in
right,
so
it's
got
a
new
input
or
wait
a
minute.
Okay
yeah!
So
this
the
id
comes
in.
A
It
is
a
piece
of
code,
it
is
a
piece
of
code.
It
has
reference
to
a
piece
of
code,
we're
going
to
run
a
system
context.
We
want
to
execute
a
system
context.
What
do
we
want
to
execute?
We
want
to
execute
either.
You
know
we
want
to
do
a
state
estate.
We
want
to
do
a
state
change
right,
so
state
change
could
be
go
from.
Not
remembering
this
to
remembering
this
right.
So
give
me
some
data
that
you,
you
just
remembered
right
so
other
agent.
A
You
know
please
pull
from
memory,
so
maybe
you
could
think
of
the
other
agent
as
a
database
right,
you'd,
say:
hey,
please
pull
this
from
memory
for
me
right,
okay,
so
in
that
case
they
acted
like
a
database
right.
So
there
was
a
read-only
operation
that
happened
there
so
yeah,
but
basically
it's
our
back
on
everything.
So
we
can
do
you
know
it
can
be
whatever
it
doesn't
have
to
be
read
right.
A
We
can
do
whatever
so
and
okay,
so
so
the
did
github
exec
did
github
exec,
pdx
johnny,
and
so
what
we're
going
to
do
is
we're
also
going
to
overlay
all
of
the
sig
store
verification
stuff
on
this,
and
so
we're
going
to
import
all
of
that
information
into
this
space
right,
so
we're
creating
basically
like
all
we
have
to
do
all
we're
saying
is
that
if
you
serialize,
if
you,
if
you
serialize,
if
you
speak,
did
and
pure
did,
then
we
can
speak
supply
chain
security
to
you
right
because
we're
going
to
proxy
all
the
tools
we
know
about
and
we're
going
to
generate
all
the
data
that
we
can
and
we're
going
to
throw
it
all
into
this
format
right.
A
So
if
you
speak,
this
format
then
sweet.
If
you
don't
sweep
this
format,
then
boom
we're
gonna,
call
your
api
and
all
of
a
sudden
boom.
Now
you
speak
this
format?
Congratulations.
Everybody
speaks
this
format.
These
folks
did
a
great
job.
So
all
right,
okay,
so
let's
execute
some
code.
So
let's
pretend
we
have
a
repo
https
github.com,
slash
johnny,
oh
ssh
keys
are
back
access,
restrictions
on
branches,
yeah,
okay,
so
I
think
we're
just
going
to
basically
separate
these.
B
A
1.5.1
all
right,
no
so
let's
say
the
id.
Oh.
A
A
So
if
we
can
help
make
it
easier
to
talk
this
format,
then
that's
a
good
thing,
because
because
we
believe
that
people
should
should
should
you
know,
communicate
effectively
and
and
effective
communication
comes
from
having
shared
patterns
and
shared
languages,
and
this
did
is
an
effective,
primitive
for
for
communication
and
so
and
it
it
seems
it
seems
as
if
it
could
be
applicable
and
used
in
its
in
its
maybe
not
in
its.
So
so
there's
you
know,
maybe
there's
specific
algorithms
or
something,
but
the
concept
conceptually
right
conceptually.
A
This
is
a
great
format
for
building
for
building
chains
of
trust,
and
we
can,
you
know,
have
intermediate
formats
wherever
we
want
and
represent
the
data
in
the
same
way.
You
know
for
things
that
may
not
support
this
directly,
but
it's
a
nice
shared
format
that
we
can
proxy
between
systems
and
systems
can
have
their
own
internal
representations
of
identifiers.
Just
like
different
static
analysis
tools
and
stuff
right,
so
let's
just
write
this
to
a
file.
Okay,.
A
Okay,
so
okay,
so
example
of
you
know:
dependency
swap
depend
density,
hot
swap.
A
Okay,
so
build
comes
in
so
now.
Remember
we
er,
the
open
architecture
allows
for
is
an
eater
is,
is
effectively.
You
know
we're
proposing
a
methodology
for
interpreting
different
arc,
different
domain,
specific
architectures
and
and
knitting
together.
The
interpretations
of
different
domain,
specific
architectures
in
a
shared
intermediate
representation,
which
one
very
good
option
for
doing
that,
which
we
suggest
is
using
dids
and
pure
dids
and
and
such
as
a
serialization
format
for
this
intermediate
representation
right
so
leveraging
this
intermediate
representation.
A
It
becomes
very
easy
right
with
the
ids
at
least
this.
This
notion
right,
so
dids
are
a
great
serialization
format
with
it
for
this,
but
this
notion
of
distributed
identifiers
in
in
general,
whether
you
want
to
write
them
like
this
or
whether
you
want
to
put
it
in
a
byte
string
format
or
whatever
the
hell
you
want
to
do,
but
conceptually
this
did
stuff
allows
us.
However,
you
want
to
serialize.
A
It
allows
us
to
build
these
intermediate
representations
of
architecture
right
and
then
we
can
apply
because
you
know
if
you
should
choose
a
serialization
format
or
you
know
serialization
and
deserialization
flow,
which
supports
you
know
the
understanding
of
the
providence
information
that
needs
to
be
involved
and
cryptographic
assurances
as
part
of
that
right,
so
didds
provide
that
for
us,
which
is
why
we're
just
going
it
with
them,
it's
just
great
stuff.
So,
okay,
so
example
of
dependency,
hot
swap,
okay,
you
know.
A
Okay,
so
let's
just
say:
let's
just
do
this!
Okay,
let's
just
say
this
key
is
for
http
test
and
it
signed
the
1.1.5.
A
Commit
or
maybe
like
in
or
let's
see,
no
okay,
so
you
need
two,
so
hd
has
signer
okay,
so
basically,
so
this
is
the
key
for
okay.
So
this
is
the
key
for
the
http
test
project
right
and
then
the
key
for
the
project
once
we're
just
building
these
trees
of
keys
right
so
we'll
have
to
figure
out
relocation.
So
I
think
revocation
will
just
I
think,
revocation
revocation
is
a
context
aware
thing.
A
So
if
we
know
that
we're
supposed
to
be
going
to
github,
then
we'll
also
have
an
overlay
that
says:
hey,
go
check
the
github
relocation
stop
stuff,
stop
before
you
import
any
of
these
things.
Unless
you've
checked
your
location,
so
it
should
be
should
be,
should
be
pretty
straightforward,
okay,
yeah,
so
this
basically
says
I'm
the
signer
right
for
0.155
whatever,
and
this
says
where's
my
okay,
all
right
so
so
say.
A
Maybe
we
have
this.
You
know
colon
separated
list
of.
Let's
actually
do
a
slash,
separated
because
you'd
be
hard-pressed
to
find
something
that
puts
a
slash
in
a
version
so
yeah,
let's
say
so.
These
things
it's
just
I
mean-
and
this
is
just
this
is
just
completely
arbitrary.
The
whole
point
is
that
you
can
do
whatever
the
hell
you
want.
A
A
Or
you
can
see
the
okay,
so
c
lookup
table
in.
B
B
A
A
Then
okay,
so
we.
A
Okay,
so
we
look
up
here
shiny
within
blanks
so
and
this
example,
the
example
level
of
dependency
hotspot,
blank
okay,
so
for
http
test.
So
look
up:
pdx
johnny
within
github.com
pda,
shiny
keys,
okay.
So
we
see
it's
here,
split
on
slash
or
yeah,
so
search
each
key
comment
for
one
that
starts
with.
B
A
With
the
you
know,
with
hp
test,
slash
behind
the
slash
split
on
slash
to
find
the
keys
for
each
release,
these
which
signed
each
release,
and
so
then
here
we
go.
We
have
a
ed
ad25519.
A
Key,
which
is
an
ssh
key
right,
and
so
these
are
keys
which
were
used
to
sign
particular
releases
right
now.
These
keys,
we
could
do
right.
So
this
is
a
a
naive
example
where
we
look
up
in
the
same
file
so
basically
any
key
that
we've
uploaded
to
github
right,
but
we
could
of
course,
have
another
indirect
jump
where
we
say:
okay,
you
know.
Maybe
you
split
on
slash
and
then
the
first
thing
is
actually
the
repo
name
where
I'm
going
to
store
all
my
keys
and
then
I
can
just
go.
B
A
There
right,
but
it's
because
I
already
am
all
and
within
the
same
domain
of
trust
within
github's
https
service
right.
So
I
think
this
is.
This
thing
is
reflected
in
my
eye.
Maybe
so
I'm
gonna
stop
this
now!
A
Oh
okay!
So.
A
A
A
Oh,
it
doesn't
matter,
it
doesn't
matter,
it
doesn't
matter
what
the
hell
am
I
doing
it
doesn't
matter.
It
doesn't
matter
because
we're
going
through
okay,
so
those
ssh
keys,
we
don't
need
them
to
be.
The
only
thing
we
needed
to
be
the
ed
key
was
the
only
thing
we
needed
to
be.
A
The
shared
key
was
that
github
key,
so
we
meant
we,
we
me
we
we,
we
generate
a
e
d,
two
five,
five
one,
nine
key,
which
we
also
do
filippo's
trick,
which
is
in
lib
sodium
to
turn
into
an
x
two
five,
five
one
nine
key,
and
then
we.
A
Do
we
even
need
to
do
that?
Actually,
no,
we
didn't
even
need
to
do
that.
We
didn't
even
need
to
do
that.
We
didn't
even
need
to
do
that
because,
oh
we
don't
even
need
to
do
that,
because
the
do.
A
Do
that?
No
we
do
need
to
do
that,
because
we
do
need
to
do
that,
because
we'll
use
that
to
create
this
basically
what
it
exists.
Almost
as
almost
like
a
verifiable
credential
or
an
ephemeral
yeah.
I
guess
it
is
a
verifiable.
It's
a
pdid,
it's
an
association.
It's
basically
like
hey.
You
know
that
I'm
linked
to
you
and
I'm
like
it's
like
a
very.
A
I
think
it's
a
verifiable
credential
in
this
case,
but
I
think
we're
effectively
going
to
have
it
be
a
purity
id,
and
so
we
do
this
thing
where
we
have
both
the
ed
key
and
the
x
key,
and
so
one
you
can
use
for
signing
and
one
you
can
use
for
encryption
and
usually
we
don't
reuse
keys
for
signing
and
encryption.
But
this
is
a
single
purpose
key
which
exists
only
to
to.
A
A
No,
but
we
trust
that
this
is
the
public.
We
trust
that
this
is
where
we
can
get
the
public
portion
from,
because
we
trust
github.
So
we
trust
that
this
is
the
correct
data.
Okay,
so
we
don't
necessarily
need
to
sign
it,
but
we
could,
if
we
wanted
to
kind
of,
doesn't
make
any
sense,
because
then
we
should
assign
the
key
in
the
first
place.
A
Well,
we
are
signing
the
key,
because
the
key
is
the
same.
It's
we're
not
signing
the
key.
We
don't
have
to
it's
the
key
same
key,
but
anybody
could
upload
the
public
key.
B
A
A
Okay,
but
this
they
can't
do
it
for
your
repo
you're,
only
doing
it
for
your
repo.
So
basically,
if
you
look
up
http
test,
this
says
this
has
to
be
this
key
that
signed
this
release
within
this
person's
repo.
So
you
ain't
you're
not
going
to
be
playing
any
tricks.
So
so
basically,
this
lookup
goes
through
here
says:
okay,
we've
got
the
key.
We've
got
the
right
key,
so
basically
we
gener
we
generate
this.
A
All
right,
so
we
go
here
and
then
maybe
we
maybe
there's
something
else,
and
then
we
like
parse
the
body
and
we
figure
out
which
one
for
this
specific
type
of
github
did
right,
like
maybe
we
even
said
github
release
body
parser
number
35
right,
it's
it's
completely
arbitrary
right.
It's
the
whole
thing.
It's
like
this
is
a
data
flow
that
you're
deciding
to
execute,
execute
you
know
to
deserialize
it
to
input
did
right.
This
is
the
whole
point.
A
A
So
this
is
how
you're
doing
the
lookup
of
the
value
in
a
cryptographically
secure
way
right
and
then
you
can
also
do
replacement
on
it,
because,
if
you're
always
storing
these
things
as
dids,
you
can
swap
out
wherever
you
want,
but
because
you're
using
a
shared
serialization,
okay,
I'm
not
going
to
do
the
rest
of
this
example.
I'm
is
this.
Is
the
chain
of
trust?
You
look
it
up.
You!