pantrybase 0.0.0-stage → 0.2.0

package/dist/chunk-QUWSBZ2V.js

@@ -0,0 +1,3429 @@
+// src/config.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { fileURLToPath } from "url";
+var MODEL_ID = "Xenova/bge-small-en-v1.5";
+var EMBED_DIMS = 384;
+var DEFAULT_UI_PORT = 7433;
+var packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+var cachedVersion;
+function packageVersion() {
+  if (!cachedVersion) {
+    try {
+      cachedVersion = JSON.parse(fs.readFileSync(path.join(packageRoot, "package.json"), "utf8")).version;
+    } catch {
+      cachedVersion = "0.0.0";
+    }
+  }
+  return cachedVersion;
+}
+function homeDir() {
+  return process.env.PANTRYBASE_HOME ?? path.join(os.homedir(), ".pantrybase");
+}
+function modelsDir() {
+  return path.join(homeDir(), "models");
+}
+function resolveProjectRoot(given) {
+  const fromEnv = [process.env.PANTRYBASE_PROJECT_ROOT, process.env.CLAUDE_PROJECT_DIR].find(
+    (v) => v && !v.includes("${")
+  );
+  return path.resolve(given ?? fromEnv ?? process.cwd());
+}
+function dataPaths(projectRoot) {
+  const data = process.env.PANTRYBASE_DATA ? path.resolve(projectRoot, process.env.PANTRYBASE_DATA) : path.join(projectRoot, "pantrybase");
+  return {
+    root: projectRoot,
+    data,
+    recipes: path.join(data, "recipes"),
+    inbox: path.join(data, "inbox"),
+    images: path.join(data, "images"),
+    db: path.join(data, "pantrybase.db"),
+    ingredientsYaml: path.join(data, "ingredients.yaml"),
+    vocabularyYaml: path.join(data, "vocabulary.yaml"),
+    providers: path.join(data, "providers")
+  };
+}
+var DATA_GITIGNORE = `# pantrybase: the database is a rebuildable index of recipes/*.md
+pantrybase.db
+pantrybase.db-*
+# byte-identical copies of photos that were already imported
+inbox/duplicates/
+`;
+function ensureDataDirs(p) {
+  for (const dir of [p.data, p.recipes, p.inbox, p.images]) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  const ignore = path.join(p.data, ".gitignore");
+  if (!fs.existsSync(ignore)) fs.writeFileSync(ignore, DATA_GITIGNORE);
+}
+function log(...args) {
+  console.error("[pantrybase]", ...args);
+}
+
+// src/embeddings/model.ts
+import fs2 from "fs";
+var QUERY_PREFIX = "Represent this sentence for searching relevant passages: ";
+var BATCH = 16;
+var MAX_CHARS = 2e3;
+var Embedder = class {
+  constructor(modelId = MODEL_ID) {
+    this.modelId = modelId;
+  }
+  modelId;
+  pipe = null;
+  loaded = false;
+  get ready() {
+    return this.loaded;
+  }
+  load() {
+    if (!this.pipe) {
+      this.pipe = (async () => {
+        const tf = await import("@huggingface/transformers");
+        fs2.mkdirSync(modelsDir(), { recursive: true });
+        tf.env.cacheDir = modelsDir();
+        const started = Date.now();
+        const p = await tf.pipeline("feature-extraction", this.modelId, {
+          dtype: "q8",
+          device: "cpu"
+        });
+        log(`embedding model ${this.modelId} ready in ${Date.now() - started}ms`);
+        this.loaded = true;
+        return p;
+      })();
+      this.pipe.catch((e) => {
+        log("embedding model failed to load:", e);
+        this.pipe = null;
+      });
+    }
+    return this.pipe;
+  }
+  async embed(texts) {
+    const pipe = await this.load();
+    const out = [];
+    for (let i = 0; i < texts.length; i += BATCH) {
+      const batch = texts.slice(i, i + BATCH).map((t) => t.slice(0, MAX_CHARS));
+      const tensor = await pipe(batch, { pooling: "cls", normalize: true });
+      for (const v of tensor.tolist()) out.push(Float32Array.from(v));
+    }
+    return out;
+  }
+  async embedQuery(query) {
+    const [v] = await this.embed([QUERY_PREFIX + query]);
+    if (!v) throw new Error("empty embedding");
+    return v;
+  }
+};
+
+// src/files/reconcile.ts
+import fs6 from "fs";
+import path3 from "path";
+
+// src/ingredients/normalize.ts
+import fs3 from "fs";
+import { parse as parseYaml } from "yaml";
+
+// src/recipes/schema.ts
+import { z } from "zod";
+
+// src/types.ts
+var TAG_CATEGORIES = [
+  "protein",
+  "diet",
+  "starch",
+  "flavor",
+  "texture",
+  "cuisine",
+  "dish",
+  "meal",
+  "method",
+  "time",
+  "season",
+  "other"
+];
+var FACET_CATEGORIES = [
+  "allergen",
+  "equipment",
+  "technique",
+  "chef",
+  "provider",
+  "plan"
+];
+var ALL_CATEGORIES = [...TAG_CATEGORIES, ...FACET_CATEGORIES];
+var SOURCE_KINDS = ["card", "url", "synthesized", "manual"];
+var DIFFICULTIES = ["easy", "medium", "hard"];
+var INGREDIENT_SOURCES = ["box", "kitchen"];
+var NUTRITION_BASES = ["per_100g", "per_serving"];
+var IMAGE_SIDES = ["front", "back", "other"];
+var INGEST_STATUSES = ["pending", "done", "skipped", "failed"];
+
+// src/recipes/schema.ts
+var num = z.number().nullable().optional();
+var str = z.string().nullable().optional();
+var componentSchema = z.object({
+  raw: z.string().min(1),
+  canonical: z.string().min(1),
+  qty: num,
+  unit: str
+});
+var ingredientSchema = z.object({
+  raw: z.string().min(1).describe('As printed, e.g. "200g Large Pasta Shells"'),
+  canonical: z.string().min(1).describe('Generic singular name without brand, e.g. "pasta shells", "cajun rub"'),
+  qty: num,
+  unit: str,
+  prep: str.describe('Prep note, e.g. "rinse & roughly shred"'),
+  optional: z.boolean().optional(),
+  staple: z.boolean().optional().describe("Pantry staple \u2014 ignored for pantry coverage"),
+  source: z.enum(INGREDIENT_SOURCES).optional().describe('"box" = supplied, "kitchen" = from your own kitchen'),
+  brand: str,
+  group: str.describe('Sub-recipe, e.g. "sauce", "salsa"'),
+  alternatives: z.array(z.string()).optional(),
+  components: z.array(componentSchema).optional().describe("Parts of a composite line")
+});
+var stepSchema = z.object({
+  title: str.describe("Heading as printed"),
+  text: z.string().min(1),
+  techniques: z.array(z.string()).optional().describe("Inferred, from the method vocabulary"),
+  uses: z.array(z.string()).optional().describe("Canonical names of ingredients used"),
+  equipment: z.array(z.string()).optional(),
+  temp_c: num,
+  minutes: z.array(z.number()).max(2).optional().describe("[min] or [min, max]")
+});
+var tagsSchema = z.partialRecord(z.enum(TAG_CATEGORIES), z.array(z.string().min(1)));
+var nutritionSchema = z.object({
+  basis: z.enum(NUTRITION_BASES),
+  energy_kj: num,
+  energy_kcal: num,
+  protein_g: num,
+  carbs_g: num,
+  sugars_g: num,
+  fibre_g: num,
+  fat_g: num,
+  saturated_g: num,
+  sodium_mg: num
+});
+var providerSchema = z.object({
+  id: z.string().min(1).describe('Provider profile id, e.g. "ucook" (see pb_providers)'),
+  name: str,
+  plan: str.describe('Plan line as printed, e.g. "Veggie"'),
+  chef: str,
+  card_code: str,
+  eat_within_days: num,
+  wine: z.object({ producer: str, name: str, vintage: num }).nullable().optional()
+});
+var extractionSchema = z.object({
+  confidence: z.number().min(0).max(1).nullable().optional(),
+  uncertain: z.array(z.string()).optional().describe('e.g. ["nutrition.protein_g"]'),
+  needs_review: z.boolean().optional(),
+  images: z.array(z.object({ file: z.string(), side: z.enum(IMAGE_SIDES) })).optional(),
+  notes: str
+});
+var recipeInputSchema = z.object({
+  title: z.string().min(1),
+  slug: z.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/).optional().describe("Only to update an existing recipe; omit to create"),
+  subtitle: z.string().optional(),
+  description: z.string().optional().describe("Card description, transcribed"),
+  blurb: z.string().optional().describe("Your own 1\u20132 sentence description for semantic search"),
+  servings: z.number().int().positive().nullable().optional(),
+  time: z.object({ prep: num, cook: num, active: num, total: num }).optional().describe("Minutes; active = hands-on"),
+  difficulty: z.enum(DIFFICULTIES).nullable().optional(),
+  source: z.object({
+    kind: z.enum(SOURCE_KINDS),
+    ref: str,
+    ingested: z.string().optional()
+  }).optional(),
+  provider: providerSchema.optional(),
+  derived_from: z.array(z.string()).optional().describe("Slugs this recipe was synthesized from"),
+  images: z.array(z.string()).optional().describe("Paths relative to the data dir"),
+  tags: tagsSchema.optional(),
+  allergens: z.array(z.string()).optional(),
+  equipment: z.array(z.string()).optional(),
+  nutrition: nutritionSchema.optional(),
+  ingredients: z.array(ingredientSchema).min(1),
+  steps: z.array(z.union([z.string().min(1), stepSchema])).min(1),
+  tips: z.array(z.string()).optional(),
+  notes: z.string().optional(),
+  extraction: extractionSchema.optional()
+});
+function normalizeName(s) {
+  return s.toLowerCase().normalize("NFKD").replace(/[̀-ͯ]/g, "").replace(/[^\p{L}\p{N}\s'-]/gu, " ").replace(/\s+/g, " ").trim();
+}
+var trimmed = (s) => {
+  const t = s?.trim();
+  return t ? t : void 0;
+};
+function compact(obj) {
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (v === void 0 || v === null || v === "") continue;
+    if (Array.isArray(v) && v.length === 0) continue;
+    out[k] = v;
+  }
+  return out;
+}
+function normalizeStep(step) {
+  if (typeof step === "string") return { text: step.trim() };
+  return compact({
+    title: trimmed(step.title),
+    text: step.text.trim(),
+    techniques: step.techniques?.map((t) => t.trim()).filter(Boolean),
+    uses: step.uses?.map(normalizeName).filter(Boolean),
+    equipment: step.equipment?.map((e) => e.trim()).filter(Boolean),
+    temp_c: step.temp_c ?? void 0,
+    minutes: step.minutes?.length ? step.minutes : void 0
+  });
+}
+function normalizeRecipe(input, slug) {
+  const time = compact({ ...input.time ?? {} });
+  if (time.total == null && (time.prep != null || time.cook != null)) {
+    time.total = (time.prep ?? 0) + (time.cook ?? 0);
+  }
+  const tags = {};
+  for (const [cat, names] of Object.entries(input.tags ?? {})) {
+    const clean = [...new Set((names ?? []).map((n) => n.trim()).filter(Boolean))];
+    if (clean.length) tags[cat] = clean;
+  }
+  const recipe = {
+    slug,
+    title: input.title.trim(),
+    time,
+    source: input.source ?? { kind: "manual" },
+    derived_from: input.derived_from ?? [],
+    images: input.images ?? [],
+    tags,
+    allergens: (input.allergens ?? []).map((a) => a.trim()).filter(Boolean),
+    equipment: (input.equipment ?? []).map((e) => e.trim()).filter(Boolean),
+    ingredients: input.ingredients.map(
+      (i) => compact({
+        raw: i.raw.trim(),
+        canonical: normalizeName(i.canonical),
+        qty: i.qty ?? void 0,
+        unit: trimmed(i.unit),
+        prep: trimmed(i.prep),
+        optional: i.optional || void 0,
+        staple: i.staple || void 0,
+        source: i.source,
+        brand: trimmed(i.brand),
+        group: trimmed(i.group),
+        alternatives: i.alternatives?.map(normalizeName).filter(Boolean),
+        components: i.components?.map(
+          (c) => compact({
+            raw: c.raw.trim(),
+            canonical: normalizeName(c.canonical),
+            qty: c.qty ?? void 0,
+            unit: trimmed(c.unit)
+          })
+        )
+      })
+    ),
+    steps: input.steps.map(normalizeStep).filter((s) => s.text),
+    tips: (input.tips ?? []).map((t) => t.trim()).filter(Boolean)
+  };
+  const opt = {
+    subtitle: trimmed(input.subtitle),
+    description: trimmed(input.description),
+    blurb: trimmed(input.blurb),
+    notes: trimmed(input.notes)
+  };
+  for (const [k, v] of Object.entries(opt))
+    if (v) recipe[k] = v;
+  if (input.servings != null) recipe.servings = input.servings;
+  if (input.difficulty) recipe.difficulty = input.difficulty;
+  if (input.provider) {
+    const p = input.provider;
+    recipe.provider = compact({
+      id: p.id.trim().toLowerCase(),
+      name: trimmed(p.name),
+      plan: trimmed(p.plan),
+      chef: trimmed(p.chef),
+      card_code: trimmed(p.card_code),
+      eat_within_days: p.eat_within_days ?? void 0,
+      wine: p.wine ? compact({ ...p.wine }) : void 0
+    });
+    if (recipe.provider.wine && Object.keys(recipe.provider.wine).length === 0) {
+      delete recipe.provider.wine;
+    }
+  }
+  if (input.nutrition) recipe.nutrition = compact({ ...input.nutrition });
+  if (input.extraction) {
+    const e = compact({ ...input.extraction });
+    if (Object.keys(e).length) recipe.extraction = e;
+  }
+  return recipe;
+}
+
+// src/ingredients/normalize.ts
+var FUZZY_THRESHOLD = 0.85;
+function dice(a, b) {
+  const grams = (s) => {
+    const g = /* @__PURE__ */ new Map();
+    const t = ` ${s} `;
+    for (let i = 0; i < t.length - 1; i++) {
+      const k = t.slice(i, i + 2);
+      g.set(k, (g.get(k) ?? 0) + 1);
+    }
+    return g;
+  };
+  const ga = grams(a);
+  const gb = grams(b);
+  let overlap = 0;
+  for (const [k, n] of ga) overlap += Math.min(n, gb.get(k) ?? 0);
+  const total = [...ga.values()].reduce((x, y) => x + y, 0) + [...gb.values()].reduce((x, y) => x + y, 0);
+  return total === 0 ? 0 : 2 * overlap / total;
+}
+function singularForms(name) {
+  const m = /^(.*?)(\S+)$/.exec(name);
+  if (!m) return [];
+  const [, head = "", last = ""] = m;
+  const out = [];
+  if (last.endsWith("ies") && last.length > 4) out.push(`${last.slice(0, -3)}y`);
+  if (last.endsWith("oes") || last.endsWith("ches") || last.endsWith("shes"))
+    out.push(last.slice(0, -2));
+  if (last.endsWith("s") && !last.endsWith("ss") && last.length > 3) out.push(last.slice(0, -1));
+  return out.map((w) => `${head}${w}`);
+}
+function lookup(store, name) {
+  const exact = store.getIngredient(name);
+  if (exact) return exact;
+  for (const s of singularForms(name)) {
+    const row = store.getIngredient(s);
+    if (row) return row;
+  }
+  return void 0;
+}
+function resolveIngredients(store, ingredients) {
+  const res = { ids: /* @__PURE__ */ new Map(), created: [], aliased: [], ingredients: [] };
+  for (const ing of ingredients) {
+    const name = normalizeName(ing.canonical);
+    let row = lookup(store, name);
+    if (row) {
+      if (row.canonical !== name) res.aliased.push({ from: name, to: row.canonical, via: "alias" });
+    } else {
+      const best = store.fuzzyIngredients(name, 3)[0];
+      if (best && dice(name, best.alias) >= FUZZY_THRESHOLD) {
+        row = best.row;
+        store.addAlias(row.id, name);
+        res.aliased.push({ from: name, to: row.canonical, via: "fuzzy" });
+      } else {
+        row = store.createIngredient({ canonical: name, staple: ing.staple ?? false });
+        res.created.push(name);
+      }
+    }
+    res.ids.set(row.canonical, row.id);
+    const out = { ...ing, canonical: row.canonical };
+    if (row.is_staple || ing.staple) out.staple = true;
+    else delete out.staple;
+    res.ingredients.push(out);
+  }
+  return res;
+}
+function readCatalogYaml(file) {
+  if (!fs3.existsSync(file)) return [];
+  const data = parseYaml(fs3.readFileSync(file, "utf8"));
+  if (!data || typeof data !== "object") return [];
+  return Object.entries(data).map(([canonical, v]) => ({
+    canonical: normalizeName(canonical),
+    aliases: (v?.aliases ?? []).map(normalizeName),
+    staple: v?.staple ?? false,
+    category: v?.category ?? null
+  }));
+}
+function findCanonical(store, name) {
+  return lookup(store, normalizeName(name))?.canonical;
+}
+function loadCatalog(store, file) {
+  const entries = readCatalogYaml(file);
+  store.transaction(() => {
+    for (const e of entries) store.upsertCatalogEntry(e);
+  });
+  return entries.length;
+}
+
+// src/vocabulary/vocabulary.ts
+import fs4 from "fs";
+import { parse as parseYaml2 } from "yaml";
+function normalizeTagValue(s) {
+  return s.normalize("NFKD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/['’]/g, "").replace(/&/g, " and ").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+var Vocabulary = class _Vocabulary {
+  categories = /* @__PURE__ */ new Map();
+  static fromFile(file) {
+    const v = new _Vocabulary();
+    if (fs4.existsSync(file)) {
+      v.load(parseYaml2(fs4.readFileSync(file, "utf8")));
+    }
+    return v;
+  }
+  load(data) {
+    for (const [name, raw] of Object.entries(data ?? {})) {
+      const cat = this.ensure(name, raw?.mode ?? "open");
+      if (raw?.mode) cat.mode = raw.mode;
+      for (const [value, def] of Object.entries(raw?.values ?? {})) {
+        this.addValue(name, value, def?.synonyms ?? [], def?.parent);
+      }
+    }
+  }
+  ensure(category, mode) {
+    let cat = this.categories.get(category);
+    if (!cat) {
+      cat = { mode, values: /* @__PURE__ */ new Map(), lookup: /* @__PURE__ */ new Map() };
+      this.categories.set(category, cat);
+    }
+    return cat;
+  }
+  addValue(category, value, synonyms = [], parent) {
+    const cat = this.ensure(category, "open");
+    const v = normalizeTagValue(value);
+    const existing = cat.values.get(v);
+    const entry = existing ?? { synonyms: [] };
+    if (parent) entry.parent = normalizeTagValue(parent);
+    cat.values.set(v, entry);
+    cat.lookup.set(v, v);
+    for (const s of synonyms) {
+      const n = normalizeTagValue(s);
+      if (!n) continue;
+      entry.synonyms.push(n);
+      if (!cat.values.has(n) || n === v) cat.lookup.set(n, v);
+    }
+  }
+  /** Extra synonyms, e.g. from a provider profile. Unknown targets are created. */
+  addSynonyms(category, map) {
+    for (const [from, to] of Object.entries(map)) this.addValue(category, to, [from]);
+  }
+  has(category) {
+    return this.categories.has(category);
+  }
+  mode(category) {
+    return this.categories.get(category)?.mode ?? "open";
+  }
+  resolve(category, raw) {
+    const n = normalizeTagValue(raw);
+    const hit = this.categories.get(category)?.lookup.get(n);
+    return hit ? { value: hit, known: true } : { value: n, known: false };
+  }
+  normalize(category, raws) {
+    const out = { values: [], mapped: [], unknown: [] };
+    for (const raw of raws) {
+      const { value, known } = this.resolve(category, raw);
+      if (!value) continue;
+      if (known && value !== normalizeTagValue(raw)) out.mapped.push({ from: raw, to: value });
+      if (!known) out.unknown.push(value);
+      if (!out.values.includes(value)) out.values.push(value);
+    }
+    return out;
+  }
+  /** The value plus everything below it in the hierarchy (thai ⊂ southeast-asian ⊂ asian). */
+  expand(category, raw) {
+    const root = this.resolve(category, raw).value;
+    const cat = this.categories.get(category);
+    if (!cat) return [root];
+    const out = /* @__PURE__ */ new Set([root]);
+    let grew = true;
+    while (grew) {
+      grew = false;
+      for (const [value, def] of cat.values) {
+        if (def.parent && out.has(def.parent) && !out.has(value)) {
+          out.add(value);
+          grew = true;
+        }
+      }
+    }
+    return [...out];
+  }
+  /** Ancestors of a value, nearest first. */
+  ancestors(category, value) {
+    const cat = this.categories.get(category);
+    const out = [];
+    let cur = cat?.values.get(value)?.parent;
+    while (cur && !out.includes(cur)) {
+      out.push(cur);
+      cur = cat?.values.get(cur)?.parent;
+    }
+    return out;
+  }
+  /** Compact summary for Claude: closed categories list every value, open ones the top values. */
+  summary(maxOpen = 40) {
+    const out = {};
+    for (const [name, cat] of this.categories) {
+      const values = [...cat.values.keys()];
+      out[name] = {
+        mode: cat.mode,
+        values: cat.mode === "closed" ? values : values.slice(0, maxOpen)
+      };
+    }
+    return out;
+  }
+};
+
+// src/recipes/enrich.ts
+function addTag(recipe, category, value) {
+  const list = recipe.tags[category] ?? [];
+  if (!list.includes(value)) list.push(value);
+  recipe.tags[category] = list;
+}
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function applyProvider(recipe, profile, report) {
+  if (!recipe.provider) return;
+  if (!recipe.provider.name) recipe.provider.name = profile.name;
+  if (recipe.servings == null && profile.default_servings != null) {
+    recipe.servings = profile.default_servings;
+    report.provider.push(`servings defaulted to ${profile.default_servings}`);
+  }
+  const plan = recipe.provider.plan;
+  if (plan) {
+    const key = Object.keys(profile.plan_labels).find(
+      (k) => normalizeTagValue(k) === normalizeTagValue(plan)
+    );
+    for (const [cat, values] of Object.entries(key ? profile.plan_labels[key] ?? {} : {})) {
+      if (!TAG_CATEGORIES.includes(cat)) continue;
+      for (const v of values) {
+        if (!recipe.tags[cat]?.includes(v)) {
+          addTag(recipe, cat, v);
+          report.provider.push(`plan "${plan}" \u2192 ${cat}:${v}`);
+        }
+      }
+    }
+  }
+  const equipmentTerms = new Map(
+    Object.entries(profile.equipment_terms).map(([k, v]) => [normalizeName(k), v])
+  );
+  const kept = [];
+  for (const ing of recipe.ingredients) {
+    const eq = equipmentTerms.get(ing.canonical) ?? equipmentTerms.get(normalizeName(ing.raw));
+    if (eq) {
+      if (!recipe.equipment.includes(eq)) recipe.equipment.push(eq);
+      report.provider.push(`"${ing.raw}" moved to equipment`);
+    } else {
+      kept.push(ing);
+    }
+  }
+  recipe.ingredients = kept;
+  for (const ing of recipe.ingredients) {
+    for (const brand of profile.brands) {
+      const re = new RegExp(`(^|\\s)${escapeRe(normalizeName(brand))}(\\s|$)`);
+      if (re.test(ing.canonical)) {
+        const stripped = ing.canonical.replace(re, " ").replace(/\s+/g, " ").trim();
+        if (stripped) {
+          report.provider.push(`brand "${brand}" stripped from "${ing.canonical}"`);
+          ing.canonical = stripped;
+          if (!ing.brand) ing.brand = brand;
+        }
+      } else if (!ing.brand && re.test(normalizeName(ing.raw))) {
+        ing.brand = brand;
+      }
+    }
+  }
+  if (recipe.nutrition && !recipe.nutrition.basis) recipe.nutrition.basis = profile.nutrition_basis;
+}
+function vocabList(vocab, category, values, report, closedFallback) {
+  const r = vocab.normalize(category, values);
+  for (const m of r.mapped) report.mapped.push(`${category}: "${m.from}" \u2192 ${m.to}`);
+  const closed = vocab.has(category) && vocab.mode(category) === "closed";
+  if (!closed) {
+    for (const u of r.unknown) report.new_tags.push(`${category}:${u}`);
+    return { kept: r.values, toOther: [] };
+  }
+  for (const u of r.unknown) {
+    report.rejected.push(
+      `${category}:${u}${closedFallback === "other" ? " (moved to other)" : " (kept)"}`
+    );
+  }
+  if (closedFallback === "keep") return { kept: r.values, toOther: [] };
+  return {
+    kept: r.values.filter((v) => !r.unknown.includes(v)),
+    toOther: r.unknown
+  };
+}
+function enrichRecipe(recipe, vocab, profile) {
+  const report = { mapped: [], new_tags: [], rejected: [], provider: [] };
+  if (profile) applyProvider(recipe, profile, report);
+  const tags = {};
+  const toOther = [];
+  for (const cat of TAG_CATEGORIES) {
+    const values = recipe.tags[cat];
+    if (!values?.length || cat === "other") continue;
+    const r = vocabList(vocab, cat, values, report, "other");
+    if (r.kept.length) tags[cat] = r.kept;
+    toOther.push(...r.toOther);
+  }
+  const other = vocabList(
+    vocab,
+    "other",
+    [...recipe.tags.other ?? [], ...toOther],
+    report,
+    "keep"
+  );
+  if (other.kept.length) tags.other = other.kept;
+  recipe.tags = tags;
+  recipe.allergens = vocabList(vocab, "allergen", recipe.allergens, report, "keep").kept;
+  const stepEquipment = recipe.steps.flatMap((s) => s.equipment ?? []);
+  recipe.equipment = vocabList(vocab, "equipment", recipe.equipment, report, "keep").kept;
+  for (const step of recipe.steps) {
+    if (step.equipment?.length) {
+      step.equipment = vocab.normalize("equipment", step.equipment).values;
+    }
+    if (step.techniques?.length) {
+      step.techniques = vocabList(vocab, "method", step.techniques, report, "keep").kept;
+    }
+  }
+  for (const e of vocab.normalize("equipment", stepEquipment).values) {
+    if (!recipe.equipment.includes(e)) recipe.equipment.push(e);
+  }
+  for (const ing of recipe.ingredients) {
+    if (ing.source === "kitchen") ing.staple = true;
+  }
+  report.mapped = [...new Set(report.mapped)];
+  report.new_tags = [...new Set(report.new_tags)];
+  report.rejected = [...new Set(report.rejected)];
+  return report;
+}
+
+// src/recipes/pipeline.ts
+function prepareRecipe(ctx, recipe) {
+  const profile = recipe.provider ? ctx.providers.resolve(recipe.provider.id) : void 0;
+  const originals = new Map(recipe.ingredients.map((i) => [i, i.canonical]));
+  const report = enrichRecipe(recipe, ctx.vocab, profile);
+  const resolution = resolveIngredients(ctx.store, recipe.ingredients);
+  const rename = /* @__PURE__ */ new Map();
+  recipe.ingredients.forEach((ing, idx) => {
+    const final = resolution.ingredients[idx]?.canonical;
+    if (!final) return;
+    rename.set(ing.canonical, final);
+    const original = originals.get(ing);
+    if (original) rename.set(original, final);
+  });
+  recipe.ingredients = resolution.ingredients;
+  const ingredientIds = new Map(resolution.ids);
+  const unmatched = [];
+  for (const step of recipe.steps) {
+    if (!step.uses?.length) continue;
+    const uses = [];
+    for (const raw of step.uses) {
+      const name = normalizeName(raw);
+      let final = rename.get(name);
+      if (!final) {
+        const known = findCanonical(ctx.store, name);
+        if (known) {
+          final = known;
+          const row = ctx.store.getIngredient(known);
+          if (row) ingredientIds.set(row.canonical, row.id);
+        }
+      }
+      if (!final) {
+        unmatched.push(name);
+        final = name;
+      }
+      if (!uses.includes(final)) uses.push(final);
+    }
+    step.uses = uses;
+  }
+  return {
+    recipe,
+    ingredientIds,
+    resolution,
+    report,
+    unmatched_uses: [...new Set(unmatched)]
+  };
+}
+
+// src/files/recipe-md.ts
+import { Document, isMap, isSeq, parse as parseYaml3 } from "yaml";
+var FORMAT_VERSION = 2;
+var FM_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+var KEY_ORDER = [
+  "pb",
+  "title",
+  "slug",
+  "subtitle",
+  "description",
+  "blurb",
+  "servings",
+  "time",
+  "difficulty",
+  "source",
+  "provider",
+  "derived_from",
+  "images",
+  "tags",
+  "allergens",
+  "equipment",
+  "nutrition",
+  "ingredients",
+  "steps",
+  "tips",
+  "extraction"
+];
+function stripEmpty(obj) {
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (v === void 0 || v === null || v === "") continue;
+    if (Array.isArray(v) && v.length === 0 && k !== "derived_from" && k !== "images") continue;
+    out[k] = v;
+  }
+  return out;
+}
+function serializeRecipe(recipe) {
+  const { notes: _notes, slug, ...rest } = recipe;
+  const record = { pb: FORMAT_VERSION, ...rest, slug };
+  const fm = {};
+  for (const key of KEY_ORDER) {
+    const v = record[key];
+    if (v === void 0 || v === null || v === "") continue;
+    if (Array.isArray(v) && v.length === 0 && key !== "derived_from" && key !== "images") continue;
+    if (typeof v === "object" && !Array.isArray(v)) {
+      const inner = stripEmpty(v);
+      if (Object.keys(inner).length === 0) continue;
+      fm[key] = inner;
+    } else {
+      fm[key] = v;
+    }
+  }
+  const doc = new Document(fm);
+  const root = doc.contents;
+  if (isMap(root)) {
+    for (const key of ["time", "source", "nutrition"]) {
+      const n = root.get(key, true);
+      if (isMap(n)) n.flow = true;
+    }
+    for (const key of ["derived_from", "images", "allergens", "equipment"]) {
+      const n = root.get(key, true);
+      if (isSeq(n)) n.flow = true;
+    }
+    const provider = root.get("provider", true);
+    if (isMap(provider)) {
+      const wine = provider.get("wine", true);
+      if (isMap(wine)) wine.flow = true;
+    }
+    const tags = root.get("tags", true);
+    if (isMap(tags)) {
+      for (const pair of tags.items) if (isSeq(pair.value)) pair.value.flow = true;
+    }
+    for (const key of ["ingredients", "steps"]) {
+      const list = root.get(key, true);
+      if (isSeq(list)) {
+        for (const item of list.items) if (isMap(item)) item.flow = true;
+      }
+    }
+    const extraction = root.get("extraction", true);
+    if (isMap(extraction)) {
+      for (const pair of extraction.items) if (isSeq(pair.value)) pair.value.flow = true;
+      const images = extraction.get("images", true);
+      if (isSeq(images)) {
+        for (const item of images.items) if (isMap(item)) item.flow = true;
+      }
+    }
+  }
+  const yaml = doc.toString({ lineWidth: 0, flowCollectionPadding: false }).trimEnd();
+  const lines = ["---", yaml, "---", "", `# ${recipe.title}`, ""];
+  if (recipe.subtitle) lines.push(`*${recipe.subtitle}*`, "");
+  if (recipe.description) lines.push(recipe.description, "");
+  const box = recipe.ingredients.filter((i) => i.source !== "kitchen");
+  const kitchen = recipe.ingredients.filter((i) => i.source === "kitchen");
+  const line = (i) => `- ${i.raw}${i.prep ? ` \u2014 ${i.prep}` : ""}${i.optional ? " (optional)" : ""}`;
+  lines.push("## Ingredients", "");
+  for (const i of box) lines.push(line(i));
+  if (kitchen.length) {
+    lines.push("", "### From your kitchen", "");
+    for (const i of kitchen) lines.push(line(i));
+  }
+  lines.push("", "## Method", "");
+  recipe.steps.forEach((s, n) => {
+    lines.push(`${n + 1}. ${s.title ? `**${s.title}** ` : ""}${s.text}`);
+  });
+  if (recipe.tips.length) {
+    lines.push("", "## Tips", "");
+    for (const t of recipe.tips) lines.push(`- ${t}`);
+  }
+  if (recipe.notes) lines.push("", "## Notes", "", recipe.notes);
+  lines.push("");
+  return lines.join("\n");
+}
+function sections(body) {
+  const out = /* @__PURE__ */ new Map();
+  let current = null;
+  let buf = [];
+  const flush = () => {
+    if (current !== null) out.set(current, buf.join("\n").trim());
+    buf = [];
+  };
+  for (const line of body.split(/\r?\n/)) {
+    const m = /^##\s+(.+?)\s*$/.exec(line);
+    if (m?.[1]) {
+      flush();
+      current = m[1].toLowerCase();
+    } else {
+      buf.push(line);
+    }
+  }
+  flush();
+  return out;
+}
+function parseSteps(method) {
+  const steps = [];
+  for (const raw of method.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line) continue;
+    const m = /^(?:\d+[.)]|[-*])\s+(.*)$/.exec(line);
+    if (m?.[1]) steps.push(m[1]);
+    else if (steps.length) steps[steps.length - 1] = `${steps[steps.length - 1]} ${line}`;
+    else steps.push(line);
+  }
+  return steps;
+}
+function parseRecipe(markdown, slugFromFile) {
+  const m = FM_RE.exec(markdown);
+  if (!m?.[1]) throw new Error("missing frontmatter");
+  const fm = parseYaml3(m[1]);
+  if (typeof fm !== "object" || fm === null) throw new Error("frontmatter is not a map");
+  const secs = sections(m[2] ?? "");
+  const { pb: _pb, summary, ...rest } = fm;
+  const fmSteps = Array.isArray(rest.steps) && rest.steps.length > 0 ? rest.steps : void 0;
+  const bodySteps = parseSteps(secs.get("method") ?? secs.get("steps") ?? "");
+  const notes = secs.get("notes");
+  const input = recipeInputSchema.parse({
+    ...rest,
+    // v1 files called the blurb "summary".
+    ...summary && !rest.blurb ? { blurb: summary } : {},
+    slug: slugFromFile,
+    steps: fmSteps ?? (bodySteps.length ? bodySteps : ["(no method recorded)"]),
+    ...notes ? { notes } : {}
+  });
+  return normalizeRecipe(input, slugFromFile);
+}
+
+// src/files/store.ts
+import { createHash } from "crypto";
+import fs5 from "fs";
+import path2 from "path";
+function recipeFilePath(paths, slug) {
+  return path2.join(paths.recipes, `${slug}.md`);
+}
+function relativeToData(paths, abs) {
+  return path2.relative(paths.data, abs).split(path2.sep).join("/");
+}
+function hashContent(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+function writeRecipeFile(paths, recipe) {
+  const abs = recipeFilePath(paths, recipe.slug);
+  const content = serializeRecipe(recipe);
+  const tmp = `${abs}.tmp-${process.pid}`;
+  fs5.mkdirSync(path2.dirname(abs), { recursive: true });
+  fs5.writeFileSync(tmp, content, "utf8");
+  fs5.renameSync(tmp, abs);
+  const st = fs5.statSync(abs);
+  return {
+    file_path: relativeToData(paths, abs),
+    file_mtime: st.mtimeMs,
+    file_size: st.size,
+    content_hash: hashContent(content)
+  };
+}
+function recipeFileExists(paths, slug) {
+  return fs5.existsSync(recipeFilePath(paths, slug));
+}
+
+// src/files/reconcile.ts
+function reconcile(ctx, opts = {}) {
+  const res = { added: 0, updated: 0, removed: 0, unchanged: 0, errors: [] };
+  const index = ctx.store.recipeFileIndex();
+  const seen = /* @__PURE__ */ new Set();
+  const files = fs6.existsSync(ctx.paths.recipes) ? fs6.readdirSync(ctx.paths.recipes).filter((f) => f.endsWith(".md") && !f.startsWith(".")) : [];
+  for (const name of files.sort()) {
+    const abs = path3.join(ctx.paths.recipes, name);
+    const rel = relativeToData(ctx.paths, abs);
+    seen.add(rel);
+    const st = fs6.statSync(abs);
+    const prev = index.get(rel);
+    if (!opts.full && prev && Math.round(prev.file_mtime) === Math.round(st.mtimeMs) && prev.file_size === st.size) {
+      res.unchanged++;
+      continue;
+    }
+    const content = fs6.readFileSync(abs, "utf8");
+    const hash = hashContent(content);
+    if (!opts.full && prev && prev.content_hash === hash) {
+      ctx.store.touchFile(rel, st.mtimeMs, st.size);
+      res.unchanged++;
+      continue;
+    }
+    try {
+      const slug = name.slice(0, -3);
+      const prepared = prepareRecipe(ctx, parseRecipe(content, slug));
+      ctx.store.upsertRecipe(
+        prepared.recipe,
+        { file_path: rel, file_mtime: st.mtimeMs, file_size: st.size, content_hash: hash },
+        prepared.ingredientIds
+      );
+      if (prev) res.updated++;
+      else res.added++;
+    } catch (e) {
+      res.errors.push({ file: rel, error: e instanceof Error ? e.message : String(e) });
+    }
+  }
+  for (const [rel, entry] of index) {
+    if (!seen.has(rel)) {
+      ctx.store.deleteRecipe(entry.slug);
+      res.removed++;
+    }
+  }
+  if (opts.reembed) ctx.store.resetVectors();
+  ctx.embedQueue.kick();
+  return res;
+}
+
+// src/core/context.ts
+import fs8 from "fs";
+import path5 from "path";
+
+// src/embeddings/queue.ts
+var PASS = 64;
+var EmbedQueue = class {
+  constructor(store, embedder) {
+    this.store = store;
+    this.embedder = embedder;
+  }
+  store;
+  embedder;
+  timer = null;
+  running = null;
+  stopped = false;
+  /** Cancel any scheduled pass; called before the store closes. */
+  stop() {
+    this.stopped = true;
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = null;
+  }
+  kick(delayMs = 300) {
+    if (!this.embedder || this.stopped) return;
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      void this.run();
+    }, delayMs);
+    this.timer.unref();
+  }
+  /** Embed everything pending; resolves when the queue is drained. */
+  run() {
+    if (!this.embedder || this.stopped) return Promise.resolve();
+    if (this.running) return this.running;
+    const embedder = this.embedder;
+    this.running = (async () => {
+      try {
+        while (!this.stopped) {
+          const pending = this.store.pendingChunks(PASS);
+          if (pending.length === 0) break;
+          const vectors = await embedder.embed(pending.map((p) => p.text));
+          if (this.stopped) break;
+          this.store.storeEmbeddings(
+            pending.map((p, i) => {
+              const embedding = vectors[i];
+              if (!embedding) throw new Error("embedding count mismatch");
+              return { id: p.id, embedding };
+            })
+          );
+        }
+      } catch (e) {
+        log("embedding pass failed:", e);
+      } finally {
+        this.running = null;
+      }
+    })();
+    return this.running;
+  }
+};
+
+// src/providers/registry.ts
+import fs7 from "fs";
+import path4 from "path";
+import { parse as parseYaml4 } from "yaml";
+var GENERIC_PROVIDER = "generic";
+function builtinProvidersDir() {
+  return path4.join(packageRoot, "providers");
+}
+function loadProfile(dir) {
+  const file = path4.join(dir, "profile.yaml");
+  if (!fs7.existsSync(file)) return null;
+  const raw = parseYaml4(fs7.readFileSync(file, "utf8")) ?? {};
+  const guideFile = path4.join(dir, "guide.md");
+  const id = (raw.id ?? path4.basename(dir)).toLowerCase();
+  return {
+    id,
+    name: raw.name ?? id,
+    country: raw.country ?? null,
+    website: raw.website,
+    recognise: raw.recognise ?? [],
+    sides: { front: raw.sides?.front ?? [], back: raw.sides?.back ?? [] },
+    pairing: raw.pairing ?? "content",
+    orientation: raw.orientation ?? null,
+    nutrition_basis: raw.nutrition_basis ?? "per_serving",
+    default_servings: raw.default_servings ?? null,
+    kitchen_section: raw.kitchen_section ?? null,
+    plan_labels: raw.plan_labels ?? {},
+    allergen_synonyms: raw.allergen_synonyms ?? {},
+    brands: raw.brands ?? [],
+    equipment_terms: raw.equipment_terms ?? {},
+    ingredient_aliases: raw.ingredient_aliases ?? {},
+    guide: fs7.existsSync(guideFile) ? fs7.readFileSync(guideFile, "utf8") : "",
+    dir
+  };
+}
+var ProviderRegistry = class {
+  profiles = /* @__PURE__ */ new Map();
+  constructor(dirs) {
+    for (const base of dirs) {
+      if (!fs7.existsSync(base)) continue;
+      for (const entry of fs7.readdirSync(base, { withFileTypes: true })) {
+        if (!entry.isDirectory()) continue;
+        const p = loadProfile(path4.join(base, entry.name));
+        if (p) this.profiles.set(p.id, p);
+      }
+    }
+  }
+  get(id) {
+    return id ? this.profiles.get(id.toLowerCase()) : void 0;
+  }
+  /** The profile for `id`, or the generic one. */
+  resolve(id) {
+    const p = this.get(id) ?? this.profiles.get(GENERIC_PROVIDER);
+    if (!p) throw new Error("no generic provider profile found");
+    return p;
+  }
+  list() {
+    return [...this.profiles.values()].sort((a, b) => a.id.localeCompare(b.id));
+  }
+};
+
+// src/storage/sqlite/adapter.ts
+import { createHash as createHash2 } from "crypto";
+import Database from "better-sqlite3";
+import * as sqliteVec from "sqlite-vec";
+
+// src/storage/sqlite/schema.ts
+var SCHEMA_VERSION = 3;
+var ALL_TABLES = [
+  "chunk_vec",
+  "chunks_fts",
+  "chunks_tri",
+  "chunks",
+  "step_ingredients",
+  "steps",
+  "recipe_tags",
+  "tags",
+  "recipe_ingredients",
+  "pantry_items",
+  "alias_tri",
+  "ingredient_aliases",
+  "ingredients",
+  "ingest_items",
+  "recipes"
+];
+var categoryList = ALL_CATEGORIES.map((c) => `'${c}'`).join(",");
+function schemaSql(dims) {
+  return `
+CREATE TABLE IF NOT EXISTS meta (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+
+-- One row per recipe file. 'doc' holds the full record (minus ingredients/steps, which have
+-- their own tables); the other columns exist for filtering and sorting.
+CREATE TABLE IF NOT EXISTS recipes (
+  id INTEGER PRIMARY KEY,
+  slug TEXT NOT NULL UNIQUE,
+  title TEXT NOT NULL,
+  subtitle TEXT,
+  servings INTEGER,
+  active_min INTEGER,
+  total_min INTEGER,
+  source_kind TEXT NOT NULL CHECK (source_kind IN ('card','url','synthesized','manual')),
+  provider_id TEXT,
+  needs_review INTEGER NOT NULL DEFAULT 0,
+  energy_kcal REAL,
+  nutrition_basis TEXT,
+  doc TEXT NOT NULL,
+  file_path TEXT NOT NULL UNIQUE,
+  file_mtime INTEGER NOT NULL,
+  file_size INTEGER NOT NULL,
+  content_hash TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS recipes_total_min ON recipes(total_min);
+CREATE INDEX IF NOT EXISTS recipes_provider ON recipes(provider_id);
+
+CREATE TABLE IF NOT EXISTS ingredients (
+  id INTEGER PRIMARY KEY,
+  canonical TEXT NOT NULL UNIQUE,
+  is_staple INTEGER NOT NULL DEFAULT 0,
+  category TEXT
+);
+
+CREATE TABLE IF NOT EXISTS ingredient_aliases (
+  id INTEGER PRIMARY KEY,
+  alias TEXT NOT NULL UNIQUE,
+  ingredient_id INTEGER NOT NULL REFERENCES ingredients(id) ON DELETE CASCADE
+);
+CREATE INDEX IF NOT EXISTS ingredient_aliases_ingredient ON ingredient_aliases(ingredient_id);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS alias_tri USING fts5(
+  alias, content='ingredient_aliases', content_rowid='id', tokenize='trigram'
+);
+CREATE TRIGGER IF NOT EXISTS alias_ai AFTER INSERT ON ingredient_aliases BEGIN
+  INSERT INTO alias_tri(rowid, alias) VALUES (new.id, new.alias);
+END;
+CREATE TRIGGER IF NOT EXISTS alias_ad AFTER DELETE ON ingredient_aliases BEGIN
+  INSERT INTO alias_tri(alias_tri, rowid, alias) VALUES ('delete', old.id, old.alias);
+END;
+CREATE TRIGGER IF NOT EXISTS alias_au AFTER UPDATE ON ingredient_aliases BEGIN
+  INSERT INTO alias_tri(alias_tri, rowid, alias) VALUES ('delete', old.id, old.alias);
+  INSERT INTO alias_tri(rowid, alias) VALUES (new.id, new.alias);
+END;
+
+CREATE TABLE IF NOT EXISTS recipe_ingredients (
+  recipe_id INTEGER NOT NULL REFERENCES recipes(id) ON DELETE CASCADE,
+  position INTEGER NOT NULL,
+  ingredient_id INTEGER NOT NULL REFERENCES ingredients(id),
+  raw TEXT NOT NULL,
+  qty REAL,
+  unit TEXT,
+  prep TEXT,
+  optional INTEGER NOT NULL DEFAULT 0,
+  staple INTEGER NOT NULL DEFAULT 0,
+  source TEXT,
+  brand TEXT,
+  grp TEXT,
+  extra TEXT,
+  PRIMARY KEY (recipe_id, position)
+);
+CREATE INDEX IF NOT EXISTS recipe_ingredients_ingredient ON recipe_ingredients(ingredient_id);
+
+CREATE TABLE IF NOT EXISTS steps (
+  recipe_id INTEGER NOT NULL REFERENCES recipes(id) ON DELETE CASCADE,
+  position INTEGER NOT NULL,
+  title TEXT,
+  text TEXT NOT NULL,
+  techniques TEXT NOT NULL DEFAULT '[]',
+  equipment TEXT NOT NULL DEFAULT '[]',
+  uses TEXT NOT NULL DEFAULT '[]',
+  temp_c REAL,
+  minutes TEXT,
+  PRIMARY KEY (recipe_id, position)
+);
+
+-- Graph edges: which catalog ingredient each step uses.
+CREATE TABLE IF NOT EXISTS step_ingredients (
+  recipe_id INTEGER NOT NULL REFERENCES recipes(id) ON DELETE CASCADE,
+  position INTEGER NOT NULL,
+  ingredient_id INTEGER NOT NULL REFERENCES ingredients(id),
+  PRIMARY KEY (recipe_id, position, ingredient_id)
+);
+CREATE INDEX IF NOT EXISTS step_ingredients_ingredient ON step_ingredients(ingredient_id);
+
+-- Tags Claude assigns and facets derived from structured fields share one table, so every
+-- category is both a filter and a graph node type.
+CREATE TABLE IF NOT EXISTS tags (
+  id INTEGER PRIMARY KEY,
+  category TEXT NOT NULL CHECK (category IN (${categoryList})),
+  name TEXT NOT NULL,
+  UNIQUE (category, name)
+);
+
+CREATE TABLE IF NOT EXISTS recipe_tags (
+  recipe_id INTEGER NOT NULL REFERENCES recipes(id) ON DELETE CASCADE,
+  tag_id INTEGER NOT NULL REFERENCES tags(id) ON DELETE CASCADE,
+  origin TEXT NOT NULL DEFAULT 'tag' CHECK (origin IN ('tag','derived')),
+  PRIMARY KEY (recipe_id, tag_id)
+);
+CREATE INDEX IF NOT EXISTS recipe_tags_tag ON recipe_tags(tag_id);
+
+CREATE TABLE IF NOT EXISTS pantry_items (
+  ingredient_id INTEGER PRIMARY KEY REFERENCES ingredients(id) ON DELETE CASCADE,
+  qty REAL,
+  unit TEXT,
+  note TEXT,
+  added_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS chunks (
+  id INTEGER PRIMARY KEY,
+  recipe_id INTEGER NOT NULL REFERENCES recipes(id) ON DELETE CASCADE,
+  kind TEXT NOT NULL,
+  text TEXT NOT NULL,
+  hash TEXT NOT NULL,
+  embed_pending INTEGER NOT NULL DEFAULT 1
+);
+CREATE INDEX IF NOT EXISTS chunks_recipe ON chunks(recipe_id);
+CREATE INDEX IF NOT EXISTS chunks_pending ON chunks(embed_pending);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS chunks_fts USING fts5(
+  text, content='chunks', content_rowid='id', tokenize='porter unicode61 remove_diacritics 2'
+);
+CREATE VIRTUAL TABLE IF NOT EXISTS chunks_tri USING fts5(
+  text, content='chunks', content_rowid='id', tokenize='trigram'
+);
+CREATE VIRTUAL TABLE IF NOT EXISTS chunk_vec USING vec0(
+  chunk_id INTEGER PRIMARY KEY,
+  embedding float[${dims}]
+);
+
+CREATE TRIGGER IF NOT EXISTS chunks_ai AFTER INSERT ON chunks BEGIN
+  INSERT INTO chunks_fts(rowid, text) VALUES (new.id, new.text);
+  INSERT INTO chunks_tri(rowid, text) VALUES (new.id, new.text);
+END;
+CREATE TRIGGER IF NOT EXISTS chunks_ad AFTER DELETE ON chunks BEGIN
+  INSERT INTO chunks_fts(chunks_fts, rowid, text) VALUES ('delete', old.id, old.text);
+  INSERT INTO chunks_tri(chunks_tri, rowid, text) VALUES ('delete', old.id, old.text);
+  DELETE FROM chunk_vec WHERE chunk_id = old.id;
+END;
+
+-- Photo queue. An index over the file system: a file's folder is its status (inbox/ pending,
+-- inbox/skipped|failed/, images/<slug>/ done), so this table can always be rebuilt by a scan.
+CREATE TABLE IF NOT EXISTS ingest_items (
+  id INTEGER PRIMARY KEY,
+  sha256 TEXT NOT NULL UNIQUE,
+  phash TEXT NOT NULL,
+  path TEXT NOT NULL UNIQUE,
+  original_name TEXT NOT NULL,
+  mime TEXT NOT NULL,
+  width INTEGER,
+  height INTEGER,
+  bytes INTEGER NOT NULL,
+  mtime INTEGER NOT NULL,
+  captured_at TEXT NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('pending','done','skipped','failed')),
+  recipe_slug TEXT,
+  side TEXT,
+  reason TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS ingest_items_status ON ingest_items(status, captured_at);
+`;
+}
+
+// src/storage/sqlite/adapter.ts
+var sha = (s) => createHash2("sha256").update(s).digest("hex");
+var toRow = (r) => ({
+  id: r.id,
+  canonical: r.canonical,
+  is_staple: r.is_staple === 1,
+  category: r.category
+});
+function recipeChunks(recipe) {
+  const tagNames = [...new Set(Object.values(recipe.tags).flat())].join(", ");
+  const title = [
+    recipe.title,
+    recipe.subtitle ?? "",
+    tagNames ? `Tags: ${tagNames}` : "",
+    recipe.provider?.plan ? `Plan: ${recipe.provider.plan}` : ""
+  ].filter(Boolean).join(". ");
+  const blurb = [recipe.blurb ?? "", recipe.description ?? ""].filter(Boolean).join(" ");
+  const ingredients = `Ingredients: ${recipe.ingredients.map(
+    (i) => i.components?.length ? `${i.raw} (${i.components.map((c) => c.raw).join(", ")})` : i.raw
+  ).join("; ")}`;
+  const steps = [
+    ...recipe.steps.map((s) => s.title ? `${s.title}: ${s.text}` : s.text),
+    ...recipe.tips.map((t) => `Tip: ${t}`)
+  ].join(" ");
+  return [
+    { kind: "title", text: title },
+    { kind: "blurb", text: blurb },
+    { kind: "ingredients", text: ingredients },
+    { kind: "steps", text: steps }
+  ].filter((c) => c.text.trim().length > 0);
+}
+function recipeFacets(recipe) {
+  const out = [];
+  const add = (cat, v) => {
+    const t = v?.trim();
+    if (t && !out.some(([c, n]) => c === cat && n === t)) out.push([cat, t]);
+  };
+  for (const a of recipe.allergens) add("allergen", a);
+  for (const e of recipe.equipment) add("equipment", e);
+  for (const s of recipe.steps) for (const t of s.techniques ?? []) add("technique", t);
+  add("chef", recipe.provider?.chef);
+  add("provider", recipe.provider?.id);
+  add("plan", recipe.provider?.plan);
+  return out;
+}
+var STOPWORDS = new Set(
+  "a an and any are as at be but by can for from have i in into is it me my of on or our recipe recipes some something that the this to use using want what with without you".split(" ")
+);
+function queryWords(query) {
+  return (query.toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? []).filter((t) => !STOPWORDS.has(t));
+}
+function ftsTerms(query) {
+  return queryWords(query).map((t) => `"${t}"`);
+}
+function vecBlob(v) {
+  return Buffer.from(v.buffer, v.byteOffset, v.byteLength);
+}
+function dice2(a, b) {
+  const grams = (s) => {
+    const g = /* @__PURE__ */ new Map();
+    const t = ` ${s.toLowerCase()} `;
+    for (let i = 0; i < t.length - 1; i++) {
+      const k = t.slice(i, i + 2);
+      g.set(k, (g.get(k) ?? 0) + 1);
+    }
+    return g;
+  };
+  const ga = grams(a);
+  const gb = grams(b);
+  let overlap = 0;
+  for (const [k, n] of ga) overlap += Math.min(n, gb.get(k) ?? 0);
+  const total = [...ga.values()].reduce((x, y) => x + y, 0) + [...gb.values()].reduce((x, y) => x + y, 0);
+  return total === 0 ? 0 : 2 * overlap / total;
+}
+var placeholders = (n) => Array.from({ length: n }, () => "?").join(",");
+var SqliteAdapter = class {
+  db;
+  cache = /* @__PURE__ */ new Map();
+  dims;
+  /** True when an older schema was found and dropped; the caller should rebuild from files. */
+  wasReset;
+  constructor(file, dims = EMBED_DIMS) {
+    this.dims = dims;
+    this.db = new Database(file);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("foreign_keys = ON");
+    sqliteVec.load(this.db);
+    this.wasReset = this.resetIfStale();
+    this.db.exec(schemaSql(dims));
+    this.setMeta("schema_version", String(SCHEMA_VERSION));
+    this.setMeta("dims", String(dims));
+  }
+  resetIfStale() {
+    const hasMeta = this.db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'meta'").get();
+    if (!hasMeta) return false;
+    const row = this.db.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get();
+    const dims = this.db.prepare("SELECT value FROM meta WHERE key = 'dims'").get();
+    if (row?.value === String(SCHEMA_VERSION) && (!dims || dims.value === String(this.dims))) {
+      return false;
+    }
+    this.db.pragma("foreign_keys = OFF");
+    this.db.transaction(() => {
+      for (const t of ALL_TABLES) this.db.exec(`DROP TABLE IF EXISTS ${t}`);
+      this.db.exec("DELETE FROM meta");
+    })();
+    this.db.pragma("foreign_keys = ON");
+    return true;
+  }
+  s(sql) {
+    let st = this.cache.get(sql);
+    if (!st) {
+      st = this.db.prepare(sql);
+      this.cache.set(sql, st);
+    }
+    return st;
+  }
+  close() {
+    this.db.close();
+  }
+  transaction(fn) {
+    return this.db.transaction(fn)();
+  }
+  getMeta(key) {
+    const row = this.s("SELECT value FROM meta WHERE key = ?").get(key);
+    return row?.value;
+  }
+  setMeta(key, value) {
+    this.s(
+      "INSERT INTO meta(key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value"
+    ).run(key, value);
+  }
+  // ---------------------------------------------------------------- recipes
+  upsertRecipe(recipe, file, ingredientIds) {
+    return this.transaction(() => {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const existing = this.s("SELECT id FROM recipes WHERE slug = ?").get(recipe.slug);
+      const cols = {
+        title: recipe.title,
+        subtitle: recipe.subtitle ?? null,
+        servings: recipe.servings ?? null,
+        active_min: recipe.time.active ?? null,
+        total_min: recipe.time.total ?? null,
+        source_kind: recipe.source.kind,
+        provider_id: recipe.provider?.id ?? null,
+        needs_review: recipe.extraction?.needs_review ? 1 : 0,
+        energy_kcal: recipe.nutrition?.energy_kcal ?? null,
+        nutrition_basis: recipe.nutrition?.basis ?? null,
+        doc: JSON.stringify(recipe),
+        file_path: file.file_path,
+        file_mtime: Math.round(file.file_mtime),
+        file_size: file.file_size,
+        content_hash: file.content_hash,
+        updated_at: now
+      };
+      let id;
+      const keep = /* @__PURE__ */ new Map();
+      if (existing) {
+        id = existing.id;
+        for (const r of this.s(
+          "SELECT c.hash, v.embedding FROM chunks c JOIN chunk_vec v ON v.chunk_id = c.id WHERE c.recipe_id = ?"
+        ).all(id)) {
+          keep.set(r.hash, r.embedding);
+        }
+        const sets = Object.keys(cols).map((k) => `${k} = @${k}`).join(", ");
+        this.s(`UPDATE recipes SET ${sets} WHERE id = @id`).run({ ...cols, id });
+        for (const t of [
+          "recipe_ingredients",
+          "step_ingredients",
+          "steps",
+          "recipe_tags",
+          "chunks"
+        ]) {
+          this.s(`DELETE FROM ${t} WHERE recipe_id = ?`).run(id);
+        }
+      } else {
+        const keys = Object.keys(cols);
+        const info = this.s(
+          `INSERT INTO recipes(slug, created_at, ${keys.join(", ")}) VALUES (@slug, @created_at, ${keys.map((k) => `@${k}`).join(", ")})`
+        ).run({ ...cols, slug: recipe.slug, created_at: now });
+        id = Number(info.lastInsertRowid);
+      }
+      const insIng = this.s(
+        `INSERT INTO recipe_ingredients(recipe_id, position, ingredient_id, raw, qty, unit, prep,
+           optional, staple, source, brand, grp, extra) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      );
+      recipe.ingredients.forEach((ing, i) => {
+        const ingId = ingredientIds.get(ing.canonical);
+        if (ingId === void 0) {
+          throw new Error(`no ingredient id resolved for "${ing.canonical}"`);
+        }
+        const extra = ing.alternatives?.length || ing.components?.length ? JSON.stringify({ alternatives: ing.alternatives, components: ing.components }) : null;
+        insIng.run(
+          id,
+          i,
+          ingId,
+          ing.raw,
+          ing.qty ?? null,
+          ing.unit ?? null,
+          ing.prep ?? null,
+          ing.optional ? 1 : 0,
+          ing.staple ? 1 : 0,
+          ing.source ?? null,
+          ing.brand ?? null,
+          ing.group ?? null,
+          extra
+        );
+      });
+      const insStep = this.s(
+        `INSERT INTO steps(recipe_id, position, title, text, techniques, equipment, uses, temp_c, minutes)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      );
+      const insUse = this.s(
+        "INSERT OR IGNORE INTO step_ingredients(recipe_id, position, ingredient_id) VALUES (?, ?, ?)"
+      );
+      recipe.steps.forEach((step, i) => {
+        insStep.run(
+          id,
+          i,
+          step.title ?? null,
+          step.text,
+          JSON.stringify(step.techniques ?? []),
+          JSON.stringify(step.equipment ?? []),
+          JSON.stringify(step.uses ?? []),
+          step.temp_c ?? null,
+          step.minutes ? JSON.stringify(step.minutes) : null
+        );
+        for (const use of step.uses ?? []) {
+          const ingId = ingredientIds.get(use);
+          if (ingId !== void 0) insUse.run(id, i, ingId);
+        }
+      });
+      const insTag = this.s("INSERT OR IGNORE INTO tags(category, name) VALUES (?, ?)");
+      const getTag = this.s("SELECT id FROM tags WHERE category = ? AND name = ?");
+      const insRT = this.s(
+        "INSERT OR IGNORE INTO recipe_tags(recipe_id, tag_id, origin) VALUES (?, ?, ?)"
+      );
+      const link = (category, name, origin) => {
+        insTag.run(category, name);
+        const t = getTag.get(category, name);
+        insRT.run(id, t.id, origin);
+      };
+      for (const [category, names] of Object.entries(recipe.tags)) {
+        for (const name of names ?? []) link(category, name, "tag");
+      }
+      for (const [category, name] of recipeFacets(recipe)) link(category, name, "derived");
+      const insChunk = this.s(
+        "INSERT INTO chunks(recipe_id, kind, text, hash, embed_pending) VALUES (?, ?, ?, ?, ?)"
+      );
+      const insVec = this.s("INSERT INTO chunk_vec(chunk_id, embedding) VALUES (?, ?)");
+      for (const c of recipeChunks(recipe)) {
+        const h = sha(c.text);
+        const kept = keep.get(h);
+        const info = insChunk.run(id, c.kind, c.text, h, kept ? 0 : 1);
+        if (kept) insVec.run(BigInt(info.lastInsertRowid), kept);
+      }
+      return id;
+    });
+  }
+  rowToRecord(row) {
+    const doc = JSON.parse(row.doc);
+    return {
+      ...doc,
+      id: row.id,
+      file_path: row.file_path,
+      file_mtime: row.file_mtime,
+      file_size: row.file_size,
+      content_hash: row.content_hash,
+      created_at: row.created_at,
+      updated_at: row.updated_at
+    };
+  }
+  getRecipe(slug) {
+    const row = this.s("SELECT * FROM recipes WHERE slug = ?").get(slug);
+    return row ? this.rowToRecord(row) : void 0;
+  }
+  rowToSummary(row) {
+    const doc = JSON.parse(row.doc);
+    const s = {
+      id: row.id,
+      slug: row.slug,
+      title: row.title,
+      total_min: row.total_min,
+      active_min: row.active_min,
+      servings: row.servings,
+      source_kind: row.source_kind,
+      provider_id: row.provider_id,
+      needs_review: row.needs_review === 1,
+      tags: doc.tags,
+      allergens: doc.allergens ?? [],
+      images: doc.images
+    };
+    if (doc.subtitle) s.subtitle = doc.subtitle;
+    if (doc.blurb) s.blurb = doc.blurb;
+    return s;
+  }
+  filterSql(filters) {
+    const where = [];
+    const params = [];
+    if (!filters) return { where: "", params };
+    if (filters.max_total_min !== void 0) {
+      where.push("total_min IS NOT NULL AND total_min <= ?");
+      params.push(filters.max_total_min);
+    }
+    if (filters.max_active_min !== void 0) {
+      where.push(
+        "COALESCE(active_min, total_min) IS NOT NULL AND COALESCE(active_min, total_min) <= ?"
+      );
+      params.push(filters.max_active_min);
+    }
+    if (filters.source_kind) {
+      where.push("source_kind = ?");
+      params.push(filters.source_kind);
+    }
+    if (filters.provider) {
+      where.push("provider_id = ?");
+      params.push(filters.provider.toLowerCase());
+    }
+    if (filters.needs_review !== void 0) {
+      where.push("needs_review = ?");
+      params.push(filters.needs_review ? 1 : 0);
+    }
+    for (const [category, names] of Object.entries(filters.tags ?? {})) {
+      if (!names || names.length === 0) continue;
+      where.push(
+        `id IN (SELECT rt.recipe_id FROM recipe_tags rt JOIN tags t ON t.id = rt.tag_id
+                WHERE t.category = ? AND lower(t.name) IN (${placeholders(names.length)}))`
+      );
+      params.push(category, ...names.map((n) => n.toLowerCase().trim()));
+    }
+    if (filters.exclude_allergens?.length) {
+      where.push(
+        `id NOT IN (SELECT rt.recipe_id FROM recipe_tags rt JOIN tags t ON t.id = rt.tag_id
+                    WHERE t.category = 'allergen' AND t.name IN (${placeholders(filters.exclude_allergens.length)}))`
+      );
+      params.push(...filters.exclude_allergens);
+    }
+    if (filters.exclude_ingredients?.length) {
+      where.push(
+        `id NOT IN (SELECT ri.recipe_id FROM recipe_ingredients ri
+                    JOIN ingredient_aliases a ON a.ingredient_id = ri.ingredient_id
+                    WHERE a.alias IN (${placeholders(filters.exclude_ingredients.length)}))`
+      );
+      params.push(...filters.exclude_ingredients.map((n) => n.toLowerCase().trim()));
+    }
+    return { where: where.length ? `WHERE ${where.join(" AND ")}` : "", params };
+  }
+  listRecipes(opts) {
+    const { where, params } = this.filterSql(opts.filters);
+    const rows = this.s(
+      `SELECT * FROM recipes ${where} ORDER BY updated_at DESC, id DESC LIMIT ? OFFSET ?`
+    ).all(...params, opts.limit ?? 50, opts.offset ?? 0);
+    return rows.map((r) => this.rowToSummary(r));
+  }
+  summariesByIds(ids) {
+    if (ids.length === 0) return [];
+    const rows = this.s(`SELECT * FROM recipes WHERE id IN (${placeholders(ids.length)})`).all(
+      ...ids
+    );
+    const byId = new Map(rows.map((r) => [r.id, this.rowToSummary(r)]));
+    return ids.map((id) => byId.get(id)).filter((x) => x !== void 0);
+  }
+  deleteRecipe(slug) {
+    this.s("DELETE FROM recipes WHERE slug = ?").run(slug);
+  }
+  recipeFileIndex() {
+    const rows = this.s(
+      "SELECT slug, file_path, file_mtime, file_size, content_hash FROM recipes"
+    ).all();
+    return new Map(rows.map((r) => [r.file_path, r]));
+  }
+  touchFile(file_path, mtime2, size) {
+    this.s("UPDATE recipes SET file_mtime = ?, file_size = ? WHERE file_path = ?").run(
+      Math.round(mtime2),
+      size,
+      file_path
+    );
+  }
+  filterRecipeIds(filters) {
+    const { where, params } = this.filterSql(filters);
+    if (!where) return null;
+    const rows = this.s(`SELECT id FROM recipes ${where}`).all(...params);
+    return new Set(rows.map((r) => r.id));
+  }
+  findDuplicates(title, canonicals, excludeSlug) {
+    const out = [];
+    const titles = this.s("SELECT id, slug, title FROM recipes").all();
+    for (const t of titles) {
+      if (t.slug === excludeSlug) continue;
+      const score = dice2(title, t.title);
+      if (score >= 0.9) out.push({ slug: t.slug, title: t.title, reason: "title", score });
+    }
+    const names = [...new Set(canonicals.map((c) => c.toLowerCase().trim()))];
+    if (names.length >= 3) {
+      const overlaps = this.s(
+        `SELECT ri.recipe_id, COUNT(DISTINCT ri.ingredient_id) AS overlap,
+                (SELECT COUNT(DISTINCT r2.ingredient_id) FROM recipe_ingredients r2
+                   JOIN ingredients i2 ON i2.id = r2.ingredient_id
+                   WHERE r2.recipe_id = ri.recipe_id AND i2.is_staple = 0) AS total
+         FROM recipe_ingredients ri JOIN ingredients i ON i.id = ri.ingredient_id
+         WHERE i.is_staple = 0 AND i.canonical IN (${placeholders(names.length)})
+         GROUP BY ri.recipe_id`
+      ).all(...names);
+      const staples = new Set(
+        this.s("SELECT canonical FROM ingredients WHERE is_staple = 1").all().map((r) => r.canonical)
+      );
+      const mineNonStaple = names.filter((n) => !staples.has(n)).length;
+      for (const o of overlaps) {
+        const union = mineNonStaple + o.total - o.overlap;
+        const jaccard = union === 0 ? 0 : o.overlap / union;
+        if (jaccard >= 0.8) {
+          const t = titles.find((x) => x.id === o.recipe_id);
+          if (t && t.slug !== excludeSlug && !out.some((d) => d.slug === t.slug)) {
+            out.push({ slug: t.slug, title: t.title, reason: "ingredients", score: jaccard });
+          }
+        }
+      }
+    }
+    return out.sort((a, b) => b.score - a.score);
+  }
+  // ------------------------------------------------------------ ingredients
+  getIngredient(nameOrAlias) {
+    const n = nameOrAlias.toLowerCase().trim();
+    const row = this.s(
+      `SELECT i.* FROM ingredients i WHERE i.canonical = ?
+       UNION ALL
+       SELECT i.* FROM ingredient_aliases a JOIN ingredients i ON i.id = a.ingredient_id WHERE a.alias = ?
+       LIMIT 1`
+    ).get(n, n);
+    return row ? toRow(row) : void 0;
+  }
+  createIngredient(entry) {
+    return this.transaction(() => {
+      const canonical = entry.canonical.toLowerCase().trim();
+      const info = this.s(
+        "INSERT INTO ingredients(canonical, is_staple, category) VALUES (?, ?, ?)"
+      ).run(canonical, entry.staple ? 1 : 0, entry.category ?? null);
+      const id = Number(info.lastInsertRowid);
+      this.addAlias(id, canonical);
+      for (const a of entry.aliases ?? []) this.addAlias(id, a);
+      return { id, canonical, is_staple: !!entry.staple, category: entry.category ?? null };
+    });
+  }
+  addAlias(ingredientId, alias) {
+    this.s("INSERT OR IGNORE INTO ingredient_aliases(alias, ingredient_id) VALUES (?, ?)").run(
+      alias.toLowerCase().trim(),
+      ingredientId
+    );
+  }
+  upsertCatalogEntry(entry) {
+    return this.transaction(() => {
+      const existing = this.getIngredient(entry.canonical);
+      if (!existing) return this.createIngredient(entry);
+      if (entry.staple !== void 0 || entry.category !== void 0) {
+        this.s("UPDATE ingredients SET is_staple = ?, category = ? WHERE id = ?").run(
+          entry.staple === void 0 ? existing.is_staple ? 1 : 0 : entry.staple ? 1 : 0,
+          entry.category === void 0 ? existing.category : entry.category,
+          existing.id
+        );
+      }
+      for (const a of entry.aliases ?? []) this.addAlias(existing.id, a);
+      return this.getIngredient(entry.canonical) ?? existing;
+    });
+  }
+  fuzzyIngredients(name, limit) {
+    const n = name.toLowerCase().trim();
+    if (n.length < 3) return [];
+    let rows = [];
+    try {
+      rows = this.s(
+        `SELECT i.*, a.alias FROM alias_tri t
+         JOIN ingredient_aliases a ON a.id = t.rowid
+         JOIN ingredients i ON i.id = a.ingredient_id
+         WHERE alias_tri MATCH ? ORDER BY t.rank LIMIT ?`
+      ).all(`"${n.replace(/"/g, '""')}"`, limit * 3);
+    } catch {
+      rows = [];
+    }
+    return rows.map((r) => ({ row: toRow(r), alias: r.alias, score: dice2(n, r.alias) })).sort((a, b) => b.score - a.score).slice(0, limit).map(({ row, alias }) => ({ row, alias }));
+  }
+  listIngredients(opts) {
+    const q = opts.query?.toLowerCase().trim();
+    const rows = this.s(
+      `SELECT i.*, (SELECT COUNT(DISTINCT recipe_id) FROM recipe_ingredients ri WHERE ri.ingredient_id = i.id) AS recipe_count
+       FROM ingredients i
+       ${q ? "WHERE i.id IN (SELECT ingredient_id FROM ingredient_aliases WHERE alias LIKE ?)" : ""}
+       ORDER BY recipe_count DESC, i.canonical LIMIT ?`
+    ).all(...q ? [`%${q}%`] : [], opts.limit ?? 100);
+    return rows.map((r) => ({ ...toRow(r), recipe_count: r.recipe_count }));
+  }
+  // ------------------------------------------------------------------- tags
+  listTags(category) {
+    return this.s(
+      `SELECT t.category, t.name, COUNT(rt.recipe_id) AS count
+       FROM tags t JOIN recipe_tags rt ON rt.tag_id = t.id
+       ${category ? "WHERE t.category = ?" : ""}
+       GROUP BY t.id ORDER BY t.category, count DESC, t.name`
+    ).all(...category ? [category] : []);
+  }
+  // ----------------------------------------------------------------- search
+  chunkHits(sql, ...params) {
+    const rows = this.s(sql).all(...params);
+    const seen = /* @__PURE__ */ new Set();
+    const out = [];
+    for (const r of rows) {
+      if (seen.has(r.recipe_id)) continue;
+      seen.add(r.recipe_id);
+      out.push({ recipe_id: r.recipe_id, slug: r.slug, chunk_kind: r.kind });
+    }
+    return out;
+  }
+  ftsHits(table, match, limit) {
+    try {
+      return this.chunkHits(
+        `SELECT c.recipe_id, r.slug, c.kind
+         FROM (SELECT rowid, rank FROM ${table} WHERE ${table} MATCH ? ORDER BY rank LIMIT ?) f
+         JOIN chunks c ON c.id = f.rowid JOIN recipes r ON r.id = c.recipe_id
+         ORDER BY f.rank`,
+        match,
+        limit * 3
+      );
+    } catch {
+      return [];
+    }
+  }
+  searchLexical(query, limit) {
+    const terms = ftsTerms(query);
+    if (terms.length === 0) return [];
+    const strict = this.ftsHits("chunks_fts", terms.join(" "), limit);
+    if (strict.length > 0 || terms.length === 1) return strict;
+    return this.ftsHits("chunks_fts", terms.join(" OR "), limit);
+  }
+  /**
+   * Typo-tolerant pass: a quoted term in a trigram index only matches as an exact substring,
+   * so split each term into its trigrams and OR them; bm25 then rewards the most overlap.
+   */
+  searchTrigram(query, limit) {
+    const grams = /* @__PURE__ */ new Set();
+    for (const term of queryWords(query).filter((t) => t.length >= 4)) {
+      for (let i = 0; i + 3 <= term.length; i++) grams.add(`"${term.slice(i, i + 3)}"`);
+    }
+    if (grams.size === 0) return [];
+    return this.ftsHits("chunks_tri", [...grams].join(" OR "), limit);
+  }
+  searchVector(embedding, limit) {
+    return this.chunkHits(
+      `SELECT c.recipe_id, r.slug, c.kind
+       FROM (SELECT chunk_id, distance FROM chunk_vec WHERE embedding MATCH ? AND k = ? ORDER BY distance) v
+       JOIN chunks c ON c.id = v.chunk_id JOIN recipes r ON r.id = c.recipe_id
+       ORDER BY v.distance`,
+      vecBlob(embedding),
+      limit * 3
+    );
+  }
+  // ------------------------------------------------------------- embeddings
+  pendingChunks(limit) {
+    return this.s("SELECT id, text FROM chunks WHERE embed_pending = 1 ORDER BY id LIMIT ?").all(
+      limit
+    );
+  }
+  storeEmbeddings(rows) {
+    this.transaction(() => {
+      const del = this.s("DELETE FROM chunk_vec WHERE chunk_id = ?");
+      const ins = this.s("INSERT INTO chunk_vec(chunk_id, embedding) VALUES (?, ?)");
+      const done = this.s("UPDATE chunks SET embed_pending = 0 WHERE id = ?");
+      for (const r of rows) {
+        del.run(r.id);
+        ins.run(BigInt(r.id), vecBlob(r.embedding));
+        done.run(r.id);
+      }
+    });
+  }
+  resetVectors() {
+    this.transaction(() => {
+      this.db.exec("DELETE FROM chunk_vec");
+      this.db.exec("UPDATE chunks SET embed_pending = 1");
+    });
+  }
+  stats() {
+    const one = (sql) => this.s(sql).get().n;
+    return {
+      recipes: one("SELECT COUNT(*) n FROM recipes"),
+      ingredients: one("SELECT COUNT(*) n FROM ingredients"),
+      tags: one("SELECT COUNT(*) n FROM tags"),
+      chunks: one("SELECT COUNT(*) n FROM chunks"),
+      chunks_pending: one("SELECT COUNT(*) n FROM chunks WHERE embed_pending = 1"),
+      vectors: one("SELECT COUNT(*) n FROM chunk_vec"),
+      needs_review: one("SELECT COUNT(*) n FROM recipes WHERE needs_review = 1")
+    };
+  }
+  // ----------------------------------------------------------------- pantry
+  pantryList() {
+    return this.s(
+      `SELECT p.ingredient_id, i.canonical, p.qty, p.unit, p.note, p.added_at
+       FROM pantry_items p JOIN ingredients i ON i.id = p.ingredient_id ORDER BY i.canonical`
+    ).all();
+  }
+  pantryUpsert(ingredientId, fields) {
+    this.s(
+      `INSERT INTO pantry_items(ingredient_id, qty, unit, note, added_at) VALUES (@id, @qty, @unit, @note, @now)
+       ON CONFLICT(ingredient_id) DO UPDATE SET
+         qty = COALESCE(excluded.qty, qty), unit = COALESCE(excluded.unit, unit), note = COALESCE(excluded.note, note)`
+    ).run({
+      id: ingredientId,
+      qty: fields.qty ?? null,
+      unit: fields.unit ?? null,
+      note: fields.note ?? null,
+      now: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  pantryRemove(ingredientIds) {
+    if (ingredientIds.length === 0) return 0;
+    return this.s(
+      `DELETE FROM pantry_items WHERE ingredient_id IN (${placeholders(ingredientIds.length)})`
+    ).run(...ingredientIds).changes;
+  }
+  pantryClear() {
+    return this.s("DELETE FROM pantry_items").run().changes;
+  }
+  recipeRequirements(recipeIds) {
+    const where = recipeIds ? `WHERE ri.recipe_id IN (${placeholders(recipeIds.length)})` : "";
+    if (recipeIds && recipeIds.length === 0) return [];
+    const rows = this.s(
+      `SELECT ri.recipe_id, r.slug, r.title, ri.ingredient_id, i.canonical, ri.raw,
+              (ri.staple OR i.is_staple) AS staple, ri.optional, ri.extra
+       FROM recipe_ingredients ri
+       JOIN ingredients i ON i.id = ri.ingredient_id
+       JOIN recipes r ON r.id = ri.recipe_id
+       ${where} ORDER BY ri.recipe_id, ri.position`
+    ).all(...recipeIds ?? []);
+    return rows.map((r) => ({ ...r, staple: r.staple === 1, optional: r.optional === 1 }));
+  }
+  recipesUsingIngredient(ingredientId) {
+    return this.s(
+      `SELECT DISTINCT r.slug FROM recipes r WHERE r.id IN (
+           SELECT recipe_id FROM recipe_ingredients WHERE ingredient_id = ?
+           UNION SELECT recipe_id FROM step_ingredients WHERE ingredient_id = ?)
+         ORDER BY r.slug`
+    ).all(ingredientId, ingredientId).map((r) => r.slug);
+  }
+  mergeIngredientRows(fromId, intoId) {
+    this.transaction(() => {
+      this.s(
+        "UPDATE OR IGNORE ingredient_aliases SET ingredient_id = ? WHERE ingredient_id = ?"
+      ).run(intoId, fromId);
+      const pantry = this.s("SELECT * FROM pantry_items WHERE ingredient_id = ?").get(fromId);
+      if (pantry) {
+        this.s(
+          "INSERT OR IGNORE INTO pantry_items(ingredient_id, qty, unit, note, added_at) SELECT ?, qty, unit, note, added_at FROM pantry_items WHERE ingredient_id = ?"
+        ).run(intoId, fromId);
+      }
+      this.s(
+        "UPDATE OR IGNORE recipe_ingredients SET ingredient_id = ? WHERE ingredient_id = ?"
+      ).run(intoId, fromId);
+      this.s("UPDATE OR IGNORE step_ingredients SET ingredient_id = ? WHERE ingredient_id = ?").run(
+        intoId,
+        fromId
+      );
+      this.s("DELETE FROM step_ingredients WHERE ingredient_id = ?").run(fromId);
+      this.s("DELETE FROM pantry_items WHERE ingredient_id = ?").run(fromId);
+      this.s("DELETE FROM ingredients WHERE id = ?").run(fromId);
+    });
+  }
+  // ------------------------------------------------------------------ graph
+  graphRows() {
+    const recipes = this.s("SELECT id, slug, title, doc FROM recipes ORDER BY id").all();
+    const uses = this.s(
+      `SELECT DISTINCT ri.recipe_id, ri.ingredient_id, i.canonical,
+                MAX(ri.staple OR i.is_staple) AS staple, i.category
+         FROM recipe_ingredients ri JOIN ingredients i ON i.id = ri.ingredient_id
+         GROUP BY ri.recipe_id, ri.ingredient_id`
+    ).all().map((u) => ({ ...u, staple: u.staple === 1 }));
+    const tags = this.s(
+      `SELECT rt.recipe_id, t.category, t.name FROM recipe_tags rt JOIN tags t ON t.id = rt.tag_id`
+    ).all();
+    return { recipes, uses, tags };
+  }
+  similarRecipes(recipeId, k) {
+    const own = this.s(
+      `SELECT v.embedding FROM chunks c JOIN chunk_vec v ON v.chunk_id = c.id
+       WHERE c.recipe_id = ? AND c.kind IN ('blurb', 'title') ORDER BY c.kind = 'blurb' DESC LIMIT 1`
+    ).get(recipeId);
+    if (!own) return [];
+    const rows = this.s(
+      `SELECT c.recipe_id, MIN(v.distance) AS distance
+       FROM (SELECT chunk_id, distance FROM chunk_vec WHERE embedding MATCH ? AND k = ? ORDER BY distance) v
+       JOIN chunks c ON c.id = v.chunk_id
+       WHERE c.recipe_id != ? AND c.kind IN ('blurb', 'title')
+       GROUP BY c.recipe_id ORDER BY distance LIMIT ?`
+    ).all(own.embedding, k * 6, recipeId, k);
+    return rows;
+  }
+  // ------------------------------------------------------------ photo queue
+  ingestByPath(path9) {
+    return this.s("SELECT * FROM ingest_items WHERE path = ?").get(path9);
+  }
+  ingestBySha(sha256) {
+    return this.s("SELECT * FROM ingest_items WHERE sha256 = ?").get(sha256);
+  }
+  ingestByIds(ids) {
+    if (ids.length === 0) return [];
+    const rows = this.s(`SELECT * FROM ingest_items WHERE id IN (${placeholders(ids.length)})`).all(
+      ...ids
+    );
+    const byId = new Map(rows.map((r) => [r.id, r]));
+    return ids.map((id) => byId.get(id)).filter((r) => r !== void 0);
+  }
+  insertIngest(item) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const row = { ...item, created_at: now, updated_at: now };
+    const keys = Object.keys(row);
+    const info = this.s(
+      `INSERT INTO ingest_items(${keys.join(", ")}) VALUES (${keys.map((k) => `@${k}`).join(", ")})`
+    ).run(row);
+    return { ...row, id: Number(info.lastInsertRowid) };
+  }
+  updateIngest(id, fields) {
+    const row = { ...fields, updated_at: (/* @__PURE__ */ new Date()).toISOString() };
+    const sets = Object.keys(row).map((k) => `${k} = @${k}`).join(", ");
+    this.s(`UPDATE ingest_items SET ${sets} WHERE id = @id`).run({ ...row, id });
+  }
+  deleteIngest(id) {
+    this.s("DELETE FROM ingest_items WHERE id = ?").run(id);
+  }
+  listIngest(opts) {
+    return this.s(
+      `SELECT * FROM ingest_items ${opts.status ? "WHERE status = ?" : ""}
+       ORDER BY captured_at, original_name, id LIMIT ? OFFSET ?`
+    ).all(
+      ...opts.status ? [opts.status] : [],
+      opts.limit ?? 50,
+      opts.offset ?? 0
+    );
+  }
+  allIngest() {
+    return this.s(
+      "SELECT * FROM ingest_items ORDER BY captured_at, original_name, id"
+    ).all();
+  }
+  ingestCounts() {
+    const counts = { pending: 0, done: 0, skipped: 0, failed: 0 };
+    for (const r of this.s(
+      "SELECT status, COUNT(*) n FROM ingest_items GROUP BY status"
+    ).all()) {
+      counts[r.status] = r.n;
+    }
+    return counts;
+  }
+};
+
+// src/core/context.ts
+var SYNC_INTERVAL_MS = 2e3;
+var contexts = /* @__PURE__ */ new Map();
+function seedPath(name) {
+  return path5.join(packageRoot, "seed", name);
+}
+function ensureSeeded(target, seed) {
+  if (!fs8.existsSync(target) && fs8.existsSync(seed)) fs8.copyFileSync(seed, target);
+}
+function mtime(file) {
+  try {
+    return fs8.statSync(file).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+function buildVocabulary(paths, providers) {
+  const vocab = Vocabulary.fromFile(paths.vocabularyYaml);
+  for (const p of providers.list()) vocab.addSynonyms("allergen", p.allergen_synonyms);
+  return vocab;
+}
+function loadProviderAliases(store, providers) {
+  store.transaction(() => {
+    for (const p of providers.list()) {
+      for (const [canonical, aliases] of Object.entries(p.ingredient_aliases)) {
+        store.upsertCatalogEntry({ canonical, aliases });
+      }
+    }
+  });
+}
+function openContext(projectRoot, opts = {}) {
+  const root = resolveProjectRoot(projectRoot);
+  const cached = contexts.get(root);
+  if (cached) return cached;
+  const paths = dataPaths(root);
+  ensureDataDirs(paths);
+  const store = new SqliteAdapter(paths.db);
+  if (store.wasReset) log("index schema changed; rebuilding from markdown");
+  ensureSeeded(paths.ingredientsYaml, seedPath("ingredients.yaml"));
+  ensureSeeded(paths.vocabularyYaml, seedPath("vocabulary.yaml"));
+  const useEmbeddings = opts.embeddings ?? process.env.PANTRYBASE_NO_EMBED !== "1";
+  const embedder = useEmbeddings ? new Embedder() : null;
+  const embedQueue = new EmbedQueue(store, embedder);
+  let seen = { catalog: -1, vocabulary: -1 };
+  let lastSync = Date.now();
+  const ctx = {
+    root,
+    paths,
+    store,
+    providers: new ProviderRegistry([builtinProvidersDir(), paths.providers]),
+    vocab: new Vocabulary(),
+    embedder,
+    embedQueue,
+    log,
+    refresh(force = false) {
+      const now = {
+        catalog: mtime(paths.ingredientsYaml),
+        vocabulary: mtime(paths.vocabularyYaml)
+      };
+      const changed = {
+        catalog: force || now.catalog !== seen.catalog,
+        vocabulary: force || now.vocabulary !== seen.vocabulary
+      };
+      if (force) ctx.providers = new ProviderRegistry([builtinProvidersDir(), paths.providers]);
+      if (changed.catalog) {
+        loadCatalog(store, paths.ingredientsYaml);
+        loadProviderAliases(store, ctx.providers);
+      }
+      if (changed.vocabulary || force) ctx.vocab = buildVocabulary(paths, ctx.providers);
+      seen = now;
+      return changed;
+    },
+    sync({ now = false } = {}) {
+      const t = Date.now();
+      if (!now && t - lastSync < SYNC_INTERVAL_MS) return null;
+      lastSync = t;
+      const changed = ctx.refresh();
+      const full = changed.catalog || changed.vocabulary;
+      const r = reconcile(ctx, { full });
+      if (full || r.added || r.updated || r.removed || r.errors.length) {
+        log("sync", { config_changed: full, ...r, unchanged: void 0 });
+      }
+      return r;
+    },
+    close() {
+      embedQueue.stop();
+      store.close();
+      contexts.delete(root);
+    }
+  };
+  ctx.refresh(true);
+  contexts.set(root, ctx);
+  if (opts.reconcile ?? true) {
+    const r = reconcile(ctx, { full: false });
+    if (r.added || r.updated || r.removed || r.errors.length) log("reconcile", r);
+  }
+  embedQueue.kick(1e3);
+  return ctx;
+}
+function closeAllContexts() {
+  for (const ctx of [...contexts.values()]) ctx.close();
+}
+
+// src/search/rrf.ts
+var K = 60;
+function fuseRrf(lists) {
+  const acc = /* @__PURE__ */ new Map();
+  for (const list of lists) {
+    list.hits.forEach((hit, rank) => {
+      const cur = acc.get(hit.recipe_id) ?? {
+        recipe_id: hit.recipe_id,
+        slug: hit.slug,
+        score: 0,
+        sources: []
+      };
+      cur.score += list.weight / (K + rank + 1);
+      if (!cur.sources.includes(list.name)) cur.sources.push(list.name);
+      acc.set(hit.recipe_id, cur);
+    });
+  }
+  return [...acc.values()].sort((a, b) => b.score - a.score);
+}
+
+// src/search/hybrid.ts
+function expandFilters(ctx, filters) {
+  if (!filters) return filters;
+  const out = { ...filters };
+  if (filters.tags) {
+    const tags = {};
+    for (const [cat, values] of Object.entries(filters.tags)) {
+      if (!values?.length) continue;
+      const free = cat === "chef" || cat === "plan";
+      tags[cat] = free ? values : [
+        ...new Set(
+          values.flatMap((v) => ctx.vocab.expand(cat === "technique" ? "method" : cat, v))
+        )
+      ];
+    }
+    out.tags = tags;
+  }
+  if (filters.exclude_allergens?.length) {
+    out.exclude_allergens = [
+      ...new Set(filters.exclude_allergens.flatMap((a) => ctx.vocab.expand("allergen", a)))
+    ];
+  }
+  return out;
+}
+async function searchRecipes(ctx, opts) {
+  const limit = Math.min(Math.max(opts.limit ?? 10, 1), 100);
+  const mode = opts.mode ?? "hybrid";
+  const query = opts.query?.trim() ?? "";
+  opts = { ...opts, filters: expandFilters(ctx, opts.filters) };
+  if (!query) {
+    const rows = ctx.store.listRecipes({ filters: opts.filters, limit });
+    return {
+      results: rows.map((r) => ({ ...r, score: null, matched: ["filter"] })),
+      vector_used: false,
+      mode
+    };
+  }
+  const allowed = ctx.store.filterRecipeIds(opts.filters);
+  const fetch = limit * 5;
+  const lists = [];
+  let vectorUsed = false;
+  if (mode !== "semantic") {
+    lists.push({ name: "lexical", weight: 1, hits: ctx.store.searchLexical(query, fetch) });
+    lists.push({ name: "trigram", weight: 0.7, hits: ctx.store.searchTrigram(query, fetch) });
+  }
+  if (mode !== "lexical" && ctx.embedder) {
+    if (ctx.embedder.ready) {
+      try {
+        const vec = await ctx.embedder.embedQuery(query);
+        lists.push({ name: "vector", weight: 1, hits: ctx.store.searchVector(vec, fetch) });
+        vectorUsed = true;
+      } catch (e) {
+        ctx.log("vector search failed", e);
+      }
+    } else {
+      void ctx.embedder.load().then(() => ctx.embedQueue.kick(0));
+    }
+  }
+  const filtered = allowed ? lists.map((l) => ({ ...l, hits: l.hits.filter((h) => allowed.has(h.recipe_id)) })) : lists;
+  const fused = fuseRrf(filtered).slice(0, limit);
+  const summaries = ctx.store.summariesByIds(fused.map((f) => f.recipe_id));
+  const byId = new Map(summaries.map((s) => [s.id, s]));
+  const results = [];
+  for (const f of fused) {
+    const s = byId.get(f.recipe_id);
+    if (s) results.push({ ...s, score: Number(f.score.toFixed(4)), matched: f.sources });
+  }
+  return { results, vector_used: vectorUsed, mode };
+}
+
+// src/web/server.ts
+import fs11 from "fs";
+import http from "http";
+import path8 from "path";
+
+// src/graph/build.ts
+var DEFAULT_CATEGORIES = ["cuisine", "dish", "protein", "diet", "allergen", "technique"];
+function buildGraph(ctx, opts = {}) {
+  const categories = new Set(opts.categories ?? DEFAULT_CATEGORIES);
+  const minDegree = opts.min_degree ?? 2;
+  const { recipes, uses, tags } = ctx.store.graphRows();
+  let allowed = null;
+  if (opts.cuisine) {
+    const wanted = new Set(ctx.vocab.expand("cuisine", opts.cuisine));
+    allowed = new Set(
+      tags.filter((t) => t.category === "cuisine" && wanted.has(t.name)).map((t) => t.recipe_id)
+    );
+  }
+  const keep = recipes.filter((r) => !allowed || allowed.has(r.id));
+  const keepIds = new Set(keep.map((r) => r.id));
+  const bySlug = new Map(keep.map((r) => [r.slug, r]));
+  const slugById = new Map(keep.map((r) => [r.id, r.slug]));
+  const nodes = /* @__PURE__ */ new Map();
+  const edges = [];
+  const docs = /* @__PURE__ */ new Map();
+  for (const r of keep) {
+    const doc = JSON.parse(r.doc);
+    docs.set(r.id, doc);
+    nodes.set(`r:${r.slug}`, {
+      id: `r:${r.slug}`,
+      kind: "recipe",
+      label: r.title,
+      group: doc.tags.cuisine?.[0] ?? null,
+      degree: 0,
+      slug: r.slug,
+      ...doc.images[0] ? { image: doc.images[0] } : {},
+      ...doc.extraction?.needs_review ? { needs_review: true } : {}
+    });
+  }
+  const linkCount = /* @__PURE__ */ new Map();
+  const pending = [];
+  if (opts.ingredients !== false) {
+    for (const u of uses) {
+      if (!keepIds.has(u.recipe_id) || u.staple && !opts.include_staples) continue;
+      const id = `i:${u.canonical}`;
+      if (!nodes.has(id)) {
+        nodes.set(id, { id, kind: "ingredient", label: u.canonical, group: u.category, degree: 0 });
+      }
+      pending.push({ source: `r:${slugById.get(u.recipe_id)}`, target: id, kind: "uses" });
+      linkCount.set(id, (linkCount.get(id) ?? 0) + 1);
+    }
+  }
+  for (const t of tags) {
+    if (!keepIds.has(t.recipe_id) || !categories.has(t.category)) continue;
+    const id = `t:${t.category}:${t.name}`;
+    if (!nodes.has(id))
+      nodes.set(id, { id, kind: "tag", label: t.name, group: t.category, degree: 0 });
+    pending.push({ source: `r:${slugById.get(t.recipe_id)}`, target: id, kind: "tagged" });
+    linkCount.set(id, (linkCount.get(id) ?? 0) + 1);
+  }
+  for (const [id, n] of nodes) {
+    if (n.kind === "recipe") continue;
+    n.degree = linkCount.get(id) ?? 0;
+    if (n.degree < minDegree) nodes.delete(id);
+  }
+  for (const e of pending) if (nodes.has(e.source) && nodes.has(e.target)) edges.push(e);
+  if (categories.has("cuisine")) {
+    for (const n of [...nodes.values()]) {
+      if (n.kind !== "tag" || n.group !== "cuisine") continue;
+      const parent = ctx.vocab.ancestors("cuisine", n.label)[0];
+      if (!parent) continue;
+      const pid = `t:cuisine:${parent}`;
+      if (!nodes.has(pid))
+        nodes.set(pid, { id: pid, kind: "tag", label: parent, group: "cuisine", degree: 0 });
+      edges.push({ source: n.id, target: pid, kind: "parent" });
+    }
+  }
+  for (const [id, doc] of docs) {
+    const slug = slugById.get(id);
+    for (const src of doc.derived_from) {
+      if (bySlug.has(src))
+        edges.push({ source: `r:${slug}`, target: `r:${src}`, kind: "derived_from" });
+    }
+  }
+  if (opts.similar && opts.similar > 0) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const r of keep) {
+      for (const s of ctx.store.similarRecipes(r.id, opts.similar)) {
+        const other = slugById.get(s.recipe_id);
+        if (!other) continue;
+        const key = [r.slug, other].sort().join("|");
+        if (seen.has(key)) continue;
+        seen.add(key);
+        edges.push({
+          source: `r:${r.slug}`,
+          target: `r:${other}`,
+          kind: "similar",
+          weight: Number((1 - s.distance / 2).toFixed(3))
+        });
+      }
+    }
+  }
+  for (const e of edges) {
+    const s = nodes.get(e.source);
+    if (s?.kind === "recipe") s.degree++;
+  }
+  const stats = {
+    recipes: 0,
+    ingredients: 0,
+    tags: 0,
+    edges: edges.length
+  };
+  for (const n of nodes.values()) {
+    const key = n.kind === "recipe" ? "recipes" : n.kind === "ingredient" ? "ingredients" : "tags";
+    stats[key] = (stats[key] ?? 0) + 1;
+  }
+  return { nodes: [...nodes.values()], edges, stats };
+}
+
+// src/ingest/images.ts
+import { execFile } from "child_process";
+import { createHash as createHash3 } from "crypto";
+import fs9 from "fs";
+import os2 from "os";
+import path6 from "path";
+import { promisify } from "util";
+import sharp from "sharp";
+var execFileP = promisify(execFile);
+var IMAGE_EXTS = /* @__PURE__ */ new Set([
+  ".jpg",
+  ".jpeg",
+  ".png",
+  ".webp",
+  ".heic",
+  ".heif",
+  ".tif",
+  ".tiff"
+]);
+var HEIF_EXTS = /* @__PURE__ */ new Set([".heic", ".heif"]);
+var MODEL_MAX_PX = 1600;
+var MODEL_MAX_BYTES = 75e4;
+var RETAKE_DISTANCE = 6;
+function isImageFile(name) {
+  return IMAGE_EXTS.has(path6.extname(name).toLowerCase()) && !path6.basename(name).startsWith(".");
+}
+function mimeFor(file) {
+  const ext = path6.extname(file).toLowerCase();
+  if (ext === ".png") return "image/png";
+  if (ext === ".webp") return "image/webp";
+  if (HEIF_EXTS.has(ext)) return "image/heic";
+  if (ext === ".tif" || ext === ".tiff") return "image/tiff";
+  return "image/jpeg";
+}
+async function heifToJpeg(file) {
+  if (process.platform === "darwin") {
+    const out = path6.join(os2.tmpdir(), `pantrybase-${process.pid}-${Date.now()}.jpg`);
+    try {
+      await execFileP("sips", ["-s", "format", "jpeg", file, "--out", out]);
+      return fs9.readFileSync(out);
+    } finally {
+      fs9.rmSync(out, { force: true });
+    }
+  }
+  try {
+    const { default: convert } = await import("heic-convert");
+    const jpeg = await convert({ buffer: fs9.readFileSync(file), format: "JPEG", quality: 0.9 });
+    return Buffer.from(jpeg);
+  } catch (e) {
+    throw new Error(
+      `cannot decode HEIC ${path6.basename(file)} (install heic-convert or convert to JPEG): ${e instanceof Error ? e.message : String(e)}`
+    );
+  }
+}
+async function openImage(file) {
+  const input = HEIF_EXTS.has(path6.extname(file).toLowerCase()) ? await heifToJpeg(file) : file;
+  return sharp(input, { failOn: "none" }).rotate();
+}
+async function rotateFile(file, degrees) {
+  const ext = path6.extname(file).toLowerCase();
+  const upright = await (await openImage(file)).toBuffer();
+  let pipeline = sharp(upright, { failOn: "none" }).rotate(degrees);
+  let target = file;
+  if (ext === ".png") pipeline = pipeline.png();
+  else if (ext === ".webp") pipeline = pipeline.webp({ quality: 92 });
+  else if (ext === ".tif" || ext === ".tiff") pipeline = pipeline.tiff();
+  else {
+    pipeline = pipeline.jpeg({ quality: 92, mozjpeg: true });
+    if (HEIF_EXTS.has(ext)) target = `${file.slice(0, -ext.length)}.jpg`;
+  }
+  const out = await pipeline.toBuffer();
+  const tmp = `${target}.rotating-${process.pid}`;
+  fs9.writeFileSync(tmp, out);
+  fs9.renameSync(tmp, target);
+  if (target !== file) fs9.rmSync(file, { force: true });
+  return target;
+}
+async function imageForModel(file, maxPx = MODEL_MAX_PX) {
+  const base = await (await openImage(file)).resize(maxPx, maxPx, { fit: "inside", withoutEnlargement: true }).toBuffer({ resolveWithObject: true });
+  let data = base.data;
+  for (const quality of [82, 72, 62, 52, 42]) {
+    data = await sharp(base.data).jpeg({ quality, mozjpeg: true }).toBuffer();
+    if (data.length <= MODEL_MAX_BYTES) break;
+  }
+  return { data, mimeType: "image/jpeg", width: base.info.width, height: base.info.height };
+}
+async function dhash(img) {
+  const px = await img.clone().greyscale().resize(9, 8, { fit: "fill" }).raw().toBuffer();
+  let bits = 0n;
+  for (let y = 0; y < 8; y++) {
+    for (let x = 0; x < 8; x++) {
+      bits = bits << 1n | ((px[y * 9 + x] ?? 0) > (px[y * 9 + x + 1] ?? 0) ? 1n : 0n);
+    }
+  }
+  return bits.toString(16).padStart(16, "0");
+}
+function hamming(a, b) {
+  let x = BigInt(`0x${a}`) ^ BigInt(`0x${b}`);
+  let n = 0;
+  while (x) {
+    n += Number(x & 1n);
+    x >>= 1n;
+  }
+  return n;
+}
+function captureTimeFromName(name) {
+  const m = /(20\d{2})(\d{2})(\d{2})[_-](\d{2})(\d{2})(\d{2})(\d{0,3})/.exec(name);
+  if (!m) return null;
+  const [, y, mo, d, h, mi, s, ms] = m;
+  const iso = `${y}-${mo}-${d}T${h}:${mi}:${s}.${(ms ?? "").padEnd(3, "0")}`;
+  return Number.isNaN(Date.parse(iso)) ? null : iso;
+}
+function captureTimeFromExif(exif) {
+  if (!exif) return null;
+  const m = /(\d{4}):(\d{2}):(\d{2}) (\d{2}):(\d{2}):(\d{2})/.exec(exif.toString("latin1"));
+  if (!m) return null;
+  const iso = `${m[1]}-${m[2]}-${m[3]}T${m[4]}:${m[5]}:${m[6]}.000`;
+  return Number.isNaN(Date.parse(iso)) ? null : iso;
+}
+async function inspectImage(file) {
+  const buf = fs9.readFileSync(file);
+  const st = fs9.statSync(file);
+  const img = await openImage(file);
+  const meta = await img.metadata();
+  const rotated = (meta.orientation ?? 1) >= 5;
+  const captured = captureTimeFromName(path6.basename(file)) ?? captureTimeFromExif(meta.exif) ?? new Date(st.mtimeMs).toISOString().slice(0, 23);
+  return {
+    sha256: createHash3("sha256").update(buf).digest("hex"),
+    phash: await dhash(img),
+    width: (rotated ? meta.height : meta.width) ?? 0,
+    height: (rotated ? meta.width : meta.height) ?? 0,
+    mime: mimeFor(file),
+    bytes: st.size,
+    mtime: Math.round(st.mtimeMs),
+    captured_at: captured
+  };
+}
+
+// src/ingest/inbox.ts
+import fs10 from "fs";
+import os3 from "os";
+import path7 from "path";
+var SKIPPED = "skipped";
+var FAILED = "failed";
+var DUPLICATES = "duplicates";
+var REASON_SUFFIX = ".reason.txt";
+function walk(dir, skipDirs = /* @__PURE__ */ new Set()) {
+  if (!fs10.existsSync(dir)) return [];
+  const out = [];
+  for (const entry of fs10.readdirSync(dir, { withFileTypes: true })) {
+    if (entry.name.startsWith(".")) continue;
+    const abs = path7.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (!skipDirs.has(abs)) out.push(...walk(abs, skipDirs));
+    } else if (isImageFile(entry.name)) {
+      out.push(abs);
+    }
+  }
+  return out;
+}
+function locate(ctx, abs) {
+  const inImages = path7.relative(ctx.paths.images, abs);
+  if (!inImages.startsWith("..") && !path7.isAbsolute(inImages)) {
+    return { status: "done", slug: inImages.split(path7.sep)[0] ?? null };
+  }
+  const inInbox = path7.relative(ctx.paths.inbox, abs).split(path7.sep);
+  if (inInbox[0] === SKIPPED) return { status: "skipped", slug: null };
+  if (inInbox[0] === FAILED) return { status: "failed", slug: null };
+  return { status: "pending", slug: null };
+}
+function readReason(abs) {
+  try {
+    return fs10.readFileSync(abs + REASON_SUFFIX, "utf8").trim() || null;
+  } catch {
+    return null;
+  }
+}
+function freeName(dir, name, taken = /* @__PURE__ */ new Set()) {
+  const ext = path7.extname(name);
+  const stem = path7.basename(name, ext);
+  let candidate = name;
+  for (let n = 2; fs10.existsSync(path7.join(dir, candidate)) || taken.has(path7.join(dir, candidate)); n++) {
+    candidate = `${stem}-${n}${ext}`;
+  }
+  return candidate;
+}
+function moveFile(from, to) {
+  fs10.mkdirSync(path7.dirname(to), { recursive: true });
+  try {
+    fs10.renameSync(from, to);
+  } catch (e) {
+    if (e.code !== "EXDEV") throw e;
+    fs10.copyFileSync(from, to);
+    fs10.rmSync(from);
+  }
+}
+var scanning = /* @__PURE__ */ new WeakMap();
+function scanInbox(ctx) {
+  const running2 = scanning.get(ctx);
+  if (running2) return running2;
+  const job = (async () => {
+    const res = { added: 0, updated: 0, removed: 0, duplicates: [], errors: [] };
+    const dupDir = path7.join(ctx.paths.inbox, DUPLICATES);
+    const files = [...walk(ctx.paths.inbox, /* @__PURE__ */ new Set([dupDir])), ...walk(ctx.paths.images)];
+    const seen = /* @__PURE__ */ new Set();
+    for (const abs of files) {
+      const rel = relativeToData(ctx.paths, abs);
+      const where = locate(ctx, abs);
+      const st = fs10.statSync(abs);
+      const row = ctx.store.ingestByPath(rel);
+      if (row && row.mtime === Math.round(st.mtimeMs) && row.bytes === st.size) {
+        seen.add(rel);
+        const reason = where.status === "skipped" || where.status === "failed" ? readReason(abs) : null;
+        if (row.status !== where.status || row.recipe_slug !== where.slug || row.reason !== reason) {
+          ctx.store.updateIngest(row.id, { status: where.status, recipe_slug: where.slug, reason });
+          res.updated++;
+        }
+        continue;
+      }
+      try {
+        const info = await inspectImage(abs);
+        const same = ctx.store.ingestBySha(info.sha256);
+        if (same && same.path !== rel) {
+          if (fs10.existsSync(path7.join(ctx.paths.data, same.path))) {
+            const target = path7.join(dupDir, freeName(dupDir, path7.basename(abs)));
+            moveFile(abs, target);
+            res.duplicates.push(`${rel} = #${same.id} ${same.path}`);
+            continue;
+          }
+          ctx.store.updateIngest(same.id, {
+            path: rel,
+            status: where.status,
+            recipe_slug: where.slug,
+            mtime: info.mtime,
+            bytes: info.bytes
+          });
+          seen.add(rel);
+          res.updated++;
+          continue;
+        }
+        if (row) ctx.store.deleteIngest(row.id);
+        ctx.store.insertIngest({
+          ...info,
+          path: rel,
+          original_name: path7.basename(abs),
+          status: where.status,
+          recipe_slug: where.slug,
+          side: null,
+          reason: where.status === "skipped" || where.status === "failed" ? readReason(abs) : null
+        });
+        seen.add(rel);
+        res.added++;
+      } catch (e) {
+        res.errors.push({ file: rel, error: e instanceof Error ? e.message : String(e) });
+      }
+    }
+    for (const row of ctx.store.allIngest()) {
+      if (!seen.has(row.path) && !fs10.existsSync(path7.join(ctx.paths.data, row.path))) {
+        ctx.store.deleteIngest(row.id);
+        res.removed++;
+      }
+    }
+    return res;
+  })().finally(() => {
+    scanning.delete(ctx);
+  });
+  scanning.set(ctx, job);
+  return job;
+}
+var lastScan = /* @__PURE__ */ new WeakMap();
+async function maybeScanInbox(ctx, intervalMs = 3e3) {
+  const t = Date.now();
+  if (t - (lastScan.get(ctx) ?? 0) < intervalMs) return null;
+  lastScan.set(ctx, t);
+  return scanInbox(ctx);
+}
+function expandHome(p) {
+  return p === "~" || p.startsWith("~/") ? path7.join(os3.homedir(), p.slice(1)) : p;
+}
+async function importPaths(ctx, inputs, opts = {}) {
+  const res = {
+    copied: 0,
+    already_known: 0,
+    unsupported: 0,
+    missing: []
+  };
+  const files = [];
+  for (const input of inputs) {
+    const abs = path7.resolve(ctx.root, expandHome(input));
+    if (!fs10.existsSync(abs)) {
+      res.missing.push(input);
+      continue;
+    }
+    if (fs10.statSync(abs).isDirectory()) {
+      const list = opts.recursive === false ? fs10.readdirSync(abs).map((f) => path7.join(abs, f)).filter((f) => fs10.statSync(f).isFile()) : walkAll(abs);
+      for (const f of list) {
+        if (isImageFile(f)) files.push(f);
+        else res.unsupported++;
+      }
+    } else if (isImageFile(abs)) {
+      files.push(abs);
+    } else {
+      res.unsupported++;
+    }
+  }
+  const known = new Set(ctx.store.allIngest().map((r) => r.sha256));
+  const { createHash: createHash4 } = await import("crypto");
+  const taken = /* @__PURE__ */ new Set();
+  for (const f of files.sort()) {
+    const sha2 = createHash4("sha256").update(fs10.readFileSync(f)).digest("hex");
+    if (known.has(sha2)) {
+      res.already_known++;
+      continue;
+    }
+    known.add(sha2);
+    const target = path7.join(ctx.paths.inbox, freeName(ctx.paths.inbox, path7.basename(f), taken));
+    taken.add(target);
+    fs10.copyFileSync(f, target);
+    const st = fs10.statSync(f);
+    fs10.utimesSync(target, st.atime, st.mtime);
+    res.copied++;
+  }
+  return { ...res, scan: await scanInbox(ctx) };
+}
+function walkAll(dir) {
+  const out = [];
+  for (const entry of fs10.readdirSync(dir, { withFileTypes: true })) {
+    if (entry.name.startsWith(".")) continue;
+    const abs = path7.join(dir, entry.name);
+    if (entry.isDirectory()) out.push(...walkAll(abs));
+    else out.push(abs);
+  }
+  return out;
+}
+async function addUpload(ctx, name, data) {
+  const safe = path7.basename(name).replace(/[^\w.\- ]+/g, "_") || "upload.jpg";
+  if (!isImageFile(safe)) throw new Error(`unsupported image type: ${safe}`);
+  const target = path7.join(ctx.paths.inbox, freeName(ctx.paths.inbox, safe));
+  fs10.writeFileSync(target, data);
+  await scanInbox(ctx);
+  return ctx.store.ingestByPath(relativeToData(ctx.paths, target));
+}
+function shapeOf(item) {
+  const w = item.width ?? 0;
+  const h = item.height ?? 0;
+  if (w > h * 1.1) return "landscape";
+  if (h > w * 1.1) return "portrait";
+  return "square";
+}
+function dominantShape(all) {
+  const counts = { landscape: 0, portrait: 0, square: 0 };
+  for (const i of all) if (i.width && i.height) counts[shapeOf(i)]++;
+  const total = counts.landscape + counts.portrait + counts.square;
+  if (total < 3) return null;
+  const [shape, n] = Object.entries(counts).sort(
+    (a, b) => b[1] - a[1]
+  )[0] ?? ["square", 0];
+  return shape !== "square" && n / total >= 0.7 ? shape : null;
+}
+function rotationHint(item, dominant) {
+  if (!dominant) return void 0;
+  const shape = shapeOf(item);
+  if (shape === "square" || shape === dominant) return void 0;
+  return `${shape} while most photos are ${dominant} \u2014 it may be sideways; if the text doesn't read upright, pb_inbox_rotate it`;
+}
+function retakeHint(item, all) {
+  let best;
+  for (const other of all) {
+    if (other.id === item.id) continue;
+    const d = hamming(item.phash, other.phash);
+    if (d <= RETAKE_DISTANCE && (!best || d < best.distance)) {
+      best = { id: other.id, status: other.status, distance: d };
+      if (other.recipe_slug) best.recipe_slug = other.recipe_slug;
+    }
+  }
+  return best;
+}
+function viewItem(item, all, dominant = all ? dominantShape(all) : null) {
+  const v = {
+    id: item.id,
+    name: item.original_name,
+    captured_at: item.captured_at,
+    size: `${item.width}x${item.height}`,
+    status: item.status,
+    version: item.mtime
+  };
+  if (item.recipe_slug) v.recipe_slug = item.recipe_slug;
+  if (item.reason) v.reason = item.reason;
+  if (all) {
+    const r = retakeHint(item, all);
+    if (r) v.retake_of = r;
+    const hint = rotationHint(item, dominant);
+    if (hint) v.rotation_hint = hint;
+  }
+  return v;
+}
+function viewItems(items, all) {
+  const dominant = dominantShape(all);
+  return items.map((i) => viewItem(i, all, dominant));
+}
+function nextBatch(ctx, window = 4) {
+  const all = ctx.store.allIngest();
+  const items = all.filter((i) => i.status === "pending").slice(0, Math.max(1, window));
+  return { progress: ctx.store.ingestCounts(), items: viewItems(items, all) };
+}
+async function rotateItem(ctx, id, degrees) {
+  const [item] = ctx.store.ingestByIds([id]);
+  if (!item) throw new Error(`no photo #${id}`);
+  const abs = path7.join(ctx.paths.data, item.path);
+  if (!fs10.existsSync(abs)) throw new Error(`photo #${id} is missing on disk (${item.path})`);
+  const heif = /\.(heic|heif)$/i.test(abs);
+  if (item.status === "done" && heif) {
+    throw new Error(
+      `photo #${id} is an archived HEIC; rotating would rename the file ${item.recipe_slug} uses`
+    );
+  }
+  const target = await rotateFile(abs, degrees);
+  const info = await inspectImage(target);
+  const rel = relativeToData(ctx.paths, target);
+  const clash = ctx.store.ingestBySha(info.sha256);
+  if (clash && clash.id !== item.id)
+    throw new Error(`rotated photo #${id} is identical to #${clash.id}`);
+  ctx.store.updateIngest(item.id, {
+    path: rel,
+    sha256: info.sha256,
+    phash: info.phash,
+    width: info.width,
+    height: info.height,
+    bytes: info.bytes,
+    mtime: info.mtime,
+    mime: info.mime
+  });
+  const updated = ctx.store.ingestByIds([id])[0] ?? item;
+  return viewItem(updated, ctx.store.allIngest());
+}
+function resolveItems(ctx, ids, status, reason) {
+  const out = { moved: 0, refused: [] };
+  const items = ctx.store.ingestByIds(ids);
+  for (const id of ids) {
+    if (!items.some((i) => i.id === id)) out.refused.push({ id, why: "unknown id" });
+  }
+  for (const item of items) {
+    if (item.status === "done") {
+      out.refused.push({ id: item.id, why: `already attached to ${item.recipe_slug}` });
+      continue;
+    }
+    const from = path7.join(ctx.paths.data, item.path);
+    const dir = status === "pending" ? ctx.paths.inbox : path7.join(ctx.paths.inbox, status === "skipped" ? SKIPPED : FAILED);
+    const name = path7.dirname(from) === dir ? path7.basename(from) : freeName(dir, path7.basename(from));
+    const to = path7.join(dir, name);
+    fs10.rmSync(from + REASON_SUFFIX, { force: true });
+    if (from !== to) moveFile(from, to);
+    const why = status === "pending" ? null : reason?.trim() || null;
+    if (why) fs10.writeFileSync(to + REASON_SUFFIX, `${why}
+`);
+    const st = fs10.statSync(to);
+    ctx.store.updateIngest(item.id, {
+      path: relativeToData(ctx.paths, to),
+      status,
+      reason: why,
+      recipe_slug: null,
+      side: null,
+      mtime: Math.round(st.mtimeMs)
+    });
+    out.moved++;
+  }
+  return out;
+}
+function planAttach(ctx, slug, ingest) {
+  const errors = [];
+  const items = ctx.store.ingestByIds(ingest.map((i) => i.id));
+  const dir = path7.join(ctx.paths.images, slug);
+  const taken = /* @__PURE__ */ new Set();
+  const targets = [];
+  for (const { id, side } of ingest) {
+    const item = items.find((i) => i.id === id);
+    if (!item) {
+      errors.push(`unknown photo #${id}`);
+      continue;
+    }
+    if (item.status === "done") {
+      if (item.recipe_slug !== slug)
+        errors.push(`photo #${id} is already attached to ${item.recipe_slug}`);
+      else targets.push({ item, side: item.side ?? side, rel: item.path });
+      continue;
+    }
+    if (!fs10.existsSync(path7.join(ctx.paths.data, item.path))) {
+      errors.push(`photo #${id} is missing on disk (${item.path})`);
+      continue;
+    }
+    const ext = path7.extname(item.path).toLowerCase() || ".jpg";
+    const name = freeName(dir, `${side}${ext}`, taken);
+    taken.add(path7.join(dir, name));
+    targets.push({ item, side, rel: relativeToData(ctx.paths, path7.join(dir, name)) });
+  }
+  return { targets, errors };
+}
+function finalizeAttach(ctx, slug, targets) {
+  for (const t of targets) {
+    if (t.item.status === "done" && t.item.path === t.rel) continue;
+    const from = path7.join(ctx.paths.data, t.item.path);
+    const to = path7.join(ctx.paths.data, t.rel);
+    fs10.rmSync(from + REASON_SUFFIX, { force: true });
+    moveFile(from, to);
+    const st = fs10.statSync(to);
+    ctx.store.updateIngest(t.item.id, {
+      path: t.rel,
+      status: "done",
+      recipe_slug: slug,
+      side: t.side,
+      reason: null,
+      mtime: Math.round(st.mtimeMs)
+    });
+  }
+}
+function mergeImages(existing, targets, claimed = []) {
+  const order = { front: 0, back: 1, other: 2 };
+  const byFile = /* @__PURE__ */ new Map();
+  for (const e of existing.extraction?.images ?? []) byFile.set(e.file, e);
+  for (const t of targets) byFile.set(t.rel, { file: t.rel, side: t.side });
+  for (const c of claimed)
+    if (c.file.startsWith("images/") && !byFile.has(c.file)) byFile.set(c.file, c);
+  const extraction = [...byFile.values()].sort(
+    (a, b) => order[a.side] - order[b.side] || a.file.localeCompare(b.file)
+  );
+  const images = [.../* @__PURE__ */ new Set([...extraction.map((e) => e.file), ...existing.images])];
+  return { images, extraction };
+}
+
+// src/pantry/pantry.ts
+var FUZZY_THRESHOLD2 = 0.85;
+function dice3(a, b) {
+  const grams = (s) => {
+    const g = /* @__PURE__ */ new Map();
+    const t = ` ${s} `;
+    for (let i = 0; i < t.length - 1; i++) {
+      const k = t.slice(i, i + 2);
+      g.set(k, (g.get(k) ?? 0) + 1);
+    }
+    return g;
+  };
+  const ga = grams(a);
+  const gb = grams(b);
+  let overlap = 0;
+  for (const [k, n] of ga) overlap += Math.min(n, gb.get(k) ?? 0);
+  const total = [...ga.values()].reduce((x, y) => x + y, 0) + [...gb.values()].reduce((x, y) => x + y, 0);
+  return total === 0 ? 0 : 2 * overlap / total;
+}
+function resolveItem(ctx, raw, create) {
+  const name = normalizeName(raw);
+  if (!name) return void 0;
+  const canonical = findCanonical(ctx.store, name);
+  if (canonical) {
+    const row = ctx.store.getIngredient(canonical);
+    if (row) return { row, how: canonical === name ? "exact" : "alias" };
+  }
+  const best = ctx.store.fuzzyIngredients(name, 3)[0];
+  if (best && dice3(name, best.alias) >= FUZZY_THRESHOLD2) {
+    ctx.store.addAlias(best.row.id, name);
+    return { row: best.row, how: "fuzzy" };
+  }
+  if (!create) return void 0;
+  return { row: ctx.store.createIngredient({ canonical: name }), how: "new" };
+}
+function addToPantry(ctx, items) {
+  return ctx.store.transaction(
+    () => items.flatMap((item) => {
+      const hit = resolveItem(ctx, item.name, true);
+      if (!hit) return [];
+      ctx.store.pantryUpsert(hit.row.id, item);
+      return [{ name: item.name, canonical: hit.row.canonical, matched: hit.how }];
+    })
+  );
+}
+function removeFromPantry(ctx, names) {
+  const inPantry = new Map(ctx.store.pantryList().map((p) => [p.ingredient_id, p.canonical]));
+  const removed = [];
+  const missing = [];
+  const ids = [];
+  for (const n of names) {
+    const hit = resolveItem(ctx, n, false);
+    if (hit && inPantry.has(hit.row.id)) {
+      ids.push(hit.row.id);
+      removed.push(hit.row.canonical);
+    } else {
+      missing.push(n);
+    }
+  }
+  ctx.store.pantryRemove(ids);
+  return { removed, not_in_pantry: missing };
+}
+function listPantry(ctx) {
+  return ctx.store.pantryList();
+}
+function availableIngredients(ctx, opts) {
+  const ids = /* @__PURE__ */ new Set();
+  if (opts.use_pantry !== false) for (const p of ctx.store.pantryList()) ids.add(p.ingredient_id);
+  const unknown = [];
+  for (const raw of opts.ingredients ?? []) {
+    const hit = resolveItem(ctx, raw, false);
+    if (hit) ids.add(hit.row.id);
+    else unknown.push(raw);
+  }
+  return { ids, unknown };
+}
+function lineAvailable(ctx, line, avail, cache) {
+  if (avail.has(line.ingredient_id)) return true;
+  if (!line.extra) return false;
+  const extra = JSON.parse(line.extra);
+  const idOf = (name) => {
+    if (!cache.has(name))
+      cache.set(name, ctx.store.getIngredient(findCanonical(ctx.store, name) ?? name)?.id ?? null);
+    return cache.get(name) ?? null;
+  };
+  if (extra.alternatives?.some((a) => {
+    const id = idOf(a);
+    return id !== null && avail.has(id);
+  })) {
+    return true;
+  }
+  const comps = extra.components ?? [];
+  return comps.length > 0 && comps.every((c) => {
+    const id = idOf(c.canonical);
+    return id !== null && avail.has(id);
+  });
+}
+function scoreRecipes(ctx, avail, recipeIds) {
+  const rows = ctx.store.recipeRequirements(recipeIds);
+  const cache = /* @__PURE__ */ new Map();
+  const byRecipe = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    const list = byRecipe.get(r.recipe_id) ?? [];
+    list.push(r);
+    byRecipe.set(r.recipe_id, list);
+  }
+  const out = [];
+  for (const lines of byRecipe.values()) {
+    const first = lines[0];
+    if (!first) continue;
+    const required = lines.filter((l) => !l.staple && !l.optional);
+    const missing = [];
+    const fromPantry = [];
+    for (const l of required) {
+      if (lineAvailable(ctx, l, avail, cache)) fromPantry.push(l.canonical);
+      else missing.push({ canonical: l.canonical, raw: l.raw });
+    }
+    const need = required.length;
+    const have = need - missing.length;
+    out.push({
+      slug: first.slug,
+      title: first.title,
+      coverage: need === 0 ? 1 : Math.round(have / need * 100) / 100,
+      have,
+      need,
+      missing,
+      from_pantry: fromPantry,
+      near_miss: missing.length > 0 && missing.length <= 2
+    });
+  }
+  return out.sort(
+    (a, b) => b.coverage - a.coverage || a.missing.length - b.missing.length || a.title.localeCompare(b.title)
+  );
+}
+function matchRecipes(ctx, opts = {}) {
+  const { ids, unknown } = availableIngredients(ctx, opts);
+  const allowed = ctx.store.filterRecipeIds(expandFilters(ctx, opts.filters));
+  let scope = opts.recipe_ids;
+  if (allowed) scope = scope ? scope.filter((id) => allowed.has(id)) : [...allowed];
+  const minCoverage = opts.min_coverage ?? 0;
+  const results = scoreRecipes(ctx, ids, scope).filter((m) => m.coverage >= minCoverage).filter((m) => opts.max_missing === void 0 || m.missing.length <= opts.max_missing).slice(0, Math.min(Math.max(opts.limit ?? 10, 1), 100));
+  return { results, available: ids.size, unknown_ingredients: unknown };
+}
+
+// src/web/server.ts
+var MAX_JSON = 1e6;
+var MAX_UPLOAD = 6e7;
+var HttpError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+  status;
+};
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".json": "application/json",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".ico": "image/x-icon",
+  ".woff2": "font/woff2"
+};
+function readBody(req, limit) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    req.on("data", (c) => {
+      size += c.length;
+      if (size > limit) {
+        reject(new HttpError(413, "request body too large"));
+        req.destroy();
+      } else {
+        chunks.push(c);
+      }
+    });
+    req.on("end", () => resolve(Buffer.concat(chunks)));
+    req.on("error", reject);
+  });
+}
+async function readJson(req) {
+  const body = await readBody(req, MAX_JSON);
+  try {
+    return JSON.parse(body.toString("utf8") || "{}");
+  } catch {
+    throw new HttpError(400, "invalid JSON body");
+  }
+}
+var num2 = (v) => v === null || v === "" ? void 0 : Number(v);
+var csv = (v) => v ? v.split(",").map((s) => s.trim()).filter(Boolean) : void 0;
+function filtersFrom(url) {
+  const p = url.searchParams;
+  let tags;
+  if (p.get("tags")) {
+    try {
+      tags = JSON.parse(p.get("tags") ?? "{}");
+    } catch {
+      throw new HttpError(400, 'tags must be JSON, e.g. {"cuisine":["thai"]}');
+    }
+  }
+  const nr = p.get("needs_review");
+  return {
+    tags,
+    exclude_allergens: csv(p.get("exclude_allergens")),
+    exclude_ingredients: csv(p.get("exclude_ingredients")),
+    max_total_min: num2(p.get("max_total_min")),
+    max_active_min: num2(p.get("max_active_min")),
+    provider: p.get("provider") ?? void 0,
+    needs_review: nr === null ? void 0 : nr === "true" || nr === "1"
+  };
+}
+function safeImagePath(ctx, rel) {
+  const abs = path8.resolve(ctx.paths.data, rel);
+  const ok = [ctx.paths.images, ctx.paths.inbox].some((dir) => abs.startsWith(dir + path8.sep));
+  if (!ok || !fs11.existsSync(abs) || !fs11.statSync(abs).isFile())
+    throw new HttpError(404, "not found");
+  return abs;
+}
+var thumbCache = /* @__PURE__ */ new Map();
+async function thumbnail(abs, width) {
+  const key = `${abs}|${fs11.statSync(abs).mtimeMs}|${width}`;
+  const hit = thumbCache.get(key);
+  if (hit) return hit;
+  const buf = await (await openImage(abs)).resize(width, width, { fit: "inside", withoutEnlargement: true }).jpeg({ quality: 78, mozjpeg: true }).toBuffer();
+  if (thumbCache.size > 400) thumbCache.delete(thumbCache.keys().next().value);
+  thumbCache.set(key, buf);
+  return buf;
+}
+function routes(ctx, version) {
+  const r = (method, pattern, handler) => ({
+    method,
+    pattern,
+    handler
+  });
+  return [
+    r("GET", /^\/api\/stats$/, () => ({
+      ...ctx.store.stats(),
+      inbox: ctx.store.ingestCounts(),
+      pantry: listPantry(ctx).length,
+      providers: ctx.providers.list().map((p) => ({ id: p.id, name: p.name })),
+      data_dir: ctx.paths.data,
+      embeddings: ctx.embedder ? ctx.embedder.ready ? "ready" : "loading" : "disabled",
+      version
+    })),
+    r("GET", /^\/api\/facets$/, () => {
+      const used = {};
+      for (const t of ctx.store.listTags()) {
+        const list = used[t.category] ?? [];
+        list.push({ name: t.name, count: t.count });
+        used[t.category] = list;
+      }
+      return { used, vocabulary: ctx.vocab.summary(200) };
+    }),
+    r("GET", /^\/api\/search$/, async (_req, url) => {
+      const p = url.searchParams;
+      return searchRecipes(ctx, {
+        query: p.get("q") ?? void 0,
+        limit: num2(p.get("limit")) ?? 48,
+        mode: p.get("mode") ?? void 0,
+        filters: filtersFrom(url)
+      });
+    }),
+    r("GET", /^\/api\/recipes\/([a-z0-9-]+)$/, (_req, _url, [slug]) => {
+      const rec = ctx.store.getRecipe(slug ?? "");
+      if (!rec) throw new HttpError(404, `no recipe "${slug}"`);
+      const { ids } = availableIngredients(ctx, {});
+      const have = new Set(
+        rec.ingredients.filter((i) => {
+          const row = ctx.store.getIngredient(i.canonical);
+          return row ? ids.has(row.id) : false;
+        }).map((i) => i.canonical)
+      );
+      const similar = ctx.store.summariesByIds(
+        ctx.store.similarRecipes(rec.id, 6).map((s) => s.recipe_id)
+      );
+      const all = ctx.store.listRecipes({ limit: 1e4 });
+      const derived = all.filter((s) => {
+        const d = ctx.store.getRecipe(s.slug)?.derived_from ?? [];
+        return d.includes(rec.slug);
+      });
+      const sources = ctx.store.summariesByIds(
+        rec.derived_from.map((d) => ctx.store.getRecipe(d)?.id).filter((x) => x !== void 0)
+      );
+      return { recipe: rec, pantry_have: [...have], similar, derived, sources };
+    }),
+    r("GET", /^\/api\/files\/(.+)$/, () => {
+      throw new HttpError(500, "handled by the file route");
+    }),
+    r("GET", /^\/api\/pantry$/, () => listPantry(ctx)),
+    r("POST", /^\/api\/pantry$/, async (req) => {
+      const body = await readJson(req);
+      if (!body.items?.length) throw new HttpError(400, "items required");
+      return { added: addToPantry(ctx, body.items), pantry: listPantry(ctx) };
+    }),
+    r("DELETE", /^\/api\/pantry$/, async (req) => {
+      const body = await readJson(req);
+      if (body.all) ctx.store.pantryClear();
+      else removeFromPantry(ctx, body.names ?? []);
+      return { pantry: listPantry(ctx) };
+    }),
+    r("GET", /^\/api\/pantry\/match$/, (_req, url) => {
+      const p = url.searchParams;
+      return matchRecipes(ctx, {
+        ingredients: csv(p.get("ingredients")),
+        min_coverage: num2(p.get("min_coverage")) ?? 0.3,
+        max_missing: num2(p.get("max_missing")),
+        limit: num2(p.get("limit")) ?? 30,
+        filters: filtersFrom(url)
+      });
+    }),
+    r(
+      "GET",
+      /^\/api\/ingredients$/,
+      (_req, url) => ctx.store.listIngredients({
+        query: url.searchParams.get("q") ?? void 0,
+        limit: num2(url.searchParams.get("limit")) ?? 20
+      })
+    ),
+    r("GET", /^\/api\/graph$/, (_req, url) => {
+      const p = url.searchParams;
+      return buildGraph(ctx, {
+        categories: csv(p.get("categories")),
+        ingredients: p.get("ingredients") !== "0",
+        min_degree: num2(p.get("min_degree")),
+        cuisine: p.get("cuisine") ?? void 0,
+        similar: num2(p.get("similar")),
+        include_staples: p.get("staples") === "1"
+      });
+    }),
+    r("GET", /^\/api\/inbox$/, (_req, url) => {
+      const p = url.searchParams;
+      const status = p.get("status");
+      if (status && !INGEST_STATUSES.includes(status))
+        throw new HttpError(400, "bad status");
+      const all = ctx.store.allIngest();
+      const items = ctx.store.listIngest({
+        status: status ?? void 0,
+        limit: num2(p.get("limit")) ?? 200,
+        offset: num2(p.get("offset"))
+      });
+      return {
+        counts: ctx.store.ingestCounts(),
+        items: viewItems(items, all).map((v, n) => ({ ...v, path: items[n]?.path ?? "" }))
+      };
+    }),
+    r("POST", /^\/api\/inbox\/upload$/, async (req) => {
+      const name = decodeURIComponent(String(req.headers["x-filename"] ?? ""));
+      if (!name) throw new HttpError(400, "X-Filename header required");
+      const data = await readBody(req, MAX_UPLOAD);
+      if (data.length === 0) throw new HttpError(400, "empty upload");
+      const item = await addUpload(ctx, name, data);
+      return { item: item ? viewItem(item) : null, counts: ctx.store.ingestCounts() };
+    }),
+    r("POST", /^\/api\/inbox\/rotate$/, async (req) => {
+      const body = await readJson(req);
+      if (typeof body.id !== "number" || ![90, 180, 270].includes(body.degrees ?? 0)) {
+        throw new HttpError(400, "id and degrees (90|180|270, clockwise) required");
+      }
+      return { item: await rotateItem(ctx, body.id, body.degrees) };
+    }),
+    r("POST", /^\/api\/inbox\/resolve$/, async (req) => {
+      const body = await readJson(req);
+      if (!body.ids?.length || !["pending", "skipped", "failed"].includes(body.status ?? "")) {
+        throw new HttpError(400, "ids and status (pending|skipped|failed) required");
+      }
+      return resolveItems(
+        ctx,
+        body.ids,
+        body.status,
+        body.reason
+      );
+    })
+  ];
+}
+var running = /* @__PURE__ */ new WeakMap();
+async function startUiServer(ctx, opts = {}) {
+  const existing = running.get(ctx);
+  if (existing) return existing;
+  ctx.embedder?.load().then(
+    () => ctx.embedQueue.kick(0),
+    () => {
+    }
+  );
+  const webDir = path8.join(packageRoot, "dist", "web");
+  const table = routes(ctx, opts.version ?? "dev");
+  const dev = opts.dev ?? process.env.PB_DEV === "1";
+  let port = opts.port ?? Number(process.env.PB_PORT ?? DEFAULT_UI_PORT);
+  const server = http.createServer(async (req, res) => {
+    const send = (status, body, type = "application/json") => {
+      const payload = type === "application/json" ? JSON.stringify(body) : body;
+      res.writeHead(status, {
+        "Content-Type": type,
+        "Cache-Control": "no-store",
+        "X-Content-Type-Options": "nosniff"
+      });
+      res.end(payload);
+    };
+    try {
+      const host = String(req.headers.host ?? "");
+      const allowedHosts = [`127.0.0.1:${port}`, `localhost:${port}`];
+      if (!allowedHosts.includes(host) && !(dev && /^(localhost|127\.0\.0\.1):\d+$/.test(host))) {
+        throw new HttpError(403, "forbidden host");
+      }
+      const origin = req.headers.origin;
+      if (origin && !allowedHosts.some((h) => origin === `http://${h}`) && !(dev && /^http:\/\/(localhost|127\.0\.0\.1):\d+$/.test(origin))) {
+        throw new HttpError(403, "forbidden origin");
+      }
+      const url = new URL(req.url ?? "/", `http://${host}`);
+      const method = req.method ?? "GET";
+      if (url.pathname.startsWith("/api/")) {
+        if (method !== "GET" && req.headers["x-pantrybase"] !== "1")
+          throw new HttpError(403, "missing X-Pantrybase header");
+        ctx.sync();
+        await maybeScanInbox(ctx);
+        const file2 = /^\/api\/files\/(.+)$/.exec(url.pathname);
+        if (file2 && method === "GET") {
+          const abs = safeImagePath(ctx, decodeURIComponent(file2[1] ?? ""));
+          const w = num2(url.searchParams.get("w"));
+          if (w)
+            return send(200, await thumbnail(abs, Math.min(Math.max(w, 64), 2400)), "image/jpeg");
+          const ext = path8.extname(abs).toLowerCase();
+          if (ext === ".heic" || ext === ".heif")
+            return send(200, await thumbnail(abs, 2400), "image/jpeg");
+          return send(200, fs11.readFileSync(abs), MIME[ext] ?? "application/octet-stream");
+        }
+        for (const route of table) {
+          if (route.method !== method) continue;
+          const m = route.pattern.exec(url.pathname);
+          if (m) return send(200, await route.handler(req, url, m.slice(1)));
+        }
+        throw new HttpError(404, `no route ${method} ${url.pathname}`);
+      }
+      if (method !== "GET") throw new HttpError(405, "method not allowed");
+      if (!fs11.existsSync(webDir)) {
+        return send(
+          503,
+          "The web UI is not built. Run `npm run build:web` in the pantrybase repo.",
+          "text/plain; charset=utf-8"
+        );
+      }
+      const rel = path8.normalize(decodeURIComponent(url.pathname)).replace(/^([/\\])+/, "");
+      let file = path8.join(webDir, rel);
+      if (!file.startsWith(webDir) || !fs11.existsSync(file) || fs11.statSync(file).isDirectory()) {
+        file = path8.join(webDir, "index.html");
+      }
+      const type = MIME[path8.extname(file)] ?? "application/octet-stream";
+      res.writeHead(200, {
+        "Content-Type": type,
+        "Cache-Control": file.includes(`${path8.sep}assets${path8.sep}`) ? "public, max-age=31536000, immutable" : "no-cache",
+        "X-Content-Type-Options": "nosniff"
+      });
+      res.end(fs11.readFileSync(file));
+    } catch (e) {
+      const status = e instanceof HttpError ? e.status : 500;
+      if (status === 500) log("ui error:", e);
+      send(status, { error: e instanceof Error ? e.message : String(e) });
+    }
+  });
+  for (let attempt = 0; attempt < 10; attempt++) {
+    try {
+      await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(port, "127.0.0.1", () => {
+          server.off("error", reject);
+          resolve();
+        });
+      });
+      break;
+    } catch (e) {
+      if (e.code !== "EADDRINUSE" || attempt === 9) throw e;
+      port++;
+    }
+  }
+  const ui = {
+    url: `http://127.0.0.1:${port}`,
+    port,
+    close: () => new Promise((resolve) => {
+      running.delete(ctx);
+      server.close(() => resolve());
+    })
+  };
+  running.set(ctx, ui);
+  return ui;
+}
+
+export {
+  MODEL_ID,
+  packageRoot,
+  packageVersion,
+  homeDir,
+  modelsDir,
+  resolveProjectRoot,
+  dataPaths,
+  log,
+  Embedder,
+  ALL_CATEGORIES,
+  SOURCE_KINDS,
+  IMAGE_SIDES,
+  INGEST_STATUSES,
+  recipeInputSchema,
+  normalizeName,
+  normalizeRecipe,
+  prepareRecipe,
+  writeRecipeFile,
+  recipeFileExists,
+  reconcile,
+  openContext,
+  closeAllContexts,
+  searchRecipes,
+  MODEL_MAX_PX,
+  imageForModel,
+  maybeScanInbox,
+  importPaths,
+  viewItems,
+  nextBatch,
+  rotateItem,
+  resolveItems,
+  planAttach,
+  finalizeAttach,
+  mergeImages,
+  resolveItem,
+  addToPantry,
+  removeFromPantry,
+  listPantry,
+  availableIngredients,
+  scoreRecipes,
+  matchRecipes,
+  startUiServer
+};
+//# sourceMappingURL=chunk-QUWSBZ2V.js.map