diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -154,3 +154,18 @@
 * Add `Covariant` constraint on schema parameter in `Adaptable` type class
 * Rename `Storage` type to `Store`
 * Define `Interpreted`, `Schematic` and `Comonadic` instances for `Store` type
+
+# 0.2.4
+* Remove `Pandora.Core.Transformation` module and move `~>` to `Functor` module
+* Define `Adaptable` instances for comonad transformer schemes
+* Make `position` and `access` methods of `Store` adaptable
+* Rename `unwrap` method of `Interpreted` type class to `run`
+* Define `Bivariant` functor type class
+* Define `zoom` optical operator - apply lens within some part of `State`
+* Make `top` method of `Stack` data structure a lens
+* Make `zoom` method of `Optics` adaptable for bigger state
+* Define `Traced` for adaptable `Environment` comonad
+* Define `cata`, `ana` and `hylo` methods of `Fix`
+* Define `Equipment` datatype to use `Comonad` `Product` transformer
+* Define adaptable `retrieve` method of `Equipment`
+* Extract `Imprint` from `Environment` module
diff --git a/Pandora/Core.hs b/Pandora/Core.hs
--- a/Pandora/Core.hs
+++ b/Pandora/Core.hs
@@ -1,5 +1,4 @@
 module Pandora.Core (module Exports) where
 
-import Pandora.Core.Transformation as Exports
 import Pandora.Core.Morphism as Exports
 import Pandora.Core.Functor as Exports
diff --git a/Pandora/Core/Functor.hs b/Pandora/Core/Functor.hs
--- a/Pandora/Core/Functor.hs
+++ b/Pandora/Core/Functor.hs
@@ -1,6 +1,6 @@
 module Pandora.Core.Functor where
 
-infixr 0 :=, <-|, |->
+infixr 0 :=, <-|, |->, ~>
 infixr 1 .:, :.
 infixr 2 ::|:., ::|.:, ::|::
 
@@ -18,6 +18,9 @@
 
 -- | Algebra's type operator
 type (<-|) a t = t a -> a
+
+-- | Natural transformation
+type (~>) t u = forall a . t a -> u a
 
 type (::|:.) p a b = p (p a b) b
 type (::|.:) p a b = p a (p a b)
diff --git a/Pandora/Core/Transformation.hs b/Pandora/Core/Transformation.hs
deleted file mode 100644
--- a/Pandora/Core/Transformation.hs
+++ /dev/null
@@ -1,9 +0,0 @@
-module Pandora.Core.Transformation (Natural, type (~>)) where
-
-import Pandora.Pattern.Functor.Covariant (Covariant)
-
-infixr 0 ~>
-
-type Natural t u = forall a . (Covariant t, Covariant u) => t a -> u a
-
-type (~>) t u = Natural t u
diff --git a/Pandora/Paradigm/Basis.hs b/Pandora/Paradigm/Basis.hs
--- a/Pandora/Paradigm/Basis.hs
+++ b/Pandora/Paradigm/Basis.hs
@@ -22,7 +22,7 @@
 import Pandora.Paradigm.Basis.Identity as Exports
 
 import Pandora.Core.Morphism ((!))
-import Pandora.Core.Transformation (type (~>))
+import Pandora.Core.Functor (type (~>))
 
 note :: e -> Maybe ~> Conclusion e
 note x = maybe (Failure x) Success
diff --git a/Pandora/Paradigm/Basis/Conclusion.hs b/Pandora/Paradigm/Basis/Conclusion.hs
--- a/Pandora/Paradigm/Basis/Conclusion.hs
+++ b/Pandora/Paradigm/Basis/Conclusion.hs
@@ -1,8 +1,8 @@
 module Pandora.Paradigm.Basis.Conclusion (Conclusion (..), Failable, conclusion, fail, failure) where
 
-import Pandora.Core.Transformation (type (~>))
+import Pandora.Core.Functor (type (~>))
 import Pandora.Pattern.Category ((.))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))
+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
 import Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic (Monadic (lay, wrap), (:>) (TM))
 import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)
 import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt))
@@ -14,6 +14,7 @@
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
 import Pandora.Pattern.Functor.Monad (Monad)
+import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))
 import Pandora.Pattern.Functor.Divariant (($))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)), Boolean (False))
 import Pandora.Pattern.Object.Chain (Chain ((<=>)), Ordering (Less, Greater))
@@ -46,6 +47,9 @@
 
 instance Monad (Conclusion e) where
 
+instance Bivariant Conclusion where
+    f <-> g = conclusion (Failure . f) (Success . g)
+
 instance (Setoid e, Setoid a) => Setoid (Conclusion e a) where
 	Success x == Success y = x == y
 	Failure x == Failure y = x == y
@@ -73,7 +77,7 @@
 
 instance Interpreted (Conclusion e) where
 	type Primary (Conclusion e) a = Conclusion e a
-	unwrap x = x
+	run x = x
 
 type instance Schematic Monad (Conclusion e) u = UT Covariant Covariant (Conclusion e) u
 
@@ -93,7 +97,7 @@
 	point = UT . point . point
 
 instance (Pointable u, Bindable u) => Bindable (UT Covariant Covariant (Conclusion e) u) where
-	UT x >>= f = UT $ x >>= conclusion (point . Failure) (unwrap . f)
+	UT x >>= f = UT $ x >>= conclusion (point . Failure) (run . f)
 
 instance Monad u => Monad (UT Covariant Covariant (Conclusion e) u) where
 
diff --git a/Pandora/Paradigm/Basis/Constant.hs b/Pandora/Paradigm/Basis/Constant.hs
--- a/Pandora/Paradigm/Basis/Constant.hs
+++ b/Pandora/Paradigm/Basis/Constant.hs
@@ -5,6 +5,7 @@
 import Pandora.Pattern.Functor.Invariant (Invariant (invmap))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
+import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))
 import Pandora.Pattern.Functor.Divariant (($))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Chain (Chain ((<=>)))
@@ -28,6 +29,9 @@
 
 instance Traversable (Constant a) where
 	Constant x ->> _ = point (Constant x)
+
+instance Bivariant Constant where
+	f <-> _ = \(Constant x) -> Constant $ f x
 
 instance Setoid a => Setoid (Constant a b) where
 	Constant x == Constant y = x == y
diff --git a/Pandora/Paradigm/Basis/Fix.hs b/Pandora/Paradigm/Basis/Fix.hs
--- a/Pandora/Paradigm/Basis/Fix.hs
+++ b/Pandora/Paradigm/Basis/Fix.hs
@@ -1,3 +1,16 @@
-module Pandora.Paradigm.Basis.Fix (Fix (..)) where
+module Pandora.Paradigm.Basis.Fix (Fix (..), cata, ana, hylo) where
 
+import Pandora.Core.Functor (type (<-|), type (|->))
+import Pandora.Pattern.Category ((.))
+import Pandora.Pattern.Functor.Covariant (Covariant (comap))
+
 newtype Fix t = Fix { unfix :: t (Fix t) }
+
+cata :: Covariant t => (a <-| t) -> Fix t -> a
+cata f = f . comap (cata f) . unfix
+
+ana :: Covariant t => (a |-> t) -> a -> Fix t
+ana f = Fix . comap (ana f) . f
+
+hylo :: Covariant t => (b <-| t) -> (a |-> t) -> (a -> b)
+hylo phi psi = cata phi . ana psi
diff --git a/Pandora/Paradigm/Basis/Jet.hs b/Pandora/Paradigm/Basis/Jet.hs
--- a/Pandora/Paradigm/Basis/Jet.hs
+++ b/Pandora/Paradigm/Basis/Jet.hs
@@ -17,7 +17,7 @@
 instance Traversable t => Traversable (Jet t) where
 	a :- as ->> f = (:-) <$> f a <*> as ->>> f
 
-instance (forall t' . Avoidable t') => Pointable (Jet t) where
+instance (forall u . Avoidable u) => Pointable (Jet t) where
 	point x = x :- empty
 
 instance Covariant t => Extractable (Jet t) where
