diff --git a/seed/helpers.go b/seed/helpers.go
index d84e413c1e1..a72a1a770d9 100644
--- a/seed/helpers.go
+++ b/seed/helpers.go
@@ -100,3 +100,20 @@ func readInfo(snapPath string, si *snap.SideInfo) (*snap.Info, error) {
 	}
 	return snap.ReadInfoFromSnapFile(snapf, si)
 }
+
+func snapTypeFromModel(modSnap *asserts.ModelSnap) snap.Type {
+	switch modSnap.SnapType {
+	case "base":
+		return snap.TypeBase
+	case "core":
+		return snap.TypeOS
+	case "gadget":
+		return snap.TypeGadget
+	case "kernel":
+		return snap.TypeKernel
+	case "snapd":
+		return snap.TypeSnapd
+	default:
+		return snap.TypeApp
+	}
+}
diff --git a/seed/seed.go b/seed/seed.go
index 4eb7ba44f8b..5042d42a26a 100644
--- a/seed/seed.go
+++ b/seed/seed.go
@@ -40,6 +40,10 @@ type Snap struct {
 
 	SideInfo *snap.SideInfo
 
+	// EssentialType is the type of the snap as specified by the model.
+	// Provided only for essential snaps (Essential = true).
+	EssentialType snap.Type
+
 	Essential bool
 	Required  bool
 
diff --git a/seed/seed16.go b/seed/seed16.go
index 01acdcedd1e..38d16feab90 100644
--- a/seed/seed16.go
+++ b/seed/seed16.go
@@ -196,7 +196,7 @@ func (s *seed16) LoadMeta(tm timings.Measurer) error {
 	}
 
 	// add the essential snaps
-	addEssential := func(snapName string, pinnedTrack string) (*Snap, error) {
+	addEssential := func(snapName string, pinnedTrack string, essType snap.Type) (*Snap, error) {
 		// be idempotent
 		if added[snapName] {
 			return nil, nil
@@ -211,6 +211,11 @@ func (s *seed16) LoadMeta(tm timings.Measurer) error {
 			return nil, err
 		}
 
+		if essType == snap.TypeBase && snapName == "core" {
+			essType = snap.TypeOS
+		}
+
+		seedSnap.EssentialType = essType
 		seedSnap.Essential = true
 		seedSnap.Required = true
 		added[snapName] = true
@@ -222,25 +227,25 @@ func (s *seed16) LoadMeta(tm timings.Measurer) error {
 	if len(yamlSnaps) != 0 {
 		// ensure "snapd" snap is installed first
 		if model.Base() != "" || classicWithSnapd {
-			if _, err := addEssential("snapd", ""); err != nil {
+			if _, err := addEssential("snapd", "", snap.TypeSnapd); err != nil {
 				return err
 			}
 		}
 		if !classicWithSnapd {
-			if _, err := addEssential(baseSnap, ""); err != nil {
+			if _, err := addEssential(baseSnap, "", snap.TypeBase); err != nil {
 				return err
 			}
 		}
 	}
 
 	if kernelName := model.Kernel(); kernelName != "" {
-		if _, err := addEssential(kernelName, model.KernelTrack()); err != nil {
+		if _, err := addEssential(kernelName, model.KernelTrack(), snap.TypeKernel); err != nil {
 			return err
 		}
 	}
 
 	if gadgetName := model.Gadget(); gadgetName != "" {
-		gadget, err := addEssential(gadgetName, model.GadgetTrack())
+		gadget, err := addEssential(gadgetName, model.GadgetTrack(), snap.TypeGadget)
 		if err != nil {
 			return err
 		}
@@ -260,7 +265,7 @@ func (s *seed16) LoadMeta(tm timings.Measurer) error {
 		if baseSnap != "" && gadgetBase != baseSnap {
 			return fmt.Errorf("cannot use gadget snap because its base %q is different from model base %q", gadgetBase, model.Base())
 		}
-		if _, err = addEssential(gadgetBase, ""); err != nil {
+		if _, err = addEssential(gadgetBase, "", snap.TypeBase); err != nil {
 			return err
 		}
 	}
diff --git a/seed/seed16_test.go b/seed/seed16_test.go
index 78cb4891e56..e9325452f8d 100644
--- a/seed/seed16_test.go
+++ b/seed/seed16_test.go
@@ -441,23 +441,26 @@ func (s *seed16Suite) TestLoadMetaCore16Minimal(c *C) {
 
 	c.Check(essSnaps, DeepEquals, []*seed.Snap{
 		{
-			Path:      s.expectedPath("core"),
-			SideInfo:  &s.AssertedSnapInfo("core").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "stable",
+			Path:          s.expectedPath("core"),
+			SideInfo:      &s.AssertedSnapInfo("core").SideInfo,
+			EssentialType: snap.TypeOS,
+			Essential:     true,
+			Required:      true,
+			Channel:       "stable",
 		}, {
-			Path:      s.expectedPath("pc-kernel"),
-			SideInfo:  &s.AssertedSnapInfo("pc-kernel").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "stable",
+			Path:          s.expectedPath("pc-kernel"),
+			SideInfo:      &s.AssertedSnapInfo("pc-kernel").SideInfo,
+			EssentialType: snap.TypeKernel,
+			Essential:     true,
+			Required:      true,
+			Channel:       "stable",
 		}, {
-			Path:      s.expectedPath("pc"),
-			SideInfo:  &s.AssertedSnapInfo("pc").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "stable",
+			Path:          s.expectedPath("pc"),
+			SideInfo:      &s.AssertedSnapInfo("pc").SideInfo,
+			EssentialType: snap.TypeGadget,
+			Essential:     true,
+			Required:      true,
+			Channel:       "stable",
 		},
 	})
 
@@ -514,29 +517,33 @@ func (s *seed16Suite) TestLoadMetaCore18Minimal(c *C) {
 
 	c.Check(essSnaps, DeepEquals, []*seed.Snap{
 		{
-			Path:      s.expectedPath("snapd"),
-			SideInfo:  &s.AssertedSnapInfo("snapd").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "stable",
+			Path:          s.expectedPath("snapd"),
+			SideInfo:      &s.AssertedSnapInfo("snapd").SideInfo,
+			EssentialType: snap.TypeSnapd,
+			Essential:     true,
+			Required:      true,
+			Channel:       "stable",
 		}, {
-			Path:      s.expectedPath("core18"),
-			SideInfo:  &s.AssertedSnapInfo("core18").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "stable",
+			Path:          s.expectedPath("core18"),
+			SideInfo:      &s.AssertedSnapInfo("core18").SideInfo,
+			EssentialType: snap.TypeBase,
+			Essential:     true,
+			Required:      true,
+			Channel:       "stable",
 		}, {
-			Path:      s.expectedPath("pc-kernel"),
-			SideInfo:  &s.AssertedSnapInfo("pc-kernel").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "18",
+			Path:          s.expectedPath("pc-kernel"),
+			SideInfo:      &s.AssertedSnapInfo("pc-kernel").SideInfo,
+			EssentialType: snap.TypeKernel,
+			Essential:     true,
+			Required:      true,
+			Channel:       "18",
 		}, {
-			Path:      s.expectedPath("pc"),
-			SideInfo:  &s.AssertedSnapInfo("pc").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "18",
+			Path:          s.expectedPath("pc"),
+			SideInfo:      &s.AssertedSnapInfo("pc").SideInfo,
+			EssentialType: snap.TypeGadget,
+			Essential:     true,
+			Required:      true,
+			Channel:       "18",
 		},
 	})
 
@@ -564,29 +571,33 @@ func (s *seed16Suite) TestLoadMetaCore18(c *C) {
 
 	c.Check(essSnaps, DeepEquals, []*seed.Snap{
 		{
-			Path:      s.expectedPath("snapd"),
-			SideInfo:  &s.AssertedSnapInfo("snapd").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "stable",
+			Path:          s.expectedPath("snapd"),
+			SideInfo:      &s.AssertedSnapInfo("snapd").SideInfo,
+			EssentialType: snap.TypeSnapd,
+			Essential:     true,
+			Required:      true,
+			Channel:       "stable",
 		}, {
-			Path:      s.expectedPath("core18"),
-			SideInfo:  &s.AssertedSnapInfo("core18").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "stable",
+			Path:          s.expectedPath("core18"),
+			SideInfo:      &s.AssertedSnapInfo("core18").SideInfo,
+			EssentialType: snap.TypeBase,
+			Essential:     true,
+			Required:      true,
+			Channel:       "stable",
 		}, {
-			Path:      s.expectedPath("pc-kernel"),
-			SideInfo:  &s.AssertedSnapInfo("pc-kernel").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "18",
+			Path:          s.expectedPath("pc-kernel"),
+			SideInfo:      &s.AssertedSnapInfo("pc-kernel").SideInfo,
+			EssentialType: snap.TypeKernel,
+			Essential:     true,
+			Required:      true,
+			Channel:       "18",
 		}, {
-			Path:      s.expectedPath("pc"),
-			SideInfo:  &s.AssertedSnapInfo("pc").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "18",
+			Path:          s.expectedPath("pc"),
+			SideInfo:      &s.AssertedSnapInfo("pc").SideInfo,
+			EssentialType: snap.TypeGadget,
+			Essential:     true,
+			Required:      true,
+			Channel:       "18",
 		},
 	})
 
@@ -653,11 +664,12 @@ func (s *seed16Suite) TestLoadMetaClassicCore(c *C) {
 	c.Check(essSnaps, HasLen, 1)
 	c.Check(essSnaps, DeepEquals, []*seed.Snap{
 		{
-			Path:      s.expectedPath("core"),
-			SideInfo:  &s.AssertedSnapInfo("core").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "stable",
+			Path:          s.expectedPath("core"),
+			SideInfo:      &s.AssertedSnapInfo("core").SideInfo,
+			EssentialType: snap.TypeOS,
+			Essential:     true,
+			Required:      true,
+			Channel:       "stable",
 		},
 	})
 
@@ -693,18 +705,20 @@ func (s *seed16Suite) TestLoadMetaClassicCoreWithGadget(c *C) {
 	c.Check(essSnaps, HasLen, 2)
 	c.Check(essSnaps, DeepEquals, []*seed.Snap{
 		{
-			Path:      s.expectedPath("core"),
-			SideInfo:  &s.AssertedSnapInfo("core").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "stable",
+			Path:          s.expectedPath("core"),
+			SideInfo:      &s.AssertedSnapInfo("core").SideInfo,
+			EssentialType: snap.TypeOS,
+			Essential:     true,
+			Required:      true,
+			Channel:       "stable",
 		},
 		{
-			Path:      s.expectedPath("classic-gadget"),
-			SideInfo:  &s.AssertedSnapInfo("classic-gadget").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "stable",
+			Path:          s.expectedPath("classic-gadget"),
+			SideInfo:      &s.AssertedSnapInfo("classic-gadget").SideInfo,
+			EssentialType: snap.TypeGadget,
+			Essential:     true,
+			Required:      true,
+			Channel:       "stable",
 		},
 	})
 
@@ -731,11 +745,12 @@ func (s *seed16Suite) TestLoadMetaClassicSnapd(c *C) {
 	c.Check(essSnaps, HasLen, 1)
 	c.Check(essSnaps, DeepEquals, []*seed.Snap{
 		{
-			Path:      s.expectedPath("snapd"),
-			SideInfo:  &s.AssertedSnapInfo("snapd").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "stable",
+			Path:          s.expectedPath("snapd"),
+			SideInfo:      &s.AssertedSnapInfo("snapd").SideInfo,
+			EssentialType: snap.TypeSnapd,
+			Essential:     true,
+			Required:      true,
+			Channel:       "stable",
 		},
 	})
 
@@ -775,20 +790,26 @@ func (s *seed16Suite) TestLoadMetaClassicSnapdWithGadget(c *C) {
 	c.Check(essSnaps, HasLen, 3)
 	c.Check(essSnaps, DeepEquals, []*seed.Snap{
 		{
-			Path:      s.expectedPath("snapd"),
-			SideInfo:  &s.AssertedSnapInfo("snapd").SideInfo,
+			Path:          s.expectedPath("snapd"),
+			SideInfo:      &s.AssertedSnapInfo("snapd").SideInfo,
+			EssentialType: snap.TypeSnapd,
+
 			Essential: true,
 			Required:  true,
 			Channel:   "stable",
 		}, {
-			Path:      s.expectedPath("classic-gadget"),
-			SideInfo:  &s.AssertedSnapInfo("classic-gadget").SideInfo,
+			Path:          s.expectedPath("classic-gadget"),
+			SideInfo:      &s.AssertedSnapInfo("classic-gadget").SideInfo,
+			EssentialType: snap.TypeGadget,
+
 			Essential: true,
 			Required:  true,
 			Channel:   "stable",
 		}, {
-			Path:      s.expectedPath("core"),
-			SideInfo:  &s.AssertedSnapInfo("core").SideInfo,
+			Path:          s.expectedPath("core"),
+			SideInfo:      &s.AssertedSnapInfo("core").SideInfo,
+			EssentialType: snap.TypeOS,
+
 			Essential: true,
 			Required:  true,
 			Channel:   "stable",
@@ -819,20 +840,26 @@ func (s *seed16Suite) TestLoadMetaClassicSnapdWithGadget18(c *C) {
 	c.Check(essSnaps, HasLen, 3)
 	c.Check(essSnaps, DeepEquals, []*seed.Snap{
 		{
-			Path:      s.expectedPath("snapd"),
-			SideInfo:  &s.AssertedSnapInfo("snapd").SideInfo,
+			Path:          s.expectedPath("snapd"),
+			SideInfo:      &s.AssertedSnapInfo("snapd").SideInfo,
+			EssentialType: snap.TypeSnapd,
+
 			Essential: true,
 			Required:  true,
 			Channel:   "stable",
 		}, {
-			Path:      s.expectedPath("classic-gadget18"),
-			SideInfo:  &s.AssertedSnapInfo("classic-gadget18").SideInfo,
+			Path:          s.expectedPath("classic-gadget18"),
+			SideInfo:      &s.AssertedSnapInfo("classic-gadget18").SideInfo,
+			EssentialType: snap.TypeGadget,
+
 			Essential: true,
 			Required:  true,
 			Channel:   "stable",
 		}, {
-			Path:      s.expectedPath("core18"),
-			SideInfo:  &s.AssertedSnapInfo("core18").SideInfo,
+			Path:          s.expectedPath("core18"),
+			SideInfo:      &s.AssertedSnapInfo("core18").SideInfo,
+			EssentialType: snap.TypeBase,
+
 			Essential: true,
 			Required:  true,
 			Channel:   "stable",
@@ -881,29 +908,33 @@ func (s *seed16Suite) TestLoadMetaCore18Local(c *C) {
 
 	c.Check(essSnaps, DeepEquals, []*seed.Snap{
 		{
-			Path:      s.expectedPath("snapd"),
-			SideInfo:  &s.AssertedSnapInfo("snapd").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "stable",
+			Path:          s.expectedPath("snapd"),
+			SideInfo:      &s.AssertedSnapInfo("snapd").SideInfo,
+			EssentialType: snap.TypeSnapd,
+			Essential:     true,
+			Required:      true,
+			Channel:       "stable",
 		}, {
-			Path:      s.expectedPath("core18"),
-			SideInfo:  &s.AssertedSnapInfo("core18").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "stable",
+			Path:          s.expectedPath("core18"),
+			SideInfo:      &s.AssertedSnapInfo("core18").SideInfo,
+			EssentialType: snap.TypeBase,
+			Essential:     true,
+			Required:      true,
+			Channel:       "stable",
 		}, {
-			Path:      s.expectedPath("pc-kernel"),
-			SideInfo:  &s.AssertedSnapInfo("pc-kernel").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "18",
+			Path:          s.expectedPath("pc-kernel"),
+			SideInfo:      &s.AssertedSnapInfo("pc-kernel").SideInfo,
+			EssentialType: snap.TypeKernel,
+			Essential:     true,
+			Required:      true,
+			Channel:       "18",
 		}, {
-			Path:      s.expectedPath("pc"),
-			SideInfo:  &s.AssertedSnapInfo("pc").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "18",
+			Path:          s.expectedPath("pc"),
+			SideInfo:      &s.AssertedSnapInfo("pc").SideInfo,
+			EssentialType: snap.TypeGadget,
+			Essential:     true,
+			Required:      true,
+			Channel:       "18",
 		},
 	})
 
@@ -991,29 +1022,33 @@ func (s *seed16Suite) TestLoadMetaCore18EnforcePinnedTracks(c *C) {
 
 	c.Check(essSnaps, DeepEquals, []*seed.Snap{
 		{
-			Path:      s.expectedPath("snapd"),
-			SideInfo:  &s.AssertedSnapInfo("snapd").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "stable",
+			Path:          s.expectedPath("snapd"),
+			SideInfo:      &s.AssertedSnapInfo("snapd").SideInfo,
+			EssentialType: snap.TypeSnapd,
+			Essential:     true,
+			Required:      true,
+			Channel:       "stable",
 		}, {
-			Path:      s.expectedPath("core18"),
-			SideInfo:  &s.AssertedSnapInfo("core18").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "stable",
+			Path:          s.expectedPath("core18"),
+			SideInfo:      &s.AssertedSnapInfo("core18").SideInfo,
+			EssentialType: snap.TypeBase,
+			Essential:     true,
+			Required:      true,
+			Channel:       "stable",
 		}, {
-			Path:      s.expectedPath("pc-kernel"),
-			SideInfo:  &s.AssertedSnapInfo("pc-kernel").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "18",
+			Path:          s.expectedPath("pc-kernel"),
+			SideInfo:      &s.AssertedSnapInfo("pc-kernel").SideInfo,
+			EssentialType: snap.TypeKernel,
+			Essential:     true,
+			Required:      true,
+			Channel:       "18",
 		}, {
-			Path:      s.expectedPath("pc"),
-			SideInfo:  &s.AssertedSnapInfo("pc").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "18/edge",
+			Path:          s.expectedPath("pc"),
+			SideInfo:      &s.AssertedSnapInfo("pc").SideInfo,
+			EssentialType: snap.TypeGadget,
+			Essential:     true,
+			Required:      true,
+			Channel:       "18/edge",
 		},
 	})
 
diff --git a/seed/seed20.go b/seed/seed20.go
index 292fea5e53b..af9b80271a7 100644
--- a/seed/seed20.go
+++ b/seed/seed20.go
@@ -362,6 +362,7 @@ func (s *seed20) addModelSnap(modelSnap *asserts.ModelSnap, essential bool, tm t
 	seedSnap.Essential = essential
 	seedSnap.Required = essential || modelSnap.Presence == "required"
 	if essential {
+		seedSnap.EssentialType = snapTypeFromModel(modelSnap)
 		s.essentialSnapsNum++
 	}
 
diff --git a/seed/seed20_test.go b/seed/seed20_test.go
index 77e5de84de2..f88513f2a01 100644
--- a/seed/seed20_test.go
+++ b/seed/seed20_test.go
@@ -137,29 +137,33 @@ func (s *seed20Suite) TestLoadMetaCore20Minimal(c *C) {
 
 	c.Check(essSnaps, DeepEquals, []*seed.Snap{
 		{
-			Path:      s.expectedPath("snapd"),
-			SideInfo:  &s.AssertedSnapInfo("snapd").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "latest/stable",
+			Path:          s.expectedPath("snapd"),
+			SideInfo:      &s.AssertedSnapInfo("snapd").SideInfo,
+			EssentialType: snap.TypeSnapd,
+			Essential:     true,
+			Required:      true,
+			Channel:       "latest/stable",
 		}, {
-			Path:      s.expectedPath("pc-kernel"),
-			SideInfo:  &s.AssertedSnapInfo("pc-kernel").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "20",
+			Path:          s.expectedPath("pc-kernel"),
+			SideInfo:      &s.AssertedSnapInfo("pc-kernel").SideInfo,
+			EssentialType: snap.TypeKernel,
+			Essential:     true,
+			Required:      true,
+			Channel:       "20",
 		}, {
-			Path:      s.expectedPath("core20"),
-			SideInfo:  &s.AssertedSnapInfo("core20").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "latest/stable",
+			Path:          s.expectedPath("core20"),
+			SideInfo:      &s.AssertedSnapInfo("core20").SideInfo,
+			EssentialType: snap.TypeBase,
+			Essential:     true,
+			Required:      true,
+			Channel:       "latest/stable",
 		}, {
-			Path:      s.expectedPath("pc"),
-			SideInfo:  &s.AssertedSnapInfo("pc").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "20",
+			Path:          s.expectedPath("pc"),
+			SideInfo:      &s.AssertedSnapInfo("pc").SideInfo,
+			EssentialType: snap.TypeGadget,
+			Essential:     true,
+			Required:      true,
+			Channel:       "20",
 		},
 	})
 
@@ -577,29 +581,33 @@ func (s *seed20Suite) TestLoadMetaCore20(c *C) {
 
 	c.Check(essSnaps, DeepEquals, []*seed.Snap{
 		{
-			Path:      s.expectedPath("snapd"),
-			SideInfo:  &s.AssertedSnapInfo("snapd").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "latest/stable",
+			Path:          s.expectedPath("snapd"),
+			SideInfo:      &s.AssertedSnapInfo("snapd").SideInfo,
+			EssentialType: snap.TypeSnapd,
+			Essential:     true,
+			Required:      true,
+			Channel:       "latest/stable",
 		}, {
-			Path:      s.expectedPath("pc-kernel"),
-			SideInfo:  &s.AssertedSnapInfo("pc-kernel").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "20",
+			Path:          s.expectedPath("pc-kernel"),
+			SideInfo:      &s.AssertedSnapInfo("pc-kernel").SideInfo,
+			EssentialType: snap.TypeKernel,
+			Essential:     true,
+			Required:      true,
+			Channel:       "20",
 		}, {
-			Path:      s.expectedPath("core20"),
-			SideInfo:  &s.AssertedSnapInfo("core20").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "latest/stable",
+			Path:          s.expectedPath("core20"),
+			SideInfo:      &s.AssertedSnapInfo("core20").SideInfo,
+			EssentialType: snap.TypeBase,
+			Essential:     true,
+			Required:      true,
+			Channel:       "latest/stable",
 		}, {
-			Path:      s.expectedPath("pc"),
-			SideInfo:  &s.AssertedSnapInfo("pc").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "20",
+			Path:          s.expectedPath("pc"),
+			SideInfo:      &s.AssertedSnapInfo("pc").SideInfo,
+			EssentialType: snap.TypeGadget,
+			Essential:     true,
+			Required:      true,
+			Channel:       "20",
 		},
 	})
 
@@ -675,29 +683,33 @@ func (s *seed20Suite) TestLoadMetaCore20LocalSnaps(c *C) {
 
 	c.Check(essSnaps, DeepEquals, []*seed.Snap{
 		{
-			Path:      s.expectedPath("snapd"),
-			SideInfo:  &s.AssertedSnapInfo("snapd").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "latest/stable",
+			Path:          s.expectedPath("snapd"),
+			SideInfo:      &s.AssertedSnapInfo("snapd").SideInfo,
+			EssentialType: snap.TypeSnapd,
+			Essential:     true,
+			Required:      true,
+			Channel:       "latest/stable",
 		}, {
-			Path:      s.expectedPath("pc-kernel"),
-			SideInfo:  &s.AssertedSnapInfo("pc-kernel").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "20",
+			Path:          s.expectedPath("pc-kernel"),
+			SideInfo:      &s.AssertedSnapInfo("pc-kernel").SideInfo,
+			EssentialType: snap.TypeKernel,
+			Essential:     true,
+			Required:      true,
+			Channel:       "20",
 		}, {
-			Path:      s.expectedPath("core20"),
-			SideInfo:  &s.AssertedSnapInfo("core20").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "latest/stable",
+			Path:          s.expectedPath("core20"),
+			SideInfo:      &s.AssertedSnapInfo("core20").SideInfo,
+			EssentialType: snap.TypeBase,
+			Essential:     true,
+			Required:      true,
+			Channel:       "latest/stable",
 		}, {
-			Path:      s.expectedPath("pc"),
-			SideInfo:  &s.AssertedSnapInfo("pc").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "20",
+			Path:          s.expectedPath("pc"),
+			SideInfo:      &s.AssertedSnapInfo("pc").SideInfo,
+			EssentialType: snap.TypeGadget,
+			Essential:     true,
+			Required:      true,
+			Channel:       "20",
 		},
 	})
 
@@ -766,29 +778,33 @@ func (s *seed20Suite) TestLoadMetaCore20ChannelOverride(c *C) {
 
 	c.Check(essSnaps, DeepEquals, []*seed.Snap{
 		{
-			Path:      s.expectedPath("snapd"),
-			SideInfo:  &s.AssertedSnapInfo("snapd").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "latest/stable",
+			Path:          s.expectedPath("snapd"),
+			SideInfo:      &s.AssertedSnapInfo("snapd").SideInfo,
+			EssentialType: snap.TypeSnapd,
+			Essential:     true,
+			Required:      true,
+			Channel:       "latest/stable",
 		}, {
-			Path:      s.expectedPath("pc-kernel"),
-			SideInfo:  &s.AssertedSnapInfo("pc-kernel").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "20",
+			Path:          s.expectedPath("pc-kernel"),
+			SideInfo:      &s.AssertedSnapInfo("pc-kernel").SideInfo,
+			EssentialType: snap.TypeKernel,
+			Essential:     true,
+			Required:      true,
+			Channel:       "20",
 		}, {
-			Path:      s.expectedPath("core20"),
-			SideInfo:  &s.AssertedSnapInfo("core20").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "latest/stable",
+			Path:          s.expectedPath("core20"),
+			SideInfo:      &s.AssertedSnapInfo("core20").SideInfo,
+			EssentialType: snap.TypeBase,
+			Essential:     true,
+			Required:      true,
+			Channel:       "latest/stable",
 		}, {
-			Path:      s.expectedPath("pc"),
-			SideInfo:  &s.AssertedSnapInfo("pc").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "20experimental/edge",
+			Path:          s.expectedPath("pc"),
+			SideInfo:      &s.AssertedSnapInfo("pc").SideInfo,
+			EssentialType: snap.TypeGadget,
+			Essential:     true,
+			Required:      true,
+			Channel:       "20experimental/edge",
 		},
 	})
 
@@ -857,29 +873,33 @@ func (s *seed20Suite) TestLoadMetaCore20ChannelOverrideSnapd(c *C) {
 
 	c.Check(essSnaps, DeepEquals, []*seed.Snap{
 		{
-			Path:      s.expectedPath("snapd"),
-			SideInfo:  &s.AssertedSnapInfo("snapd").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "20experimental/edge",
+			Path:          s.expectedPath("snapd"),
+			SideInfo:      &s.AssertedSnapInfo("snapd").SideInfo,
+			EssentialType: snap.TypeSnapd,
+			Essential:     true,
+			Required:      true,
+			Channel:       "20experimental/edge",
 		}, {
-			Path:      s.expectedPath("pc-kernel"),
-			SideInfo:  &s.AssertedSnapInfo("pc-kernel").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "20",
+			Path:          s.expectedPath("pc-kernel"),
+			SideInfo:      &s.AssertedSnapInfo("pc-kernel").SideInfo,
+			EssentialType: snap.TypeKernel,
+			Essential:     true,
+			Required:      true,
+			Channel:       "20",
 		}, {
-			Path:      s.expectedPath("core20"),
-			SideInfo:  &s.AssertedSnapInfo("core20").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "latest/stable",
+			Path:          s.expectedPath("core20"),
+			SideInfo:      &s.AssertedSnapInfo("core20").SideInfo,
+			EssentialType: snap.TypeBase,
+			Essential:     true,
+			Required:      true,
+			Channel:       "latest/stable",
 		}, {
-			Path:      s.expectedPath("pc"),
-			SideInfo:  &s.AssertedSnapInfo("pc").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "20",
+			Path:          s.expectedPath("pc"),
+			SideInfo:      &s.AssertedSnapInfo("pc").SideInfo,
+			EssentialType: snap.TypeGadget,
+			Essential:     true,
+			Required:      true,
+			Channel:       "20",
 		},
 	})
 
@@ -941,28 +961,32 @@ func (s *seed20Suite) TestLoadMetaCore20LocalSnapd(c *C) {
 
 	c.Check(essSnaps, DeepEquals, []*seed.Snap{
 		{
-			Path:      filepath.Join(s.SeedDir, "systems", sysLabel, "snaps", "snapd_1.0.snap"),
-			SideInfo:  &snap.SideInfo{RealName: "snapd"},
-			Essential: true,
-			Required:  true,
+			Path:          filepath.Join(s.SeedDir, "systems", sysLabel, "snaps", "snapd_1.0.snap"),
+			SideInfo:      &snap.SideInfo{RealName: "snapd"},
+			Essential:     true,
+			EssentialType: snap.TypeSnapd,
+			Required:      true,
 		}, {
-			Path:      s.expectedPath("pc-kernel"),
-			SideInfo:  &s.AssertedSnapInfo("pc-kernel").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "20",
+			Path:          s.expectedPath("pc-kernel"),
+			SideInfo:      &s.AssertedSnapInfo("pc-kernel").SideInfo,
+			EssentialType: snap.TypeKernel,
+			Essential:     true,
+			Required:      true,
+			Channel:       "20",
 		}, {
-			Path:      s.expectedPath("core20"),
-			SideInfo:  &s.AssertedSnapInfo("core20").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "latest/stable",
+			Path:          s.expectedPath("core20"),
+			SideInfo:      &s.AssertedSnapInfo("core20").SideInfo,
+			EssentialType: snap.TypeBase,
+			Essential:     true,
+			Required:      true,
+			Channel:       "latest/stable",
 		}, {
-			Path:      s.expectedPath("pc"),
-			SideInfo:  &s.AssertedSnapInfo("pc").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "20",
+			Path:          s.expectedPath("pc"),
+			SideInfo:      &s.AssertedSnapInfo("pc").SideInfo,
+			EssentialType: snap.TypeGadget,
+			Essential:     true,
+			Required:      true,
+			Channel:       "20",
 		},
 	})
 
@@ -1019,29 +1043,33 @@ func (s *seed20Suite) TestLoadMetaCore20ModelOverrideSnapd(c *C) {
 
 	c.Check(essSnaps, DeepEquals, []*seed.Snap{
 		{
-			Path:      s.expectedPath("snapd"),
-			SideInfo:  &s.AssertedSnapInfo("snapd").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "latest/edge",
+			Path:          s.expectedPath("snapd"),
+			SideInfo:      &s.AssertedSnapInfo("snapd").SideInfo,
+			EssentialType: snap.TypeSnapd,
+			Essential:     true,
+			Required:      true,
+			Channel:       "latest/edge",
 		}, {
-			Path:      s.expectedPath("pc-kernel"),
-			SideInfo:  &s.AssertedSnapInfo("pc-kernel").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "20",
+			Path:          s.expectedPath("pc-kernel"),
+			SideInfo:      &s.AssertedSnapInfo("pc-kernel").SideInfo,
+			EssentialType: snap.TypeKernel,
+			Essential:     true,
+			Required:      true,
+			Channel:       "20",
 		}, {
-			Path:      s.expectedPath("core20"),
-			SideInfo:  &s.AssertedSnapInfo("core20").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "latest/stable",
+			Path:          s.expectedPath("core20"),
+			SideInfo:      &s.AssertedSnapInfo("core20").SideInfo,
+			EssentialType: snap.TypeBase,
+			Essential:     true,
+			Required:      true,
+			Channel:       "latest/stable",
 		}, {
-			Path:      s.expectedPath("pc"),
-			SideInfo:  &s.AssertedSnapInfo("pc").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "20",
+			Path:          s.expectedPath("pc"),
+			SideInfo:      &s.AssertedSnapInfo("pc").SideInfo,
+			EssentialType: snap.TypeGadget,
+			Essential:     true,
+			Required:      true,
+			Channel:       "20",
 		},
 	})
 
@@ -1107,29 +1135,33 @@ func (s *seed20Suite) TestLoadMetaCore20OptionalSnaps(c *C) {
 
 	c.Check(essSnaps, DeepEquals, []*seed.Snap{
 		{
-			Path:      s.expectedPath("snapd"),
-			SideInfo:  &s.AssertedSnapInfo("snapd").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "latest/stable",
+			Path:          s.expectedPath("snapd"),
+			SideInfo:      &s.AssertedSnapInfo("snapd").SideInfo,
+			EssentialType: snap.TypeSnapd,
+			Essential:     true,
+			Required:      true,
+			Channel:       "latest/stable",
 		}, {
-			Path:      s.expectedPath("pc-kernel"),
-			SideInfo:  &s.AssertedSnapInfo("pc-kernel").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "20",
+			Path:          s.expectedPath("pc-kernel"),
+			SideInfo:      &s.AssertedSnapInfo("pc-kernel").SideInfo,
+			EssentialType: snap.TypeKernel,
+			Essential:     true,
+			Required:      true,
+			Channel:       "20",
 		}, {
-			Path:      s.expectedPath("core20"),
-			SideInfo:  &s.AssertedSnapInfo("core20").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "latest/stable",
+			Path:          s.expectedPath("core20"),
+			SideInfo:      &s.AssertedSnapInfo("core20").SideInfo,
+			EssentialType: snap.TypeBase,
+			Essential:     true,
+			Required:      true,
+			Channel:       "latest/stable",
 		}, {
-			Path:      s.expectedPath("pc"),
-			SideInfo:  &s.AssertedSnapInfo("pc").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "20",
+			Path:          s.expectedPath("pc"),
+			SideInfo:      &s.AssertedSnapInfo("pc").SideInfo,
+			EssentialType: snap.TypeGadget,
+			Essential:     true,
+			Required:      true,
+			Channel:       "20",
 		},
 	})
 
@@ -1203,29 +1235,33 @@ func (s *seed20Suite) TestLoadMetaCore20OptionalSnapsLocal(c *C) {
 
 	c.Check(essSnaps, DeepEquals, []*seed.Snap{
 		{
-			Path:      s.expectedPath("snapd"),
-			SideInfo:  &s.AssertedSnapInfo("snapd").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "latest/stable",
+			Path:          s.expectedPath("snapd"),
+			SideInfo:      &s.AssertedSnapInfo("snapd").SideInfo,
+			EssentialType: snap.TypeSnapd,
+			Essential:     true,
+			Required:      true,
+			Channel:       "latest/stable",
 		}, {
-			Path:      s.expectedPath("pc-kernel"),
-			SideInfo:  &s.AssertedSnapInfo("pc-kernel").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "20",
+			Path:          s.expectedPath("pc-kernel"),
+			SideInfo:      &s.AssertedSnapInfo("pc-kernel").SideInfo,
+			EssentialType: snap.TypeKernel,
+			Essential:     true,
+			Required:      true,
+			Channel:       "20",
 		}, {
-			Path:      s.expectedPath("core20"),
-			SideInfo:  &s.AssertedSnapInfo("core20").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "latest/stable",
+			Path:          s.expectedPath("core20"),
+			SideInfo:      &s.AssertedSnapInfo("core20").SideInfo,
+			EssentialType: snap.TypeBase,
+			Essential:     true,
+			Required:      true,
+			Channel:       "latest/stable",
 		}, {
-			Path:      s.expectedPath("pc"),
-			SideInfo:  &s.AssertedSnapInfo("pc").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "20",
+			Path:          s.expectedPath("pc"),
+			SideInfo:      &s.AssertedSnapInfo("pc").SideInfo,
+			EssentialType: snap.TypeGadget,
+			Essential:     true,
+			Required:      true,
+			Channel:       "20",
 		},
 	})
 
@@ -1292,29 +1328,33 @@ func (s *seed20Suite) TestLoadMetaCore20ExtraSnaps(c *C) {
 
 	c.Check(essSnaps, DeepEquals, []*seed.Snap{
 		{
-			Path:      s.expectedPath("snapd"),
-			SideInfo:  &s.AssertedSnapInfo("snapd").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "latest/stable",
+			Path:          s.expectedPath("snapd"),
+			SideInfo:      &s.AssertedSnapInfo("snapd").SideInfo,
+			EssentialType: snap.TypeSnapd,
+			Essential:     true,
+			Required:      true,
+			Channel:       "latest/stable",
 		}, {
-			Path:      s.expectedPath("pc-kernel"),
-			SideInfo:  &s.AssertedSnapInfo("pc-kernel").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "20",
+			Path:          s.expectedPath("pc-kernel"),
+			SideInfo:      &s.AssertedSnapInfo("pc-kernel").SideInfo,
+			EssentialType: snap.TypeKernel,
+			Essential:     true,
+			Required:      true,
+			Channel:       "20",
 		}, {
-			Path:      s.expectedPath("core20"),
-			SideInfo:  &s.AssertedSnapInfo("core20").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "latest/stable",
+			Path:          s.expectedPath("core20"),
+			SideInfo:      &s.AssertedSnapInfo("core20").SideInfo,
+			EssentialType: snap.TypeBase,
+			Essential:     true,
+			Required:      true,
+			Channel:       "latest/stable",
 		}, {
-			Path:      s.expectedPath("pc"),
-			SideInfo:  &s.AssertedSnapInfo("pc").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "20",
+			Path:          s.expectedPath("pc"),
+			SideInfo:      &s.AssertedSnapInfo("pc").SideInfo,
+			EssentialType: snap.TypeGadget,
+			Essential:     true,
+			Required:      true,
+			Channel:       "20",
 		},
 	})
 
@@ -1411,29 +1451,33 @@ func (s *seed20Suite) TestLoadMetaCore20NotRunSnaps(c *C) {
 
 	c.Check(essSnaps, DeepEquals, []*seed.Snap{
 		{
-			Path:      s.expectedPath("snapd"),
-			SideInfo:  &s.AssertedSnapInfo("snapd").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "latest/stable",
+			Path:          s.expectedPath("snapd"),
+			SideInfo:      &s.AssertedSnapInfo("snapd").SideInfo,
+			EssentialType: snap.TypeSnapd,
+			Essential:     true,
+			Required:      true,
+			Channel:       "latest/stable",
 		}, {
-			Path:      s.expectedPath("pc-kernel"),
-			SideInfo:  &s.AssertedSnapInfo("pc-kernel").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "20",
+			Path:          s.expectedPath("pc-kernel"),
+			SideInfo:      &s.AssertedSnapInfo("pc-kernel").SideInfo,
+			EssentialType: snap.TypeKernel,
+			Essential:     true,
+			Required:      true,
+			Channel:       "20",
 		}, {
-			Path:      s.expectedPath("core20"),
-			SideInfo:  &s.AssertedSnapInfo("core20").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "latest/stable",
+			Path:          s.expectedPath("core20"),
+			SideInfo:      &s.AssertedSnapInfo("core20").SideInfo,
+			EssentialType: snap.TypeBase,
+			Essential:     true,
+			Required:      true,
+			Channel:       "latest/stable",
 		}, {
-			Path:      s.expectedPath("pc"),
-			SideInfo:  &s.AssertedSnapInfo("pc").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "20",
+			Path:          s.expectedPath("pc"),
+			SideInfo:      &s.AssertedSnapInfo("pc").SideInfo,
+			EssentialType: snap.TypeGadget,
+			Essential:     true,
+			Required:      true,
+			Channel:       "20",
 		},
 	})
 
@@ -1539,29 +1583,33 @@ func (s *seed20Suite) TestLoadMetaCore20LocalAssertedSnaps(c *C) {
 
 	c.Check(essSnaps, DeepEquals, []*seed.Snap{
 		{
-			Path:      s.expectedPath("snapd"),
-			SideInfo:  &s.AssertedSnapInfo("snapd").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "latest/stable",
+			Path:          s.expectedPath("snapd"),
+			SideInfo:      &s.AssertedSnapInfo("snapd").SideInfo,
+			EssentialType: snap.TypeSnapd,
+			Essential:     true,
+			Required:      true,
+			Channel:       "latest/stable",
 		}, {
-			Path:      s.expectedPath("pc-kernel"),
-			SideInfo:  &s.AssertedSnapInfo("pc-kernel").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "20",
+			Path:          s.expectedPath("pc-kernel"),
+			SideInfo:      &s.AssertedSnapInfo("pc-kernel").SideInfo,
+			EssentialType: snap.TypeKernel,
+			Essential:     true,
+			Required:      true,
+			Channel:       "20",
 		}, {
-			Path:      s.expectedPath("core20"),
-			SideInfo:  &s.AssertedSnapInfo("core20").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "latest/stable",
+			Path:          s.expectedPath("core20"),
+			SideInfo:      &s.AssertedSnapInfo("core20").SideInfo,
+			EssentialType: snap.TypeBase,
+			Essential:     true,
+			Required:      true,
+			Channel:       "latest/stable",
 		}, {
-			Path:      s.expectedPath("pc"),
-			SideInfo:  &s.AssertedSnapInfo("pc").SideInfo,
-			Essential: true,
-			Required:  true,
-			Channel:   "20/edge",
+			Path:          s.expectedPath("pc"),
+			SideInfo:      &s.AssertedSnapInfo("pc").SideInfo,
+			EssentialType: snap.TypeGadget,
+			Essential:     true,
+			Required:      true,
+			Channel:       "20/edge",
 		},
 	})