diff --git a/CHANGELOG.md b/CHANGELOG.md
index fa91c7d..bb1acc5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -37,6 +37,17 @@ follow [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
   for any figure the recipe file didn't state (e.g. ABV on an imported BeerXML
   without an estimate) and no color swatch. It now falls back to Werb's
   estimate from the ingredients, as the recipe screen already did.
+- **BeerXML imports that failed on one odd value now go through**
+  ([#19](https://github.com/werb-dev/werb/issues/19)). Decimal commas
+  (`5,5`), values in another case (`boil`, `DRY HOP`) and common synonyms
+  (`Whirlpool`, `Hop stand` → Aroma; `Malt` → Grain; `Whole` → Leaf) are
+  read; an unknown value falls back to the default instead of failing the
+  whole file; a missing hop alpha or amount reads as 0, like an empty one.
+  BeerJSON files that write `null` for optional properties import too.
+- **Import errors say where the file breaks** (#19). BeerXML errors give
+  the element, e.g. `/RECIPES/RECIPE[1]/HOPS/HOP[2]/AMOUNT: not a number:
+  "lots"`; BeerJSON errors name the missing or unknown property, or the
+  value and the allowed ones. Same messages for GitHub Pull.
 - **Default water on the web app.** New recipes now start from your water on
   the web too; they used to start from zero because the saved default loaded
   after the recipe had already picked its water. A recipe you haven't touched
diff --git a/Cargo.lock b/Cargo.lock
index bd61a20..acea6ae 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3328,6 +3328,17 @@ dependencies = [
  "zmij",
 ]
 
+[[package]]
+name = "serde_path_to_error"
+version = "0.1.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "10a9ff822e371bb5403e391ecd83e182e0e77ba7f6fe0160b795797109d1b457"
+dependencies = [
+ "itoa",
+ "serde",
+ "serde_core",
+]
+
 [[package]]
 name = "serde_repr"
 version = "0.1.20"
@@ -4861,6 +4872,7 @@ dependencies = [
  "quick-xml 0.36.2",
  "serde",
  "serde_json",
+ "serde_path_to_error",
  "thiserror 1.0.69",
  "werb-beerjson",
 ]
diff --git a/apps/desktop/src/data/recipes.ts b/apps/desktop/src/data/recipes.ts
index 5c47af1..0f8773a 100644
--- a/apps/desktop/src/data/recipes.ts
+++ b/apps/desktop/src/data/recipes.ts
@@ -1,5 +1,5 @@
 import type { BeerJsonFile, BeerJsonRecipe } from "@werb/adapters";
-import { validateBeerJson } from "@werb/validate";
+import { describeErrors, stripNulls, validateBeerJson } from "@werb/validate";
 import type { StorageBackend } from "../storage/index.ts";
 import { isTauri } from "./runtime.ts";
 import { WerbError } from "./errors.ts";
@@ -86,7 +86,7 @@ const bundledRaw = import.meta.glob("../../../../examples/*.beerjson", {
 function parseAndCollect(path: string, raw: string): BeerJsonRecipe[] {
   let parsed: unknown;
   try {
-    parsed = JSON.parse(raw);
+    parsed = stripNulls(JSON.parse(raw));
   } catch (err) {
     console.warn(`[recipes] ${path}: invalid JSON — ${(err as Error).message}`);
     return [];
@@ -150,7 +150,7 @@ export interface ImportResult {
 export function parseBeerJsonText(raw: string): ImportResult {
   let parsed: unknown;
   try {
-    parsed = JSON.parse(raw);
+    parsed = stripNulls(JSON.parse(raw));
   } catch (err) {
     return {
       recipes: [],
@@ -159,8 +159,7 @@ export function parseBeerJsonText(raw: string): ImportResult {
   }
   const result = validateBeerJson(parsed);
   if (!result.valid) {
-    const first = result.errors[0];
-    const detail = first ? `${first.path}: ${first.message}` : "unknown";
+    const detail = describeErrors(parsed, result.errors);
     return { recipes: [], error: new WerbError("import.not_beerjson", { detail }) };
   }
   const recipes = (parsed as BeerJsonFile).beerjson?.recipes ?? [];
diff --git a/apps/desktop/src/screens/Library.tsx b/apps/desktop/src/screens/Library.tsx
index 3d3ffc9..656f06b 100644
--- a/apps/desktop/src/screens/Library.tsx
+++ b/apps/desktop/src/screens/Library.tsx
@@ -148,7 +148,9 @@ export function LibraryScreen({
               <p className="text-caption uppercase tracking-widest text-warning font-medium">
                 {t("library.import_failed")}
               </p>
-              <p className="text-body-sm text-text mt-2 font-mono break-all">{importError}</p>
+              <p data-testid="import-error" className="text-body-sm text-text mt-2 font-mono break-all">
+                {importError}
+              </p>
             </div>
           )}
 
diff --git a/apps/desktop/src/storage/github-recipes.ts b/apps/desktop/src/storage/github-recipes.ts
index 1ab9313..99a5c14 100644
--- a/apps/desktop/src/storage/github-recipes.ts
+++ b/apps/desktop/src/storage/github-recipes.ts
@@ -13,7 +13,7 @@
  */
 
 import type { BeerJsonRecipe, BeerJsonFile } from "@werb/adapters";
-import { validateBeerJson } from "@werb/validate";
+import { describeErrors, stripNulls, validateBeerJson } from "@werb/validate";
 import type { GitHubBackendConfig } from "./github.ts";
 import { slugify } from "../data/recipe-export.ts";
 import {
@@ -249,18 +249,14 @@ export async function pullRecipes(
     if (!entry) continue;
     let parsed: BeerJsonFile;
     try {
-      parsed = JSON.parse(entry.raw) as BeerJsonFile;
+      parsed = stripNulls(JSON.parse(entry.raw)) as BeerJsonFile;
     } catch (err) {
       result.failed.push({ file: entry.file, error: `JSON parse: ${(err as Error).message}` });
       continue;
     }
     const validation = validateBeerJson(parsed);
     if (!validation.valid) {
-      const first = validation.errors[0];
-      result.failed.push({
-        file: entry.file,
-        error: first ? `${first.path}: ${first.message}` : "schema invalid",
-      });
+      result.failed.push({ file: entry.file, error: describeErrors(parsed, validation.errors) });
       continue;
     }
     const incoming = parsed.beerjson?.recipes ?? [];
diff --git a/apps/desktop/test/beerjson-roundtrip.test.ts b/apps/desktop/test/beerjson-roundtrip.test.ts
index 94f71b0..3bb3151 100644
--- a/apps/desktop/test/beerjson-roundtrip.test.ts
+++ b/apps/desktop/test/beerjson-roundtrip.test.ts
@@ -108,6 +108,25 @@ describe("BeerJSON round-trip", () => {
     expect(result.error?.code).toBe("import.not_beerjson");
   });
 
+  it("imports a file that writes null for optional properties", () => {
+    const withNulls = JSON.parse(FIXTURE_RAW);
+    withNulls.beerjson.recipes[0].notes = null;
+    withNulls.beerjson.recipes[0].style = null;
+    const result = parseBeerJsonText(JSON.stringify(withNulls));
+    expect(result.error).toBeUndefined();
+    expect(result.recipes[0]).not.toHaveProperty("notes");
+  });
+
+  it("names the property that breaks validation", () => {
+    const broken = JSON.parse(FIXTURE_RAW);
+    delete broken.beerjson.recipes[0].batch_size;
+    const result = parseBeerJsonText(JSON.stringify(broken));
+    expect(result.error?.code).toBe("import.not_beerjson");
+    expect(result.error?.params?.detail).toBe(
+      '/beerjson/recipes/0: missing required property "batch_size"',
+    );
+  });
+
   it("rejects valid BeerJSON with no recipes inside", () => {
     const empty = JSON.stringify({ beerjson: { version: 2.06, recipes: [] } });
     const result = parseBeerJsonText(empty);
diff --git a/apps/desktop/test/beerxml-to-beerjson.test.ts b/apps/desktop/test/beerxml-to-beerjson.test.ts
index ca0fa2a..04416d9 100644
--- a/apps/desktop/test/beerxml-to-beerjson.test.ts
+++ b/apps/desktop/test/beerxml-to-beerjson.test.ts
@@ -170,3 +170,36 @@ describe("BeerXML → BeerJSON validates against the schema", () => {
     expect(result.valid, JSON.stringify(result.errors)).toBe(true);
   });
 });
+
+describe("BeerXML import tolerates common variations (#19)", () => {
+  const wrap = (body: string) =>
+    `<?xml version="1.0"?><RECIPES><RECIPE><NAME>Variations</NAME><VERSION>1</VERSION>` +
+    `<TYPE>all grain</TYPE><BATCH_SIZE>20</BATCH_SIZE><BOIL_TIME>60</BOIL_TIME>${body}</RECIPE></RECIPES>`;
+
+  it("imports decimal commas, lowercase values and common synonyms", () => {
+    const recipe = importXml(
+      wrap(
+        "<FERMENTABLES><FERMENTABLE><NAME>Pale</NAME><TYPE>Malt</TYPE><AMOUNT>4,5</AMOUNT>" +
+          "<YIELD>80</YIELD><COLOR>6</COLOR></FERMENTABLE></FERMENTABLES>" +
+          "<HOPS><HOP><NAME>Cascade</NAME><ALPHA>5,5</ALPHA><AMOUNT>0,03</AMOUNT>" +
+          "<USE>whirlpool</USE><TIME>20</TIME><FORM>pellets</FORM></HOP></HOPS>",
+      ),
+    );
+    expect(validateBeerJson(asDocument(recipe)).valid).toBe(true);
+    expect(recipe.ingredients.fermentable_additions[0]!.amount.value).toBeCloseTo(4.5, 6);
+    expect(recipe.ingredients.fermentable_additions[0]!.type).toBe("grain");
+    expect(recipe.ingredients.hop_additions![0]!.alpha_acid.value).toBeCloseTo(5.5, 6);
+    expect(recipe.ingredients.hop_additions![0]!.form).toBe("pellet");
+  });
+
+  it("says where a file breaks", () => {
+    const xml = wrap(
+      "<HOPS><HOP><NAME>A</NAME><ALPHA>5</ALPHA><AMOUNT>0.01</AMOUNT></HOP>" +
+        "<HOP><NAME>B</NAME><ALPHA>5</ALPHA><AMOUNT>lots</AMOUNT></HOP></HOPS>",
+    );
+    expect(() => wasm.parseBeerXmlJson(xml)).toThrow(
+      '/RECIPES/RECIPE[1]/HOPS/HOP[2]/AMOUNT: not a number: "lots"',
+    );
+  });
+});
+
diff --git a/apps/desktop/test/e2e/pages.ts b/apps/desktop/test/e2e/pages.ts
index 33e7eb6..f542fc5 100644
--- a/apps/desktop/test/e2e/pages.ts
+++ b/apps/desktop/test/e2e/pages.ts
@@ -131,6 +131,13 @@ class LibraryPage {
     }
   }
 
+  /** Import a recipe file through the Import button's file picker. */
+  async importFile(name: string, content: string) {
+    const chooser = this.page.waitForEvent("filechooser");
+    await this.page.getByRole("button", { name: /^Import recipes/i }).click();
+    await (await chooser).setFiles({ name, mimeType: "text/plain", buffer: Buffer.from(content) });
+  }
+
   /** Create a new empty recipe and save it. Lands on the recipe view. */
   async newEmptyRecipe(name: string) {
     await this.page.getByRole("button", { name: /\+\s*New recipe/i }).click();
diff --git a/apps/desktop/test/e2e/smoke.spec.ts b/apps/desktop/test/e2e/smoke.spec.ts
index 0159685..561b0cb 100644
--- a/apps/desktop/test/e2e/smoke.spec.ts
+++ b/apps/desktop/test/e2e/smoke.spec.ts
@@ -355,6 +355,61 @@ test.describe("Library cards", () => {
   });
 });
 
+test.describe("Import (#19)", () => {
+  const beerXml = (hops: string) =>
+    `<?xml version="1.0"?><RECIPES><RECIPE><NAME>Comma Pale</NAME><VERSION>1</VERSION>` +
+    `<TYPE>All Grain</TYPE><BATCH_SIZE>20</BATCH_SIZE><BOIL_TIME>60</BOIL_TIME>` +
+    `<FERMENTABLES><FERMENTABLE><NAME>Pale</NAME><TYPE>Malt</TYPE><AMOUNT>4,5</AMOUNT>` +
+    `<YIELD>80</YIELD><COLOR>6</COLOR></FERMENTABLE></FERMENTABLES><HOPS>${hops}</HOPS></RECIPE></RECIPES>`;
+
+  test("a BeerXML with decimal commas and loose values imports", async ({ page }) => {
+    const app = new App(page);
+    await app.go("Library");
+    await app.library.importFile(
+      "comma.xml",
+      beerXml("<HOP><NAME>Cascade</NAME><ALPHA>5,5</ALPHA><AMOUNT>0,03</AMOUNT><USE>whirlpool</USE><TIME>20</TIME></HOP>"),
+    );
+    await expect(page.locator("li h2", { hasText: /comma pale/i })).toBeVisible();
+    await expect(page.getByTestId("import-error")).toHaveCount(0);
+  });
+
+  test("a broken BeerXML says where it breaks", async ({ page }) => {
+    const app = new App(page);
+    await app.go("Library");
+    await app.library.importFile(
+      "broken.xml",
+      beerXml(
+        "<HOP><NAME>A</NAME><ALPHA>5</ALPHA><AMOUNT>0.01</AMOUNT></HOP>" +
+          "<HOP><NAME>B</NAME><ALPHA>5</ALPHA><AMOUNT>lots</AMOUNT></HOP>",
+      ),
+    );
+    await expect(page.getByTestId("import-error")).toContainText(
+      '/RECIPES/RECIPE[1]/HOPS/HOP[2]/AMOUNT: not a number: "lots"',
+    );
+  });
+
+  test("a BeerJSON error names the property", async ({ page }) => {
+    const app = new App(page);
+    await app.go("Library");
+    const doc = {
+      beerjson: {
+        version: 2.06,
+        recipes: [
+          {
+            name: "No batch",
+            type: "all grain",
+            author: "x",
+            efficiency: { brewhouse: { value: 72, unit: "%" } },
+            ingredients: { fermentable_additions: [] },
+          },
+        ],
+      },
+    };
+    await app.library.importFile("bad.beerjson", JSON.stringify(doc));
+    await expect(page.getByTestId("import-error")).toContainText('missing required property "batch_size"');
+  });
+});
+
 test.describe("Discoverability", () => {
   test("Library onboarding mentions local storage + GitHub sync", async ({ page }) => {
     const app = new App(page);
diff --git a/crates/werb-beerxml/Cargo.toml b/crates/werb-beerxml/Cargo.toml
index 4cc98dc..fd3466d 100644
--- a/crates/werb-beerxml/Cargo.toml
+++ b/crates/werb-beerxml/Cargo.toml
@@ -13,6 +13,7 @@ readme = "README.md"
 quick-xml = { version = "0.36", features = ["serde", "serialize"] }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
+serde_path_to_error = "0.1"
 thiserror = "1"
 werb-beerjson = { path = "../werb-beerjson" }
 
diff --git a/crates/werb-beerxml/src/error.rs b/crates/werb-beerxml/src/error.rs
index a1a055a..2bc73f4 100644
--- a/crates/werb-beerxml/src/error.rs
+++ b/crates/werb-beerxml/src/error.rs
@@ -7,10 +7,20 @@ use thiserror::Error;
 #[derive(Debug, Error)]
 pub enum Error {
     /// The input is not well-formed XML, or does not match the expected
-    /// BeerXML structure (e.g. missing `<RECIPES>` root).
+    /// BeerXML structure, at the document root (e.g. missing `<RECIPES>`).
     #[error("BeerXML parse error: {0}")]
     Xml(#[from] quick_xml::DeError),
 
+    /// An element's content does not fit BeerXML, at `location`: an XPath
+    /// with 1-based indices, e.g. `/RECIPES/RECIPE[1]/HOPS/HOP[3]/AMOUNT`.
+    #[error("{location}: {source}")]
+    Invalid {
+        /// Where in the document the problem is.
+        location: String,
+        /// What is wrong there.
+        source: quick_xml::DeError,
+    },
+
     /// A field that should be a number could not be parsed as one. The
     /// inner string is the offending raw text from the XML.
     #[error("invalid number in field {field}: {raw:?}")]
diff --git a/crates/werb-beerxml/src/joliebulle.rs b/crates/werb-beerxml/src/joliebulle.rs
index 6ce3e12..4fb1889 100644
--- a/crates/werb-beerxml/src/joliebulle.rs
+++ b/crates/werb-beerxml/src/joliebulle.rs
@@ -36,7 +36,8 @@ use crate::model::{
 /// the same Option semantics as the BeerXML parser.
 pub fn parse_joliebulle(json: &str) -> Result<Vec<Recipe>, Error> {
     let doc: JoliebulleDocument =
-        serde_json::from_str(json).map_err(|e| Error::Json(e.to_string()))?;
+        serde_path_to_error::deserialize(&mut serde_json::Deserializer::from_str(json))
+            .map_err(|e| Error::Json(format!("{}: {}", e.path(), e.inner())))?;
     Ok(doc.recipes.into_iter().map(Recipe::from).collect())
 }
 
diff --git a/crates/werb-beerxml/src/model.rs b/crates/werb-beerxml/src/model.rs
index 337b489..480dea9 100644
--- a/crates/werb-beerxml/src/model.rs
+++ b/crates/werb-beerxml/src/model.rs
@@ -16,13 +16,31 @@ where
     D: Deserializer<'de>,
 {
     match Option::<String>::deserialize(de)? {
-        Some(s) if !s.trim().is_empty() => {
-            s.trim().parse::<f64>().map(Some).map_err(de::Error::custom)
-        }
+        Some(s) if !s.trim().is_empty() => number::<D>(&s).map(Some),
         _ => Ok(None),
     }
 }
 
+/// Parses a BeerXML number. A decimal comma (`5,5`, from comma-decimal
+/// locales) reads as a point; with a point present, commas are thousands
+/// separators.
+fn parse_number(s: &str) -> Option<f64> {
+    let t = s.trim();
+    if let Ok(n) = t.parse::<f64>() {
+        return Some(n);
+    }
+    let normalized = if t.contains('.') {
+        t.replace(',', "")
+    } else {
+        t.replacen(',', ".", 1)
+    };
+    normalized.parse().ok()
+}
+
+fn number<'de, D: Deserializer<'de>>(s: &str) -> Result<f64, D::Error> {
+    parse_number(s).ok_or_else(|| de::Error::custom(format!("not a number: {:?}", s.trim())))
+}
+
 /// Serde helper for required `f64` fields: empty string falls back to
 /// `0.0` instead of failing. Used for fields the BeerXML spec calls
 /// required but real exports occasionally leave blank.
@@ -34,34 +52,39 @@ where
     if s.trim().is_empty() {
         Ok(0.0)
     } else {
-        s.trim().parse::<f64>().map_err(de::Error::custom)
+        number::<D>(&s)
     }
 }
 
-/// Serde helper for `Option<T>` fields where `T` is normally a
-/// string-tagged enum. joliebulle (and probably others) export empty
-/// self-closing elements (`<TYPE />`) instead of omitting the tag
-/// entirely — quick-xml hands those to serde as the literal token
-/// `$text`, which fails enum deserialization with `unknown variant`.
-///
-/// This helper intercepts that case: deserialize to `Option<String>`
-/// first, treat empty / whitespace / `$text` as `None`, and only on
-/// a real value drive the inner deserializer via the captured string.
-fn empty_str_to_none_enum<'de, T, D>(de: D) -> Result<Option<T>, D::Error>
+/// BeerXML enums read leniently: real exports vary in case and spacing
+/// (`boil`, `DRY HOP`) and use common synonyms (`Whirlpool` for `Aroma`).
+/// `from_text` gets the value lowercased with only letters and digits kept.
+trait LenientEnum: Sized {
+    fn from_text(normalized: &str) -> Option<Self>;
+}
+
+/// Serde helper for `Option<T>` enum fields. Empty elements, joliebulle's
+/// self-closing `<TYPE />` (which quick-xml hands over as `$text`) and
+/// unknown values all read as `None`, so one odd value never fails a whole
+/// import; the converter applies its default instead.
+fn lenient_enum<'de, T, D>(de: D) -> Result<Option<T>, D::Error>
 where
     D: Deserializer<'de>,
-    T: serde::de::DeserializeOwned,
+    T: LenientEnum,
 {
     let raw: Option<String> = Option::deserialize(de)?;
-    let Some(s) = raw else { return Ok(None) };
-    let trimmed = s.trim();
-    if trimmed.is_empty() || trimmed == "$text" {
-        return Ok(None);
-    }
-    T::deserialize(serde::de::value::StringDeserializer::<D::Error>::new(
-        trimmed.to_string(),
-    ))
-    .map(Some)
+    Ok(raw.and_then(|s| {
+        let trimmed = s.trim();
+        if trimmed.is_empty() || trimmed == "$text" {
+            return None;
+        }
+        let normalized: String = trimmed
+            .chars()
+            .filter(|c| c.is_alphanumeric())
+            .collect::<String>()
+            .to_lowercase();
+        T::from_text(&normalized)
+    }))
 }
 
 /// A single brewing recipe — the top-level `<RECIPE>` element.
@@ -82,7 +105,7 @@ pub struct Recipe {
     /// Optional in practice: many exporters omit this even though the
     /// spec lists it as required. joliebulle writes `<TYPE />` when
     /// unset, which the empty-str helper folds back to `None`.
-    #[serde(default, rename = "TYPE", deserialize_with = "empty_str_to_none_enum")]
+    #[serde(default, rename = "TYPE", deserialize_with = "lenient_enum")]
     pub recipe_type: Option<RecipeType>,
     /// Optional brewer name.
     #[serde(default)]
@@ -259,6 +282,17 @@ pub enum RecipeType {
     AllGrain,
 }
 
+impl LenientEnum for RecipeType {
+    fn from_text(t: &str) -> Option<Self> {
+        match t {
+            "extract" => Some(Self::Extract),
+            "partialmash" => Some(Self::PartialMash),
+            "allgrain" => Some(Self::AllGrain),
+            _ => None,
+        }
+    }
+}
+
 // ─── Style ────────────────────────────────────────────────────────────────
 
 /// A `<STYLE>` block describing the target style of a recipe.
@@ -331,19 +365,19 @@ pub struct Hop {
     #[serde(default = "default_version")]
     pub version: u32,
     /// Alpha-acid percentage.
-    #[serde(deserialize_with = "empty_str_to_zero_f64")]
+    #[serde(default, deserialize_with = "empty_str_to_zero_f64")]
     pub alpha: f64,
     /// Amount, in kilograms.
-    #[serde(deserialize_with = "empty_str_to_zero_f64")]
+    #[serde(default, deserialize_with = "empty_str_to_zero_f64")]
     pub amount: f64,
     /// Where in the brew the hop is added.
-    #[serde(default, rename = "USE", deserialize_with = "empty_str_to_none_enum")]
+    #[serde(default, rename = "USE", deserialize_with = "lenient_enum")]
     pub hop_use: Option<HopUse>,
     /// Boil time (or dry-hop duration), in minutes.
     #[serde(default, deserialize_with = "empty_str_to_none_f64")]
     pub time: Option<f64>,
     /// Pellet / leaf / plug.
-    #[serde(default, deserialize_with = "empty_str_to_none_enum")]
+    #[serde(default, deserialize_with = "lenient_enum")]
     pub form: Option<HopForm>,
     /// Bittering / aroma / both.
     #[serde(default, rename = "TYPE")]
@@ -370,6 +404,19 @@ pub enum HopUse {
     Aroma,
 }
 
+impl LenientEnum for HopUse {
+    fn from_text(t: &str) -> Option<Self> {
+        match t {
+            "boil" => Some(Self::Boil),
+            "dryhop" | "dryhopping" => Some(Self::DryHop),
+            "mash" => Some(Self::Mash),
+            "firstwort" | "fwh" => Some(Self::FirstWort),
+            "aroma" | "whirlpool" | "hopstand" | "flameout" => Some(Self::Aroma),
+            _ => None,
+        }
+    }
+}
+
 /// Physical form of the hop.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub enum HopForm {
@@ -381,6 +428,17 @@ pub enum HopForm {
     Leaf,
 }
 
+impl LenientEnum for HopForm {
+    fn from_text(t: &str) -> Option<Self> {
+        match t {
+            "pellet" | "pellets" => Some(Self::Pellet),
+            "plug" | "plugs" => Some(Self::Plug),
+            "leaf" | "whole" | "wholeleaf" | "cone" | "cones" => Some(Self::Leaf),
+            _ => None,
+        }
+    }
+}
+
 // ─── Fermentables ─────────────────────────────────────────────────────────
 
 /// Wrapper for a list of `<FERMENTABLE>` elements inside `<FERMENTABLES>`.
@@ -403,10 +461,10 @@ pub struct Fermentable {
     /// Grain / sugar / extract / dry extract / adjunct. Optional in
     /// practice — falls back to [`FermentableType::Adjunct`] via
     /// [`Fermentable::effective_type`] when missing.
-    #[serde(default, rename = "TYPE", deserialize_with = "empty_str_to_none_enum")]
+    #[serde(default, rename = "TYPE", deserialize_with = "lenient_enum")]
     pub fermentable_type: Option<FermentableType>,
     /// Amount, in kilograms.
-    #[serde(deserialize_with = "empty_str_to_zero_f64")]
+    #[serde(default, deserialize_with = "empty_str_to_zero_f64")]
     pub amount: f64,
     /// Yield percentage — sugar potential as a fraction of dry weight.
     #[serde(default, rename = "YIELD", deserialize_with = "empty_str_to_none_f64")]
@@ -449,6 +507,19 @@ pub enum FermentableType {
     Adjunct,
 }
 
+impl LenientEnum for FermentableType {
+    fn from_text(t: &str) -> Option<Self> {
+        match t {
+            "grain" | "malt" => Some(Self::Grain),
+            "sugar" => Some(Self::Sugar),
+            "extract" | "liquidextract" => Some(Self::Extract),
+            "dryextract" => Some(Self::DryExtract),
+            "adjunct" => Some(Self::Adjunct),
+            _ => None,
+        }
+    }
+}
+
 // ─── Yeasts ───────────────────────────────────────────────────────────────
 
 /// Wrapper for a list of `<YEAST>` elements inside `<YEASTS>`.
@@ -470,11 +541,11 @@ pub struct Yeast {
     pub version: u32,
     /// Yeast family — Ale, Lager, Wheat, Wine, Champagne. Optional —
     /// falls back to [`YeastType::Ale`] via [`Yeast::effective_type`].
-    #[serde(default, rename = "TYPE", deserialize_with = "empty_str_to_none_enum")]
+    #[serde(default, rename = "TYPE", deserialize_with = "lenient_enum")]
     pub yeast_type: Option<YeastType>,
     /// Liquid, dry, slant, or culture. Optional — falls back to
     /// [`YeastForm::Dry`] via [`Yeast::effective_form`].
-    #[serde(default, deserialize_with = "empty_str_to_none_enum")]
+    #[serde(default, deserialize_with = "lenient_enum")]
     pub form: Option<YeastForm>,
     /// Amount in liters (for liquid) or kilograms (for dry, when
     /// `amount_is_weight` is true). joliebulle omits the element
@@ -531,6 +602,19 @@ pub enum YeastType {
     Champagne,
 }
 
+impl LenientEnum for YeastType {
+    fn from_text(t: &str) -> Option<Self> {
+        match t {
+            "ale" => Some(Self::Ale),
+            "lager" => Some(Self::Lager),
+            "wheat" => Some(Self::Wheat),
+            "wine" => Some(Self::Wine),
+            "champagne" => Some(Self::Champagne),
+            _ => None,
+        }
+    }
+}
+
 /// Physical form of the culture.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub enum YeastForm {
@@ -544,6 +628,18 @@ pub enum YeastForm {
     Culture,
 }
 
+impl LenientEnum for YeastForm {
+    fn from_text(t: &str) -> Option<Self> {
+        match t {
+            "liquid" => Some(Self::Liquid),
+            "dry" => Some(Self::Dry),
+            "slant" => Some(Self::Slant),
+            "culture" => Some(Self::Culture),
+            _ => None,
+        }
+    }
+}
+
 // ─── Miscs ────────────────────────────────────────────────────────────────
 
 /// Wrapper for a list of `<MISC>` elements inside `<MISCS>`.
@@ -567,13 +663,13 @@ pub struct Misc {
     #[serde(rename = "TYPE")]
     pub misc_type: Option<String>,
     /// Where it is added — boil, mash, primary, secondary, bottling.
-    #[serde(default, rename = "USE", deserialize_with = "empty_str_to_none_enum")]
+    #[serde(default, rename = "USE", deserialize_with = "lenient_enum")]
     pub misc_use: Option<MiscUse>,
     /// Time at addition, in minutes.
     #[serde(default, deserialize_with = "empty_str_to_none_f64")]
     pub time: Option<f64>,
     /// Amount in liters or kilograms (see [`amount_is_weight`](Self::amount_is_weight)).
-    #[serde(deserialize_with = "empty_str_to_zero_f64")]
+    #[serde(default, deserialize_with = "empty_str_to_zero_f64")]
     pub amount: f64,
     /// `true` when [`amount`](Self::amount) is in kg rather than L.
     #[serde(default)]
@@ -595,6 +691,19 @@ pub enum MiscUse {
     Bottling,
 }
 
+impl LenientEnum for MiscUse {
+    fn from_text(t: &str) -> Option<Self> {
+        match t {
+            "boil" => Some(Self::Boil),
+            "mash" => Some(Self::Mash),
+            "primary" => Some(Self::Primary),
+            "secondary" => Some(Self::Secondary),
+            "bottling" => Some(Self::Bottling),
+            _ => None,
+        }
+    }
+}
+
 // ─── Mash ─────────────────────────────────────────────────────────────────
 
 /// A `<MASH>` profile.
@@ -636,7 +745,7 @@ pub struct MashStep {
     pub version: u32,
     /// Infusion / temperature / decoction. Optional — falls back to
     /// [`MashStepType::Infusion`] via [`MashStep::effective_type`].
-    #[serde(default, rename = "TYPE", deserialize_with = "empty_str_to_none_enum")]
+    #[serde(default, rename = "TYPE", deserialize_with = "lenient_enum")]
     pub step_type: Option<MashStepType>,
     /// Volume of water added at this step, in liters (for infusion steps).
     #[serde(default, deserialize_with = "empty_str_to_none_f64")]
@@ -673,3 +782,14 @@ pub enum MashStepType {
     /// Decoction — pull part of the mash, boil it, return it.
     Decoction,
 }
+
+impl LenientEnum for MashStepType {
+    fn from_text(t: &str) -> Option<Self> {
+        match t {
+            "infusion" => Some(Self::Infusion),
+            "temperature" => Some(Self::Temperature),
+            "decoction" => Some(Self::Decoction),
+            _ => None,
+        }
+    }
+}
diff --git a/crates/werb-beerxml/src/parse.rs b/crates/werb-beerxml/src/parse.rs
index d70a967..49c958f 100644
--- a/crates/werb-beerxml/src/parse.rs
+++ b/crates/werb-beerxml/src/parse.rs
@@ -19,8 +19,9 @@ struct Recipes {
 ///
 /// # Errors
 ///
-/// Returns [`Error::Xml`] for malformed XML and [`Error::NoRecipes`] when
-/// the document parses but contains no `<RECIPE>` elements.
+/// Returns [`Error::Invalid`] (or [`Error::Xml`] at the document root) for
+/// XML that doesn't fit BeerXML, and [`Error::NoRecipes`] when the document
+/// parses but contains no `<RECIPE>` elements.
 ///
 /// # Example
 ///
@@ -32,13 +33,42 @@ struct Recipes {
 /// }
 /// ```
 pub fn parse(xml: &str) -> Result<Vec<Recipe>, Error> {
-    let recipes: Recipes = quick_xml::de::from_str(xml)?;
+    let mut de = quick_xml::de::Deserializer::from_str(xml);
+    let recipes: Recipes = serde_path_to_error::deserialize(&mut de).map_err(|e| {
+        let location = xpath(e.path());
+        let source = e.into_inner();
+        if location == ROOT {
+            Error::Xml(source)
+        } else {
+            Error::Invalid { location, source }
+        }
+    })?;
     if recipes.items.is_empty() {
         return Err(Error::NoRecipes);
     }
     Ok(recipes.items)
 }
 
+const ROOT: &str = "/RECIPES";
+
+/// The serde path as an XPath with 1-based indices, the form someone
+/// opening the file in an editor can follow.
+fn xpath(path: &serde_path_to_error::Path) -> String {
+    use serde_path_to_error::Segment;
+    let mut out = String::from(ROOT);
+    for segment in path.iter() {
+        match segment {
+            Segment::Map { key } => {
+                out.push('/');
+                out.push_str(key);
+            }
+            Segment::Seq { index } => out.push_str(&format!("[{}]", index + 1)),
+            Segment::Enum { .. } | Segment::Unknown => {}
+        }
+    }
+    out
+}
+
 /// Convenience wrapper for the common "one recipe per file" case.
 ///
 /// Returns the first `<RECIPE>` in the document, or [`Error::NoRecipes`]
diff --git a/crates/werb-beerxml/tests/parse_sample.rs b/crates/werb-beerxml/tests/parse_sample.rs
index 56b1952..1ab3db9 100644
--- a/crates/werb-beerxml/tests/parse_sample.rs
+++ b/crates/werb-beerxml/tests/parse_sample.rs
@@ -141,7 +141,11 @@ fn empty_input_errors() {
 #[test]
 fn malformed_xml_errors() {
     let xml = "<RECIPES><RECIPE><NAME>oops"; // truncated
-    assert!(matches!(parse(xml), Err(Error::Xml(_))));
+    match parse(xml) {
+        Err(Error::Invalid { location, .. }) => assert_eq!(location, "/RECIPES/RECIPE[1]/NAME"),
+        other => panic!("expected a located error, got {other:?}"),
+    }
+    assert!(matches!(parse("not xml at all <"), Err(Error::Xml(_))));
 }
 
 #[test]
@@ -259,3 +263,88 @@ fn joliebulle_v4_sniff_matches_real_exports() {
     // Random JSON shouldn't either.
     assert!(!werb_beerxml::looks_like_joliebulle(r#"{"hello":"world"}"#));
 }
+
+// ─── Lenient values and located errors ────────────────────────────────────
+
+fn one_hop(hop: &str) -> String {
+    format!(
+        r#"<?xml version="1.0"?><RECIPES><RECIPE><NAME>P</NAME><VERSION>1</VERSION>
+<BATCH_SIZE>20</BATCH_SIZE><HOPS>{hop}</HOPS></RECIPE></RECIPES>"#
+    )
+}
+
+#[test]
+fn reads_a_decimal_comma() {
+    let r = werb_beerxml::parse_one(&one_hop(
+        "<HOP><NAME>C</NAME><ALPHA>5,5</ALPHA><AMOUNT>0,03</AMOUNT><USE>Boil</USE></HOP>",
+    ))
+    .unwrap();
+    let hop = &r.hops.unwrap().items[0];
+    assert!((hop.alpha - 5.5).abs() < 1e-9);
+    assert!((hop.amount - 0.03).abs() < 1e-9);
+}
+
+#[test]
+fn enums_ignore_case_and_read_common_synonyms() {
+    use werb_beerxml::{FermentableType, HopForm, HopUse};
+    let r = werb_beerxml::parse_one(&one_hop(
+        "<HOP><NAME>A</NAME><ALPHA>5</ALPHA><AMOUNT>0.01</AMOUNT><USE>boil</USE><FORM>PELLETS</FORM></HOP>\
+         <HOP><NAME>B</NAME><ALPHA>5</ALPHA><AMOUNT>0.01</AMOUNT><USE>Whirlpool</USE><FORM>Whole</FORM></HOP>\
+         <HOP><NAME>C</NAME><ALPHA>5</ALPHA><AMOUNT>0.01</AMOUNT><USE>dry hop</USE></HOP>",
+    ))
+    .unwrap();
+    let hops = r.hops.unwrap().items;
+    assert_eq!(hops[0].hop_use, Some(HopUse::Boil));
+    assert_eq!(hops[0].form, Some(HopForm::Pellet));
+    assert_eq!(hops[1].hop_use, Some(HopUse::Aroma));
+    assert_eq!(hops[1].form, Some(HopForm::Leaf));
+    assert_eq!(hops[2].hop_use, Some(HopUse::DryHop));
+
+    let malt = werb_beerxml::parse_one(
+        r#"<RECIPES><RECIPE><NAME>P</NAME><BATCH_SIZE>20</BATCH_SIZE><FERMENTABLES>
+<FERMENTABLE><NAME>Pale</NAME><TYPE>Malt</TYPE><AMOUNT>4</AMOUNT></FERMENTABLE>
+</FERMENTABLES></RECIPE></RECIPES>"#,
+    )
+    .unwrap();
+    assert_eq!(
+        malt.fermentables.unwrap().items[0].fermentable_type,
+        Some(FermentableType::Grain)
+    );
+}
+
+#[test]
+fn an_unknown_enum_value_reads_as_absent() {
+    let r = werb_beerxml::parse_one(&one_hop(
+        "<HOP><NAME>A</NAME><ALPHA>5</ALPHA><AMOUNT>0.01</AMOUNT><USE>Kettle soup</USE></HOP>",
+    ))
+    .unwrap();
+    assert_eq!(r.hops.unwrap().items[0].hop_use, None);
+}
+
+#[test]
+fn a_missing_alpha_reads_as_zero_like_an_empty_one() {
+    let r = werb_beerxml::parse_one(&one_hop(
+        "<HOP><NAME>A</NAME><AMOUNT>0.01</AMOUNT><USE>Boil</USE></HOP>",
+    ))
+    .unwrap();
+    assert_eq!(r.hops.unwrap().items[0].alpha, 0.0);
+}
+
+#[test]
+fn a_bad_value_names_its_element() {
+    let err = werb_beerxml::parse(&one_hop(
+        "<HOP><NAME>A</NAME><ALPHA>5</ALPHA><AMOUNT>0.01</AMOUNT></HOP>\
+         <HOP><NAME>B</NAME><ALPHA>5</ALPHA><AMOUNT>lots</AMOUNT></HOP>",
+    ))
+    .unwrap_err();
+    assert_eq!(
+        err.to_string(),
+        r#"/RECIPES/RECIPE[1]/HOPS/HOP[2]/AMOUNT: not a number: "lots""#
+    );
+}
+
+#[test]
+fn joliebulle_errors_name_their_field() {
+    let err = werb_beerxml::parse_joliebulle(r#"{"recipes": [{"name": 3}]}"#).unwrap_err();
+    assert!(err.to_string().contains("recipes[0].name"), "{err}");
+}
diff --git a/packages/validate/src/index.ts b/packages/validate/src/index.ts
index 745db3a..f3f4ea5 100644
--- a/packages/validate/src/index.ts
+++ b/packages/validate/src/index.ts
@@ -37,6 +37,8 @@ const rootValidator = _rootValidator;
 export interface ValidationError {
   /** JSON pointer into the data, e.g. "/beerjson/recipes/0/style". */
   path: string;
+  /** Ajv keyword that failed: "required", "enum", "type", … */
+  keyword: string;
   /** Human-readable message from Ajv. */
   message: string;
   /** Ajv-specific params (missing property name, allowed values, etc.). */
@@ -62,7 +64,75 @@ export function validateBeerJson(data: unknown): ValidationResult {
 function formatError(err: ErrorObject): ValidationError {
   return {
     path: err.instancePath || "/",
+    keyword: err.keyword,
     message: err.message ?? "validation failed",
     params: err.params as Record<string, unknown>,
   };
 }
+
+/**
+ * Drop `null` values from objects, recursively. Some tools write `null` for
+ * an optional property they have no value for; BeerJSON means "absent".
+ */
+export function stripNulls<T>(data: T): T {
+  if (Array.isArray(data)) return data.map(stripNulls) as T;
+  if (data && typeof data === "object") {
+    return Object.fromEntries(
+      Object.entries(data)
+        .filter(([, v]) => v !== null)
+        .map(([k, v]) => [k, stripNulls(v)]),
+    ) as T;
+  }
+  return data;
+}
+
+// Most telling first. Combinators ("must match a schema in anyOf") only
+// say that a deeper error exists.
+const KEYWORD_RANK = ["required", "additionalProperties", "enum", "const", "type"];
+const COMBINATORS = new Set(["anyOf", "oneOf", "allOf", "if", "not"]);
+
+function valueAt(data: unknown, pointer: string): unknown {
+  if (pointer === "/" || pointer === "") return data;
+  return pointer
+    .split("/")
+    .slice(1)
+    .map((p) => p.replace(/~1/g, "/").replace(/~0/g, "~"))
+    .reduce<unknown>(
+      (node, key) =>
+        node && typeof node === "object" ? (node as Record<string, unknown>)[key] : undefined,
+      data,
+    );
+}
+
+/**
+ * One line a brewer can forward: the most specific error, as
+ * `<JSON pointer>: <what is wrong>`, naming the property, the allowed
+ * values or the value found.
+ */
+export function describeErrors(data: unknown, errors: ValidationError[]): string {
+  const candidates = errors.filter((e) => !COMBINATORS.has(e.keyword));
+  const pool = candidates.length > 0 ? candidates : errors;
+  const rank = (e: ValidationError) => {
+    const r = KEYWORD_RANK.indexOf(e.keyword);
+    return r === -1 ? KEYWORD_RANK.length : r;
+  };
+  const depth = (e: ValidationError) => e.path.split("/").length;
+  const best = [...pool].sort((a, b) => depth(b) - depth(a) || rank(a) - rank(b))[0];
+  if (!best) return "unknown";
+  const value = JSON.stringify(valueAt(data, best.path));
+  const p = best.params;
+  switch (best.keyword) {
+    case "required":
+      return `${best.path}: missing required property "${String(p.missingProperty)}"`;
+    case "additionalProperties":
+      return `${best.path}: unknown property "${String(p.additionalProperty)}"`;
+    case "enum":
+      return `${best.path}: ${value} is not one of ${(p.allowedValues as unknown[])
+        .map((v) => JSON.stringify(v))
+        .join(", ")}`;
+    case "type":
+      return `${best.path}: expected ${String(p.type)}, found ${value}`;
+    default:
+      return `${best.path}: ${best.message}`;
+  }
+}
diff --git a/packages/validate/test/validate.test.ts b/packages/validate/test/validate.test.ts
index cbabfe0..8e4be26 100644
--- a/packages/validate/test/validate.test.ts
+++ b/packages/validate/test/validate.test.ts
@@ -2,7 +2,7 @@ import { describe, it, expect } from "vitest";
 import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
-import { validateBeerJson } from "../src/index.js";
+import { describeErrors, stripNulls, validateBeerJson } from "../src/index.js";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const EXAMPLES = join(__dirname, "../../../examples");
@@ -52,3 +52,56 @@ describe("validateBeerJson", () => {
     expect(result.errors.length).toBeGreaterThan(0);
   });
 });
+
+describe("stripNulls", () => {
+  it("drops null properties at any depth, keeps everything else", () => {
+    expect(
+      stripNulls({ a: null, b: 0, c: "", d: { e: null, f: [1, { g: null, h: false }] } }),
+    ).toEqual({ b: 0, c: "", d: { f: [1, { h: false }] } });
+  });
+
+  it("lets a document with null optional properties validate", () => {
+    const doc = load("brewdog-punk-ipa-2007.beerjson") as {
+      beerjson: { recipes: Array<Record<string, unknown>> };
+    };
+    doc.beerjson.recipes[0]!.ibu_estimate = null;
+    doc.beerjson.recipes[0]!.notes = null;
+    expect(validateBeerJson(doc).valid).toBe(false);
+    expect(validateBeerJson(stripNulls(doc)).valid).toBe(true);
+  });
+});
+
+describe("describeErrors", () => {
+  const recipeWith = (patch: (r: Record<string, unknown>) => void) => {
+    const doc = load("brewdog-punk-ipa-2007.beerjson") as {
+      beerjson: { recipes: Array<Record<string, unknown>> };
+    };
+    patch(doc.beerjson.recipes[0]!);
+    return doc;
+  };
+  const describe1 = (doc: unknown) => describeErrors(doc, validateBeerJson(doc).errors);
+
+  it("names a bad enum value and the allowed ones", () => {
+    const doc = recipeWith((r) => {
+      r.type = "all-grain";
+    });
+    expect(describe1(doc)).toBe(
+      '/beerjson/recipes/0/type: "all-grain" is not one of "cider", "kombucha", "soda", "other", "mead", "wine", "extract", "partial mash", "all grain"',
+    );
+  });
+
+  it("names a missing required property", () => {
+    const doc = recipeWith((r) => {
+      delete r.batch_size;
+    });
+    expect(describe1(doc)).toBe('/beerjson/recipes/0: missing required property "batch_size"');
+  });
+
+  it("names the value of a wrong type", () => {
+    const doc = recipeWith((r) => {
+      r.name = 42;
+    });
+    expect(describe1(doc)).toBe("/beerjson/recipes/0/name: expected string, found 42");
+  });
+});
+