diff --git a/Pandora/Paradigm/Basis/Maybe.hs b/Pandora/Paradigm/Basis/Maybe.hs
--- a/Pandora/Paradigm/Basis/Maybe.hs
+++ b/Pandora/Paradigm/Basis/Maybe.hs
@@ -1,6 +1,6 @@
 module Pandora.Paradigm.Basis.Maybe (Maybe (..), Optional, maybe, nothing) where
 
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))
+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
 import Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic (Monadic (lay, wrap), (:>) (TM))
 import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)
 import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt))
@@ -91,7 +91,7 @@
 
 instance Interpreted Maybe where
 	type Primary Maybe a = Maybe a
-	unwrap x = x
+	run x = x
 
 instance Monadic Maybe where
 	lay x = TM . UT $ Just <$> x
@@ -109,7 +109,7 @@
 	point = UT . point . point
 
 instance (Pointable u, Bindable u) => Bindable (UT Covariant Covariant Maybe u) where
-	UT x >>= f = UT $ x >>= maybe (point Nothing) (unwrap . f)
+	UT x >>= f = UT $ x >>= maybe (point Nothing) (run . f)
 
 instance Monad u => Monad (UT Covariant Covariant Maybe u) where
 
diff --git a/Pandora/Paradigm/Basis/Product.hs b/Pandora/Paradigm/Basis/Product.hs
--- a/Pandora/Paradigm/Basis/Product.hs
+++ b/Pandora/Paradigm/Basis/Product.hs
@@ -7,6 +7,8 @@
 import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
 import Pandora.Pattern.Functor.Comonad (Comonad)
 import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
+import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))
+import Pandora.Pattern.Functor.Divariant (($))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)), (&&))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 import Pandora.Pattern.Object.Monoid (Monoid (zero))
@@ -14,7 +16,6 @@
 import Pandora.Pattern.Object.Semilattice (Infimum ((/\)), Supremum ((\/)))
 import Pandora.Pattern.Object.Lattice (Lattice)
 import Pandora.Pattern.Object.Group (Group (inverse))
-import Pandora.Pattern.Functor.Divariant (($))
 
 infixr 1 :*:
 
@@ -39,6 +40,9 @@
 instance Adjoint (Product a) ((->) a) where
 	x -| f = \y -> f $ y :*: x
 	(y :*: x) |- f = f x y
+
+instance Bivariant Product where
+	f <-> g = \(x :*: y) -> f x :*: g y
 
 instance (Setoid a, Setoid b) => Setoid (Product a b) where
 	(x :*: y) == (x' :*: y') = x == x' && y == y'
diff --git a/Pandora/Paradigm/Basis/Tagged.hs b/Pandora/Paradigm/Basis/Tagged.hs
--- a/Pandora/Paradigm/Basis/Tagged.hs
+++ b/Pandora/Paradigm/Basis/Tagged.hs
@@ -11,6 +11,7 @@
 import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Pattern.Functor.Comonad (Comonad)
+import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))
 import Pandora.Pattern.Functor.Divariant (($))
 import Pandora.Pattern.Object.Setoid (Setoid ((==)))
 import Pandora.Pattern.Object.Chain (Chain ((<=>)))
@@ -53,6 +54,9 @@
 	x =>> f = Tag . f $ x
 
 instance Comonad (Tagged tag)
+
+instance Bivariant Tagged where
+	_ <-> g = \(Tag x) -> Tag $ g x
 
 instance Setoid a => Setoid (Tagged tag a) where
 	Tag x == Tag y = x == y
diff --git a/Pandora/Paradigm/Basis/Twister.hs b/Pandora/Paradigm/Basis/Twister.hs
--- a/Pandora/Paradigm/Basis/Twister.hs
+++ b/Pandora/Paradigm/Basis/Twister.hs
@@ -1,7 +1,6 @@
 module Pandora.Paradigm.Basis.Twister (Twister (..), untwist, coiterate, section) where
 
-import Pandora.Core.Functor (type (:.), type (:=), type (|->))
-import Pandora.Core.Transformation (type (~>))
+import Pandora.Core.Functor (type (:.), type (:=), type (|->), type (~>))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
 import Pandora.Pattern.Functor.Avoidable (Avoidable (empty))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
diff --git a/Pandora/Paradigm/Basis/Validation.hs b/Pandora/Paradigm/Basis/Validation.hs
--- a/Pandora/Paradigm/Basis/Validation.hs
+++ b/Pandora/Paradigm/Basis/Validation.hs
@@ -1,11 +1,15 @@
 module Pandora.Paradigm.Basis.Validation (Validation (..)) where
 
+import Pandora.Pattern.Category ((.))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
 import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
 import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>)))
+import Pandora.Pattern.Functor.Bivariant (Bivariant ((<->)))
 import Pandora.Pattern.Functor.Divariant (($))
+import Pandora.Pattern.Object.Setoid (Setoid ((==)), Boolean (False))
+import Pandora.Pattern.Object.Chain (Chain ((<=>)), Ordering (Less, Greater))
 import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
 
 data Validation e a = Flaws e | Validated a
@@ -20,7 +24,7 @@
 instance Semigroup e => Applicative (Validation e) where
 	Flaws e <*> Flaws e' = Flaws $ e + e'
 	Flaws e <*> Validated _ = Flaws e
-	Validated _ <*> Flaws e2 = Flaws e2
+	Validated _ <*> Flaws e' = Flaws e'
 	Validated f <*> Validated x = Validated $ f x
 
 instance Alternative (Validation e) where
@@ -30,3 +34,27 @@
 instance Traversable (Validation e) where
 	Validated x ->> f = Validated <$> f x
 	Flaws e ->> _ = point $ Flaws e
+
+instance Bivariant Validation where
+    f <-> g = validation (Flaws . f) (Validated . g)
+
+instance (Setoid e, Setoid a) => Setoid (Validation e a) where
+	Validated x == Validated y = x == y
+	Flaws x == Flaws y = x == y
+	_ == _ = False
+
+instance (Chain e, Chain a) => Chain (Validation e a) where
+	Validated x <=> Validated y = x <=> y
+	Flaws x <=> Flaws y = x <=> y
+	Flaws _ <=> Validated _ = Less
+	Validated _ <=> Flaws _ = Greater
+
+instance (Semigroup e, Semigroup a) => Semigroup (Validation e a) where
+	Validated x + Validated y = Validated $ x + y
+	Flaws x + Flaws y = Flaws $ x + y
+	Flaws _ + Validated y = Validated y
+	Validated x + Flaws _ = Validated x
+
+validation :: (e -> r) -> (a -> r) -> Validation e a -> r
+validation f _ (Flaws x) = f x
+validation _ s (Validated x) = s x
diff --git a/Pandora/Paradigm/Controlflow.hs b/Pandora/Paradigm/Controlflow.hs
--- a/Pandora/Paradigm/Controlflow.hs
+++ b/Pandora/Paradigm/Controlflow.hs
@@ -2,3 +2,4 @@
 
 import Pandora.Paradigm.Controlflow.Pipeline as Exports
 import Pandora.Paradigm.Controlflow.Observable as Exports
+import Pandora.Paradigm.Controlflow.Joint as Exports
diff --git a/Pandora/Paradigm/Controlflow/Joint/Adaptable.hs b/Pandora/Paradigm/Controlflow/Joint/Adaptable.hs
--- a/Pandora/Paradigm/Controlflow/Joint/Adaptable.hs
+++ b/Pandora/Paradigm/Controlflow/Joint/Adaptable.hs
@@ -2,20 +2,25 @@
 
 module Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (..)) where
 
-import Pandora.Core.Transformation (type (~>))
+import Pandora.Core.Functor (type (~>))
 import Pandora.Pattern.Category (identity, (.))
 import Pandora.Pattern.Functor.Covariant (Covariant)
 import Pandora.Pattern.Functor.Pointable (Pointable)
+import Pandora.Pattern.Functor.Extractable (Extractable)
+import Pandora.Pattern.Functor.Comonad (Comonad)
 import Pandora.Pattern.Functor.Monad (Monad)
 import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)
 import Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic (Monadic (lay, wrap), (:>))
+import Pandora.Paradigm.Controlflow.Joint.Transformer.Comonadic (Comonadic (flick, bring), (:<))
 
