pantrybase 0.1.0 → 0.3.0

package/dist/{chunk-2EMC6TJB.js → chunk-IUQQ3I2E.js}

@@ -1056,6 +1056,7 @@ function loadProfile(dir) {
     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,
@@ -1924,8 +1925,8 @@ var SqliteAdapter = class {
     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
+      `SELECT ri.recipe_id, r.slug, r.title, ri.ingredient_id, i.canonical, ri.raw, ri.qty, ri.unit,
+              i.category, (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
@@ -2421,6 +2422,25 @@ 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;
@@ -2686,6 +2706,29 @@ async function addUpload(ctx, name, 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) {
@@ -2698,26 +2741,63 @@ function retakeHint(item, all) {
   }
   return best;
 }
-function viewItem(item, all) {
+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
+    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: items.map((i) => viewItem(i, all)) };
+  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: [] };
@@ -2957,6 +3037,469 @@ function matchRecipes(ctx, opts = {}) {
   return { results, available: ids.size, unknown_ingredients: unknown };
 }
 
+// src/plan/plan.ts
+var PLAN_META_KEY = "meal_plan";
+function getPlan(ctx) {
+  const raw = ctx.store.getMeta(PLAN_META_KEY);
+  if (!raw) return { items: [], confirmed: [], updated_at: "" };
+  try {
+    const p = JSON.parse(raw);
+    return {
+      items: (p.items ?? []).filter((i) => ctx.store.getRecipe(i.slug)),
+      confirmed: p.confirmed ?? [],
+      updated_at: p.updated_at ?? ""
+    };
+  } catch {
+    return { items: [], confirmed: [], updated_at: "" };
+  }
+}
+function savePlan(ctx, plan) {
+  const seen = /* @__PURE__ */ new Set();
+  const items = [];
+  for (const i of plan.items) {
+    if (seen.has(i.slug) || !ctx.store.getRecipe(i.slug)) continue;
+    seen.add(i.slug);
+    items.push(i.servings ? { slug: i.slug, servings: i.servings } : { slug: i.slug });
+  }
+  const stored = {
+    items,
+    confirmed: [...new Set(plan.confirmed)],
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  ctx.store.setMeta(PLAN_META_KEY, JSON.stringify(stored));
+  return stored;
+}
+var CATEGORY_WEIGHT = {
+  herb: 1.5,
+  protein: 1.3,
+  seafood: 1.3,
+  vegetable: 1.2,
+  fruit: 1.2,
+  dairy: 1.2
+};
+var DEFAULT_WEIGHT = 0.7;
+function wasteWeight(category) {
+  return category && CATEGORY_WEIGHT[category] || DEFAULT_WEIGHT;
+}
+var AISLE_ORDER = [
+  "fruit & veg",
+  "meat, fish & eggs",
+  "dairy & chilled",
+  "bakery & grains",
+  "pantry",
+  "spices",
+  "other"
+];
+var AISLES = {
+  vegetable: "fruit & veg",
+  fruit: "fruit & veg",
+  herb: "fruit & veg",
+  protein: "meat, fish & eggs",
+  seafood: "meat, fish & eggs",
+  dairy: "dairy & chilled",
+  grain: "bakery & grains",
+  legume: "pantry",
+  baking: "pantry",
+  nut: "pantry",
+  stock: "pantry",
+  oil: "pantry",
+  condiment: "pantry",
+  spice: "spices",
+  seasoning: "spices"
+};
+function aisleOf(category) {
+  return category && AISLES[category] || "other";
+}
+var UNITS = {
+  g: ["g", 1],
+  gram: ["g", 1],
+  grams: ["g", 1],
+  kg: ["g", 1e3],
+  ml: ["ml", 1],
+  l: ["ml", 1e3],
+  litre: ["ml", 1e3],
+  liter: ["ml", 1e3],
+  tbsp: ["tbsp", 1],
+  tbs: ["tbsp", 1],
+  tablespoon: ["tbsp", 1],
+  tablespoons: ["tbsp", 1],
+  tsp: ["tsp", 1],
+  teaspoon: ["tsp", 1],
+  teaspoons: ["tsp", 1],
+  piece: ["", 1],
+  pieces: ["", 1],
+  pc: ["", 1],
+  pcs: ["", 1],
+  x: ["", 1],
+  whole: ["", 1],
+  tin: ["tin", 1],
+  tins: ["tin", 1],
+  can: ["tin", 1],
+  cans: ["tin", 1],
+  cup: ["cup", 1],
+  cups: ["cup", 1],
+  bunch: ["bunch", 1],
+  bunches: ["bunch", 1],
+  clove: ["clove", 1],
+  cloves: ["clove", 1],
+  sachet: ["sachet", 1],
+  sachets: ["sachet", 1],
+  pack: ["pack", 1],
+  packs: ["pack", 1],
+  packet: ["pack", 1],
+  slice: ["slice", 1],
+  slices: ["slice", 1],
+  sprig: ["sprig", 1],
+  sprigs: ["sprig", 1]
+};
+function toAmount(qty, unit, scale) {
+  if (qty === null || qty === void 0 || !Number.isFinite(qty)) return void 0;
+  const key = (unit ?? "").trim().toLowerCase();
+  const [u, mult] = UNITS[key] ?? [key, 1];
+  return { qty: qty * mult * scale, unit: u };
+}
+function fmtNumber(n) {
+  const r = Math.round(n * 10) / 10;
+  return Number.isInteger(r) ? String(r) : r.toFixed(1);
+}
+function formatAmount(parts, unmeasured = 0) {
+  const sums = /* @__PURE__ */ new Map();
+  for (const p of parts) sums.set(p.unit, (sums.get(p.unit) ?? 0) + p.qty);
+  const out = [];
+  for (const [unit, qty] of sums) {
+    if (unit === "g" && qty >= 1e3) out.push(`${fmtNumber(qty / 1e3)} kg`);
+    else if (unit === "ml" && qty >= 1e3) out.push(`${fmtNumber(qty / 1e3)} l`);
+    else out.push(unit ? `${fmtNumber(qty)} ${unit}` : fmtNumber(qty));
+  }
+  if (unmeasured > 0 && out.length) out.push(`+${unmeasured} unmeasured`);
+  return out.length ? out.join(" + ") : null;
+}
+function loadProfiles(ctx, ids) {
+  const map = /* @__PURE__ */ new Map();
+  for (const r of ctx.store.recipeRequirements(ids)) {
+    let p = map.get(r.recipe_id);
+    if (!p) {
+      p = {
+        id: r.recipe_id,
+        slug: r.slug,
+        title: r.title,
+        required: [],
+        optional: [],
+        staples: [],
+        weight: 0
+      };
+      map.set(r.recipe_id, p);
+    }
+    if (r.staple) p.staples.push(r);
+    else if (r.optional) p.optional.push(r);
+    else {
+      p.required.push(r);
+      p.weight += wasteWeight(r.category);
+    }
+  }
+  return map;
+}
+function resolveSlugs(ctx, slugs) {
+  const ids = [];
+  const unknown = [];
+  for (const s of slugs) {
+    const rec = ctx.store.getRecipe(s);
+    if (rec) ids.push(rec.id);
+    else unknown.push(s);
+  }
+  return { ids, unknown };
+}
+var VARIETY_PENALTY = 0.15;
+var BEAM_WIDTH = 4;
+var BEAM_FANOUT = 12;
+var Planner = class {
+  constructor(ctx, usePantry) {
+    this.ctx = ctx;
+    this.avail = usePantry ? availableIngredients(ctx, {}).ids : /* @__PURE__ */ new Set();
+    this.profiles = loadProfiles(ctx);
+    for (const p of this.profiles.values()) this.bySlug.set(p.slug, p);
+    for (const s of ctx.store.listRecipes({ limit: 1e4 })) this.summaries.set(s.id, s);
+  }
+  ctx;
+  avail;
+  profiles;
+  bySlug = /* @__PURE__ */ new Map();
+  summaries = /* @__PURE__ */ new Map();
+  cache = /* @__PURE__ */ new Map();
+  dishesOf(id) {
+    return this.summaries.get(id)?.tags.dish ?? [];
+  }
+  state(ids) {
+    const s = {
+      profiles: [],
+      buy: /* @__PURE__ */ new Map(),
+      buyIds: /* @__PURE__ */ new Set(),
+      pantryIds: /* @__PURE__ */ new Set(),
+      demand: 0,
+      dishes: /* @__PURE__ */ new Map(),
+      path: []
+    };
+    for (const id of ids) {
+      const p = this.profiles.get(id);
+      if (p) this.add(s, p);
+    }
+    return s;
+  }
+  add(s, p) {
+    s.profiles.push(p);
+    s.demand += p.weight;
+    for (const l of p.required) {
+      if (lineAvailable(this.ctx, l, this.avail, this.cache)) s.pantryIds.add(l.ingredient_id);
+      else if (!s.buy.has(l.ingredient_id)) {
+        s.buy.set(l.ingredient_id, l);
+        s.buyIds.add(l.ingredient_id);
+      }
+    }
+    for (const d of this.dishesOf(p.id)) s.dishes.set(d, (s.dishes.get(d) ?? 0) + 1);
+  }
+  extend(s, p, sug) {
+    const next = {
+      profiles: [...s.profiles],
+      buy: new Map(s.buy),
+      buyIds: new Set(s.buyIds),
+      pantryIds: new Set(s.pantryIds),
+      demand: s.demand,
+      dishes: new Map(s.dishes),
+      path: [...s.path, sug]
+    };
+    this.add(next, p);
+    return next;
+  }
+  evaluate(s, p, variety) {
+    const shares = [];
+    const pantry = [];
+    const fresh = [];
+    for (const l of p.required) {
+      if (lineAvailable(this.ctx, l, this.avail, this.cache)) pantry.push(l);
+      else if (lineAvailable(this.ctx, l, s.buyIds, this.cache)) shares.push(l);
+      else fresh.push(l);
+    }
+    const w = (rows) => rows.reduce((n, r) => n + wasteWeight(r.category), 0);
+    const reuse = p.weight === 0 ? 0 : (w(shares) + w(pantry)) / p.weight;
+    const repeated = this.dishesOf(p.id).filter((d) => s.dishes.has(d));
+    const penalty = variety ? repeated.length * VARIETY_PENALTY : 0;
+    const names = (rows) => [...new Set(rows.map((r) => r.canonical))];
+    return {
+      slug: p.slug,
+      title: p.title,
+      total_min: this.summaries.get(p.id)?.total_min ?? null,
+      reuse: Math.round(reuse * 100) / 100,
+      shares: names(shares),
+      from_pantry: names(pantry),
+      new: names(fresh),
+      new_cost: Math.round(w(fresh) * 10) / 10,
+      repeats: repeated.length ? repeated.join(", ") : void 0,
+      score: reuse - penalty
+    };
+  }
+  rank(s, allowed, variety) {
+    const planned = new Set(s.profiles.map((p) => p.id));
+    const out = [];
+    for (const p of this.profiles.values()) {
+      if (planned.has(p.id) || p.required.length === 0) continue;
+      if (allowed && !allowed.has(p.id)) continue;
+      out.push(this.evaluate(s, p, variety));
+    }
+    return out.sort(
+      (a, b) => b.score - a.score || a.new.length - b.new.length || b.shares.length - a.shares.length || a.title.localeCompare(b.title)
+    );
+  }
+  objective(s, variety) {
+    let repeats = 0;
+    for (const n of s.dishes.values()) if (n > 1) repeats += n - 1;
+    return this.reuse(s) - (variety ? repeats * VARIETY_PENALTY : 0);
+  }
+  reuse(s) {
+    if (s.demand === 0) return 0;
+    let bought = 0;
+    for (const l of s.buy.values()) bought += wasteWeight(l.category);
+    return Math.max(0, 1 - bought / s.demand);
+  }
+  summary(s, servings) {
+    const users = /* @__PURE__ */ new Map();
+    for (const p of s.profiles) {
+      const seen = /* @__PURE__ */ new Set();
+      for (const l of p.required) {
+        if (s.buyIds.has(l.ingredient_id) && !seen.has(l.ingredient_id)) {
+          seen.add(l.ingredient_id);
+          users.set(l.ingredient_id, (users.get(l.ingredient_id) ?? 0) + 1);
+        }
+      }
+    }
+    return {
+      recipes: s.profiles.map((p) => ({
+        slug: p.slug,
+        title: p.title,
+        servings: servings?.get(p.slug) ?? void 0
+      })),
+      to_buy: s.buy.size,
+      from_pantry: s.pantryIds.size,
+      shared: [...users.values()].filter((n) => n >= 2).length,
+      reuse: Math.round(this.reuse(s) * 100) / 100
+    };
+  }
+};
+function planContext(ctx, opts) {
+  const slugs = [...opts.plan ?? getPlan(ctx).items.map((i) => i.slug)];
+  if (opts.seed && !slugs.includes(opts.seed)) slugs.push(opts.seed);
+  const { ids, unknown } = resolveSlugs(ctx, slugs);
+  return { ids, slugs: slugs.filter((s) => !unknown.includes(s)), unknown };
+}
+function suggestRecipes(ctx, opts = {}) {
+  const planner = new Planner(ctx, opts.use_pantry !== false);
+  const { ids, unknown } = planContext(ctx, opts);
+  const state = planner.state(ids);
+  const allowed = ctx.store.filterRecipeIds(expandFilters(ctx, opts.filters));
+  const limit = Math.min(Math.max(opts.limit ?? 10, 1), 50);
+  return {
+    plan: planner.summary(state),
+    suggestions: planner.rank(state, allowed, opts.variety !== false).slice(0, limit),
+    unknown_slugs: unknown
+  };
+}
+function autofillPlan(ctx, opts) {
+  const planner = new Planner(ctx, opts.use_pantry !== false);
+  const { ids, slugs, unknown } = planContext(ctx, opts);
+  const allowed = ctx.store.filterRecipeIds(expandFilters(ctx, opts.filters));
+  const variety = opts.variety !== false;
+  const width = Math.min(Math.max(opts.beam ?? BEAM_WIDTH, 1), 10);
+  const count = Math.min(Math.max(opts.count, 0), 14);
+  let beam = [planner.state(ids)];
+  for (let step = 0; step < count; step++) {
+    const next = /* @__PURE__ */ new Map();
+    for (const s of beam) {
+      for (const sug of planner.rank(s, allowed, variety).slice(0, BEAM_FANOUT)) {
+        const p = planner.bySlug.get(sug.slug);
+        if (!p) continue;
+        const ns = planner.extend(s, p, sug);
+        const key = ns.profiles.map((x) => x.id).sort((a, b) => a - b).join(",");
+        if (!next.has(key)) next.set(key, ns);
+      }
+    }
+    if (next.size === 0) break;
+    beam = [...next.values()].sort(
+      (a, b) => planner.objective(b, variety) - planner.objective(a, variety) || a.buy.size - b.buy.size
+    ).slice(0, width);
+  }
+  const best = beam[0] ?? planner.state(ids);
+  return {
+    plan: planner.summary(best),
+    slugs: [...slugs, ...best.path.map((s) => s.slug)],
+    added: best.path,
+    unknown_slugs: unknown
+  };
+}
+function shoppingList(ctx, opts = {}) {
+  const stored = getPlan(ctx);
+  const items = opts.items ?? stored.items;
+  const removed = opts.out_of?.length ? removeFromPantry(ctx, opts.out_of).removed : [];
+  let confirmed = new Set(stored.confirmed);
+  for (const c of opts.confirmed ?? []) confirmed.add(c);
+  for (const r of removed) confirmed.delete(r);
+  if (opts.confirmed?.length || removed.length) {
+    confirmed = new Set(
+      savePlan(ctx, { items: opts.items ? stored.items : items, confirmed: [...confirmed] }).confirmed
+    );
+  }
+  const planner = new Planner(ctx, true);
+  const { ids, unknown } = resolveSlugs(
+    ctx,
+    items.map((i) => i.slug)
+  );
+  const state = planner.state(ids);
+  const wanted = new Map(items.map((i) => [i.slug, i.servings]));
+  const pantryQty = new Map(
+    ctx.store.pantryList().map((p) => [
+      p.ingredient_id,
+      p.qty !== null ? `${fmtNumber(p.qty)}${p.unit ? ` ${p.unit}` : ""}` : null
+    ])
+  );
+  const buy = /* @__PURE__ */ new Map();
+  const pantry = /* @__PURE__ */ new Map();
+  const optional = /* @__PURE__ */ new Map();
+  const staples = /* @__PURE__ */ new Set();
+  const recipes = [];
+  const cache = /* @__PURE__ */ new Map();
+  const put = (map, l, scale, title) => {
+    let b = map.get(l.ingredient_id);
+    if (!b) {
+      b = {
+        canonical: l.canonical,
+        category: l.category,
+        amounts: [],
+        unmeasured: 0,
+        for: /* @__PURE__ */ new Set()
+      };
+      map.set(l.ingredient_id, b);
+    }
+    const a = toAmount(l.qty, l.unit, scale);
+    if (a) b.amounts.push(a);
+    else b.unmeasured++;
+    b.for.add(title);
+  };
+  for (const p of state.profiles) {
+    const base = planner.summaries.get(p.id)?.servings ?? null;
+    const want = wanted.get(p.slug) ?? null;
+    const scale = base && want ? want / base : 1;
+    recipes.push({ slug: p.slug, title: p.title, servings: want ?? base, scale });
+    for (const l of p.required) {
+      if (lineAvailable(ctx, l, planner.avail, cache)) put(pantry, l, scale, p.title);
+      else put(buy, l, scale, p.title);
+    }
+    for (const l of p.optional) put(optional, l, scale, p.title);
+    for (const l of p.staples) staples.add(l.canonical);
+  }
+  const line = (b) => ({
+    canonical: b.canonical,
+    amount: formatAmount(b.amounts, b.unmeasured),
+    aisle: aisleOf(b.category),
+    for: [...b.for]
+  });
+  const byAisle = (a, b) => AISLE_ORDER.indexOf(a.aisle) - AISLE_ORDER.indexOf(b.aisle) || a.canonical.localeCompare(b.canonical);
+  const check = [...pantry.entries()].map(([id, b]) => ({
+    canonical: b.canonical,
+    amount: formatAmount(b.amounts, b.unmeasured),
+    for: [...b.for],
+    in_pantry: pantryQty.get(id) ?? null,
+    confirmed: confirmed.has(b.canonical)
+  })).sort((a, b) => a.canonical.localeCompare(b.canonical));
+  return {
+    recipes,
+    buy: [...buy.values()].map(line).sort(byAisle),
+    pantry_check: check,
+    needs_confirmation: check.filter((c) => !c.confirmed).map((c) => c.canonical),
+    optional: [...optional.values()].map(line).sort(byAisle),
+    staples: [...staples].sort(),
+    summary: planner.summary(state, wanted),
+    removed_from_pantry: removed,
+    unknown_slugs: unknown
+  };
+}
+function renderShoppingList(list) {
+  const out = [];
+  out.push(`Shopping list for ${list.recipes.map((r) => r.title).join(", ")}`);
+  let aisle;
+  for (const l of list.buy) {
+    if (l.aisle !== aisle) {
+      aisle = l.aisle;
+      out.push("", `${aisle[0]?.toUpperCase()}${aisle.slice(1)}`);
+    }
+    out.push(`- ${l.canonical}${l.amount ? ` \u2014 ${l.amount}` : ""}`);
+  }
+  if (list.pantry_check.length) {
+    out.push("", "From your pantry (check you have enough)");
+    for (const c of list.pantry_check)
+      out.push(`- ${c.canonical}${c.amount ? ` \u2014 ${c.amount}` : ""}${c.confirmed ? "" : " (?)"}`);
+  }
+  if (list.staples.length) out.push("", `Staples used: ${list.staples.join(", ")}`);
+  return out.join("\n");
+}
+
 // src/web/server.ts
 var MAX_JSON = 1e6;
 var MAX_UPLOAD = 6e7;
@@ -3045,6 +3588,20 @@ async function thumbnail(abs, width) {
   thumbCache.set(key, buf);
   return buf;
 }
+function planView(ctx) {
+  const plan = getPlan(ctx);
+  const ids = plan.items.map((i) => ctx.store.getRecipe(i.slug)?.id).filter((x) => x !== void 0);
+  const summaries = new Map(ctx.store.summariesByIds(ids).map((s) => [s.slug, s]));
+  const { plan: summary } = suggestRecipes(ctx, {
+    plan: plan.items.map((i) => i.slug),
+    limit: 1
+  });
+  return {
+    items: plan.items.map((i) => ({ ...i, recipe: summaries.get(i.slug) ?? null })),
+    confirmed: plan.confirmed,
+    summary
+  };
+}
 function routes(ctx, version) {
   const r = (method, pattern, handler) => ({
     method,
@@ -3056,6 +3613,7 @@ function routes(ctx, version) {
       ...ctx.store.stats(),
       inbox: ctx.store.ingestCounts(),
       pantry: listPantry(ctx).length,
+      plan: getPlan(ctx).items.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",
@@ -3127,6 +3685,31 @@ function routes(ctx, version) {
         filters: filtersFrom(url)
       });
     }),
+    // Meal plan: the saved plan plus its summary, with recipe summaries for the UI.
+    r("GET", /^\/api\/plan$/, () => planView(ctx)),
+    r("PUT", /^\/api\/plan$/, async (req) => {
+      const body = await readJson(req);
+      if (!Array.isArray(body.items)) throw new HttpError(400, "items required");
+      savePlan(ctx, { items: body.items, confirmed: getPlan(ctx).confirmed });
+      return planView(ctx);
+    }),
+    r("GET", /^\/api\/plan\/suggest$/, (_req, url) => {
+      const p = url.searchParams;
+      const common = {
+        seed: p.get("seed") ?? void 0,
+        plan: csv(p.get("plan")),
+        variety: p.get("variety") !== "0",
+        use_pantry: p.get("use_pantry") !== "0",
+        filters: filtersFrom(url)
+      };
+      const auto = num2(p.get("auto"));
+      if (auto) return autofillPlan(ctx, { ...common, count: auto });
+      return suggestRecipes(ctx, { ...common, limit: num2(p.get("limit")) ?? 12 });
+    }),
+    r("POST", /^\/api\/plan\/shopping$/, async (req) => {
+      const body = await readJson(req);
+      return shoppingList(ctx, body);
+    }),
     r(
       "GET",
       /^\/api\/ingredients$/,
@@ -3159,7 +3742,7 @@ function routes(ctx, version) {
       });
       return {
         counts: ctx.store.ingestCounts(),
-        items: items.map((i) => ({ ...viewItem(i, all), path: i.path }))
+        items: viewItems(items, all).map((v, n) => ({ ...v, path: items[n]?.path ?? "" }))
       };
     }),
     r("POST", /^\/api\/inbox\/upload$/, async (req) => {
@@ -3170,6 +3753,13 @@ function routes(ctx, version) {
       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 ?? "")) {
@@ -3323,8 +3913,9 @@ export {
   imageForModel,
   maybeScanInbox,
   importPaths,
-  viewItem,
+  viewItems,
   nextBatch,
+  rotateItem,
   resolveItems,
   planAttach,
   finalizeAttach,
@@ -3336,6 +3927,12 @@ export {
   availableIngredients,
   scoreRecipes,
   matchRecipes,
+  getPlan,
+  savePlan,
+  suggestRecipes,
+  autofillPlan,
+  shoppingList,
+  renderShoppingList,
   startUiServer
 };
-//# sourceMappingURL=chunk-2EMC6TJB.js.map
+//# sourceMappingURL=chunk-IUQQ3I2E.js.map