diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9fa14c0..93165c8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,24 @@
 
 ## Unreleased - ReleaseDate
 
+- Add support in `cooklang::metadata` for [canonical
+  metadata](https://cooklang.org/docs/spec/#canonical-metadata), making it
+  easier to query these keys and expected values.
+- Add warnings for missused canonical metadata keys.
+- Improve custom checks for metadata keys. Now they can choose to skip the
+  included checks too.
+- Fix ingredients aliases from aisle configuration not being merged in
+  `IngredientList`. (#24 @kaylee-kiako)
+
+## 0.14.0 - 2024/12/11
+
+- Add YAML frontmatter for metadata. Deprecate old style metadata keys with the
+  `>>` syntax. This also comes with changes in the `cooklang::metadata` module.
+- Add deprecation and how to fix warnings when using old style metadata.
+- Remove `MULTILINE_STEPS`, `COMPONENT_NOTE`, `SECTIONS` and `TEXT_STEPS`
+  **extensions** as they are now part of the cooklang specification and are
+  always enabled.
+
 ## 0.13.3 - 2024/08/12
 - Replace `ariadne` dependency with `codesnake`. Because of this, errors may
   have some minor differences.
diff --git a/Cargo.lock b/Cargo.lock
index b54cd22..4547dea 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -273,7 +273,6 @@ dependencies = [
  "codesnake",
  "criterion",
  "either",
- "emojis",
  "enum-map",
  "finl_unicode",
  "indoc",
@@ -439,15 +438,6 @@ version = "1.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0"
 
-[[package]]
-name = "emojis"
-version = "0.6.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99e1f1df1f181f2539bac8bf027d31ca5ffbf9e559e3f2d09413b9107b5c02f4"
-dependencies = [
- "phf",
-]
-
 [[package]]
 name = "enum-map"
 version = "2.7.3"
@@ -957,24 +947,6 @@ dependencies = [
  "sha2",
 ]
 
-[[package]]
-name = "phf"
-version = "0.11.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ade2d8b8f33c7333b51bcf0428d37e217e9f32192ae4772156f65063b8ce03dc"
-dependencies = [
- "phf_shared",
-]
-
-[[package]]
-name = "phf_shared"
-version = "0.11.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90fcb95eef784c2ac79119d1dd819e162b5da872ce6f3c3abe1e8ca1c082f72b"
-dependencies = [
- "siphasher",
-]
-
 [[package]]
 name = "pin-project-lite"
 version = "0.2.15"
diff --git a/Cargo.toml b/Cargo.toml
index 85e35a5..fe7958f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -19,7 +19,6 @@ thiserror = "1"
 url = { version = "2", features = ["serde"] }
 pest = { version = "2", optional = true }
 pest_derive = { version = "2", optional = true }
-emojis = "0.6"
 toml = { version = "0.8", optional = true }
 once_cell = "1"
 enum-map = { version = "2", features = ["serde"] }
diff --git a/playground/index.html b/playground/index.html
index 04d4cea..0d46481 100644
--- a/playground/index.html
+++ b/playground/index.html
@@ -174,9 +174,10 @@ <h1>cooklang-rs playground</h1>
 
         <select id="parserSelect">
           <option value="render" selected>Render</option>
-          <option value="full" selected>Full parse</option>
+          <option value="full">Full parse</option>
           <option value="events">Events</option>
           <option value="ast">AST</option>
+          <option value="stdmeta">Standard metadata</option>
         </select>
         <div hidden id="servingscontainer">
           <label for="servings">Servings</label>
@@ -219,7 +220,7 @@ <h1>cooklang-rs playground</h1>
   </main>
 
   <script type="module">
-    import init, { State,version } from "./pkg/cooklang_playground.js";
+    import init, { State, version } from "./pkg/cooklang_playground.js";
 
     async function run() {
       await init();
@@ -286,7 +287,13 @@ <h1>cooklang-rs playground</h1>
             break;
           }
           case "render": {
-            const { value, error } = state.parse_render(input, servings.value.length === 0 ? null : servings.valueAsNumber );
+            const { value, error } = state.parse_render(input, servings.value.length === 0 ? null : servings.valueAsNumber);
+            output.innerHTML = value;
+            errors.innerHTML = error;
+            break;
+          }
+          case "stdmeta": {
+            const { value, error } = state.std_metadata(input);
             output.innerHTML = value;
             errors.innerHTML = error;
             break;
@@ -329,21 +336,19 @@ <h1>cooklang-rs playground</h1>
       servings.addEventListener("change", () => parse());
 
       const extensionsContainer = document.getElementById("extensions-container");
+
       const extensions = [
-        "COMPONENT_MODIFIERS",
-        "COMPONENT_ALIAS",
-        "ADVANCED_UNITS",
-        "MODES",
-        "TEMPERATURE",
-        "RANGE_VALUES",
-        "TIMER_REQUIRES_TIME",
-        "INTERMEDIATE_PREPARATIONS",
-        "SPECIAL_METADATA",
-      ].forEach((e, i) => {
-        let bits = 1 << i;
-        if (i == 11) {
-          bits |= 1 << 1;
-        }
+        ["COMPONENT_MODIFIERS", 1 << 1],
+        ["COMPONENT_ALIAS", 1 << 3],
+        ["ADVANCED_UNITS", 1 << 5],
+        ["MODES", 1 << 6],
+        ["TEMPERATURE", 1 << 7],
+        ["RANGE_VALUES", 1 << 9],
+        ["TIMER_REQUIRES_TIME", 1 << 10],
+        ["INTERMEDIATE_PREPARATIONS", 1 << 11 | 1 << 1]
+      ];
+
+      extensions.forEach(([e, bits]) => {
         const elem = document.createElement("input");
         elem.setAttribute("type", "checkbox");
         elem.setAttribute("id", e);
@@ -414,4 +419,4 @@ <h1>cooklang-rs playground</h1>
   </script>
 </body>
 
-</html>
+</html>
\ No newline at end of file
diff --git a/playground/src/lib.rs b/playground/src/lib.rs
index 8e4061c..e2001aa 100644
--- a/playground/src/lib.rs
+++ b/playground/src/lib.rs
@@ -1,5 +1,6 @@
 use cooklang::ast::build_ast;
 use cooklang::error::SourceReport;
+use cooklang::metadata::{NameAndUrl, RecipeTime};
 use cooklang::{parser::PullParser, Extensions};
 use cooklang::{Converter, CooklangParser, IngredientReferenceTarget, Item};
 use std::fmt::Write;
@@ -103,6 +104,35 @@ impl State {
         };
         FallibleResult::new(value, report, input)
     }
+
+    pub fn std_metadata(&self, input: &str) -> FallibleResult {
+        let (meta, report) = self.parser.parse_metadata(input).into_tuple();
+        let value = match meta {
+            Some(m) => {
+                #[derive(Debug)]
+                #[allow(dead_code)]
+                struct StdMeta<'a> {
+                    tags: Option<Vec<std::borrow::Cow<'a, str>>>,
+                    author: Option<NameAndUrl>,
+                    source: Option<NameAndUrl>,
+                    time: Option<RecipeTime>,
+                    servings: Option<Vec<u32>>,
+                    locale: Option<(&'a str, Option<&'a str>)>,
+                }
+                let val = StdMeta {
+                    tags: m.tags(),
+                    author: m.author(),
+                    source: m.source(),
+                    time: m.time(self.parser.converter()),
+                    servings: m.servings(),
+                    locale: m.locale(),
+                };
+                format!("{val:#?}")
+            }
+            None => "<no output>".to_string(),
+        };
+        FallibleResult::new(value, report, input)
+    }
 }
 
 impl State {
diff --git a/src/analysis/event_consumer.rs b/src/analysis/event_consumer.rs
index b54a7ba..22e3c33 100644
--- a/src/analysis/event_consumer.rs
+++ b/src/analysis/event_consumer.rs
@@ -16,7 +16,7 @@ use crate::span::Span;
 use crate::text::Text;
 use crate::{model::*, Extensions, ParseOptions};
 
-use super::{AnalysisResult, DefineMode, DuplicateMode};
+use super::{AnalysisResult, CheckOptions, DefineMode, DuplicateMode};
 
 macro_rules! error {
     ($msg:expr, $label:expr $(,)?) => {
@@ -241,43 +241,9 @@ impl<'i> RecipeCollector<'i, '_> {
 
     fn process_frontmatter(&mut self, yaml_text: Text<'i>) {
         self.old_style_metadata = false;
-        match serde_yaml::from_str::<serde_yaml::Mapping>(&yaml_text.text()) {
-            Ok(yaml_map) => {
-                self.content.metadata.map = yaml_map;
-                let mut to_remove = Vec::new();
-                for (key, value) in self.content.metadata.map.iter() {
-                    if let Some(sk) = key.as_str().and_then(|s| StdKey::from_str(s).ok()) {
-                        match check_std_entry(sk, value, self.converter) {
-                            Ok(Some(servings)) => self.content.data = servings,
-                            Ok(None) => {}
-                            Err(err) => {
-                                // TODO can we get the position of the key value pair inside yaml_text?
-                                let diag = warning!(format!(
-                                    "Unsupported value for key: '{}'",
-                                    key.as_str().unwrap()
-                                ))
-                                .set_source(err);
-                                self.ctx.warn(diag);
-                            }
-                        }
-                    }
-
-                    // run custom validator if any
-                    if let Some(validator) = self.parse_options.metadata_validator.as_mut() {
-                        let (res, incl) = validator(key, value);
-                        if let Some(diag) = res.into_source_diag(|| "Invalid metadata entry") {
-                            // TODO can we get the position of the key value pair inside yaml_text?
-                            self.ctx.push(diag);
-                        }
-                        if !incl {
-                            to_remove.push(key.clone());
-                        }
-                    }
-                }
-                for key in &to_remove {
-                    self.content.metadata.map.remove(key);
-                }
-            }
+        let yaml_str = yaml_text.text();
+        let mut yaml_map = match serde_yaml::from_str::<serde_yaml::Mapping>(&yaml_str) {
+            Ok(yaml_map) => yaml_map,
             Err(err) => {
                 // ! This message (can) contains line and column number, but line numbers
                 // ! are off by one thanks to the starting `---`
@@ -289,8 +255,93 @@ impl<'i> RecipeCollector<'i, '_> {
                     diag = diag.label(label!(loc));
                 }
                 self.ctx.error(diag);
+                return;
+            }
+        };
+
+        let mut to_remove = Vec::new();
+        for (key, value) in yaml_map.iter() {
+            let mut action = CheckOptions::default();
+            // run custom validator if any
+            if let Some(validator) = self.parse_options.metadata_validator.as_mut() {
+                let res = validator(key, value, &mut action);
+                if let Some(mut diag) = res.into_source_diag(|| "Invalid metadata entry") {
+                    if let Some(key_s) = key.as_str() {
+                        if let Some(pos) = yaml_find_key_position(&yaml_str, key_s) {
+                            diag.add_label(label!(Span::pos(yaml_text.span().start() + pos)));
+                        }
+                    }
+                    self.ctx.push(diag);
+                }
+                if !action.include {
+                    to_remove.push(key.clone());
+                    continue;
+                }
+            }
+
+            if !action.run_std_checks {
+                continue;
+            }
+            if let Some(sk) = key.as_str().and_then(|s| StdKey::from_str(s).ok()) {
+                match check_std_entry(sk, value, self.converter) {
+                    Ok(Some(servings)) => self.content.data = servings,
+                    Ok(None) => {}
+                    Err(err) => {
+                        let mut diag = warning!(format!(
+                            "Unsupported value for key: '{}'",
+                            key.as_str().unwrap()
+                        ))
+                        .set_source(err);
+                        if let Some(key_s) = key.as_str() {
+                            if let Some(pos) = yaml_find_key_position(&yaml_str, key_s) {
+                                diag.add_label(label!(Span::pos(yaml_text.span().start() + pos)));
+                            }
+                        }
+                        self.ctx.warn(diag);
+                    }
+                }
             }
         }
+        for key in &to_remove {
+            yaml_map.shift_remove(key);
+        }
+
+        if yaml_map.contains_key(StdKey::Time.as_ref()) {
+            // ? I guess I could group calls to `yaml_find_key_pos` into a single
+            // iteration of yaml_str but doesn't really matter
+
+            let loc = |key: StdKey| -> Option<usize> {
+                yaml_map
+                    .contains_key(key.as_ref())
+                    .then(|| yaml_find_key_position(&yaml_str, key.as_ref()))
+                    .flatten()
+            };
+
+            let prep = loc(StdKey::PrepTime);
+            let cook = loc(StdKey::CookTime);
+
+            const OVERRIDEN: &str = "this entry is overriden";
+            const OVERRIDES: &str = "this entry has preference";
+
+            if prep.is_some() || cook.is_some() {
+                let mut w = warning!("Time overriden");
+                if let Some(p) = prep {
+                    w.add_label(label!(Span::pos(yaml_text.span().start() + p), OVERRIDEN));
+                }
+                if let Some(p) = cook {
+                    w.add_label(label!(Span::pos(yaml_text.span().start() + p), OVERRIDEN));
+                }
+                if let Some(p) = yaml_find_key_position(&yaml_str, StdKey::Time.as_ref()) {
+                    w.add_label(label!(Span::pos(yaml_text.span().start() + p), OVERRIDES));
+                }
+                w.add_hint(
+                    "Top level 'prep time' and/or 'cook time' are not compatible with 'time'",
+                );
+                self.ctx.warn(w);
+            }
+        }
+
+        self.content.metadata.map = yaml_map;
     }
 
     fn metadata(&mut self, key: Text<'i>, value: Text<'i>) {
@@ -358,14 +409,15 @@ impl<'i> RecipeCollector<'i, '_> {
         let yaml_value = serde_yaml::Value::String(value_t.to_string());
 
         // run custom validator if any
+        let mut action = CheckOptions::default();
         if let Some(validator) = self.parse_options.metadata_validator.as_mut() {
-            let (res, incl) = validator(&yaml_key, &yaml_value);
+            let res = validator(&yaml_key, &yaml_value, &mut action);
             if let Some(mut diag) = res.into_source_diag(|| "Invalid metadata entry") {
                 diag.add_label(label!(key.span()));
                 diag.add_label(label!(value.span()));
                 self.ctx.push(diag);
             }
-            if !incl {
+            if !action.include {
                 return;
             }
         }
@@ -373,7 +425,10 @@ impl<'i> RecipeCollector<'i, '_> {
         // insert the value into the map
         self.content.metadata.map.insert(yaml_key, yaml_value);
 
-        // check if it's a special key
+        // check if it's a std key
+        if !action.run_std_checks {
+            return;
+        }
         if let Ok(sp_key) = StdKey::from_str(&key_t) {
             let check_result = crate::metadata::check_std_entry(
                 sp_key,
@@ -387,10 +442,7 @@ impl<'i> RecipeCollector<'i, '_> {
                 Err(err) => {
                     self.ctx.warn(
                         warning!(
-                            format!(
-                                "Unsupported value for special key: '{}'",
-                                key.text_trimmed()
-                            ),
+                            format!("Unsupported value for key: '{}'", key.text_trimmed()),
                             label!(value.span(), "this value"),
                         )
                         .label(label!(key.span(), "this key does not support"))
@@ -1395,3 +1447,26 @@ fn text_val_in_ref_warn(
     }
     w
 }
+
+fn yaml_find_key_position(text: &str, key: &str) -> Option<usize> {
+    // This is a bit of a hack, but it will work almost always and if it doesn't
+    // it only tells the user a bad position
+
+    let mut offset = 0;
+    for line in text.split_inclusive('\n') {
+        let l_offset = offset;
+        offset += line.len();
+        let line = line.trim_start();
+
+        let Some((k, _)) = line.split_once(':') else {
+            continue;
+        };
+        let Some(start) = k.find(|c: char| !c.is_ascii_whitespace()) else {
+            continue;
+        };
+        if k[start..].trim_ascii_end() == key {
+            return Some(l_offset + start);
+        }
+    }
+    None
+}
diff --git a/src/analysis/mod.rs b/src/analysis/mod.rs
index ae5c217..7705ada 100644
--- a/src/analysis/mod.rs
+++ b/src/analysis/mod.rs
@@ -34,10 +34,9 @@ pub struct ParseOptions<'a> {
     /// Check metadata entries for validity
     ///
     /// Some checks are performed by default, but you can add your own here.
-    /// The function receives the key and the value.
-    ///
-    /// The boolean returned indicates if the value should be included in the
-    /// recipe.
+    /// The function receives the key, value and an [`CheckOptions`] where you
+    /// can customize what happens to the key, including not running the default
+    /// checks.
     pub metadata_validator: Option<MetadataValidator<'a>>,
 }
 
@@ -72,6 +71,45 @@ impl CheckResult {
     }
 }
 
+/// Customize how a metadata entry should be treated
+///
+/// By default the entry is included and the [`StdKey`](crate::metadata::StdKey)
+/// checks run.
+pub struct CheckOptions {
+    include: bool,
+    run_std_checks: bool,
+}
+
+impl Default for CheckOptions {
+    fn default() -> Self {
+        Self {
+            include: true,
+            run_std_checks: true,
+        }
+    }
+}
+
+impl CheckOptions {
+    /// To include or not the metadata entry in the recipe
+    ///
+    /// If this is `false`, the entry will not be in the recipe. This will avoid
+    /// keeping invalid values.
+    pub fn include(&mut self, do_include: bool) {
+        self.include = do_include;
+    }
+
+    /// To run or not the checks for [`StdKey`](crate::metadata::StdKey)
+    ///
+    /// Disable these checks if you want to change the semantics or structure of a
+    /// [`StdKey`](crate::metadata::StdKey) and don't want the parser to issue
+    /// warnings about it.
+    ///
+    /// If the key is **not** an [`StdKey`](crate::metadata::StdKey) this has no effect.
+    pub fn run_std_checks(&mut self, do_check: bool) {
+        self.run_std_checks = do_check;
+    }
+}
+
 pub type RecipeRefCheck<'a> = Box<dyn FnMut(&str) -> CheckResult + 'a>;
 pub type MetadataValidator<'a> =
-    Box<dyn FnMut(&serde_yaml::Value, &serde_yaml::Value) -> (CheckResult, bool) + 'a>;
+    Box<dyn FnMut(&serde_yaml::Value, &serde_yaml::Value, &mut CheckOptions) -> CheckResult + 'a>;
diff --git a/src/error.rs b/src/error.rs
index cb90de3..991e550 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -6,10 +6,10 @@ use crate::Span;
 
 /// Handy label creation for [`SourceDiag`]
 macro_rules! label {
-    ($span:expr) => {
+    ($span:expr $(,)?) => {
         ($span.to_owned().into(), None)
     };
-    ($span:expr, $message:expr) => {
+    ($span:expr, $message:expr $(,)?) => {
         ($span.to_owned().into(), Some($message.into()))
     };
     ($span:expr, $fmt:literal, $($arg:expr),+) => {
diff --git a/src/lib.rs b/src/lib.rs
index cae7989..9b00cb7 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -129,8 +129,6 @@ bitflags! {
         const TIMER_REQUIRES_TIME      = 1 << 10;
         /// This extensions also enables [`Self::COMPONENT_MODIFIERS`].
         const INTERMEDIATE_PREPARATIONS = 1 << 11 | Self::COMPONENT_MODIFIERS.bits();
-        /// Enables special metadata key parsing
-        const SPECIAL_METADATA = 1 << 12;
 
         /// Enables a subset of extensions to maximize compatibility with other
         /// cooklang parsers.
@@ -145,8 +143,7 @@ bitflags! {
                         | Self::MODES.bits()
                         | Self::TEMPERATURE.bits()
                         | Self::RANGE_VALUES.bits()
-                        | Self::INTERMEDIATE_PREPARATIONS.bits()
-                        | Self::SPECIAL_METADATA.bits();
+                        | Self::INTERMEDIATE_PREPARATIONS.bits();
     }
 }
 
diff --git a/src/metadata.rs b/src/metadata.rs
index 6f81b8a..7008510 100644
--- a/src/metadata.rs
+++ b/src/metadata.rs
@@ -1,6 +1,6 @@
 //! Metadata of a recipe
 
-use std::{num::ParseFloatError, str::FromStr};
+use std::{borrow::Cow, num::ParseFloatError, str::FromStr};
 
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
@@ -26,55 +26,114 @@ use crate::{
 
 /// Metadata of a recipe
 ///
-/// The raw key/value pairs from the recipe are in the `map` field. Many methods
-/// on this struct are the parsed values with some special meaning. They return
-/// `None` if the key is missing or the value failed to parse.
+/// You can use [`Metadata::get`] to get a value. The key can be a `&str`, a
+/// [`StdKey`] or any [yaml value](serde_yaml::Value). Once you get a
+/// [`serde_yaml::Value`], you can use any of it's methods to get your desired
+/// type, or any of the [`CooklangValueExt`] which adds more ways to interpret
+/// it.
+///
+/// Many other methods on this struct are a way to access [`StdKey`] with their
+/// _expected_ type. If these methods return `None` it can be because the key
+/// was not present or the value was not of the expected type. You can also
+/// decide to not use them and extract the metadata you prefer.
 #[derive(Debug, PartialEq, Clone, Default, Serialize, Deserialize)]
 pub struct Metadata {
     /// All the raw key/value pairs from the recipe
     pub map: serde_yaml::Mapping,
 }
 
-#[derive(
-    Debug,
-    Clone,
-    Copy,
-    strum::Display,
-    strum::EnumString,
-    strum::AsRefStr,
-    PartialEq,
-    Eq,
-    Hash,
-    Serialize,
-    Deserialize,
-)]
+/// Standard keys from the cooklang spec
+///
+/// These keys are recommended to be used to maximise the compatibility of a
+/// recipe between different cooklang applications. You can read more about it
+/// in [the spec](https://cooklang.org/docs/spec/#canonical-metadata).
+///
+/// To use them, use [`Metadata::get`].
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
-#[strum(serialize_all = "snake_case")]
-pub(crate) enum StdKey {
+pub enum StdKey {
+    Title,
     Description,
-    #[strum(serialize = "tag", to_string = "tags")]
     Tags,
-    Emoji,
     Author,
     Source,
+    Course,
     Time,
-    #[strum(serialize = "prep_time", to_string = "prep time")]
     PrepTime,
-    #[strum(serialize = "cook_time", to_string = "cook time")]
     CookTime,
     Servings,
+    Difficulty,
+    Cuisine,
+    Diet,
+    Images,
+    Locale,
+}
+
+impl std::fmt::Display for StdKey {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(self.as_ref())
+    }
+}
+
+#[derive(thiserror::Error, Debug, Clone)]
+#[error("Faile to parse '{0}' as a standard key")]
+pub struct StdKeyParseError(String);
+
+impl FromStr for StdKey {
+    type Err = StdKeyParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let k = match s {
+            "title" => Self::Title,
+            "description" | "introduction" => Self::Description,
+            "tags" | "tag" => Self::Tags,
+            "author" => Self::Author,
+            "source" => Self::Source,
+            "servings" | "serves" | "yield" => Self::Servings,
+            "course" | "category" => Self::Course,
+            "locale" => Self::Locale,
+            "time" | "duration" | "time required" => Self::Time,
+            "prep time" | "prep_time" => Self::PrepTime,
+            "cook time" | "cook_time" => Self::CookTime,
+            "difficulty" => Self::Difficulty,
+            "cuisine" => Self::Cuisine,
+            "diet" => Self::Diet,
+            "image" | "images" | "picture" | "pictures" => Self::Images,
+            _ => return Err(StdKeyParseError(s.to_string())),
+        };
+        Ok(k)
+    }
+}
+
+impl AsRef<str> for StdKey {
+    fn as_ref(&self) -> &str {
+        match self {
+            StdKey::Title => "title",
+            StdKey::Description => "description",
+            StdKey::Tags => "tags",
+            StdKey::Author => "author",
+            StdKey::Source => "source",
+            StdKey::Servings => "servings",
+            StdKey::Course => "course",
+            StdKey::Locale => "locale",
+            StdKey::Time => "time",
+            StdKey::PrepTime => "prep time",
+            StdKey::CookTime => "cook time",
+            StdKey::Difficulty => "difficulty",
+            StdKey::Cuisine => "cuisine",
+            StdKey::Diet => "diet",
+            StdKey::Images => "image",
+        }
+    }
 }
 
 impl Metadata {
-    pub fn get(&self, index: impl serde_yaml::mapping::Index) -> Option<&serde_yaml::Value> {
-        self.map.get(index)
+    pub fn get(&self, index: impl MetaIndex) -> Option<&serde_yaml::Value> {
+        index.index_into(&self.map)
     }
 
-    pub fn get_mut(
-        &mut self,
-        index: impl serde_yaml::mapping::Index,
-    ) -> Option<&mut serde_yaml::Value> {
-        self.map.get_mut(index)
+    pub fn get_mut(&mut self, index: impl MetaIndex) -> Option<&mut serde_yaml::Value> {
+        index.index_into_mut(&mut self.map)
     }
 
     /// Iterates over all entries except the standard keys
@@ -88,62 +147,60 @@ impl Metadata {
         })
     }
 
+    /// Title of the recipe
+    pub fn title(&self) -> Option<&str> {
+        self.get(StdKey::Title).and_then(serde_yaml::Value::as_str)
+    }
+
     /// Description of the recipe
     ///
     /// Just the `description` key as a string.
     pub fn description(&self) -> Option<&str> {
-        self.get(StdKey::Description.as_ref())
-            .and_then(|v| v.as_str())
-    }
-
-    /// Emoji for the recipe
-    ///
-    /// The `emoji` key [`as_emoji`](CooklangValueExt::as_emoji)
-    pub fn emoji(&self) -> Option<&str> {
-        self.get(StdKey::Emoji.as_ref()).and_then(|v| v.as_emoji())
+        self.get(StdKey::Description)
+            .and_then(serde_yaml::Value::as_str)
     }
 
     /// List of tags
     ///
     /// The `tags` key [`as_tags`](CooklangValueExt::as_tags)
-    pub fn tags(&self) -> Option<Vec<&str>> {
-        self.get(StdKey::Tags.as_ref()).and_then(|v| v.as_tags())
+    pub fn tags(&self) -> Option<Vec<Cow<str>>> {
+        self.get(StdKey::Tags).and_then(CooklangValueExt::as_tags)
     }
 
     /// Author
     ///
     /// This *who* wrote the recipe.
     ///
-    /// The `author` key [`as_name_and_url`](CooklangValueExt::as_value_and_url).
+    /// The `author` key [`as_name_and_url`](CooklangValueExt::as_name_and_url).
     pub fn author(&self) -> Option<NameAndUrl> {
-        self.get(StdKey::Author.as_ref())
-            .and_then(|v| v.as_name_and_url())
+        self.get(StdKey::Author)
+            .and_then(CooklangValueExt::as_name_and_url)
     }
 
     /// Source
     ///
     /// This *where* the recipe was obtained from.
     ///
-    /// The `source` key [`as_name_and_url`](CooklangValueExt::as_value_and_url).
+    /// The `source` key [`as_name_and_url`](CooklangValueExt::as_name_and_url).
     pub fn source(&self) -> Option<NameAndUrl> {
-        self.get(StdKey::Source.as_ref())
-            .and_then(|v| v.as_name_and_url())
+        self.get(StdKey::Source)
+            .and_then(CooklangValueExt::as_name_and_url)
     }
 
     /// Time it takes to prepare/cook the recipe
     ///
     /// The `time` key [`as_time`](CooklangValueExt::as_time). Or, if missing,
-    /// the combination of the `prep_time` and `cook_time` keys
+    /// the combination of the `prep time` and `cook time` keys
     /// [`as_minutes`](CooklangValueExt::as_minutes).
     pub fn time(&self, converter: &Converter) -> Option<RecipeTime> {
-        if let Some(time_val) = self.get(StdKey::Time.as_ref()) {
+        if let Some(time_val) = self.get(StdKey::Time) {
             time_val.as_time(converter)
         } else {
             let prep_time = self
-                .get(StdKey::PrepTime.as_ref())
+                .get(StdKey::PrepTime)
                 .and_then(|v| v.as_minutes(converter));
             let cook_time = self
-                .get(StdKey::CookTime.as_ref())
+                .get(StdKey::CookTime)
                 .and_then(|v| v.as_minutes(converter));
             if prep_time.is_some() || cook_time.is_some() {
                 Some(RecipeTime::Composed {
@@ -157,28 +214,111 @@ impl Metadata {
     }
 
     /// Servings the recipe is made for
+    ///
+    /// This returns a list of servings to support scaling. See
+    /// [`CooklangValueExt::as_servings`] for the expected format.
     pub fn servings(&self) -> Option<Vec<u32>> {
-        self.get(StdKey::Servings.as_ref())
-            .and_then(|v| v.as_servings())
+        self.get(StdKey::Servings)
+            .and_then(CooklangValueExt::as_servings)
+    }
+
+    /// Recipe locale
+    /// See [`CooklangValueExt`] for the expected format.
+    pub fn locale(&self) -> Option<(&str, Option<&str>)> {
+        self.get(StdKey::Locale)
+            .and_then(CooklangValueExt::as_locale)
     }
 }
 
-pub trait CooklangValueExt: private::Sealed {
-    /// Returns `Some` only if the value is a string and it's an emoji.
-    ///
-    /// It can be a literal emoji (`🦀`) or a shortcode like `:crab:`
-    fn as_emoji(&self) -> Option<&str>;
+pub trait MetaIndex: private::Sealed {
+    fn index_into<'a>(&self, m: &'a serde_yaml::Mapping) -> Option<&'a serde_yaml::Value>;
+    fn index_into_mut<'a>(
+        &self,
+        m: &'a mut serde_yaml::Mapping,
+    ) -> Option<&'a mut serde_yaml::Value>;
+}
+
+mod private {
+    pub trait Sealed {}
+    impl Sealed for super::StdKey {}
+    impl<T> Sealed for T where T: serde_yaml::mapping::Index {}
+}
 
-    /// Comma (',') separated string or YAML sequence of string
+impl MetaIndex for StdKey {
+    #[inline]
+    fn index_into<'a>(&self, m: &'a serde_yaml::Mapping) -> Option<&'a serde_yaml::Value> {
+        m.get(self.as_ref())
+    }
+
+    #[inline]
+    fn index_into_mut<'a>(
+        &self,
+        m: &'a mut serde_yaml::Mapping,
+    ) -> Option<&'a mut serde_yaml::Value> {
+        m.get_mut(self.as_ref())
+    }
+}
+
+impl<T> MetaIndex for T
+where
+    T: serde_yaml::mapping::Index,
+{
+    #[inline]
+    fn index_into<'a>(&self, m: &'a serde_yaml::Mapping) -> Option<&'a serde_yaml::Value> {
+        m.get(self)
+    }
+
+    #[inline]
+    fn index_into_mut<'a>(
+        &self,
+        m: &'a mut serde_yaml::Mapping,
+    ) -> Option<&'a mut serde_yaml::Value> {
+        m.get_mut(self)
+    }
+}
+
+/// This trait is implemented for [`serde_yaml::Value`] and adds more ways to
+/// transform the value from YAML.
+pub trait CooklangValueExt: private::Sealed {
+    /// Comma (',') separated string or YAML sequence of strings
     ///
     /// Duplicates and empty entries removed.
-    fn as_tags(&self) -> Option<Vec<&str>>;
+    fn as_tags(&self) -> Option<Vec<Cow<str>>>;
 
     /// Pipe ('|') separated string or YAML sequence of numbers
     ///
-    /// Duplicates not allowed.
+    /// This extracts only the number at the beginning, but the entry can have
+    /// extra text, like the unit. For example:
+    /// ```yaml
+    /// servings: 5 cups worth
+    /// ```
+    /// will return `vec![5]`.
+    ///
+    /// These values will be used for scaling the recipe. If you want to display
+    /// the full text alongside the values, you can do something like:
+    ///
+    /// ```no_run
+    /// # use cooklang::metadata::*;
+    /// # fn f() -> Option<()> {
+    /// # let metadata = Metadata::default();
+    /// let nums = metadata.get("servings")?.as_servings()?;
+    /// let texts  = metadata.get("servings")?.as_string_list("|")?;
+    ///
+    /// for (num, text) in nums.iter().zip(texts.iter()) {
+    ///     println!("{num} - '{text}'")
+    /// }
+    /// # Some(())
+    /// # }
+    /// ```
+    ///
+    /// Duplicates not allowed, will return `None`.
     fn as_servings(&self) -> Option<Vec<u32>>;
 
+    /// String separated by `sep` or YAML sequence of strings and/or numbers
+    ///
+    /// This only checks types and convert numbers to strings if neccesary.
+    fn as_string_list<'a>(&'a self, sep: &str) -> Option<Vec<std::borrow::Cow<'a, str>>>;
+
     /// Get a [`NameAndUrl`]
     ///
     /// This can be a single string or a YAML mapping with `name` and `url` fields.
@@ -198,25 +338,31 @@ pub trait CooklangValueExt: private::Sealed {
 
     /// Get a [`RecipeTime`]
     ///
-    /// This can be a single number or string like in [`as_minutes`] or a mapping
-    /// of `prep_time` and `cook_time` where each of them is a number or string.
+    /// This can be a single number or string like in
+    /// [`as_minutes`](CooklangValueExt::as_minutes) or a mapping of `prep_time`
+    /// and `cook_time` where each of them is a number or string.
     fn as_time(&self, converter: &Converter) -> Option<RecipeTime>;
 
     /// Like [`serde_yaml::Value::as_u64`] but ensuring the value fits in a u32
     fn as_u32(&self) -> Option<u32>;
-}
 
-mod private {
-    pub trait Sealed {}
-    impl Sealed for serde_yaml::Value {}
+    /// Locale string
+    ///
+    /// ISO 639 language code, then optionally an underscore and the ISO 3166
+    /// alpha2 "country code" for dialect variants.
+    ///
+    /// **This only check that the value is a string and has the correct
+    /// structure**. Therefore it can return non existent/assigned locales.
+    /// Capitalisation is not checked, so, for example, `en_gb` works even
+    /// though it _should_ be `en_GB`.
+    fn as_locale(&self) -> Option<(&str, Option<&str>)>;
+
+    /// String or number as a string
+    fn as_str_like(&self) -> Option<Cow<str>>;
 }
 
 impl CooklangValueExt for serde_yaml::Value {
-    fn as_emoji(&self) -> Option<&str> {
-        value_as_emoji(self).ok()
-    }
-
-    fn as_tags(&self) -> Option<Vec<&str>> {
+    fn as_tags(&self) -> Option<Vec<Cow<str>>> {
         value_as_tags(self).ok()
     }
 
@@ -224,14 +370,38 @@ impl CooklangValueExt for serde_yaml::Value {
         value_as_servings(self).ok()
     }
 
-    fn as_name_and_url(&self) -> Option<NameAndUrl> {
+    fn as_string_list<'a>(&'a self, sep: &str) -> Option<Vec<Cow<'a, str>>> {
         if let Some(s) = self.as_str() {
-            Some(NameAndUrl::parse(s))
+            let v = s.split(sep).map(|e| e.into()).collect();
+            Some(v)
+        } else if let Some(seq) = self.as_sequence() {
+            let mut v = Vec::<std::borrow::Cow<'a, str>>::with_capacity(seq.len());
+            for e in seq {
+                if let Some(s) = e.as_str_like() {
+                    v.push(s);
+                } else {
+                    return None;
+                }
+            }
+            Some(v)
+        } else {
+            None
+        }
+    }
+
+    fn as_name_and_url(&self) -> Option<NameAndUrl> {
+        if let Some(s) = self.as_str_like() {
+            Some(NameAndUrl::parse(&s))
         } else if let Some(map) = self.as_mapping() {
-            let name = map.get("name")?.as_str()?;
-            let url_str = map.get("url")?.as_str()?;
-            let url = Url::parse(url_str).ok()?;
-            Some(NameAndUrl::new(Some(name), Some(url)))
+            let name = map.get("name").and_then(|v| v.as_str());
+            let url = map
+                .get("url")
+                .and_then(|v| v.as_str())
+                .and_then(|s| Url::parse(s).ok());
+            if name.is_none() && url.is_none() {
+                return None;
+            }
+            Some(NameAndUrl::new(name.as_deref(), url))
         } else {
             None
         }
@@ -245,36 +415,38 @@ impl CooklangValueExt for serde_yaml::Value {
         value_as_time(self, converter).ok()
     }
 
-    #[inline]
     fn as_u32(&self) -> Option<u32> {
         self.as_u64()?.try_into().ok()
     }
-}
 
-fn value_as_emoji(val: &serde_yaml::Value) -> Result<&str, MetadataError> {
-    let s = val.as_str().ok_or(MetadataError::UnexpectedType)?;
-    let emoji = if s.starts_with(':') && s.ends_with(':') {
-        emojis::get_by_shortcode(&s[1..s.len() - 1])
-    } else {
-        emojis::get(s)
-    };
-    emoji
-        .map(|e| e.as_str())
-        .ok_or_else(|| MetadataError::NotEmoji {
-            value: s.to_string(),
-        })
+    fn as_locale(&self) -> Option<(&str, Option<&str>)> {
+        value_as_locale(self).ok()
+    }
+
+    fn as_str_like(&self) -> Option<Cow<str>> {
+        if let Some(s) = self.as_str() {
+            Some(Cow::from(s))
+        } else if let serde_yaml::Value::Number(num) = self {
+            Some(Cow::from(num.to_string()))
+        } else {
+            None
+        }
+    }
 }
 
-fn value_as_tags(val: &serde_yaml::Value) -> Result<Vec<&str>, MetadataError> {
+fn value_as_tags(val: &serde_yaml::Value) -> Result<Vec<Cow<str>>, MetadataError> {
     let entries = if let Some(s) = val.as_str() {
-        s.split(',').map(|e| e.trim()).collect()
+        s.split(',').map(|e| e.trim().into()).collect()
     } else if let Some(seq) = val.as_sequence() {
         seq.iter()
-            .map(|val| val.as_str())
-            .collect::<Option<Vec<&str>>>()
-            .ok_or(MetadataError::UnexpectedType)?
+            .map(|val| val.as_str_like())
+            .collect::<Option<Vec<_>>>()
+            .ok_or(MetadataError::BadSequenceType {
+                expected: MetaType::String,
+                got: seq.first().map(MetaType::from).unwrap_or(MetaType::Unknown),
+            })?
     } else {
-        return Err(MetadataError::UnexpectedType);
+        return Err(MetadataError::expect_type(MetaType::Sequence, val));
     };
     let mut tags = Vec::with_capacity(entries.len());
     for tag in entries {
@@ -287,20 +459,38 @@ fn value_as_tags(val: &serde_yaml::Value) -> Result<Vec<&str>, MetadataError> {
 }
 
 fn value_as_servings(val: &serde_yaml::Value) -> Result<Vec<u32>, MetadataError> {
-    let servings: Vec<u32> = if let Some(s) = val.as_str() {
+    fn extract_value(s: &str) -> Result<u32, std::num::ParseIntError> {
+        let idx = s
+            .find(|c: char| !c.is_ascii_alphanumeric())
+            .unwrap_or(s.len());
+        let n_str = &s[..idx];
+        n_str.parse()
+    }
+
+    let servings: Vec<u32> = if let Some(n) = val.as_u32() {
+        vec![n]
+    } else if let Some(s) = val.as_str() {
         s.split('|')
             .map(str::trim)
-            .map(str::parse)
+            .map(extract_value)
             .collect::<Result<Vec<_>, _>>()?
     } else if let Some(seq) = val.as_sequence() {
         let mut v = Vec::with_capacity(seq.len());
         for e in seq {
-            let n = e.as_u32().ok_or(MetadataError::UnexpectedType)?;
-            v.push(n);
+            if let Some(n) = e.as_u32() {
+                v.push(n);
+            } else if let Some(s) = e.as_str() {
+                v.push(extract_value(s)?);
+            } else {
+                return Err(MetadataError::BadSequenceType {
+                    expected: MetaType::Number,
+                    got: MetaType::from(e),
+                });
+            }
         }
         v
     } else {
-        return Err(MetadataError::UnexpectedType);
+        return Err(MetadataError::expect_type(MetaType::Sequence, val));
     };
 
     let l = servings.len();
@@ -323,7 +513,7 @@ fn value_as_minutes(val: &serde_yaml::Value, converter: &Converter) -> Result<u3
     } else if let Some(n) = val.as_u32() {
         Ok(n)
     } else {
-        Err(MetadataError::UnexpectedType)
+        Err(MetadataError::expect_type(MetaType::String, val))
     }
 }
 
@@ -334,14 +524,16 @@ fn value_as_time(
     let total_res = value_as_minutes(val, converter);
     match total_res {
         Ok(total) => Ok(RecipeTime::Total(total)),
-        Err(MetadataError::UnexpectedType) => {
-            let map = val.as_mapping().ok_or(MetadataError::UnexpectedType)?;
+        Err(MetadataError::BadType { .. }) => {
+            let map = val
+                .as_mapping()
+                .ok_or(MetadataError::expect_type(MetaType::Mapping, val))?;
             let prep_time = map
-                .get(StdKey::PrepTime.as_ref())
+                .get("prep")
                 .map(|v| value_as_minutes(v, converter))
                 .transpose()?;
             let cook_time = map
-                .get(StdKey::CookTime.as_ref())
+                .get("cook")
                 .map(|v| value_as_minutes(v, converter))
                 .transpose()?;
             Ok(RecipeTime::Composed {
@@ -353,19 +545,65 @@ fn value_as_time(
     }
 }
 
+fn value_as_locale(val: &serde_yaml::Value) -> Result<(&str, Option<&str>), MetadataError> {
+    let s = val
+        .as_str()
+        .ok_or(MetadataError::expect_type(MetaType::String, val))?;
+
+    fn validate(s: &str) -> bool {
+        s.len() == 2 && s.chars().all(|c| c.is_ascii_alphabetic())
+    }
+
+    if let Some((lang, dial)) = s.split_once("_") {
+        if validate(lang) && validate(dial) {
+            return Ok((lang, Some(dial)));
+        }
+    } else if validate(s) {
+        return Ok((s, None));
+    }
+    Err(MetadataError::InvalidLocale(s.to_string()))
+}
+
 pub(crate) fn check_std_entry(
     key: StdKey,
     value: &serde_yaml::Value,
     converter: &Converter,
 ) -> Result<Option<crate::scale::Servings>, MetadataError> {
     match key {
-        StdKey::Tags => value_as_tags(value).map(|_| None),
-        StdKey::Emoji => value_as_emoji(value).map(|_| None),
-        StdKey::Time => value_as_time(value, converter).map(|_| None),
-        StdKey::PrepTime | StdKey::CookTime => value_as_minutes(value, converter).map(|_| None),
-        StdKey::Servings => value_as_servings(value).map(|s| Some(crate::scale::Servings(Some(s)))),
-        _ => Ok(None),
+        StdKey::Servings => {
+            return value_as_servings(value).map(|s| Some(crate::scale::Servings(Some(s))))
+        }
+        StdKey::Tags => {
+            value_as_tags(value)?;
+        }
+        StdKey::Time => {
+            value_as_time(value, converter)?;
+        }
+        StdKey::PrepTime | StdKey::CookTime => {
+            value_as_minutes(value, converter)?;
+        }
+        StdKey::Title | StdKey::Description => {
+            value
+                .as_str()
+                .ok_or(MetadataError::expect_type(MetaType::String, value))?;
+        }
+        StdKey::Locale => {
+            value_as_locale(value)?;
+        }
+        // these have no validation
+        StdKey::Author | StdKey::Source => {
+            value
+                .as_name_and_url()
+                .ok_or(MetadataError::expect_type(MetaType::Mapping, value))?;
+        }
+        StdKey::Course => {}
+        StdKey::Difficulty => {}
+        StdKey::Cuisine => {}
+        StdKey::Diet => {}
+        StdKey::Images => {}
     }
+
+    Ok(None)
 }
 
 /// Combination of name and URL.
@@ -378,6 +616,57 @@ pub struct NameAndUrl {
     url: Option<Url>,
 }
 
+impl NameAndUrl {
+    /// Parse a string into [`NameAndUrl`]
+    ///
+    /// The string is of the form:
+    /// - `Name <Url>`
+    /// - `Url`
+    /// - `<Url>`
+    /// - `Name`
+    ///
+    /// The Url validated, so it has to be correct. If no url is found or it's
+    /// invalid, everything will be the name.
+    pub fn parse(s: &str) -> Self {
+        let regex_encapsulated_url = regex!(r"^([^<]*)<([^<>]+)>$");
+        if let Some(captures) = regex_encapsulated_url.captures(s) {
+            if let Ok(url) = Url::parse(captures[2].trim()) {
+                // if the user has written the URL inside '<..>', keep it even
+                // if it has no host
+                return Self::new(Some(&captures[1]), Some(url));
+            }
+        }
+
+        if let Ok(url) = Url::parse(s.trim()) {
+            // Safety check so a URL like `Rachel: best recipes`, where "Rachel"
+            // is the protocol, doesn't get detected.
+            if url.has_host() {
+                return Self::new(None, Some(url));
+            }
+        }
+
+        Self::new(Some(s), None)
+    }
+
+    fn new(name: Option<&str>, url: Option<Url>) -> Self {
+        let name = name
+            .map(|n| n.trim())
+            .filter(|n| !n.is_empty())
+            .map(String::from);
+        Self { name, url }
+    }
+
+    /// Get the name
+    pub fn name(&self) -> Option<&str> {
+        self.name.as_deref()
+    }
+
+    /// Get the url
+    pub fn url(&self) -> Option<&Url> {
+        self.url.as_ref()
+    }
+}
+
 /// Time that takes to prep/cook a recipe
 ///
 /// All values are in minutes.
@@ -402,6 +691,12 @@ fn parse_time(s: &str, converter: &Converter) -> Result<u32, ParseTimeError> {
     if s.is_empty() {
         return Err(ParseTimeError::Empty);
     }
+
+    // first try a simpler format. Only "HhMm" allowed, no spaces, no other units
+    if let Some(minutes) = parse_common_time_format(s) {
+        return Ok(minutes);
+    }
+
     let r = parse_time_with_units(s, converter);
     // if any error, try to fall back to a full float parse
     if r.is_err() {
@@ -428,41 +723,38 @@ pub(crate) enum ParseTimeError {
     Empty,
 }
 
-fn dynamic_time_units(
-    value: f64,
-    unit: &str,
-    converter: &Converter,
-) -> Result<f64, ParseTimeError> {
-    // TODO maybe make this configurable? It will work for 99% of users...
-    let minutes = converter
-        .find_unit("min")
-        .or_else(|| converter.find_unit("minute"))
-        .or_else(|| converter.find_unit("minutes"))
-        .or_else(|| converter.find_unit("m"))
-        .ok_or(ParseTimeError::MinutesNotFound)?;
-    if minutes.physical_quantity != PhysicalQuantity::Time {
-        return Err(ParseTimeError::MinutesNotFound);
-    }
-    let (value, _) = converter.convert(
-        ConvertValue::Number(value),
-        ConvertUnit::Key(unit),
-        ConvertTo::from(&minutes),
-    )?;
-    match value {
-        ConvertValue::Number(n) => Ok(n),
-        _ => unreachable!(),
+fn parse_common_time_format(s: &str) -> Option<u32> {
+    const H_SEP: char = 'h';
+    const M_SEP: char = 'm';
+
+    if s.is_empty() {
+        return None;
     }
-}
 
-fn hard_coded_time_units(value: f64, unit: &str) -> Result<f64, ParseTimeError> {
-    let minutes = match unit {
-        "s" | "sec" | "secs" | "second" | "seconds" => value / 60.0,
-        "m" | "min" | "minute" | "minutes" => value,
-        "h" | "hour" | "hours" => value * 60.0,
-        "d" | "day" | "days" => value * 24.0 * 60.0,
-        _ => return Err(ConvertError::UnknownUnit(UnknownUnit(unit.to_string())).into()),
-    };
-    Ok(minutes)
+    let mut it = s.split_inclusive(&[H_SEP, M_SEP]);
+
+    let mut total_minutes: u32 = 0;
+    let mut hours_found = false;
+    loop {
+        match it.next() {
+            Some(s) if s.ends_with(H_SEP) && !hours_found => {
+                let hours = &s[..s.len() - H_SEP.len_utf8()].parse::<u32>().ok()?;
+                total_minutes += hours * 60;
+                hours_found = true;
+            }
+            Some(s) if s.ends_with(M_SEP) => {
+                let minutes = &s[..s.len() - M_SEP.len_utf8()].parse::<u32>().ok()?;
+                total_minutes += minutes;
+                break;
+            }
+            None => break,
+            _ => return None,
+        }
+    }
+    if it.next().is_some() {
+        return None;
+    }
+    return Some(total_minutes);
 }
 
 fn parse_time_with_units(s: &str, converter: &Converter) -> Result<u32, ParseTimeError> {
@@ -495,55 +787,41 @@ fn parse_time_with_units(s: &str, converter: &Converter) -> Result<u32, ParseTim
     Ok(total.round() as u32)
 }
 
-impl NameAndUrl {
-    /// Parse a string into [`NameAndUrl`]
-    ///
-    /// The string is of the form:
-    /// - `Name <Url>`
-    /// - `Url`
-    /// - `<Url>`
-    /// - `Name`
-    ///
-    /// The Url validated, so it has to be correct. If no url is found or it's
-    /// invalid, everything will be the name.
-    pub fn parse(s: &str) -> Self {
-        let regex_encapsulated_url = regex!(r"^([^<]*)<([^<>]+)>$");
-        if let Some(captures) = regex_encapsulated_url.captures(s) {
-            if let Ok(url) = Url::parse(captures[2].trim()) {
-                // if the user has written the URL inside '<..>', keep it even
-                // if it has no host
-                return Self::new(Some(&captures[1]), Some(url));
-            }
-        }
-
-        if let Ok(url) = Url::parse(s.trim()) {
-            // Safety check so a URL like `Rachel: best recipes`, where "Rachel"
-            // is the protocol, doesn't get detected.
-            if url.has_host() {
-                return Self::new(None, Some(url));
-            }
-        }
-
-        Self::new(Some(s), None)
-    }
-
-    fn new(name: Option<&str>, url: Option<Url>) -> Self {
-        let name = name
-            .map(|n| n.trim())
-            .filter(|n| !n.is_empty())
-            .map(String::from);
-        Self { name, url }
+fn dynamic_time_units(
+    value: f64,
+    unit: &str,
+    converter: &Converter,
+) -> Result<f64, ParseTimeError> {
+    // TODO maybe make this configurable? It will work for 99% of users...
+    let minutes = converter
+        .find_unit("min")
+        .or_else(|| converter.find_unit("minute"))
+        .or_else(|| converter.find_unit("minutes"))
+        .or_else(|| converter.find_unit("m"))
+        .ok_or(ParseTimeError::MinutesNotFound)?;
+    if minutes.physical_quantity != PhysicalQuantity::Time {
+        return Err(ParseTimeError::MinutesNotFound);
     }
-
-    /// Get the name
-    pub fn name(&self) -> Option<&str> {
-        self.name.as_deref()
+    let (value, _) = converter.convert(
+        ConvertValue::Number(value),
+        ConvertUnit::Key(unit),
+        ConvertTo::from(&minutes),
+    )?;
+    match value {
+        ConvertValue::Number(n) => Ok(n),
+        _ => unreachable!(),
     }
+}
 
-    /// Get the url
-    pub fn url(&self) -> Option<&Url> {
-        self.url.as_ref()
-    }
+fn hard_coded_time_units(value: f64, unit: &str) -> Result<f64, ParseTimeError> {
+    let minutes = match unit {
+        "s" | "sec" | "secs" | "second" | "seconds" => value / 60.0,
+        "m" | "min" | "minute" | "minutes" => value,
+        "h" | "hour" | "hours" => value * 60.0,
+        "d" | "day" | "days" => value * 24.0 * 60.0,
+        _ => return Err(ConvertError::UnknownUnit(UnknownUnit(unit.to_string())).into()),
+    };
+    Ok(minutes)
 }
 
 impl RecipeTime {
@@ -562,16 +840,56 @@ impl RecipeTime {
 #[derive(Debug, Error)]
 #[non_exhaustive]
 pub(crate) enum MetadataError {
-    #[error("Unexpected value data type")]
-    UnexpectedType,
-    #[error("Value is not an emoji: {value}")]
-    NotEmoji { value: String },
+    #[error("Expected '{expected}' but got '{got}'")]
+    BadType { expected: MetaType, got: MetaType },
+    #[error("Expected sequence of '{expected}' but got '{got}'")]
+    BadSequenceType { expected: MetaType, got: MetaType },
+    #[error("Incorrect mapping fields")]
+    BadMapping,
     #[error(transparent)]
     ParseIntError(#[from] std::num::ParseIntError),
     #[error("Duplicate servings: {servings:?}")]
     DuplicateServings { servings: Vec<u32> },
     #[error(transparent)]
     ParseTimeError(#[from] ParseTimeError),
+    #[error("Invalid locale: {0}")]
+    InvalidLocale(String),
+}
+
+impl MetadataError {
+    fn expect_type(expected: MetaType, val: &serde_yaml::Value) -> Self {
+        let got = MetaType::from(val);
+        if expected == got && expected == MetaType::Mapping {
+            return Self::BadMapping;
+        }
+        Self::BadType { expected, got }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, strum::Display, strum::AsRefStr)]
+#[strum(serialize_all = "snake_case")]
+pub(crate) enum MetaType {
+    String,
+    Bool,
+    Number,
+    Sequence,
+    Mapping,
+    Null,
+    Unknown,
+}
+
+impl From<&serde_yaml::Value> for MetaType {
+    fn from(value: &serde_yaml::Value) -> Self {
+        match value {
+            serde_yaml::Value::Null => Self::Null,
+            serde_yaml::Value::Bool(_) => Self::Bool,
+            serde_yaml::Value::Number(_) => Self::Number,
+            serde_yaml::Value::String(_) => Self::String,
+            serde_yaml::Value::Sequence(_) => Self::Sequence,
+            serde_yaml::Value::Mapping(_) => Self::Mapping,
+            serde_yaml::Value::Tagged(_) => Self::Unknown,
+        }
+    }
 }
 
 #[cfg(test)]
@@ -600,28 +918,37 @@ mod tests {
     }
 
     #[test]
-    fn special_keys() {
-        let t = |s: &str, key: StdKey| {
-            assert_eq!(StdKey::from_str(s).unwrap(), key);
-            assert_eq!(key.to_string(), s);
-        };
-        let t_alias = |s: &str, key: StdKey| {
-            assert_eq!(StdKey::from_str(s).unwrap(), key);
-            assert_ne!(key.to_string(), s);
-        };
+    fn test_common_time() {
+        let f = parse_common_time_format;
+        assert_eq!(f(""), None);
+        assert_eq!(f("1"), None);
+        assert_eq!(f("1m"), Some(1));
+        assert_eq!(f("1h"), Some(60));
+        assert_eq!(f("1h1m"), Some(61));
+        assert_eq!(f("1h90m"), Some(150));
+        assert_eq!(f("1d1h1m"), None);
+        assert_eq!(f("1d1h1m1s"), None);
+        assert_eq!(f("1m1s"), None)
+    }
 
-        t("description", StdKey::Description);
-        t("tags", StdKey::Tags);
-        t_alias("tag", StdKey::Tags);
-        t("emoji", StdKey::Emoji);
-        t("author", StdKey::Author);
-        t("source", StdKey::Source);
-        t("time", StdKey::Time);
-        t("prep time", StdKey::PrepTime);
-        t_alias("prep_time", StdKey::PrepTime);
-        t("cook time", StdKey::CookTime);
-        t_alias("cook_time", StdKey::CookTime);
-        t("servings", StdKey::Servings);
+    #[test]
+    fn special_keys() {
+        let t = |k: StdKey| assert_eq!(k, StdKey::from_str(k.as_ref()).unwrap());
+        t(StdKey::Title);
+        t(StdKey::Description);
+        t(StdKey::Tags);
+        t(StdKey::Author);
+        t(StdKey::Source);
+        t(StdKey::Servings);
+        t(StdKey::Course);
+        t(StdKey::Locale);
+        t(StdKey::Time);
+        t(StdKey::PrepTime);
+        t(StdKey::CookTime);
+        t(StdKey::Difficulty);
+        t(StdKey::Cuisine);
+        t(StdKey::Diet);
+        t(StdKey::Images);
     }
 
     #[test]
@@ -723,17 +1050,16 @@ mod tests {
     }
 
     #[test]
-    fn shortcode_emoji() {
-        let v = serde_yaml::Value::from("taco");
-        let r = value_as_emoji(&v);
-        assert!(r.is_err());
-
-        let v = serde_yaml::Value::from(":taco:");
-        let r = value_as_emoji(&v);
-        assert_eq!(r.unwrap(), "🌮");
-
-        let v = serde_yaml::Value::from("🌮");
-        let r = value_as_emoji(&v);
-        assert_eq!(r.unwrap(), "🌮");
+    fn tags_from_nums() {
+        let v = serde_yaml::from_str("[2022, baking, summer]").unwrap();
+        let res = value_as_tags(&v).unwrap();
+        assert_eq!(
+            res,
+            vec![
+                Cow::Owned(String::from("2022")),
+                Cow::Borrowed("baking"),
+                Cow::Borrowed("summer"),
+            ]
+        );
     }
 }
diff --git a/src/scale.rs b/src/scale.rs
index 107d9c9..9b8b619 100644
--- a/src/scale.rs
+++ b/src/scale.rs
@@ -384,7 +384,7 @@ impl ScalableRecipe {
     /// Get the defined number of servings in the recipe
     ///
     /// This is set automatically from the metadata. To change it manually use
-    /// [`set_servings`].
+    /// [`set_servings`](ScalableRecipe::set_servings).
     pub fn servings(&self) -> Option<&[u32]> {
         if let Servings(Some(s)) = &self.data {
             Some(s.as_slice())