-class Covariant u => Adaptable t u where
+class Adaptable t u where
 	{-# MINIMAL adapt #-}
 	adapt :: t ~> u
 
 type Layable t u = (Monadic t, Covariant u)
 type Wrappable t u = (Monadic t, Pointable u)
+type Flickable t u = (Comonadic t, Covariant u)
+type Bringable t u = (Comonadic t, Extractable u)
 
 instance Covariant t => Adaptable t t where
 	adapt = identity
@@ -26,6 +31,12 @@
 instance (Covariant (t :> u), Wrappable t u) => Adaptable t (t :> u) where
 	adapt = wrap
 
+instance (Covariant (t :> u), Flickable t u) => Adaptable (t :< u) u where
+	adapt = flick
+
+instance (Covariant (t :< u), Bringable t u) => Adaptable (t :< u) t where
+	adapt = bring
+
 instance
 	( Covariant (t :> u :> v)
 	, Layable t (Schematic Monad u v)
@@ -41,6 +52,20 @@
 	adapt = lay . lay
 
 instance
+	( Covariant (t :< u :< v)
+	, Flickable t (Schematic Comonad u v)
+	, Bringable u v
+	) => Adaptable (t :< u :< v) u where
+	adapt = bring . flick
+
+instance
+	( Covariant (t :< u :< v)
+	, Flickable t (Schematic Comonad u v)
+	, Flickable u v
+	) => Adaptable (t :< u :< v) v where
+	adapt = flick . flick
+
+instance
 	( Covariant (t :> u :> v :> w)
 	, Layable t (Schematic Monad u (v :> w))
 	, Layable u (Schematic Monad v w)
@@ -58,6 +83,23 @@
 	adapt = lay . lay . lay
 
 instance
+	( Covariant (t :< u :< v :< w)
+	, Flickable t (Schematic Comonad u (v :< w))
+	, Flickable u (Schematic Comonad v w)
+	, Bringable v w
+	) => Adaptable (t :< u :< v :< w) v where
+	adapt = bring . flick . flick
+
+instance
+	( Covariant (t :< u :< v :< w)
+	, Flickable t (Schematic Comonad u v)
+	, Flickable t (Schematic Comonad u (v :< w))
+	, Flickable u (Schematic Comonad v w)
+	, Flickable v w
+	) => Adaptable (t :< u :< v :< w) w where
+	adapt = flick . flick . flick
+
+instance
 	( Covariant (t :> u :> v :> w :> x)
 	, Layable t (Schematic Monad u (v :> w :> x))
 	, Layable u (Schematic Monad v (w :> x))
@@ -76,6 +118,24 @@
 	adapt = lay . lay . lay . wrap
 
 instance
+	( Covariant (t :< u :< v :< w :< x)
+	, Flickable t (Schematic Comonad u (v :< w :< x))
+	, Flickable u (Schematic Comonad v (w :< x))
+	, Flickable v (Schematic Comonad w x)
+	, Flickable w x
+	) => Adaptable (t :< u :< v :< w :< x) x where
+	adapt = flick . flick . flick . flick
+
+instance
+	( Covariant (t :< u :< v :< w :< x)
+	, Flickable t (Schematic Comonad u (v :< w :< x))
+	, Flickable u (Schematic Comonad v (w :< x))
+	, Flickable v (Schematic Comonad w x)
+	, Bringable w x
+	) => Adaptable (t :< u :< v :< w :< x) w where
+	adapt = bring . flick . flick . flick
+
+instance
 	( Covariant (t :> u :> v :> w :> x :> y)
 	, Layable t (Schematic Monad u (v :> w :> x :> y))
 	, Layable u (Schematic Monad v (w :> x :> y))
@@ -96,6 +156,26 @@
 	adapt = lay . lay . lay . lay . wrap
 
 instance
+	( Covariant (t :< u :< v :< w :< x :< y)
+	, Flickable t (Schematic Comonad u (v :< w :< x :< y))
+	, Flickable u (Schematic Comonad v (w :< x :< y))
+	, Flickable v (Schematic Comonad w (x :< y))
+	, Flickable w (Schematic Comonad x y)
+	, Flickable x y
+	) => Adaptable (t :< u :< v :< w :< x :< y) y where
+	adapt = flick . flick . flick . flick . flick
+
+instance
+	( Covariant (t :< u :< v :< w :< x :< y)
+	, Flickable t (Schematic Comonad u (v :< w :< x :< y))
+	, Flickable u (Schematic Comonad v (w :< x :< y))
+	, Flickable v (Schematic Comonad w (x :< y))
+	, Flickable w (Schematic Comonad x y)
+	, Bringable x y
+	) => Adaptable (t :< u :< v :< w :< x :< y) x where
+	adapt = bring . flick . flick . flick . flick
+
+instance
 	( Covariant (t :> u :> v :> w :> x :> y :> z)
 	, Layable t (Schematic Monad u (v :> w :> x :> y :> z))
 	, Layable u (Schematic Monad v (w :> x :> y :> z))
@@ -118,6 +198,28 @@
 	adapt = lay . lay . lay . lay . lay . wrap
 
 instance
+	( Covariant (t :< u :< v :< w :< x :< y :< z)
+	, Flickable t (Schematic Comonad u (v :< w :< x :< y :< z))
+	, Flickable u (Schematic Comonad v (w :< x :< y :< z))
+	, Flickable v (Schematic Comonad w (x :< y :< z))
+	, Flickable w (Schematic Comonad x (y :< z))
+	, Flickable x (Schematic Comonad y z)
+	, Flickable y z
+	) => Adaptable (t :< u :< v :< w :< x :< y :< z) z where
+	adapt = flick . flick . flick . flick . flick . flick
+
+instance
+	( Covariant (t :< u :< v :< w :< x :< y :< z)
+	, Flickable t (Schematic Comonad u (v :< w :< x :< y :< z))
+	, Flickable u (Schematic Comonad v (w :< x :< y :< z))
+	, Flickable v (Schematic Comonad w (x :< y :< z))
+	, Flickable w (Schematic Comonad x (y :< z))
+	, Flickable x (Schematic Comonad y z)
+	, Bringable y z
+	) => Adaptable (t :< u :< v :< w :< x :< y :< z) y where
+	adapt = bring . flick . flick . flick . flick . flick
+
+instance
 	( Covariant (t :> u :> v :> w :> x :> y :> z :> f)
 	, Layable t (Schematic Monad u (v :> w :> x :> y :> z :> f))
 	, Layable u (Schematic Monad v (w :> x :> y :> z :> f))
@@ -142,6 +244,30 @@
 	adapt = lay . lay . lay . lay . lay . lay . wrap
 
 instance
+	( Covariant (t :< u :< v :< w :< x :< y :< z :< f)
+	, Flickable t (Schematic Comonad u (v :< w :< x :< y :< z :< f))
+	, Flickable u (Schematic Comonad v (w :< x :< y :< z :< f))
+	, Flickable v (Schematic Comonad w (x :< y :< z :< f))
+	, Flickable w (Schematic Comonad x (y :< z :< f))
+	, Flickable x (Schematic Comonad y (z :< f))
+	, Flickable y (Schematic Comonad z f)
+	, Flickable z f
+	) => Adaptable (t :< u :< v :< w :< x :< y :< z :< f) f where
+	adapt = flick . flick . flick . flick . flick . flick . flick
+
+instance
+	( Covariant (t :< u :< v :< w :< x :< y :< z :< f)
+	, Flickable t (Schematic Comonad u (v :< w :< x :< y :< z :< f))
+	, Flickable u (Schematic Comonad v (w :< x :< y :< z :< f))
+	, Flickable v (Schematic Comonad w (x :< y :< z :< f))
+	, Flickable w (Schematic Comonad x (y :< z :< f))
+	, Flickable x (Schematic Comonad y (z :< f))
+	, Flickable y (Schematic Comonad z f)
+	, Bringable z f
+	) => Adaptable (t :< u :< v :< w :< x :< y :< z :< f) z where
+	adapt = bring . flick . flick . flick . flick . flick . flick
+
+instance
 	( Covariant (t :> u :> v :> w :> x :> y :> z :> f :> h)
 	, Layable t (Schematic Monad u (v :> w :> x :> y :> z :> f :> h))
 	, Layable u (Schematic Monad v (w :> x :> y :> z :> f :> h))
@@ -166,3 +292,29 @@
 	, Wrappable f h
 	) => Adaptable f (t :> u :> v :> w :> x :> y :> z :> f :> h) where
 	adapt = lay . lay . lay . lay . lay . lay . lay . wrap
+
+instance
+	( Covariant (t :< u :< v :< w :< x :< y :< z :< f :< h)
+	, Flickable t (Schematic Comonad u (v :< w :< x :< y :< z :< f :< h))
+	, Flickable u (Schematic Comonad v (w :< x :< y :< z :< f :< h))
+	, Flickable v (Schematic Comonad w (x :< y :< z :< f :< h))
+	, Flickable w (Schematic Comonad x (y :< z :< f :< h))
+	, Flickable x (Schematic Comonad y (z :< f :< h))
+	, Flickable y (Schematic Comonad z (f :< h))
+	, Flickable z (Schematic Comonad f h)
+	, Flickable f h
+	) => Adaptable (t :< u :< v :< w :< x :< y :< z :< f :< h) h where
+	adapt = flick . flick . flick . flick . flick . flick . flick . flick
+
+instance
+	( Covariant (t :< u :< v :< w :< x :< y :< z :< f :< h)
+	, Flickable t (Schematic Comonad u (v :< w :< x :< y :< z :< f :< h))
+	, Flickable u (Schematic Comonad v (w :< x :< y :< z :< f :< h))
+	, Flickable v (Schematic Comonad w (x :< y :< z :< f :< h))
+	, Flickable w (Schematic Comonad x (y :< z :< f :< h))
+	, Flickable x (Schematic Comonad y (z :< f :< h))
+	, Flickable y (Schematic Comonad z (f :< h))
+	, Flickable z (Schematic Comonad f h)
+	, Bringable f h
+	) => Adaptable (t :< u :< v :< w :< x :< y :< z :< f :< h) f where
+	adapt = bring . flick . flick . flick . flick . flick . flick . flick
diff --git a/Pandora/Paradigm/Controlflow/Joint/Interpreted.hs b/Pandora/Paradigm/Controlflow/Joint/Interpreted.hs
--- a/Pandora/Paradigm/Controlflow/Joint/Interpreted.hs
+++ b/Pandora/Paradigm/Controlflow/Joint/Interpreted.hs
@@ -1,6 +1,6 @@
 module Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (..)) where
 
 class Interpreted t where
-	{-# MINIMAL unwrap #-}
+	{-# MINIMAL run #-}
 	type Primary t a :: *
-	unwrap :: t a -> Primary t a
+	run :: t a -> Primary t a
diff --git a/Pandora/Paradigm/Controlflow/Joint/Schemes/TU.hs b/Pandora/Paradigm/Controlflow/Joint/Schemes/TU.hs
--- a/Pandora/Paradigm/Controlflow/Joint/Schemes/TU.hs
+++ b/Pandora/Paradigm/Controlflow/Joint/Schemes/TU.hs
@@ -1,10 +1,10 @@
 module Pandora.Paradigm.Controlflow.Joint.Schemes.TU (TU (..)) where
 
 import Pandora.Core.Functor (type (:.), type (:=))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))
+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
 
 newtype TU ct cu t u a = TU (t :. u := a)
 
 instance Interpreted (TU ct cu t u) where
 	type Primary (TU ct cu t u) a = t :. u := a
-	unwrap (TU x) = x
+	run (TU x) = x
diff --git a/Pandora/Paradigm/Controlflow/Joint/Schemes/TUV.hs b/Pandora/Paradigm/Controlflow/Joint/Schemes/TUV.hs
--- a/Pandora/Paradigm/Controlflow/Joint/Schemes/TUV.hs
+++ b/Pandora/Paradigm/Controlflow/Joint/Schemes/TUV.hs
@@ -1,10 +1,10 @@
 module Pandora.Paradigm.Controlflow.Joint.Schemes.TUV (TUV (..)) where
 
 import Pandora.Core.Functor (type (:.), type (:=))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))
+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
 
 newtype TUV ct cu cv t u v a = TUV (t :. u :. v := a)
 
 instance Interpreted (TUV ct cu cv t u v) where
 	type Primary (TUV ct cu cv t u v) a = t :. u :. v := a
-	unwrap (TUV x) = x
+	run (TUV x) = x
diff --git a/Pandora/Paradigm/Controlflow/Joint/Schemes/TUVW.hs b/Pandora/Paradigm/Controlflow/Joint/Schemes/TUVW.hs
--- a/Pandora/Paradigm/Controlflow/Joint/Schemes/TUVW.hs
+++ b/Pandora/Paradigm/Controlflow/Joint/Schemes/TUVW.hs
@@ -1,10 +1,10 @@
 module Pandora.Paradigm.Controlflow.Joint.Schemes.TUVW (TUVW (..)) where
 
 import Pandora.Core.Functor (type (:.), type (:=))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))
+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
 
 newtype TUVW ct cu cv cw t u v w a = TUVW (t :. u :. v :. w := a)
 
 instance Interpreted (TUVW ct cu cv cw t u v w) where
 	type Primary (TUVW ct cu cv cw t u v w) a = t :. u :. v :. w := a
-	unwrap (TUVW x) = x
+	run (TUVW x) = x
diff --git a/Pandora/Paradigm/Controlflow/Joint/Schemes/UT.hs b/Pandora/Paradigm/Controlflow/Joint/Schemes/UT.hs
--- a/Pandora/Paradigm/Controlflow/Joint/Schemes/UT.hs
+++ b/Pandora/Paradigm/Controlflow/Joint/Schemes/UT.hs
@@ -1,10 +1,10 @@
 module Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (..)) where
 
 import Pandora.Core.Functor (type (:.), type (:=))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))
