►
From YouTube: OCI Weekly Discussion - 2022-10-20
B
Doing
all
right,
I
shifted
around
I,
saw
you
through
your
two
items
over
on
the
action
items,
I
put
them
down
into
the
discussion
items
down
below.
B
B
So
the
mid
empty
missing
means
that
if
you
ever
build
one
of
these
with
the
go
it's
missing,
but
all
of
the
other
code
around
it
all
of
the
Json
schemas,
all
the
other
testing
and
everything
else.
None
of
that
requires
it
and
so
reading
it.
It
doesn't
fail
when
it
reads
it:
it's
only
if
you
build
it
using
the
go,
and
so
we
only
missed
that
one
spot.
E
Pretty
much
I
mean
I
saw
that
we
had
an
agenda
item
for
the
meeting
on
Monday.
So
yes,
please
add
in
your
things
and
apologies
to
the
folks
that
aren't
going
to
be
joining
us
on
site
and
sorry
about
like
time
zones.
Basically,
it.
B
B
E
B
D
E
B
So
the
one
thing
I
put
on
the
actual
items
is
957.,
see:
yeah
I,
don't
see
Sasha
here
for
this,
but
he
put
a
request
out
a
while
back
for
any
of
the
image
spec
maintainers.
Do
we
have
an
image
spec
maintainer.
D
B
Other
than
me,
because
mine's
already
on
there,
no
I'm
just
talking
to
The
Ether
at
that
point
yeah,
so
we
just
need
to
get
another
set
of
eyes
on
that
one.
It
looked
good
to
me
and
I
think
that's
just
going
to
be
a
prerequisite
to
a
lot
of
stuff
you're
talking
about
Lockheed.
B
B
B
B
That's
why
I'm
here
I'll
I'll
drop
the
link
in
whenever
you
get
a
chance,
but
I
just
figured
it's
been
sitting
out
there
for
a
little
bit.
Sanjay
did
a
good
job
going
through
all
the
places,
we're
missing
things
and
clean
up
the
spec
for
us.
So
it
looked
like
it
was
ready
to
merge.
So
that
was
one
actual
item
next
week.
Anybody
have
other
agenda
items
for
our
chat
at
kubecon
on
the
24th.
B
D
B
A
I
will
be
there
in
person,
but
not
until
Monday
night,
so
I'll
join
remotely,
but
I'd
love
to
if
anyone's
going
to
be
there
on
love
to
see
you.
B
A
B
C
Sure,
thank
you
thanks.
Brandon
I'll,
just
put
it
in
the
in
the
chat
the
issue
we're
referring
to.
So
it
came
up
the
the
other
day
when
we
were
doing
some
work
with
artifact
type
that
the
what's
written
in
the
spec
is
assured
and
all
the
examples
are
assured
and
in
the
go
code
there
is
a
must
and
we've
tried
to
figure
out
what
the
decision
or
whether
any
prior
decisions
were
made
on
shoulder
or
a
must
and
that's
happening
in
the
issue
968,
which
I've
linked
there.
C
B
And
welcome
Sasha
we're
already
talking
about
your
stuff
earlier
I'll,
throw
in
my
quick
one,
which
is
I,
don't
have
a
hard
opinion
on
this.
One
I
just
want
to
make
sure
whatever
we
pick.
We
do
it
earlier
rather
than
later,
because
changing
is
after
the
fact
as
much
as
we
say,
it's
easy
to
change
and
easy
relax.
F
B
Well,
we
already
had
someone
to
try
that
the
other
day
I'm
not
saying
let's
go
to
the
sample,
I'm,
just
saying
that
people
look
at
the
spec,
they
read
it
and
they
just
use
it
as
this.
Let
me
see
if
I
can
find
it
all
keep
on
discussing
myself
talk
about
it.
F
Well,
the
reason
why
I
ask
is
because
I,
if
I
recall
correctly,
the
reason
why
we
have
artifact
type
is
to
support
the
API
for
a
querying
artifacts
that
have
a
certain
type
that
it.
That
is
a
certain
type.
And
if
that's
the
case,
then
shouldn't
this
be,
must
in
order
for
the
API
to
return
something.
B
B
But
I
did
find
the
one
example
and,
like
I,
say
not
saying
it's
good
to
sample,
but
as
soon
as
people
start
reading
this
they
come
up
and
just
say:
okay,
here's
our
media
type.
We
put
a
couple
things
in
there.
We
cut
a
couple
layers
and
they
throw
a
whole
bunch
of
data
on
annotations
for
them
to
key
off
of.
F
B
F
Well
so,
but
implementing
an
API
that
you
know.
F
Checks
for
whether
the
artifact
type
is
a
valid
artifact
type
versus
you
know,
implementing
an
API
that
just
knows.
Okay,
I
am
expecting
this
because
that's
what
the
specification
says.
F
C
I
think
you
know
where
I
got
to
on
Nisha
was,
you
know,
obviously
for
filtering
right.
I
expect
tools
to
be
like
hey
I
want
to
pull
the
s-bombs
associated
with
this
image
right.
There
is
no
server-side
validation
that
if
you
say
you
declare
it's
artifact
type
as
s-bomb.
That
is
indeed
an
s-bomb
right.
There's
no
server
that
says!
Oh
you
said
it's
an
s-bomb
I
will
validate
that.
C
This
is
indeed
an
s-bomb
I,
don't
believe
in
the
thing
I
was
trying
to
key
off
in
my
thought
is
how
does
the
platform
OS
stuff
used
right?
It
doesn't
this?
The
server
doesn't
actually
say:
oh
yeah,
that
that's
actually
the
correct
Hardware
platform
type
and
has
the
appropriate
headers
in
there.
C
It
just
says
shove
that
thing
in
there
you
said
it's
this
platform,
and
then
you
have
to
validate
it
at
the
runtime
that
it
is
indeed
that
platform
so
I
just
thought
about
it,
like
you
know,
platform
OS
being
able
to
narrow
down
exactly
what
you
want
so
I,
just
imagine
an
artifact
with
hundreds
of
signatures,
hundreds
of
s-bombs,
hundreds
of
attestations,
and
without
this
field
you
go.
Okay,
I
gotta,
pull
them
all
and
then
figure
out
which
one
is
which
so,
if
you
do
this
at
least
you
could
say
well.
C
That's
what
I
think
the
value
is
there
of
artifact
type
and
that's
why
I'd
push
on
it
being
a
must
just
to
spare
the
spare
the
registry
pulling
everything
and
then
pulling
every
blob
and
then
figuring
out
what
the
hell.
It
is
because
you
didn't
have
a
place
or
require
a
place
to
say
what
you're
declaring
it
is.
B
C
C
H
They
do
look
at
config
but
different
operators
to
look
at
the
config
blob,
but
that's
also
because
the
config
blob
has
a
good
schema
defined
in
it.
So
the
media
type
can
be
used
to
kind
of
crack
open
that.
B
Let
me
throw
the
flip
question
because
I
think
a
lot
of
the
comments
are
saying:
hey
if
we
don't
have
the
artifact
type,
that
makes
it
more
difficult
for
the
Registries
trying
to
figure
out
what
they
have
and
more
difficult
to
communicate
and
filter
and
whatnot
does
requiring
that
it
does
making
this
feel
require
required,
say
it
right
if
we
make
the
fuel
required.
Does
that
put
more
effort
on
Registries
to
do
more
validation
of
this
input,
because,
right
now,
all
we
validate
is
that
you
have
a
media
type.
D
B
That's
not
a
lot
of
work
on
them
once
you
say.
Okay,
if
you
see
it's
an
artifact
now
you
need
to
parse
this
manifest
apart.
You
need
to
look
and
find
out.
The
artifact
height
make
sure
it's
a
valid
string.
Parse
that
string
make
sure
that
string
itself
is
valid,
unknown,
yeah
and
now
on
Ayanna,
Elise
and
I
in
a
format
it
doesn't
have
to
be
registered,
put
in
a
format
so
you're
forcing
that
string
apart.
Are
we
making
more
work
on
the
registry
at
that
point?
Is
where
I'm
asking.
C
B
I
Have
opinions
but
I
feel
bad,
because
I've
been
absent
when
all
the
decisions
were
made
so
I
don't
even
have
context
for
why
they
were
made
and
I'm
too
lazy
to
go
back
and
watch
all
the
recording.
I
I
yeah
I
mean
my
problem,
mostly
with
artifact
type
being
must
everywhere.
Is
that
I
can't
use
the
refers
API
in
the
way
that
I
thought
it
was
gonna
work,
but
I,
don't
I,
don't
know
that
we
can
walk
that
back.
It's
probably
too
late.
C
Well,
that's
it
only
because
it
it
only
becomes
an
issue
when
it's
a
must
John
that
you
can't
use
this
API.
The
way
that
you
thought
you
would.
D
C
But
if
we
came
with
something
that
was
hey,
you
can
do
it
use
it
every
way
you
like
nobody
would
have
ever
gotten
to
the
RC
point
so,
but
I
did
I
had
that
same
thought
as
what
does
the
must
hog
ties
to
here,
because
if
there
are
other
things
you
could
do
with
this
API
that
we
aren't
looking
at
and
that's
what
that's
really
what
I
want
to
know
is.
I
I
So
right
so
from
like
from
a
registry
perspective,
it's
easy
to
go
from
like
a
must
to
a
shoulder
may
as
I'm
like
oh
yeah,
we
can
relax
this
requirement
but
like
from
a
client
perspective,
if
something
used
to
be
a
must-
and
you
write
some
code
that
assumes
that
that
field
is
always
going
to
be
there.
Then
you
know,
let's
say
later
on.
We
say:
oh
okay,
we're
gonna
use
this
for
other
stuff,
so
artifact
type
is
May.
Now
then,
like
you
potentially
break
a
bunch
of
clients
that
assume
that
that
already
exists.
I
You
know
give
me
all
the
indexes
that
reference
this
image
and
as
long
as
artifact
type
is
a
must
in
the
refers
API
that
doesn't
make
sense.
I
But
you
know
that's
not
exactly
the
question
you
asked
me,
but
but
it's
related
to
like
I,
can't
answer
your
question
without
kind
of
talking
about
that
yeah.
The
other
thing
is
like
right
now.
Kind
of
all
of
the
tables
that
exist
in
my
head
are
based
on,
like
descriptors
of
things.
D
I
So
for
the
refers
API
like
if
we're.
I
Descriptors
of
things
as
metadata-
that's
easy
but
like
if
I
have
to
pull
out
artifact
type,
then
now
that's
like
a
backfill
of
things.
It's
kind
of
annoying
and
I
mean
similar
thing
with
annotations,
but
that's
a
different
issue
again.
Artifact
type
for
me
is
a
little
bit
cumbersome
but
I'm
interested
in
like
what
other
people
think,
because
again
I'm
coming
to
this
with
like
no
context
that
all
of
y'all
have
and
I
apologize.
D
B
F
D
F
B
I
I
B
B
It
is
but
the
way
we're
going
to
encourage
people
to
use
it
for
garbage
collection
and
whatnot.
H
It
was
more
about
just
time
check,
I'm
hoping
we
can
close
on
the
first
issue
right,
which
is
whether
we
want
this,
must
shirt
or
just
leave
it
as
it
is
right
now.
I
think.
The
point
is
that
the
spec
is
inconsistent
with
the
go
files,
so
we
have
to
get
that
sorted
out
as
well
and
I
do
kind
of
agree
with
what
John
was
saying,
which
is.
H
We
have
on
had
a
couple
of
discussions,
whether
we
could
query
using
the
refers
API
other
things
like
layers
and
blobs,
that
a
manifest
refers
or
an
index
refers.
We
can
do
like
really
interesting
things,
but
if
the
artifact
type
is
a
must,
then
that
filter
becomes
a
important
criteria
everywhere.
B
The
filter
for
me
it's
an
optional
filter,
so
I,
don't
know
that
breaks
it.
If
you,
if
this
semester
breaks
using
the
filter
for
or
if
it's
a
should
it
breaks
using
that
filter
for
certain
things
that
you
want
to
filter
on
unless
you
accept
an
empty
string
for
a
filter,
but
it
doesn't
mean
you
can't
run
this
query
without
the
filter
and
get
all
all
the
artifacts
back.
It.
B
It
just
it
doesn't
have
all
the
other
situations
in
there
that
John's
thinking
of
but
I
do
want
to
Circle
back
real
quick,
because
I
saw
John
come
off.
I
got
so
excited
from
the
registry
operator
standpoint.
If
this
is
a
must
and
you
need
to
parse
this
artifact
type
string
and
verify
that
it's
in
an
Iona
format
is
that
concerning
it
all
or
registry,
to
validate
that.
B
I
Michael
I,
don't
think
I
would
actually
validate
that.
It's
like
consistent
with
ayanna's
rfcs
but
like.
I
F
Did
someone
do
me
a
favor
and
document
somewhere?
Why
making
the
artifact
type
should
help
with
the
I
guess
the
the
word
I'm
hearing
is
interesting.
Future
things.
F
F
But
I'd
like
to
also
yeah
but
I'd
like
but
I'd
like
to
also
know
like
what
this.
What
exactly
are
you
using
the
subject.
C
B
Okay,
that's
a
future
looking
statement,
I,
don't
think
we
ever
so
filter
on
the
client
side,
not
on
the
server
side
where
I
was
going
with
other
fields.
Is
we
have
media
type?
We
have
blobs
subject
annotations
someone
could
upload
a.
B
F
No
I
think
I'm
I'm,
just
like
trying
to
document
it
somewhere
in
the
notes,
yeah,
but
you've
sold
me.
C
Well,
I
guess
the
thing
that
we've
always
been
was:
if
we
rally
around
the
specific
supply
chain
security
use
case,
it
gave
us
grounds
to
actually
move
this
forward
at
a
reasonable
rate.
If
we
came
in
and
said,
let's
create
an
API
that
does
anything
you
want
and
reference.
We
would
have
never
made
it
here,
but
now
that
we're
here
and
we
wouldn't
overmate
it
here
in
this
amount
of
time-
I,
don't
think,
because
we
didn't
have
smaller
enough
a
scope
to
make
a
change,
but
now
that
we're
here,
given
John's
comments
is
well.
C
What
else
could
you
do
with
this
thing?
If
we're
going
to
land
it
anyway,
I
feel
like
not
being
so
myopically
focused
on
now
I'm
thinking
of
it,
I
was
thinking
of
it
through
the
scope
of
the
supply
chain,
security.
Things
I
want
an
s
bomb
I
want
an
attestation.
I
want
a
signature,
that's
going
to
basically
be
purely
up
to
Convention.
Essentially,
if
that
artifact
type
field
is
used,
you
may
be
incentivized
to
do
it,
because
registry
providers
might
index
it
and
filter
it
right.
C
Much
as
the
tag
listing
apis
used
today
with
sha.sig
or
shar.att,
you
know
I
guess.
The
hope
is
that
those
things
end
up
in
an
artifact
type
and
or
represented
on
in
you
know
fallback
scenarios.
But
if
we're
willing
to
say
look,
this
could
be
used
for
other
things.
That's
just
a
different.
C
C
B
B
E
B
Empty
pocket
for
them
to
fill
in,
however,
they
need
to
and
to
be
clear.
I
still
think
this
is
should
and
I
think
that
95
99
of
artifacts
will
be
ever
see
up
there
on
a
registry
will
have
us
filled
out
I'm,
hoping
that
annotations
is
also
going
to
be
nice.
Some
percent
of
the
artifacts
uploaded
will
have
that
as
well.
We
always
say
it's
optional,
but
I
hope
that
most
of
them
do.
F
You
think
that
satisfies
like,
if
I
go
back
to
the
working
group,
that
some
requirements
for
receiving
updates
and
organizing
things
and
getting
trying
to
figure
out
the
latest
thing
that
was
uploaded.
F
C
But
that's
you
know:
that's
actually
covered
in
convention
today.
It's
not
covered
in
it's
not
codified
in
specification,
so
you
know,
as
truth,
would
have
it
it's
working
today
in
Registries
and
they
probably
will
use
this
field
anyway.
It
just
gives
them
a
place
to
put
that
in
a
sane
format,
rather
than
kind
of
using
tag.
Name
convention,
you
could
put
it
here,
so
I
mean
I,
don't
but
I
think
there
are
other
things
that
we
might
get
shoes
like
hamstrung
by
later
and
like
oh,
you
could
use
this
thing
rather
than
okay.
C
C
Well,
I
think
the
good
thing
is
I
was
trying
to
dig
into
what
John
was
saying
too
I.
Think
John's
context
was
useful
here
and
I
couldn't
kind
of
grok.
What
John
was
asking
yesterday,
so
I
don't
even
know
if
the
artifact
type
definition
and
examples
like
we
even
have
to
Broach
that
if
it's
a
should
I
don't
know
if
John
was
just
trying
to
you
know
pass
that
as
if
it's
a
must
I
have
my
and
then
I
have
to
understand
it
more.
C
But
if
it's
a
should
I,
don't
know
if
I
care
about
it
at
all,
and
we
don't
need
to
change
anything.
So
that's
you
know
that
there
are
the
two
things
I
wanted
to
kind
of
answer.
So
are
we
out
I
should
I'll
go,
put
update
there
the
issue
and
then
you've
already
put
the
pr
in.
C
If
there
are
some
I
guess
image,
spec
maintainers,
it's
actually
already
issued
it's
just
representing.
D
C
B
We're
not
changing
anything
at
this
point,
given
that
I
think
that's
an
easy
fix
to
get
that
merged
in
I.
Think
if
I
got
one
approval
on
that,
which
is
surprising,
and
so
the
the
biggest
action
I
want
to
take
from
this
is
that
we
capture
this
discussion
in
the
issue,
make
sure
that
we're
all
in
agreement
that
way
we
come
back
to
it
later
on.
We,
we
know
where
to
find
this.
B
B
I
think
the
examples
can
still
use
a
little
bit
of
clarification,
but
I
want
to
make
sure
that
we
clarify
it
from
the
perspective
of
someone.
That's
reading
this
from
the
first
time,
because
I
think
a
lot
of
us
have
been
heads
down
on
this
for
so
long.
We
know
we're
trying
to
go,
and
so
hearing
John's
perspective
is
really
useful.
To
me.
B
That's
reason
for
the
first
time
saying
what
on
Earth
did
you
guys
do?
That's
super
helpful
to
me.
I
I
feel
a
little
bit
that
way.
I
kind
of
wanted
to
talk
about
the
artifact
I
feel
if
we
feel
like
we've
resolved
the
thing.
Well,
actually,
let
me
look
at
the
agenda.
Maybe
I'm,
jumping
on
somebody.
No.
B
I
I
I
Some
intention
of
the
field
is
useful,
like
what
I
imagine
this
is
is
a
media
type
that
represents
something
that
has
been
wrapped
in
this
artifact,
manifest
envelope
right
so
like
more
or
less
to
hide
it
from
the
registry
right
like.
If,
if
we
didn't
have
Registries,
then
we
wouldn't
really
care
about
the
artifact
type,
because
you
could
just
push
arbitrary
things
with
whatever
media
type
you
want,
but
because,
like
Registries,
have
to
parse
this
Json
and
care
about
it
in
order
to
maintain
invariance
of
their.
I
Between
I
can't
say,
artifacts
between
various
other
things,
like,
for
example,
for
a
garbage
collection.
D
I
Have
a
static
structure
for
the
Manifest,
but
we
want
to
support
arbitrary
artifact
types,
so,
like
this
artifact
type
is
just
a
string
that
says
hey
I
know
of
an
artifact
manifest,
but
you
should
interpret
me
as
though
I
were
this
other
thing
right.
That
is
that,
roughly
what
this
means
is
did
I
miss
something:
let's
go
on
cool,
okay,
that
seems
fine
I,
think
maybe
some
more
verbiage
to
express
that
in
a
more
eloquent
way
than
I
have
would
be
really
helpful
for
folks,
like.
B
This
is
what
all
it
feels
like
if
you're
uploading
the
specific
type
of
signature,
this
would
all
the
fields
look
like
to
start
capturing
it
and
documenting
it
of
specific
use
cases
as
examples,
but
but
just
capturing
okay,
that
other
people
have
already
defined
what
their
media
types
are.
Here's
how
you
apply
that
to
this
artifact
type,
how
you
apply
it
to
the
blobs
and
all
those
scriptures,
so
that
I
think
it
gives
a
common
place
for
people
to
come,
look
and
say
I'm.
Trying
to
query
for
this.
B
B
B
B
B
Yeah
and-
and
we
don't
earn
like
you-
know-
I'm
assuming
The
Singularity
group
did
their
own
thing
to
throw
an
eye
in
a
registration.
We're
not
we're
not
trying
to
claim
their
thing,
we're
just
trying
to
say
when
you
do
it,
here's
what
it
looks
like
the
reason
I'm
pushing
for
that
is
The
Blob
media
type.
B
It
can
be
a
lot
of
things.
You
know,
application
g-zip
is
perfectly
valid,
but
that's
not
useful.
If
you
really
want
to
capture
that
as
Json
gzip
versus
XML,
G
zipped
so
trying
to
capture
this
stuff,
maybe
there's
a
full.
You
know
Helm,
you
know
vendor
config,
Helm,
dot,
whatever.g,
zip
or
something
like
that.
Maybe
that's
what
you
want
to
be.
There
are
a
lot
of
possibilities
for
those
fields
and
trying
to
capture
all
that
one
place
means
that,
if
somebody's
writing
one
side
of
the
tool,
it's
almost
writing
the
other
side
of
the
tool.
I
I
just
think
we
need,
probably
at
the
top
like
we
explained
the
goal
of
the
artifact
manifest,
and
that
is
useful.
I
think
maybe
flushing
that
out
a
little
bit
more
to
like
the
rationale
for
like
oh
hey,
like
here's,
why
there
are
two
media
types:
I
know
it's
very
confusing,
but
it
makes
sense,
I
promise.
You
know.
I
Yeah
I
I,
like
maybe
some
verbias,
that
describes
this
thing
as
an
envelope
for
other
things.
I
want
to
say
it's
a
container,
but
that's
a
terrible
word
in.
I
Yeah,
the
artifact
manifests
like
an
envelope
for
arbitrary
things
and
here's
here's
how
some
examples
of
those
arbitrary
things
and
how
how
they've
defined
this
wrapping
it
would
be
I
think
useful,
mostly
I
I,
really
don't
like
the
current
example,
because
I
think
it's
very
misleading.
Oh
sorry,.
F
Oh
no
I
was
actually
going
to
agree
with
you
that
that's
probably
the
term
referenced
referenced.
Artifact
is
misleading
and
needs
to
be
elaborated.
A
little
more
I
think
the
the
first
time
we
had
tried
to
describe
it.
It
was
more
like
this
property
should
be
used
it
for
this
property
should
be
of
of
the
form
media
type
and.
F
Because
and
that's
what
it
is,
it's
a
it's
a
descriptor,
that's
pointing
to.
I
I
I
B
B
B
You're,
not
alone
in
your
concern,
Michael's
over
there
doing
the
song
and
dance
right
now
saying
yes
preach
through
the
scenario
up
there.
The
problem
that
we're
looking
at,
which
is
that,
if
we're
trying
to
filter
on
a
random
artifact
type,
the
artifact
type
itself
isn't
enough.
When
you
have
a
lot
of
these
things
for
store
registry,
and
so
there
may
be
certain
kinds
of
artifacts
where
you'll
have
multiples
of
them
and
be
able
to
figure
out
which
one
you
want
out
of
the
multiple
comes
down
and
need
and
there's
annotations.
I
I
Yeah,
so
how
I
would
imagine
solving
this
and
it
it's
not
great,
but
sometimes
you
probably
don't
want,
like
all
of
the
annotations
in
the
response
right,
maybe
I
just
literally
want
the
descriptors
and
there's
like
when
this
is
a
must
there's
no
way
to
indicate
like
oh
actually,
I,
don't
care
about
annotations,
which
is
a
little
annoying,
because
those
can
be
arbitrarily
large,
and
so
the
registry
might
pay
some
price
for
that.
I
D
I
Sure
yeah
I
mean
we
can
that's
what
pagination
is
for
right.
B
I
Is
the
structure
is
a
manifest
list,
but
this
isn't
something
that
is
uploaded
by
a
user.
The.
B
You
know
yeah,
but
the
thing
that's
wrapped
in
there,
because
your
concern
is
Visa
these
annotation
big.
So
potentially,
we
know
the
limit
of
someone
uploading
a
lot
of
annotations
today,
which
is
the
four
make
limit
that
we
specified
for
the
Manifest.
You
can't
put
more
annotations
than
you
would
fill
up
the
whole
thing
so
potentially
someone's
going
to
upload
an
image
manifest
or
an
artifact,
manifest
with
a
whole
bunch
of
annotations
and
get
you
close
to
that
four
megabyte
limit.
I
Right
but
the
four,
the
four
Mega,
like
suggestion,
isn't:
doesn't
Force
Registries
not
to
return
like
larger
payloads.
This
is
about
like,
if
you
want
a
portable
artifact,
it
shouldn't
be
larger
than
four
Megs,
because
some
Registries
won't
respect
that.
But
the
registry
can
return
that
pretty
trivially
right.
They
sort
of
blobs.
B
I
I
A
list
of
things,
and
so
it's
a
little
bit
different
in
my
mind,
because
it's
a
synthesized
thing.
It's
not
like
something
you
address
by
digest
that
you
can't
manipulate
in
ways
right
again
like
putting
the
entire
thing
in
the
data
field.
E
I
A
little
gross
because
it's
larger
than
the
annotations
would
be,
but
it
means
that
I
don't
have
to
store
annotations
separately
or
fetch
them
like.
If,
if
I
always
have
to
serve
annotations,
then
I
always
need
to
fetch
this
thing
or
I
need
to
store
it.
But
if
it's
an
optional
thing
then,
like
I
can
just
serve
up
descriptors,
which
is
what
I
want
to
do
and
like
clients
can
do
the
n
plus
one.
Yes
welcome.
C
E
C
That
was
the
one
we
did
and
then
we
said
well,
you
can
do
both
because
I
was
like
hey,
don't
you
don't
want
to
have
to
dig
into
annotations
because
I've
seen
this
video
I've
seen
this
movie
in
kubernetes
yeah,
but
we
kind
of
hedged
on
that.
Well,
you
can
do
both,
but
we
pulled
down
it.
Wasn't
that
how
it
went,
that's
how
we
ended
up
with
that
artifact
type
right,
Brandon,
the.
B
Middle
ground,
because
originally
we
were
saying
you
could
filter
on
any
annotation,
and
so
the
middle
ground
was,
we
said,
you're
only
going
to
filter
on
artifact
type,
but
you're
going
to
return
the
artifact
type
and
the
annotations,
and
so
the
client
can
do
the
filtering
beyond
that
on
the
annotations.
If
the
client
needs
to
do
that,
so
we
kind
of
we
try
to
find
that
medium
ground,
where
you
still
had
the
annotations
here
for
the
clients
to
use.
But
the
registry
didn't
have
to
do
any
filtering
or
processing.
B
I
Yeah
I
guess
like
it
is
weird
I
I
get
the
blessing
of
artifact
hype
as
like.
Oh
this
is
a
very
special
annotation
I
think
that's
useful
and,
like
maybe
worth
the
trouble
of
projecting
that
into.
D
I
Database
schema
so
that,
like
that
use
case,
is
fast
and
efficient,
but
to
do
also
annotations
seems
like
a
half
measure
and
I'd
rather
just
send
you
the
whole
thing,
because
I'm
gonna
have
to
query
for
the
whole
thing
and
parse
out
the
annotations,
and
it's
actually
way
easier
for
me
to
just
ship.
You
the
whole
manifest
if
you
wanted.
A
F
Think
I
really
have
I.
Think
I
may
have
misunderstood
something.
What's
the
difference
between
what
do
you
mean
by
parsing
out
the
annotations?
Don't
you
just
return
the
value
of
annotations.
I
F
Okay,
this
is
this
is
what
I
think
I
misinterpreted
I
think
I
wasn't
thinking
that
annotations
would
be
grafted
onto
the
refers
API.
I
was
thinking
that
it's
an
optional
place
where
you
can
put
things
for
more
sophisticated
filtering,
but
the
client
will
do
that.
Not
the
registry.
B
F
B
Yeah
every
descriptor
that
they
generate
for
this,
so
that
if
we
have
an
image
out
there
that
we're
referring
to,
they
have
to
not
only
maintain
that
here's,
the
artifact
type
for
the
subscriptor
and
this
digest.
But
here
is
the
list
of
annotations
and
tracking
that
data
for
every
descriptor
they're
going
to
return.
This
response
is
overhead
for
the
registry,
so
they
prefer
not
to
manage
it's
an
arbitrarily
long,
not
arbitrarily,
but
relatively
potentially
long
strength
for
them
to
manage.
F
B
I
I
Right,
like
I.
I
But
per
how
this
is
currently.
E
F
Yeah
I'm
sorry
I
didn't
think
that
that
was
the
intention,
or
at
least
that
wasn't
the
I
didn't
think
that
was
the
intention.
In
my
mind,
I,
don't
know
about
everyone
else.
B
F
No
I.