►
From YouTube: PWA Studio Community Meeting 13 Mar, 2020
Description
GraphQL Mutation Queuing, New Extension APIs, Secure PIIs, and updates to Community Backlog
B
A
C
C
C
C
You
do
want
it
to
be
easy.
I
think
there
was
an
Italian
Renaissance
concept
which
I've
always
loved
calls,
but
that's
a
tool
where
you
have
to
do
really
cool
difficult
things,
but
you
have
to
make
it
look
easy,
just
be
very
fashionable,
but
look
like
you
kind
of
don't
care
like
I'm
wearing
a
million
dollars,
but
I
put
a
Rolex
like
on
the
outside
of
the
suit
sleeve.
C
A
A
C
A
C
Gonna
say:
yeah
well,
you've
got
a
couple
more
contributions.
I'm
gonna
say
that
we
have
enough
attendees
to
begin
good
morning
afternoon
and
evening,
like
I
said,
everybody
welcome
to
PW
a
studio
communities.
Sync,
we
don't
have
a
lot
to
show
off
today,
but
we
want
to
do
as
few
cancellations
this
past
we'll
cancel
a
lot
of
things,
get
to
be
canceled
right
now
and
we'd
like
to
just
remind
everyone.
We
are
a
distributive
team.
We
have
already
gotten
used
to
working
from
home
and
working
remotely.
Our
employers
Adobe
have
a
good
policy
surrounding
it.
C
So
if
you
want
to,
if
you're
around
be
in
touch
with
us,
we're
gonna
be
as
available
as
possible
during
this
time.
So
let's
just
proceed,
we're
doing
great
right
now.
The
first
thing
is
a
little
bit
of
a
callback
to
last
week's
demo,
where
Stephen
showed
off
that
he
has
solved
a
bug
with
the
way
that
we
interact
with
the
graph
QL
API
when
doing
mutations,
which
are
unsafe
in
an
HTTP
definition,
and
they
therefore
kind
of
need
to
be
properly
queued.
C
A
A
At
some
point,
if
the
server
is
able
to
sort
of
resilient
Li
handle
the
those
multiple
requests
hitting
at
the
same
time,
we
wouldn't
need
this,
but
for
now
it's
it's.
It's
a
simple
addition:
its
one-line
added
to
our
Apollo
link
that
just
instantiate
s--
the
mutation
queue
there's
a
package
on
npm
published
under
the
adobe
organization.
That's
pretty
much
just
the
the
readme
saw
and
hopefully
they'll
publish
it
to
their
apollo
community
links.
A
That
would
be
kind
of
cool,
but
the
effect
is
pretty
straightforward
and
I'll
try
to
do
it,
but
it'll
be
pretty
quick.
I'm
gonna,
I'm
gonna
hit
both
of
these
Update
button
or
the
increase
quantity
buttons
and
normally
on
normally
before
this
PR,
you
would
have
seen
when
you
click
the
Update
button.
The
whole
cart
would
sort
of
blank
out
and
you
wouldn't
be
able
to
do
anything
else
until
that
mutation
resolved,
and
we
did
that
because
of
the
this,
this
problem
with
the
server
state.
So
now
we
don't
have
to
block
the
user.
A
The
user
can
do
whatever
they
want
on
the
front
end,
but
will
and
will
block
a
very
minimal
amount
of
things.
So
dev
has
a
good
point
and
he
opened
a
ticket
for
this,
but
but
you'll
see
that
the
after
the
mutations
are
called
the
totals
blank
out
while
they're
in
flight.
Now,
and
will
eventually
have
the
proceed
to
checkout
button,
also
blank
out
just
to
make
sure
that
you
don't
go
to
the
next
page
before
you.
A
The
card
is
actually
ready,
but
we
allow
people
to
do
all
sorts
of
mutations
at
the
same
time,
if
they're
just
a
really
fast
either
so
I'll
just
show
real,
quick
D,
and
you
can
see
here
on
the
waterfall
that
I
did
this
mole.
I
did
four
requests
and
there
was
no
blocking
that
occurred
on
the
UI,
my
mine,
okay,
there's
no
blocking
that
occurred
on
the
UI
and
the
requests
were
all
handled
successfully
queued
one
after
another,
and
that's
that's
the
gist
of
it.
A
It
just
it
just
enforces
that
each
of
these
mutations
occur
after
the
after
the
the
previous
one
has
completed,
and
this
results
in
the
correct
price
total,
because
the
last
thing
that
you
get
is
this
is
the
total
from
the
from
the
last
mutation
and
the
last
mutation
waited
until
the
one
before
it
was
done.
So
it's
correct
simple
as
that.
D
A
D
Yeah
so
like
I
kind
of
liked
that
if
you
were
following
our
talyn's,
the
kind
of
the
the
properties
for
those
towns
were
getting
a
little
unwieldy
and
yeah.
It's
kind
of
nice
way
to
clean
it
up
and
kind
of
just
going
forward.
We're
gonna
continue
like
expanding
on
this
and
like
defining
just
patterns
that
we're
going
to
use
and
be
consistent
about
yeah.
A
And
this
is
a
good
time
to
also
call
out
this
code
standards
wiki
that
we
probably
haven't
been
doing
a
great
job
of
keeping
up
to
date,
as
we've
been
developing
a
lot
of
this
new
stuff.
This
sort
of
because
of
the
nature
of
we're
doing
a
lot
of
exploratory
development,
so
we're
kind
of
trying
things
out
and
then
working
out
the
kinks.
You
know
we
were
passing
queries
just
wholesale
as
the
as
the
first
level
props
to
the
talents,
but
I
think
at
some
point.
A
Somebody
had
suggested
that
we
instead
sort
of
encapsulate
the
court,
the
operations
inside
inside
a
property
that
you
can
list
them
all
out
in
and
it
sort
of
namespaces
things
nicely
when
you're
trying
to
reference
them
within
the
talent.
So
I
did
that
in
a
lot
of
places
inside
this
PR
and
I
also
was
spending
a
lot
of
time
passing
down
we're
doing
this
so
that
the
the
card
state
was
updating
correctly.
A
We
were
spending
a
lot
of
time,
drilling
down
this
prop
or
set
his
card
updating
and
there's
some
loading
state
checks
and
stuff
just
to
make
sure
that
the
that
the
the
overall
card
state
is
correct,
but
without
having
to
like
put
a
mask
over
the
whole
UI.
But
as
you
can
see,
here's
those
mutations
and
queries
and
there's
a
whole
other
argument
about
whether
we
should
be
destructuring,
an
object
within
an
object,
but
well
we'll
do
that.
We'll
handle
that
another
time
anyway.
A
Yeah,
so
any
brings
up
a
good
point
and
I
added
this.
This
thing
you
can,
you
can
do
so
if,
right
now,
if
in
in
Vanina,
all
mutations
are
now
queued,
the
code
basically
just
checks.
The
key
the
operation
key,
which
is
just
a
stratified
version
of
your
of
your
your
operation
and
it
looks
for
operation,
is
mutation
or
something
like
that,
and
then
it
just
adds
it
to
a
queue.
If
it's
not
a
mutation,
it
just
lets
it
through.
A
So
if
you
have
to
write
a
mutation
that
you
want
to
be
able
to
skip
just
to
happen
immediately,
you
can
just
pass
a
context
value
when
you
call
your
mutate
function.
So,
as
you
see
here,
it's
really
straightforward.
You
just
create
your
mutate
function,
with
the
use
mutation
hook
and
then
inside
your
effect.
Whenever
you're
calling
the
mutation,
you
would
just
pass
context
skip
future
and
if
you
want
to
see
logs
I,
also
added
a
debug
flag
for
you
when
you're
initializing
the
queue.
C
Excuse
me.
So
next
up,
we
were
sort
of
tentatively
going
to
talk
a
little
bit
about
additional
features
of
the
blooding
extension
framework,
and
this
stuff
hasn't
been
opened
as
a
pull
request,
because
right
now
it's
sort
of
very
researchy
but
I
think
it's
still
kind
of
worth,
showing
off
some
cool
stuff.
Nothing
give
me
just
a
second
I
will
share
my
screen,
provided
that
my
computer
isn't
consuming
a
bunch
of
network,
which
often
is
the
case.
C
C
C
What
it
wants
to
do
is
it
exposes
a
function
which
is
going
to
receive
from
the
build
process.
This
target's
object
and
his
targets
object.
Give
it
sax
gives
it
access
to
a
bunch
of
specific
targets
which
operate
almost
exactly
the
same
as
webpack
hooks
and
so
for
different
features
that
we
have
exposed,
including
the
web
pack,
features
themselves.
A
package
such
as
page
builder
can
tap
into
those
things
and
make
modifications
or
just
monitor
them
and
log,
or
make
changes
to
its
own
logic,
based
on
what
it
sees.
C
So
what
we
have
right
now
for
page
builder
is
I
may
have
shown
before.
Is
it
a
couple
of
our
built
in
targets
which
are
part
of
our
build
pack
are
available
now
for
page
builder
to
do
two
things:
it's
identifying
that
it
as
a
package
has
es
modules
and
CSS
modules,
which
affects
how
it's
built,
and
it
adds
some
configuration
values
which
are
relevant
only
to
it.
C
In
this
case
the
Google
Maps
API
to
the
environment,
variable
definition,
which
makes
those
environment
variables
required
and
be
validated
and
be
in
the
user
interface
and
be
available
in
the
dot
env
file
along
with
all
of
the
built
in
and,
lastly,
it
targets
the
venue
I
package
instead
of
the
build
pack
package,
because
venue
UI,
which
it
depends
on
or
as
it
lists
as
a
peer
dependency.
It
expects
Venier
UI
to
exist
and
Vinnie
a
UI
exposes
this
one
extension
point
called
rich
content,
renderers
and
rich
content.
C
All
of
these
things
have
something
in
common,
which
is
that
they
want
to
sort
of
spread
across
your
application.
Some
monitoring
events
in
the
manner
that
an
old-school,
Dom
based
analytics
tracker
would
just
put
a
little
code
snippet
at
the
bottom
of
your
page
and
watch
for
clicks
and
in
our
application,
we're
not
looking
for
Dom
events
and
watching
for
clicks,
because
that's
not
how
we,
as
developers,
design
the
application.
Instead,
we
use
higher-level
more
convenient
concepts.
Let's
take
you
in
the
product
full
detail.
C
This
is
the
part
of
the
product
page
that
renders
the
core
central
UI,
and
specifically,
it
has
a
button.
Excuse
me
for
adding
to
the
cart
and
in
the
case
of
this
button,
it
holds
in
its
handler,
which
initiates
an
add
to
cart
action
from
where
from
here,
which
our
talent
props,
which
are
emitted
by
the
used
product
full
detail
tap.
C
So
this
would
be
a
great
place
for
us
to
insert
extension
functionality
without
having
to
copy
the
product
full
deal
to
detail
component
without
having
to
take
it
over
and
what
we've
done
in
Peregrine,
which
is
where
we
consume
these
talents
from
is.
We
have
started
in
Peregrine's
to
expose
our
own
extensibility
interface,
like
everywhere.
That's
always
exposed
first
via
the
Peregrine
package
declaring
in
its
package
JSON
that
it
has
extension
points.
C
It
wishes
to
declare
some
and
it
wishes
to
intercept
others,
and
so
those
files
which
actually
do
that
or
sitting
here
in
the
library
folder
and
in
the
case
of
declare
Peregrine
says
I,
have
a
target
called
talons
in
the
declare
file
you're,
not
actually
implementing
what
the
talons
target
can
do.
You're
just
saying
that
it
exists
which
allows
other
packages
to
intercept
it
and
then
later
it
will
be
implemented.
So
you
can
intercept
this
talent
in
the
way
of
subscribing
to
an
event.
C
Before
anything
happens,
and
that's
where
you
guarantee
that
here
and
here
in
the
intercept
file,
we
have
started
to
implement
talons
for
intercepting
right
now
in
a
pretty
manual
way,
but
it's
starting
to
use
some
common
concepts
which
you
can
use
and
the
first
one
here
is
use
product
full
detail.
In
this
case
this
is
just
a
class
for
creating
a
configuration
object
which
you
can
then
use
to
pass
to
your
subscribers.
We
have
now
got
a
new
build
pack
target
which
is
built-in
target
available
for
consumption
by
other
packages.
C
This
is
called
wrap,
es
modules,
a
general-purpose
low-level
target
that
allows
you
to
declare
that
specific
files
which
expose
specific
exports
can
have
those
exports
wrapped
in
functionality.
You
might
recognize
this
is
the
interceptor
pattern
which
you
use
in
magenta
today.
The
interceptor
pattern
can
be
slow,
but
in
our
case
we
are
implementing
those
interceptors
by
generating
code
at
build
time
which
solves
a
lot
of
the
performance
problems.
I
mean
in
this
case,
wrap
es
modules
is
passing
in
a
wrap
config
we're
making
our
own
cute
wrapper
configure
round.
C
It
called
Talon
wrapper
config,
which
presents
a
really
simple
API.
This
just
says:
there's
a
used
product,
full
detail,
property
and
a
use,
app
property,
and
those
are
simple
sets
and
you
can
just
add
file
names
to
them.
So
here's
where
things
get
interesting
over
here
in
a
separate
whoops,
not
there
over
here
in
a
separate
package
that
I
apparently
closed
the
editor
for
I.
C
Am
working
on
the
snowplow
tracker,
which
is
a
general-purpose
tracker
system
that
right
now
we're
using
for
collecting
data
regarding
product
recommendations,
events,
this
tracker
is
a
completely
separate
module
and
right
now
it
contains
a
lot
of
code
that
is,
for
the
magento
consisting
storefront
for
luma.
Well,
we
have
a
PW,
a
folder
that
we've
added
to
this
tracker,
and
indeed
it
does
have
an
intercept
file
which
again
is
mentioned
here
in
the
base
package:
JSON,
the
W,
a
studio
targets,
intercept,
and
here
in
this
intercept
file.
What
are
we
doing?
C
We're
adding
this
code
to
the
special
features,
we're
adding
some
environment,
variable
definitions
for
configuration
on
a
project
level,
and
we
are
targeting
this
new
talyn's
feature
of
Paragon.
We
receive
talents
and
sure
enough.
We
can
use
the
properties
hanging
right
off
this
talyn's
config
to
say:
I
want
to
add
this
interceptor
to
use
app
and
I
want
to
add
this
interceptor
to
product
full
detail.
C
Actually,
maybe
I'll
do
yeah,
we'll
just
do
the
plain
old
watch.
Let's
see
we
had
a
question
chants.
How
does
the
author
of
snow
plow
know
the
names
ow
hello
Steven?
This
is
going
to
be
public
API,
just
like
all
of
the
bass
built-in
targets,
such
as
n
VAR
definitions
and
special
features.
Any
given
package
that
exposes
or
declares
these
targets
needs
to
document
them
as
part
of
its
public
API.
Additionally,
it
needs
to
have
testing
for
it.
C
C
C
The
shopping
cart,
one
I
find
it.
There
is
one,
that's
actually
posting
shopping,
cart
data,
but
because
I'm
doing
this
on
the
fly
can't
find
it
there.
We
go.
Posting
shopping,
cart
data
because
we
clicked
handle
Add
to
Cart.
We
got
the
cart
ID.
You
got
other
data.
How
is
this
working
well
in
our
sources?
Tab
where
we
can
see
the
source
Maps
generated
code?
Let's
look
at
what
use
product
full
detail
is
now.
C
It
was
what
Magento
to
snowplow
Jas
requested
to
be
added.
What
did
that
do
down
here?
Where
the
actual
to
be
exported
talent
is
declared.
It's
done,
a
small
change
to
the
name
of
the
talent
and
it's
stopped
exporting
it
and
then,
at
the
end
it
exports
the
names
talent
again
that
runs
that
wrapper
on
it.
C
You
can
stack
these
rappers
and
they'll.
Just
be
composed.
Function
calls
right
here,
but
this
is
editing
the
code
in
real
time
during
the
build
process,
and
if
you
just
want
to
check
here
to
make
sure
that
I'm
not
cheating
a
little
bit
of
look
behind
the
curtain,
the
source
code
still
makes
no
mention
of
that.
C
There's
no
additional
export,
there's
no
additional
import
so
because
we've
done
that
rap
use
product
full
detail
is
now
a
function
that
has
executed
on
the
talent
function
itself
before
the
talent
function
is
exported.
So,
let's
see
what
it
does
rap
use
product
fold
detail
receives
the
talon,
the
original
implementation
and
returns
a
new
function
which
runs
the
original
implementation,
because
you're
going
to
want
to
do
that
and
then,
with
that
API
it
wraps
its
handle
add-to-cart
event
and
runs
its
own
tracker.
A
C
C
In
this
case,
you
can
just
use
the
card
context
and
we'll
find
out.
You
know
if
that
has
any
serious
side
effects
it
shouldn't,
because
that's
how
our
hooks
work,
but,
as
you
develop
extensions
that
work
with
and
intercept
these
talents,
which
will
have
a
great
deal
of
functionality
all
over
the
codebase.
It
would
be
great,
if
not
only
internally
as
we
develop
extensions
as
functionality,
but
externally
you
can
open
pull
requests
and
follow
the
pattern
like
we've
shown
here
in
the.
C
The
Interceptor
for
Peregrine
and
expose
additional
talents,
it's
obviously
a
really
common,
simple
pattern,
but
per
our
general
practice.
We're
gonna
try
not
to
expose
a
whole
bunch
of
functionality
at
once,
but
rather
individual
functionality.
That
can
achieve
a
particular
business
case,
in
this
case
monitoring,
adding
to
cart.
C
But
you
can
see
here
that
this
is
a
way
that
you
could
go
throughout
the
entire
code
base
right
in
your
Interceptor,
a
whole
lot
of
other
taps
into
these
talons
and
instrument
your
entire
code
base
with
analytics
code
without
having
to
go
through
all
of
your
actual
react
components
and
paste
little
tracking
code
snippets
all
over
the
place.
We're
really
excited
about
that
is
a
concept
and
all
the
other
things
that
you
can
do
with
extending
talents,
and
that's
my
demo.
A
C
A
Thank
you
I
quick
question,
and
this
may
be
not
super
pertinent,
but
I
noticed
that
this
kind
of
comes
down
to
that.
Naming
again
that
I
had
a
question
about
so
we
know
that
the
snowplow
author
knows
because
we
have
a
public
API.
Is
it
possible
that
we
could
just
instead
of
instead
of
maintaining
a
list
of
functions,
we
just
have
a
single
getter
function
for
those
and
then
that
can
return
like
it
feels
like
you're
accessing
a
prop
that
may
or
may
not.
It
makes
it
harder
to
deprecate,
etc.
I.
C
C
The
other
thing
is
that
one
of
the
ways
that
this
code
base
should
be
discoverable
is
that
when
you
are
debugging
and
and/or,
when
you
are
expecting
intellisense
to
come
out
of
your
code
editor,
you
should
get
autocompletes,
so
you
should
be
able
to
do
press
Talon,
wrapper,
config
dot
and
then
see
what's
available
for
tap
as
a
list
of
sets,
so
both
of
those
things
I
think
affected
my
decision
to
do
it
this
way,
but
my
decision
isn't
necessarily
final.
We
can
discuss
it
more.
That's
my
reasoning.
Yeah,
okay,.
C
At
this,
I
will
be
opening
a
pull
requests
sometime
in
the
middle
of
next
week.
I
needed
to
get
the
code
coverage
finished
for
this,
and
in
doing
so,
I
think
I
may
also
soon
have
some
testing
utilities
for
your
own
code,
like
if
you're
developing
an
extension
so
that
you
can
quickly
test
one
of
these
targets
and
your
interceptor
for
it.
C
C
C
Okay,
oh,
we
have
one
more
chat.
Thank
you.
Michael
more
cats
is
what
comes
in.
I
can
go,
get
my
cat
he's
a
dog
but
I'll
just
move
him,
so
he's
blurring
all
right.
So
that's
my
demo.
The
last
thing
that
we
have
on
the
actual
agenda
is
demonstration
of
a
little
story
that
we
went
through
about
personal,
identifying
information
and
how
we
can
make
sure
that
we
store
it
responsibly
in
our
live
PWA
and
that
is
Andy's
job
to
to
talk
about
and
Andy
turn
over.
Are
you
ready
to
do
so?
Oh
yeah,.
B
Remove
mutation
Pai,
while
still
updating
the
cache
correctly
so
a
couple
weeks
ago,
I
think
probably
we
were
running
and
we
identified
this
issue
over
here
in
our
Apollo
cache
when
we're
issuing
mutations,
PII
or
personally
identifying
information
was
showing
up
here
as
keys
in
the
cache
which,
because
we
use
Apollo
cache
persist,
gets
persisted
out
to
local
storage,
which
introduces
some
attack
vectors
anyway.
I
won't
go
into
too
much
detail
on
that.
There's
a
blog
post
here,
that's
linked
from
this
PR.
So
if
you're
interested,
you
can
definitely
dive
deeper
into
that.
B
But
that's
basically
the
problem,
yeah
I
was
showing
up
as
keys
in
the
cache
and
so
I
think
a
couple
of
weeks
ago
we
said:
hey
all
you
have
to
do
and
we
modified
our
code
base
to
do.
This
was
just
set
no
cache
on
these
as
a
fetch
policy
on
these
mutations
and
that
solved
the
problem
of
the
keys.
But
we
have
some
mutations
and
you
can
see
one
here
who
are
they?
B
You
know
call
the
graph
QL
endpoint
that
mutation,
but
then
they're
also,
you
know
getting
a
response
back,
and
so
when
the
problem
was
when
you
set
no
cash
as
a
fetch
policy
on
those
mutations,
our
cash,
our
customer
item
in
our
Apollo
cash
was
not
getting
updated.
That's
kind
of
the
definition
of
no
cash
it
won't.
It
won't
catch
the
response,
so
we
kind
of
went
overboard
a
little
bit
as
a
short
way
of
saying
all
that.
So
this
PR
kind
of
comes
back
and
says:
hey,
let's
not
just
blanket
no
cash.
B
These
things
is
there
any
other
way
that
we
can
hide
the
PII
on
the
way
out.
So
we
don't
have
you
know
this
create
customer
call
his
email,
a
first
name
last
name
even
a
password
here,
so
we
don't
want
all
that
stuff
in
there,
but
we
do
want
when
this
operation
comes
back
to
update,
you
know
any
cash
entries
we
have
this
one
is
a
customer
type.
B
Most
often
it's
the
cart
type
that
we
want
to
be
updating
so
anyway
long
story
short.
There
is
a
way
to
do
that.
It
is
this
connection
directive
and
again
for
more
details.
You
can
go
check
out
this
blog
post,
but
the
idea,
the
guts
of
it
I'll
say,
are
right
here.
So
just
in
your
the
definition
of
your
mutation
in
your
graph
QL,
this
is
an
Apollo
specific
directive
and
so
like
the
magenta
graph,
QL
back-end
doesn't
actually
do
anything
with
this.
You
can
tell
it
hey.
B
This
is
this
is
the
kea
that
I
want
you
to
use
in
the
cache,
and
so
when
I
do
that,
and
I
issue
this
mutation
you
can
see
instead
of
all
the
PII
showing
up
it,
just
uses
this
my
custom
key,
which
is
just
a
simple
string
that
I
put
in
there,
but
you
can
put
whatever
string
you
want
in
there.
We
ended
up
going
with
in
the
PWI
studio
code
base
the
same
the
string
name
of
the
operation
that
you
were
performing
just
to
kind
of
keep
it
simple.
B
B
So
and
I
added
this
Stephen
had
brought
up
the
contribution
guidelines
wiki.
So
I
added
this
as
a
separate
section
in
that.
So
you
don't
have
to
go,
dig
up
this
er
to
find
that
it
should
be
in
the
guidelines.
So
just
a
simple
truth
table
for
when
you
should
use
connection
and
when
you
should
use
no
cash.
B
Oh
I
remember
what
I
wanted
to
say:
cool
yeah
brain
welcome
to
the
day,
so
we
did
this
in
the
PWA
studio
code
base
right,
but
I
wanted
to
show
y'all,
because
we
don't
we
have
a
ticket
for
it,
but
we
don't
yet
have
a
solution
to
make
this
super
easy
for
you
merchants
or
extension
authors
or
anything
like
this.
So
we're
kind
of
we
our
idea
our
goal.
B
Our
target
is
to
kind
of
bake
this
in
so
you
can't
mess
it
up,
but
that's
not
there
yet
so
I
just
wanted
to
highlight
this,
as
these
are
all
things
that
are
in
PWA
studio
right
now.
We've
we've
set
all
our
fetch
policies
and
directives,
but
when
you're
writing
your
own
stuff
you'll
want
to
reference
this
table
for
when
you
should
use
these
things
and
we'll
try
to
bake
that
into
the
core
here.
Coming
up.
C
So
thank
you
very
much
for
that
and
I
am
told
that's.
There
aren't
a
lot
of
subjects
and
there's
no
pressing
matter
for
our
community
chat,
which
comes
after
our
own
demos,
but
I
want
to
open
the
floor
for
a
couple
of
minutes.
If
anyone
has
stuff
that
you'd
like
to
bring
up-
and
we
can
talk
about
it
at
your
leisure,
you
have
a
few
minutes
left
to
do
that.
I.
D
D
D
Can
you
see
pwace
studio,
yep?
Alright?
So
if
you
are
a
community
member
looking
to
contribute-
and
you
make
your
way
to
the
P
to
the
PW
Studio
repo
go
and
head
into
projects,
there's
a
community
backlog
project
specifically
for
y'all
and
in
here
we
are
going
to
try
to
start
kind
of
grooming
and
have
work
ready
for
the
community
to
pick
up.
D
So
instead
of
you
having
to
comb
through
like
170
issues
or
something
and
find
one
that
has
some
specific
set
of
labels
that
might
might
be
accepted
when
you
submit
it
to
us.
We
now
have
a
very
groomed
prioritized
list
of
things
that
you
can
pick
up
and
work
on.
This
almost
guarantees
that,
if
you
pick
up
one
of
these
items,
we
will
accept
it
like
we're.
Gonna
have
no
reason
to
push
back
that.
It's
something!
That's
not
a
priority.
It's
something!
That's
obsolete!
D
It's
something
that
we're
working
on
internally
like
this
is
the
list
to
go
to.
We
have
a
bunch
of
contributors
flying
through
this
process.
Already
Lars
Andriy
is
doing
some
good
work
as
well,
so
we're
off
to
a
good
start.
We
maybe
have
not
had
as
much
contribution
as
we
accepted
like
it
seemed
like.
A
lot
of
people
were
interested.
Then,
as
soon
as
we
said
here,
it
is
everybody
kind
of
backed
off
a
little
bit,
so
anybody
who's
interested
in
work.
Here
it
is.
We
have
two
things
here.
D
In
the
prioritize
column,
we
meet
weekly
to
replenish
this
column.
So
if
there's
there's
anything
in
the
backlog
or
just
a
feature
that
you
think
is
missing
you
can
you
can
go
ahead
and
create
an
issue
for
it,
go
ahead
and
add
a
Help
Wanted
label
to
it.
That'll
bring
it
to
our
attention,
we'll
groom
it.
If
we
agree
that
it
is
something
that
should
be
in
the
codebase,
we'll
groom
it
move
it
to
the
prioritized
column.
D
Give
you
the
first
crack
at
addressing
that
new
feature,
otherwise,
we'll
open
it
up
to
the
community,
and
anybody
else
can
pick,
though
pretty
straightforward.
You
need
work,
want
to
contribute,
come
to
this
project
and
I.
Think
as
if
you-
and
if
you
have
any
questions
for
any
of
us,
Jordan
is
kind
of
our
kind
of
community,
not
liaison
I
hate.
That
word,
but
he's
kind
of
like,
are
the
are
at
our
community
advocate
out
there.
You
can
reach
him
on
the
community
slack
channel.