+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
 
 newtype UT ct cu t u a = UT (u :. t := a)
 
 instance Interpreted (UT ct cu t u) where
 	type Primary (UT ct cu t u) a = u :. t := a
-	unwrap (UT x) = x
+	run (UT x) = x
diff --git a/Pandora/Paradigm/Controlflow/Joint/Schemes/UTU.hs b/Pandora/Paradigm/Controlflow/Joint/Schemes/UTU.hs
--- a/Pandora/Paradigm/Controlflow/Joint/Schemes/UTU.hs
+++ b/Pandora/Paradigm/Controlflow/Joint/Schemes/UTU.hs
@@ -1,10 +1,10 @@
 module Pandora.Paradigm.Controlflow.Joint.Schemes.UTU (UTU (..)) where
 
 import Pandora.Core.Functor (type (:.), type (:=))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))
+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
 
 newtype UTU ct cu t u a = UTU (u :. t u := a)
 
 instance Interpreted (UTU ct cu t u) where
 	type Primary (UTU ct cu t u) a = u :. t u := a
-	unwrap (UTU x) = x
+	run (UTU x) = x
diff --git a/Pandora/Paradigm/Controlflow/Joint/Transformer/Comonadic.hs b/Pandora/Paradigm/Controlflow/Joint/Transformer/Comonadic.hs
--- a/Pandora/Paradigm/Controlflow/Joint/Transformer/Comonadic.hs
+++ b/Pandora/Paradigm/Controlflow/Joint/Transformer/Comonadic.hs
@@ -2,8 +2,8 @@
 
 module Pandora.Paradigm.Controlflow.Joint.Transformer.Comonadic (Comonadic (..), (:<) (..)) where
 
-import Pandora.Core.Transformation (type (~>))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))
+import Pandora.Core.Functor (type (~>))
+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
 import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)
 import Pandora.Pattern.Category ((.))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
@@ -55,4 +55,4 @@
 
 instance (Interpreted (Schematic Comonad t u)) => Interpreted (t :< u) where
 	type Primary (t :< u) a = Primary (Schematic Comonad t u) a
-	unwrap (TC x) = unwrap x
+	run (TC x) = run x
diff --git a/Pandora/Paradigm/Controlflow/Joint/Transformer/Monadic.hs b/Pandora/Paradigm/Controlflow/Joint/Transformer/Monadic.hs
--- a/Pandora/Paradigm/Controlflow/Joint/Transformer/Monadic.hs
+++ b/Pandora/Paradigm/Controlflow/Joint/Transformer/Monadic.hs
@@ -2,8 +2,8 @@
 
 module Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic (Monadic (..), (:>) (..)) where
 
-import Pandora.Core.Transformation (type (~>))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))
+import Pandora.Core.Functor (type (~>))
+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
 import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)
 import Pandora.Pattern.Category ((.))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
@@ -55,4 +55,4 @@
 
 instance (Interpreted (Schematic Monad t u)) => Interpreted (t :> u) where
 	type Primary (t :> u) a = Primary (Schematic Monad t u) a
-	unwrap (TM x) = unwrap x
+	run (TM x) = run x
diff --git a/Pandora/Paradigm/Inventory.hs b/Pandora/Paradigm/Inventory.hs
--- a/Pandora/Paradigm/Inventory.hs
+++ b/Pandora/Paradigm/Inventory.hs
@@ -3,5 +3,7 @@
 import Pandora.Paradigm.Inventory.Optics as Exports
 import Pandora.Paradigm.Inventory.Store as Exports
 import Pandora.Paradigm.Inventory.State as Exports
+import Pandora.Paradigm.Inventory.Imprint as Exports
+import Pandora.Paradigm.Inventory.Equipment as Exports
 import Pandora.Paradigm.Inventory.Environment as Exports
 import Pandora.Paradigm.Inventory.Accumulator as Exports
diff --git a/Pandora/Paradigm/Inventory/Accumulator.hs b/Pandora/Paradigm/Inventory/Accumulator.hs
--- a/Pandora/Paradigm/Inventory/Accumulator.hs
+++ b/Pandora/Paradigm/Inventory/Accumulator.hs
@@ -3,7 +3,7 @@
 module Pandora.Paradigm.Inventory.Accumulator (Accumulator (..), Accumulated, gather) where
 
 import Pandora.Paradigm.Basis.Product (Product ((:*:)), type (:*:))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))
+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
 import Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic (Monadic (lay, wrap), (:>) (TM))
 import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)
 import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt))
@@ -24,25 +24,25 @@
 	f <$> Accumulator x = Accumulator $ f <$> x
 
 instance Semigroup e => Applicative (Accumulator e) where
-	f <*> v = Accumulator $ k (unwrap f) (unwrap v) where
+	f <*> v = Accumulator $ k (run f) (run v) where
 		k ~(e :*: g) ~(e' :*: w) = e + e' :*: g w
 
 instance Monoid e => Pointable (Accumulator e) where
 	point = Accumulator . (zero :*:)
 
 instance Semigroup e => Bindable (Accumulator e) where
-	Accumulator (e :*: x) >>= f = let (e' :*: b) = unwrap $ f x in
+	Accumulator (e :*: x) >>= f = let (e' :*: b) = run $ f x in
 		Accumulator $ e + e':*: b
 
 type instance Schematic Monad (Accumulator e) u = UT Covariant Covariant ((:*:) e) u
 
 instance Interpreted (Accumulator e) where
 	type Primary (Accumulator e) a = e :*: a
-	unwrap (Accumulator x) = x
+	run (Accumulator x) = x
 
 instance Monoid e => Monadic (Accumulator e) where
 	lay x = TM . UT $ (zero :*:) <$> x
-	wrap = TM . UT . point . unwrap
+	wrap = TM . UT . point . run
 
 type Accumulated e t = Adaptable (Accumulator e) t
 
@@ -57,7 +57,7 @@
 	point = UT . point . (zero :*:)
 
 instance (Semigroup e, Pointable u, Bindable u) => Bindable (UT Covariant Covariant ((:*:) e) u) where
-	UT x >>= f = UT $ x >>= \(acc :*: v) -> (\(acc' :*: y) -> (acc + acc' :*: y)) <$> unwrap (f v)
+	UT x >>= f = UT $ x >>= \(acc :*: v) -> (\(acc' :*: y) -> (acc + acc' :*: y)) <$> run (f v)
 
 gather :: Accumulated e t => e -> t ()
 gather x = adapt . Accumulator $ x :*: ()
diff --git a/Pandora/Paradigm/Inventory/Environment.hs b/Pandora/Paradigm/Inventory/Environment.hs
--- a/Pandora/Paradigm/Inventory/Environment.hs
+++ b/Pandora/Paradigm/Inventory/Environment.hs
@@ -3,15 +3,15 @@
 module Pandora.Paradigm.Inventory.Environment (Environment (..), Configured, env) where
 
 import Pandora.Core.Morphism ((!), (%))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))
+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
 import Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic (Monadic (lay, wrap), (:>) (TM))
 import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)
 import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt))
 import Pandora.Paradigm.Controlflow.Joint.Schemes.TU (TU (TU))
 import Pandora.Pattern.Category (identity, (.))
-import Pandora.Pattern.Functor.Covariant (Covariant ((<$>)))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
 import Pandora.Pattern.Functor.Pointable (Pointable (point))
-import Pandora.Pattern.Functor.Applicative (Applicative ((<*>)))
+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (<**>)))
 import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
 import Pandora.Pattern.Functor.Monad (Monad)
@@ -26,39 +26,39 @@
 	point x = Environment (x !)
 
 instance Applicative (Environment e) where
-	f <*> x = Environment $ \e -> unwrap f e $ unwrap x e
+	f <*> x = Environment $ \e -> run f e $ run x e
 
 instance Distributive (Environment e) where
-	g >>- f = Environment $ g >>- (unwrap <$> f)
+	g >>- f = Environment $ g >>- (run <$> f)
 
 instance Bindable (Environment e) where
-	Environment x >>= f = Environment $ \e -> unwrap % e . f . x $ e
+	Environment x >>= f = Environment $ \e -> run % e . f . x $ e
 
 instance Monad (Environment e) where
 
-type instance Schematic Monad (Environment e) u = TU Covariant Covariant ((->) e) u
-
 instance Interpreted (Environment e) where
 	type Primary (Environment e) a = (->) e a
-	unwrap (Environment x) = x
+	run (Environment x) = x
 
+type instance Schematic Monad (Environment e) u = TU Covariant Covariant ((->) e) u
+
 instance Monadic (Environment e) where
 	lay = TM . TU . (!)
-	wrap x = TM. TU $ point <$> unwrap x
+	wrap x = TM . TU $ point <$> run x
 
 type Configured e = Adaptable (Environment e)
 
 instance Covariant u => Covariant (TU Covariant Covariant ((->) e) u) where
-	f <$> TU x = TU $ \r -> f <$> x r
+	f <$> TU x = TU $ f <$$> x
 
 instance (Covariant u, Pointable u) => Pointable (TU Covariant Covariant ((->) e) u) where
 	point = TU . point . point
 
 instance Applicative u => Applicative (TU Covariant Covariant ((->) e) u) where
-	TU f <*> TU x = TU $ \r -> f r <*> x r
+	TU f <*> TU x = TU $ f <**> x
 
 instance Bindable u => Bindable (TU Covariant Covariant ((->) e) u) where
-	TU x >>= f = TU $ \e -> x e >>= ($ e) . unwrap . f
+	TU x >>= f = TU $ \e -> x e >>= ($ e) . run . f
 
 env :: Configured e t => t e
 env = adapt $ Environment identity
diff --git a/Pandora/Paradigm/Inventory/Equipment.hs b/Pandora/Paradigm/Inventory/Equipment.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Inventory/Equipment.hs
@@ -0,0 +1,48 @@
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+
+module Pandora.Paradigm.Inventory.Equipment (Equipment (..), retrieve) where
+
+import Pandora.Paradigm.Basis.Product (Product ((:*:)), type (:*:), attached)
+import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt))
+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
+import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)
+import Pandora.Paradigm.Controlflow.Joint.Schemes.TU (TU (TU))
+import Pandora.Pattern.Category ((.))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
+import Pandora.Pattern.Functor.Extractable (Extractable (extract))
+import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
+import Pandora.Pattern.Functor.Comonad (Comonad)
+import Pandora.Pattern.Functor.Divariant (($))
+
+newtype Equipment e a = Equipment (e :*: a)
+
+instance Covariant (Equipment e) where
+	f <$> Equipment x = Equipment $ f <$> x
+
+instance Extractable (Equipment e) where
+	extract = extract . run
+
+instance Extendable (Equipment e) where
+	Equipment (e :*: x) =>> f = Equipment . (:*:) e . f . Equipment $ e :*: x
+
+type instance Schematic Comonad (Equipment e) u = TU Covariant Covariant ((:*:) e) u
+
+instance Interpreted (Equipment e) where
+	type Primary (Equipment e) a = e :*: a
+	run (Equipment x) = x
+
+type Equipped e t = Adaptable t (Equipment e)
+
+instance Covariant u => Covariant (TU Covariant Covariant ((:*:) e) u) where
+	f <$> TU x = TU $ f <$$> x
+
+instance Extractable u => Extractable (TU Covariant Covariant ((:*:) e) u) where
+	extract (TU x) = extract . extract $ x
+
+instance Extendable u => Extendable (TU Covariant Covariant ((:*:) e) u) where
+	TU (e :*: x) =>> f = TU . (:*:) e $ x =>> f . TU . (:*:) e
+
+instance Comonad (Equipment e) where
+
+retrieve :: Equipped e t => t a -> e
+retrieve = attached . run @(Equipment _) . adapt
diff --git a/Pandora/Paradigm/Inventory/Imprint.hs b/Pandora/Paradigm/Inventory/Imprint.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Paradigm/Inventory/Imprint.hs
@@ -0,0 +1,57 @@
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+
+module Pandora.Paradigm.Inventory.Imprint (Imprint (..), Traceable) where
+
+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
+import Pandora.Paradigm.Controlflow.Joint.Transformer.Comonadic (Comonadic (flick, bring), (:<) (TC))
+import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)
+import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable)
+import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT))
+import Pandora.Pattern.Category ((.))
+import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
+import Pandora.Pattern.Functor.Extractable (Extractable (extract))
+import Pandora.Pattern.Functor.Applicative (Applicative ((<*>), (<**>)))
+import Pandora.Pattern.Functor.Distributive (Distributive ((>>-)))
+import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
+import Pandora.Pattern.Functor.Comonad (Comonad)
+import Pandora.Pattern.Functor.Divariant (($))
+import Pandora.Pattern.Object.Monoid (Monoid (zero))
+import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
+
+newtype Imprint e a = Imprint (e -> a)
+
+instance Covariant (Imprint e) where
+	f <$> Imprint x = Imprint $ f . x
+
+instance Distributive (Imprint e) where
+	g >>- f = Imprint $ g >>- (run <$> f)
+
+instance Monoid e => Extractable (Imprint e) where
+	extract (Imprint x) = x zero
+
+instance Semigroup e => Extendable (Imprint e) where
+	Imprint x =>> f = Imprint $ \e -> f $ Imprint $ x . (e +)
+
+instance Interpreted (Imprint e) where
+	type Primary (Imprint e) a = (->) e a
+	run (Imprint x) = x
+
+type instance Schematic Comonad (Imprint e) u = UT Covariant Covariant ((->) e) u
+
+instance Monoid e => Comonadic (Imprint e) where
+	flick (TC (UT x)) = extract <$> x
+	bring (TC (UT x)) = Imprint . extract $ x
+
+instance Covariant u => Covariant (UT Covariant Covariant ((->) e) u) where
+	f <$> UT x = UT $ f <$$> x
+
+instance Applicative u => Applicative (UT Covariant Covariant ((->) e) u) where
+	UT f <*> UT x = UT $ f <**> x
+
+instance (Monoid e, Extractable u) => Extractable (UT Covariant Covariant ((->) e) u) where
+	extract (UT x) = extract . extract $ x
+
+instance (Semigroup e, Extendable u) => Extendable (UT Covariant Covariant ((->) e) u) where
+	UT x =>> f = UT $ x =>> (\x' e -> f . UT . (<$>) (. (e +)) $ x')
+
+type Traceable e t = Adaptable t (Imprint e)
diff --git a/Pandora/Paradigm/Inventory/Optics.hs b/Pandora/Paradigm/Inventory/Optics.hs
--- a/Pandora/Paradigm/Inventory/Optics.hs
+++ b/Pandora/Paradigm/Inventory/Optics.hs
@@ -1,26 +1,29 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 
-module Pandora.Paradigm.Inventory.Optics (Lens, type (:-.), (|>), view, set, over, (^.), (.~), (%~)) where
+module Pandora.Paradigm.Inventory.Optics (Lens, type (:-.), (|>), view, set, over, zoom, (^.), (.~), (%~)) where
 
+import Pandora.Core.Functor (type (|->))
 import Pandora.Core.Morphism ((!), (%))
 import Pandora.Paradigm.Basis.Product (Product ((:*:)))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (unwrap))
-import Pandora.Paradigm.Inventory.State (State (State))
+import Pandora.Paradigm.Controlflow.Joint.Adaptable (adapt)
+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (run))
+import Pandora.Paradigm.Inventory.State (State (State), Stateful)
 import Pandora.Paradigm.Inventory.Store (Store (Store), access, position, retrofit)
-import Pandora.Pattern.Category ((.))
+import Pandora.Pattern.Category (identity, (.))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$)))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
 import Pandora.Pattern.Functor.Adjoint (Adjoint ((-|), (|-)))
 import Pandora.Pattern.Functor.Divariant (($))
+import Pandora.Pattern.Functor.Bivariant ((<->))
 
 instance Adjoint (Store s) (State s) where
 	v -| f = State $ \s -> (:*:) s . f . Store $ s :*: (v !)
-	Store (s :*: f) |- g = extract . unwrap % s . g $ f s
+	Store (s :*: f) |- g = extract . run % s . g $ f s
 
 infixr 0 :-.
 type (:-.) src tgt = Lens src tgt
 
-type Lens src tgt = src -> Store tgt src
+type Lens src tgt = src |-> Store tgt
 
 -- | Lens composition infix operator
 (|>) :: Lens src btw -> Lens btw tgt -> Lens src tgt
@@ -49,3 +52,6 @@
 -- | Infix version of `over`
 (%~) :: Lens src tgt -> (tgt -> tgt) -> src -> src
 lens %~ f = over lens f
+
+zoom :: Stateful bg t => Lens bg ls -> State ls a -> t a
+zoom lens (State f) = adapt . State $ (\(Store (p :*: g)) -> (g <-> identity) . f $ p) . lens
diff --git a/Pandora/Paradigm/Inventory/State.hs b/Pandora/Paradigm/Inventory/State.hs
--- a/Pandora/Paradigm/Inventory/State.hs
+++ b/Pandora/Paradigm/Inventory/State.hs
@@ -17,7 +17,7 @@
 import Pandora.Pattern.Functor.Divariant (($))
 import Pandora.Pattern.Object.Setoid (bool)
 import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))
+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
 import Pandora.Paradigm.Controlflow.Joint.Transformer.Monadic (Monadic (lay, wrap), (:>) (TM))
 import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)
 import Pandora.Paradigm.Controlflow.Joint.Schemes.TUV (TUV (TUV))
@@ -39,12 +39,12 @@
 
 instance Bindable (State s) where
 	State x >>= f = State $ \old ->
-		uncurry (unwrap %) $ f <$> x old
+		uncurry (run %) $ f <$> x old
 
 instance Monad (State s) where
 
 fold :: Traversable t => s -> (a -> s -> s) -> t a -> s
-fold start op struct = extract . unwrap @(State _) % start $
+fold start op struct = extract . run @(State _) % start $
 	struct ->> modify . op $> () *> current
 
 find :: (Pointable u, Avoidable u, Alternative u, Traversable t) => Predicate a -> t a -> u a
@@ -52,14 +52,14 @@
 
 instance Interpreted (State s) where
 	type Primary (State s) a = (->) s :. (:*:) s := a
-	unwrap (State x) = x
+	run (State x) = x
 
 type instance Schematic Monad (State s) u =
 	TUV Covariant Covariant Covariant ((->) s) u ((:*:) s)
 
 instance Monadic (State s) where
 	lay x = TM . TUV $ \s -> (s :*:) <$> x
-	wrap x = TM . TUV $ point <$> unwrap x
+	wrap x = TM . TUV $ point <$> run x
 
 type Stateful s = Adaptable (State s)
 
@@ -73,7 +73,7 @@
 	point x = TUV $ \s -> point $ s :*: x
 
 instance Bindable u => Bindable (TUV Covariant Covariant Covariant ((->) s) u ((:*:) s)) where
-	TUV x >>= f = TUV $ \old -> x old >>= \(new :*: y) -> ($ new) . unwrap . f $ y
+	TUV x >>= f = TUV $ \old -> x old >>= \(new :*: y) -> ($ new) . run . f $ y
 
 instance Monad u => Monad (TUV Covariant Covariant Covariant ((->) s) u ((:*:) s)) where
 
diff --git a/Pandora/Paradigm/Inventory/Store.hs b/Pandora/Paradigm/Inventory/Store.hs
--- a/Pandora/Paradigm/Inventory/Store.hs
+++ b/Pandora/Paradigm/Inventory/Store.hs
@@ -1,18 +1,18 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 
-module Pandora.Paradigm.Inventory.Store (Store (..), position, access, retrofit) where
+module Pandora.Paradigm.Inventory.Store (Store (..), Storable, position, access, retrofit) where
 
-import Pandora.Core.Functor (type (:.), type (:=), type (<-|))
+import Pandora.Core.Functor (type (:.), type (:=), type (<-|), type (~>))
 import Pandora.Core.Morphism ((%))
-import Pandora.Core.Transformation (type (~>))
 import Pandora.Pattern.Category ((.))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
 import Pandora.Pattern.Functor.Extractable (Extractable (extract))
 import Pandora.Pattern.Functor.Extendable (Extendable ((=>>)))
 import Pandora.Pattern.Functor.Comonad (Comonad)
 import Pandora.Pattern.Functor.Divariant (($))
-import Pandora.Paradigm.Basis.Product (Product ((:*:)), type (:*:))
-import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, unwrap))
+import Pandora.Paradigm.Basis.Product (Product ((:*:)), type (:*:), attached)
+import Pandora.Paradigm.Controlflow.Joint.Adaptable (Adaptable (adapt))
+import Pandora.Paradigm.Controlflow.Joint.Interpreted (Interpreted (Primary, run))
 import Pandora.Paradigm.Controlflow.Joint.Schematic (Schematic)
 import Pandora.Paradigm.Controlflow.Joint.Schemes.TUV (TUV (TUV))
 import Pandora.Paradigm.Controlflow.Joint.Transformer.Comonadic (Comonadic (flick, bring), (:<) (TC))
@@ -33,7 +33,7 @@
 
 instance Interpreted (Store p) where
 	type Primary (Store p) a = (:*:) p :. (->) p := a
-	unwrap (Store x) = x
+	run (Store x) = x
 
 type instance Schematic Comonad (Store p) u =
 	TUV Covariant Covariant Covariant ((:*:) p) u ((->) p)
@@ -42,6 +42,8 @@
 	flick (TC (TUV (p :*: f))) = ($ p) <$> f
 	bring (TC (TUV (p :*: f))) = Store $ p :*: extract f
 
+type Storable s x = Adaptable x (Store s)
+
 instance Covariant u => Covariant (TUV Covariant Covariant Covariant ((:*:) p) u ((->) p)) where
 	f <$> TUV (p :*: x) = TUV . (:*:) p $ f <$$> x
 
@@ -51,11 +53,11 @@
 instance Extendable u => Extendable (TUV Covariant Covariant Covariant ((:*:) p) u ((->) p)) where
 	TUV (old :*: x) =>> f = TUV . (:*:) old $ x =>> (\x' new -> f . TUV . (:*:) new $ x')
 
-position :: Store p a -> p
-position (Store (p :*: _)) = p
+position :: Storable s t => t a -> s
+position = attached . run @(Store _) . adapt
 
-access :: p -> a <-| Store p
-access p = extract % p . unwrap
+access :: Storable s t => s -> a <-| t
+access p = extract % p . run @(Store _) . adapt
 
 retrofit :: (p -> p) -> Store p ~> Store p
 retrofit g (Store (p :*: f)) = Store $ g p :*: f
diff --git a/Pandora/Paradigm/Structure/Nonempty.hs b/Pandora/Paradigm/Structure/Nonempty.hs
--- a/Pandora/Paradigm/Structure/Nonempty.hs
+++ b/Pandora/Paradigm/Structure/Nonempty.hs
@@ -1,9 +1,12 @@
 module Pandora.Paradigm.Structure.Nonempty (Nonempty) where
 
 import Pandora.Paradigm.Basis.Maybe (Maybe)
+import Pandora.Paradigm.Basis.Edges (Edges)
 import Pandora.Paradigm.Basis.Twister (Twister)
 import Pandora.Paradigm.Structure.Specific.Stack (Stack)
+import Pandora.Paradigm.Structure.Specific.Graph (Graph)
 
 -- | Type synonymous for at least one element data structure
 type family Nonempty (structure :: * -> *) where
 	Nonempty Stack = Twister Maybe
+	Nonempty Graph = Twister Edges
diff --git a/Pandora/Paradigm/Structure/Specific/Graph.hs b/Pandora/Paradigm/Structure/Specific/Graph.hs
--- a/Pandora/Paradigm/Structure/Specific/Graph.hs
+++ b/Pandora/Paradigm/Structure/Specific/Graph.hs
@@ -2,7 +2,7 @@
 
 module Pandora.Paradigm.Structure.Specific.Graph (Graph, loose) where
 
-import Pandora.Core.Transformation (type (~>))
+import Pandora.Core.Functor (type (~>))
 import Pandora.Pattern.Category ((.))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
 import Pandora.Pattern.Functor.Divariant (($))
@@ -15,10 +15,10 @@
 -- | Directed acyclic graph structure
 type Graph = UT Covariant Covariant (Twister Edges) Edges
 
-instance Covariant (UT Covariant Covariant (Twister Edges) Edges) where
+instance Covariant Graph where
 	f <$> UT g = UT $ f <$$> g
 
-instance Traversable (UT Covariant Covariant (Twister Edges) Edges) where
+instance Traversable Graph where
 	UT g ->> f = UT <$> g ->>> f
 
 -- | Transform any traversable structure into all loose edges graph
diff --git a/Pandora/Paradigm/Structure/Specific/Stack.hs b/Pandora/Paradigm/Structure/Specific/Stack.hs
--- a/Pandora/Paradigm/Structure/Specific/Stack.hs
+++ b/Pandora/Paradigm/Structure/Specific/Stack.hs
@@ -2,12 +2,8 @@
 
 module Pandora.Paradigm.Structure.Specific.Stack (Stack, push, top, pop, filter, linearize) where
 
-import Pandora.Core.Transformation (type (~>))
-import Pandora.Paradigm.Basis.Maybe (Maybe (Just, Nothing))
-import Pandora.Paradigm.Basis.Predicate (Predicate (Predicate))
-import Pandora.Paradigm.Basis.Twister (Twister (Twister), untwist)
-import Pandora.Paradigm.Inventory.State (fold)
-import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT))
+import Pandora.Core.Functor (type (~>))
+import Pandora.Core.Morphism ((&))
 import Pandora.Pattern.Category ((.))
 import Pandora.Pattern.Functor.Covariant (Covariant ((<$>), (<$$>)))
 import Pandora.Pattern.Functor.Alternative (Alternative ((<+>)))
@@ -18,34 +14,58 @@
 import Pandora.Pattern.Functor.Traversable (Traversable ((->>), (->>>)))
 import Pandora.Pattern.Functor.Bindable (Bindable ((>>=)))
 import Pandora.Pattern.Functor.Divariant (($))
-import Pandora.Pattern.Object.Setoid ((?))
+import Pandora.Pattern.Object.Setoid (Setoid ((==)), (?))
+import Pandora.Pattern.Object.Semigroup (Semigroup ((+)))
+import Pandora.Pattern.Object.Monoid (Monoid (zero))
+import Pandora.Paradigm.Basis.Maybe (Maybe (Just, Nothing))
+import Pandora.Paradigm.Basis.Predicate (Predicate (Predicate))
+import Pandora.Paradigm.Basis.Product (Product ((:*:)))
+import Pandora.Paradigm.Basis.Twister (Twister (Twister), untwist)
+import Pandora.Paradigm.Inventory.State (fold)
+import Pandora.Paradigm.Inventory.Store (Store (Store))
+import Pandora.Paradigm.Inventory.Optics (type (:-.))
+import Pandora.Paradigm.Controlflow.Joint.Interpreted (run)
+import Pandora.Paradigm.Controlflow.Joint.Schemes.UT (UT (UT))
 
 -- | Linear data structure that serves as a collection of elements
 type Stack = UT Covariant Covariant (Twister Maybe) Maybe
 
-instance Covariant (UT Covariant Covariant (Twister Maybe) Maybe) where
+instance Covariant Stack where
 	f <$> UT stack = UT $ f <$$> stack
 
-instance Pointable (UT Covariant Covariant (Twister Maybe) Maybe) where
+instance Pointable Stack where
 	point = UT . Just . point
 
-instance Alternative (UT Covariant Covariant (Twister Maybe) Maybe) where
+instance Alternative Stack where
 	UT x <+> UT y = UT $ x <+> y
 
-instance Avoidable (UT Covariant Covariant (Twister Maybe) Maybe) where
+instance Avoidable Stack where
 	empty = UT Nothing
 
-instance Applicative (UT Covariant Covariant (Twister Maybe) Maybe) where
+instance Applicative Stack where
 	UT f <*> UT x = UT $ f <**> x
 
-instance Traversable (UT Covariant Covariant (Twister Maybe) Maybe) where
+instance Traversable Stack where
 	UT stack ->> f = UT <$> stack ->>> f
 
+instance Setoid a => Setoid (Stack a) where
+	UT ls == UT rs = ls == rs
+
+instance Semigroup (Stack a) where
+	UT Nothing + UT ys = UT ys
+	UT (Just (Twister x xs)) + UT ys = UT . Just . Twister x . run
+		$ UT @Covariant @Covariant xs + UT @Covariant @Covariant ys
+
+instance Monoid (Stack a) where
+	zero = UT Nothing
+
+top :: Stack a :-. Maybe a
+top stack = Store $ (:*:) (extract <$> run stack) $ \case
+    Just x -> stack & pop & push x
+    Nothing -> pop stack
+
 push :: a -> Stack a -> Stack a
 push x (UT stack) = UT $ (Twister x . Just <$> stack) <+> (point . point) x
-
-top :: Stack ~> Maybe
-top (UT stack) = extract <$> stack
 
 pop :: Stack ~> Stack
 pop (UT stack) = UT $ stack >>= untwist
diff --git a/Pandora/Pattern/Functor.hs b/Pandora/Pattern/Functor.hs
--- a/Pandora/Pattern/Functor.hs
+++ b/Pandora/Pattern/Functor.hs
@@ -1,5 +1,6 @@
 module Pandora.Pattern.Functor (module Exports) where
 
+import Pandora.Pattern.Functor.Bivariant as Exports
 import Pandora.Pattern.Functor.Divariant as Exports
 import Pandora.Pattern.Functor.Lowerable as Exports
 import Pandora.Pattern.Functor.Liftable as Exports
diff --git a/Pandora/Pattern/Functor/Bivariant.hs b/Pandora/Pattern/Functor/Bivariant.hs
new file mode 100644
--- /dev/null
+++ b/Pandora/Pattern/Functor/Bivariant.hs
@@ -0,0 +1,18 @@
+module Pandora.Pattern.Functor.Bivariant (Bivariant (..)) where
+
+import Pandora.Pattern.Functor.Divariant (($))
+
+infixl 4 <->
+
+{- |
+> When providing a new instance, you should ensure it satisfies the two laws:
+> * Identity: bimap identity identity ≡ identity
+> * Parametricity: bimap  (f . g) (h . i) ≡ bimap f h . bimap g i
+-}
+
+class Bivariant (v :: * -> * -> *) where
+	{-# MINIMAL (<->) #-}
+	(<->) :: (a -> b) -> (c -> d) -> v a c -> v b d
+	-- | Prefix version of '<->'
+	bimap :: (a -> b) -> (c -> d) -> v a c -> v b d
+	bimap f g x = f <-> g $ x
diff --git a/Pandora/Pattern/Functor/Extractable.hs b/Pandora/Pattern/Functor/Extractable.hs
--- a/Pandora/Pattern/Functor/Extractable.hs
+++ b/Pandora/Pattern/Functor/Extractable.hs
@@ -2,6 +2,10 @@
 
 import Pandora.Core.Functor (type (<-|))
 import Pandora.Pattern.Functor.Covariant (Covariant)
+import Pandora.Pattern.Object.Monoid (Monoid (zero))
 
 class Covariant t => Extractable t where
 	extract :: a <-| t
+
+instance Monoid e => Extractable ((->) e) where
+	extract f = f zero
diff --git a/Pandora/Pattern/Functor/Liftable.hs b/Pandora/Pattern/Functor/Liftable.hs
--- a/Pandora/Pattern/Functor/Liftable.hs
+++ b/Pandora/Pattern/Functor/Liftable.hs
@@ -1,6 +1,6 @@
 module Pandora.Pattern.Functor.Liftable (Liftable (..)) where
 
-import Pandora.Core.Transformation (type (~>))
+import Pandora.Core.Functor (type (~>))
 import Pandora.Pattern.Functor.Covariant (Covariant)
 
 class Liftable t where
diff --git a/Pandora/Pattern/Functor/Lowerable.hs b/Pandora/Pattern/Functor/Lowerable.hs
--- a/Pandora/Pattern/Functor/Lowerable.hs
+++ b/Pandora/Pattern/Functor/Lowerable.hs
@@ -1,6 +1,6 @@
 module Pandora.Pattern.Functor.Lowerable (Lowerable (..)) where
 
-import Pandora.Core.Transformation (type (~>))
+import Pandora.Core.Functor (type (~>))
 import Pandora.Pattern.Functor.Covariant (Covariant)
 
 class Lowerable t where
diff --git a/pandora.cabal b/pandora.cabal
--- a/pandora.cabal
+++ b/pandora.cabal
@@ -1,5 +1,5 @@
 name:                pandora
-version:             0.2.3
+version:             0.2.4
 synopsis:            A box of patterns and paradigms
 description:         Humble attempt to define a library for problem solving based on math abstractions.
 homepage:            https://github.com/iokasimov/pandora
@@ -23,7 +23,6 @@
     Pandora.Core
     Pandora.Core.Functor
     Pandora.Core.Morphism
-    Pandora.Core.Transformation
 
     Pandora.Paradigm
     -- Basic constructions
@@ -71,6 +70,8 @@
     Pandora.Paradigm.Inventory
     Pandora.Paradigm.Inventory.Accumulator
     Pandora.Paradigm.Inventory.Environment
+    Pandora.Paradigm.Inventory.Equipment
+    Pandora.Paradigm.Inventory.Imprint
     Pandora.Paradigm.Inventory.Optics
     Pandora.Paradigm.Inventory.State
     Pandora.Paradigm.Inventory.Store
@@ -108,6 +109,7 @@
     Pandora.Pattern.Functor.Representable
     Pandora.Pattern.Functor.Traversable
     Pandora.Pattern.Functor.Divariant
+    Pandora.Pattern.Functor.Bivariant
     -- Typeclassess about object internals
     Pandora.Pattern.Object
     Pandora.Pattern.Object.Chain
@@ -121,7 +123,7 @@
     Pandora.Pattern.Object.Setoid
   default-extensions:
     DataKinds, ConstraintKinds, ExistentialQuantification, GADTs, QuantifiedConstraints
-    FlexibleContexts, FlexibleInstances, KindSignatures, LiberalTypeSynonyms
+    FlexibleContexts, FlexibleInstances, KindSignatures, LiberalTypeSynonyms, LambdaCase
     MultiParamTypeClasses, NoImplicitPrelude, PackageImports, PolyKinds, RankNTypes
     ScopedTypeVariables, TypeApplications, TypeFamilies, TypeFamilyDependencies, TypeOperators
   default-language: Haskell2010