[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8,"_9":10},"actionData","errors","root",{"_564":565,"_566":567},"routes/_app.x.$handle.$name",{"_11":12,"_13":14,"_15":-7,"_18":19,"_17":-7,"_425":-5,"_20":426,"_22":427,"_428":429,"_430":431,"_26":432,"_24":433,"_434":-5,"_435":-5,"_436":61,"_437":438,"_439":58,"_440":-5,"_441":-5,"_442":443},"routes/_app.x.$handle.$name.code.$",{"_11":12,"_13":14,"_15":16,"_17":-7,"_18":19,"_20":21,"_22":23,"_24":25,"_26":27,"_28":-5,"_29":-5,"_30":-5,"_31":-5,"_32":-5},"handle","wakawaka1","name","mealplanner","branchName","main","version","path","main.http.ts","project",{"_33":370,"_13":14,"_45":371,"_372":-5,"_373":61,"_374":375,"_376":375,"_377":378,"_379":-5,"_380":381,"_382":38,"_383":58,"_384":-5,"_385":-5,"_386":70,"_387":388,"_389":-5,"_390":-5,"_391":-5,"_392":-5,"_393":394,"_395":394,"_396":397,"_398":397,"_399":397,"_400":394,"_401":394,"_402":403,"_404":405,"_406":407,"_408":61},"tree",[51,52,53,54,55,56],"file",{"_33":34,"_35":36,"_37":38,"_13":19,"_39":40,"_41":42,"_17":43,"_44":-5,"_45":46,"_47":48,"_49":-5,"_18":50},"contents",[],"upstream","pull","ahead","behind","envVars","id","7574d6b4-8cd2-4ac0-a28d-1fd26f44a175","branchId","1292f370-aeda-42ab-9f99-660cd13fe90d","fileId","ebb4a234-a45a-11f1-9160-1607ee4eb77e","content","/** Meal planner — Val Town HTTP val.\n *\n * Storage: SQLite for anything mutable (Val Town's docs are explicit that blob\n * is not concurrency safe), blob for the catalog, which is large and rewritten\n * wholesale rather than edited.\n *\n * The Anthropic key stays here. It is never sent to the browser.\n */\nimport { sqlite } from 'https://esm.town/v/std/sqlite';\nimport { blob } from 'https://esm.town/v/std/blob/main.ts';\n\nimport { Store, KEYS } from './src/store.mjs';\nimport { indexCatalog } from './src/catalog.mjs';\nimport { AnthropicModel } from './src/model.mjs';\nimport { generatePlan } from './src/generate.mjs';\nimport { validatePlan } from './src/validate.mjs';\nimport { buildShoppingList } from './src/shopping.mjs';\nimport {\n setMealStatus, adherence, returnToStock, surplusToStock, mergeStock,\n ageStock, useFirst, wasteReport, pruneStock,\n} from './src/reconcile.mjs';\nimport { storeTurn, QUICK_CHIPS } from './src/storemode.mjs';\nimport { parseCatalogCSV, catalogToCSV } from './src/csv.mjs';\nimport { selectCandidates, buildRepairPrompt } from './src/prompts.mjs';\nimport { parseJSON, sanitiseMeals } from './src/model.mjs';\nimport { trackerExport, trackerCSV } from './src/export.mjs';\nimport { readLabel, sanitiseLabel, applyLabels, captureQueue } from './src/labels.mjs';\nimport { sanitiseRecipe, buildRecipeParsePrompt, FREQUENCIES } from './src/recipes.mjs';\nimport { verifyMealPhoto, proofCard, claimableMeals } from './src/mealproof.mjs';\nimport { mergeCatalog } from './src/catalog-merge.mjs';\nimport { buildReceiptPrompt, sanitiseReceipt, readReceipt } from './src/receipt.mjs';\nimport { summarisePlan, reusePlan } from './src/plansummary.mjs';\nimport { resolveRoutine, dailyMacros } from './src/supplements.mjs';\nimport { solveGrams } from './src/solver.mjs';\nimport { describeAmount, describePurchase } from './src/units.mjs';\nimport { CLIENT_HTML, APP_JS, CSS } from './client/index.ts';\n\n/* ── driver ─────────────────────────────────────────────────────────────── */\n\nconst driver = {\n async run(sql, params = []) {\n const r = await sqlite.execute({ sql, args: params });\n return { changes: Number(r.rowsAffected ?? 0) };\n },\n async all(sql, params = []) {\n const r = await sqlite.execute({ sql, args: params });\n return r.rows.map((row) => Object.fromEntries(r.columns.map((c, i) => [c, row[i]])));\n },\n};\n\nconst store = new Store(driver);\nlet ready = null;\nconst init = () => (ready ??= store.init());\n\n/* ── catalog ────────────────────────────────────────────────────────────── */\n\nconst catalogCache = new Map();\n\nasync function loadCatalog(storeCode) {\n const cached = catalogCache.get(storeCode);\n if (cached) return cached;\n const file = await blob.getJSON(`mp_catalog_${storeCode}`);\n if (!file) throw new HttpError(503, `No catalog for \"${storeCode}\". Upload it with PUT /api/catalog/${storeCode}.`);\n // Photographed panels overlay the shipped estimates. Applied at load so a\n // catalog refresh can never overwrite a number read off a real packet.\n const byId = applyLabels(indexCatalog(file), await store.listLabels());\n const indexed = { file, byId };\n catalogCache.set(storeCode, indexed);\n return indexed;\n}\n\n/** Any write that changes nutrition or the catalog must drop the cache. */\nconst invalidateCatalog = () => catalogCache.clear();\n\nconst TZ = Deno.env.get('TZ') || 'Pacific/Auckland';\n\n/* ── access ─────────────────────────────────────────────────────────────────\n * Free-tier vals are public, so the PIN is what keeps this private — and what\n * stops a stranger spending the API key. Same arrangement as Vouch.\n * Set MP_PIN in the val's environment variables.\n */\nconst PIN = Deno.env.get('MP_PIN') || '';\nconst COOKIE = 'mp_auth';\n\n/** Constant-time-ish compare, so the PIN can't be guessed a character at a time. */\nfunction pinMatches(given: string): boolean {\n if (!PIN || given.length !== PIN.length) return false;\n let diff = 0;\n for (let i = 0; i < PIN.length; i++) diff |= given.charCodeAt(i) ^ PIN.charCodeAt(i);\n return diff === 0;\n}\n\nconst authed = (req: Request) =>\n !PIN || (req.headers.get('cookie') || '').split(';')\n .map((c) => c.trim()).some((c) => c === `${COOKIE}=${PIN}`);\nconst CATALOG_STALE_DAYS = 7;\nconst catalogAgeDays = (file) => Math.floor((Date.now() - file.builtAt) / 86400000);\n\n/* ── helpers ────────────────────────────────────────────────────────────── */\n\nclass HttpError extends Error {\n constructor(status, message) { super(message); this.status = status; }\n}\n\nconst json = (body, status = 200) =>\n new Response(JSON.stringify(body), {\n status,\n headers: { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' },\n });\n\nasync function body(req) {\n try { return await req.json(); } catch { throw new HttpError(400, 'Expected a JSON body'); }\n}\n\nconst DEFAULT_SETTINGS = {\n targets: { kcal: 2400, protein: 180, carbs: 240, fat: 80 },\n restrictions: '', dislikes: '', dislikedItemIds: [],\n mustInclude: '', philosophy: 'max variety, gut-friendly',\n store: 'pns', storeBranch: { pns: null, ww: null },\n slotsPerDay: ['breakfast', 'lunch', 'dinner', 'snack'],\n effortCeiling: 'moderate', equipment: ['oven'], varietyStrictness: 'normal',\n macroStrictness: 'normal',\n supplements: [], wantedItemIds: [],\n};\n\nconst getSettings = async () => {\n const { value, rev } = await store.getDoc(KEYS.settings);\n return { settings: { ...DEFAULT_SETTINGS, ...(value ?? {}) }, rev };\n};\n\n/* ── routes ─────────────────────────────────────────────────────────────── */\n\nexport default async function (req: Request): Promise {\n await init();\n const url = new URL(req.url);\n const path = url.pathname;\n\n try {\n // Unlock. The PIN never appears in a URL, so it can't end up in a log or a\n // browser history entry.\n if (req.method === 'POST' && path === '/api/auth') {\n const { pin } = await body(req);\n if (!pinMatches(String(pin ?? ''))) {\n // A slow answer costs a guesser far more than it costs you.\n await new Promise((r) => setTimeout(r, 700));\n return json({ error: 'Wrong PIN' }, 401);\n }\n return new Response(JSON.stringify({ ok: true }), {\n headers: {\n 'content-type': 'application/json',\n 'set-cookie': `${COOKIE}=${PIN}; Path=/; Max-Age=31536000; HttpOnly; Secure; SameSite=Lax`,\n },\n });\n }\n\n if (req.method === 'GET' && path === '/api/auth') {\n return json({ required: !!PIN, authed: authed(req) });\n }\n\n if (path.startsWith('/api/') && !authed(req)) {\n return json({ error: 'Locked' }, 401);\n }\n\n if (req.method === 'GET' && path === '/app.js') {\n return new Response(APP_JS, {\n headers: { 'content-type': 'text/javascript; charset=utf-8', 'cache-control': 'no-cache' },\n });\n }\n\n if (req.method === 'GET' && path === '/app.css') {\n return new Response(CSS, {\n headers: { 'content-type': 'text/css; charset=utf-8', 'cache-control': 'no-cache' },\n });\n }\n\n if (req.method === 'GET' && path === '/') {\n return new Response(CLIENT_HTML, { headers: { 'content-type': 'text/html; charset=utf-8' } });\n }\n\n /* current state — one call, so the app opens in one round trip */\n if (req.method === 'GET' && path === '/api/state') {\n const { settings, rev } = await getSettings();\n const planDoc = await store.getDoc(KEYS.currentPlan);\n const plan = await store.hydratePlan(planDoc.value);\n const stock = await store.listStock();\n\n let catalogAge = null;\n try { catalogAge = catalogAgeDays((await loadCatalog(settings.store)).file); } catch { /* not uploaded yet */ }\n\n let items = {};\n let view = plan;\n if (plan) {\n const { byId } = await loadCatalog(plan.store ?? settings.store);\n const used = new Set();\n for (const m of plan.meals) for (const c of m.components) used.add(c.itemId);\n for (const l of plan.shopping ?? []) { used.add(l.primaryItemId); for (const c of l.candidates ?? []) used.add(c.itemId ?? c); }\n for (const e of stock) used.add(e.itemId);\n items = Object.fromEntries([...used].filter((id) => byId[id]).map((id) => {\n const it = byId[id];\n return [id, {\n name: it.name, aisle: it.aisle, packSize: it.packSize, packUnit: it.packUnit,\n unitGrams: it.unitGrams ?? null,\n price: it.price, shelfLifeDays: it.shelfLifeDays, freezable: it.freezable,\n staple: it.staple, carryForward: it.carryForward, estimated: it.per100Source === 'estimate',\n }];\n }));\n\n // A batch is cooked ONCE. Storing it as N identical per-serving meals is\n // right for the macros and wrong for a person: it asked you to chop 38g\n // of onion four times instead of one onion once. The cook day carries\n // the whole pot; the others are portions out of the fridge.\n const batches = new Map();\n for (const m of plan.meals) {\n if (!m.batchGroup) continue;\n const b = batches.get(m.batchGroup) ?? { portions: 0, cookDay: Infinity, name: m.name };\n b.portions += 1;\n b.cookDay = Math.min(b.cookDay, m.day);\n batches.set(m.batchGroup, b);\n }\n\n view = {\n ...plan,\n meals: plan.meals.map((m) => {\n const b = m.batchGroup ? batches.get(m.batchGroup) : null;\n const cooking = !!b && m.day === b.cookDay;\n const scale = cooking ? b.portions : 1;\n return {\n ...m,\n batch: b ? { portions: b.portions, cookDay: b.cookDay, cooking } : null,\n components: m.components.map((c) => ({\n ...c,\n // What to put in the pot, at the scale you are actually cooking.\n display: describeAmount(byId[c.itemId], c.grams * scale, c.role),\n })),\n };\n }),\n shopping: (plan.shopping ?? []).map((l) => ({\n ...l, buy: describePurchase(byId[l.primaryItemId], l),\n })),\n };\n }\n\n return json({\n settings, settingsRev: rev,\n plan: view, planRev: planDoc.rev,\n adherence: plan ? adherence(plan) : null,\n stock: ageStock(stock),\n items,\n catalog: {\n store: settings.store,\n ageDays: catalogAge,\n stale: catalogAge != null && catalogAge > CATALOG_STALE_DAYS,\n },\n });\n }\n\n if (req.method === 'PUT' && path === '/api/settings') {\n const { settings, rev } = await body(req);\n const res = await store.putDoc(KEYS.settings, settings, rev ?? 0);\n if (!res.ok) return json({ error: 'Settings changed elsewhere', current: res.current }, 409);\n return json({ ok: true, rev: res.rev });\n }\n\n /* generate a plan — streamed, because it takes 30-90s and a fake\n spinner would be a lie about what's happening (§10) */\n if (req.method === 'POST' && path === '/api/plan') {\n const { days = 3, bought = null } = await body(req);\n if (!(days >= 2 && days <= 7)) throw new HttpError(400, 'days must be between 2 and 7');\n if (bought !== null && bought !== 'yes' && bought !== 'no') {\n throw new HttpError(400, \"bought must be 'yes', 'no' or omitted\");\n }\n\n const { settings } = await getSettings();\n const { byId } = await loadCatalog(settings.store);\n\n // Replacing a plan you already shopped for is different from replacing\n // one you never bought. Answering \"yes\" books that food into stock first,\n // so the new plan is built to eat it rather than to buy it twice. This\n // has to happen BEFORE stock is read below, or the plan is generated\n // against the fridge as it was a moment ago.\n let carried: number | null = null;\n if (bought === 'yes') {\n const doc = await store.getDoc(KEYS.currentPlan);\n const previous = await store.hydratePlan(doc.value);\n if (previous && !previous.shoppedAt) {\n const now = Date.now();\n const { byId: prevCatalog } = await loadCatalog(previous.store ?? settings.store);\n const next = mergeStock([\n ...pruneStock(await store.listStock(), { now }),\n ...surplusToStock({ lines: previous.shopping ?? [] }, prevCatalog, { shoppedOn: now }),\n ...returnToStock(previous, prevCatalog, { shoppedOn: previous.createdAt ?? now }),\n ]);\n await store.replaceStock(next);\n await store.updateDoc(KEYS.currentPlan, (p) => ({ ...p, shoppedAt: now }));\n carried = next.length;\n }\n }\n\n const stock = await store.listStock();\n const pantry = (await store.getDoc(KEYS.pantry)).value ?? {};\n const favourites = new Set((await store.getDoc(KEYS.favourites)).value ?? []);\n\n const stream = new ReadableStream({\n async start(controller) {\n const send = (obj) => controller.enqueue(new TextEncoder().encode(JSON.stringify(obj) + '\\n'));\n\n // A single phase can run for a minute, and a response that goes quiet\n // for ~10s is closed by the platform mid-generation. The isolate is\n // then torn down, so the plan is lost before it is ever saved. Keep\n // the connection warm; the client ignores frames it doesn't know.\n const beat = setInterval(() => {\n try { send({ type: 'ping', t: Date.now() }); } catch { /* already closed */ }\n }, 5000);\n\n try {\n const result = await generatePlan({\n model: new AnthropicModel({ apiKey: Deno.env.get('ANTHROPIC_API_KEY') }),\n catalog: byId, settings, days, favourites, pantry, stock,\n recipes: await store.listRecipes(),\n onPhase: (phase, { round }) => send({ type: 'phase', phase, round }),\n });\n\n const current = await store.getDoc(KEYS.currentPlan);\n if (current.value) {\n const archived = await store.hydratePlan(current.value);\n await store.updateDoc(KEYS.history, (h) => [...(h ?? []).slice(-19), { ...archived, archivedAt: Date.now() }]);\n }\n await store.putDoc(KEYS.currentPlan, {\n ...result.plan,\n storeBranch: settings.storeBranch?.[settings.store] ?? null,\n }, current.rev);\n\n send({\n type: 'done', plan: result.plan, usable: result.usable, banner: result.banner,\n log: result.log, rejected: result.rejected, useFirst: result.useFirst, waste: result.waste,\n carriedStock: carried,\n });\n } catch (err) {\n try { send({ type: 'error', error: err.message }); } catch { /* client gone */ }\n } finally {\n clearInterval(beat);\n controller.close();\n }\n },\n });\n\n return new Response(stream, {\n headers: { 'content-type': 'application/x-ndjson; charset=utf-8', 'cache-control': 'no-store' },\n });\n }\n\n /* Cook a saved plan again. The whole point is that this costs nothing:\n generating a plan is several minutes and a handful of model calls, and\n a week you already liked is worth repeating. */\n if (req.method === 'POST' && path === '/api/plan/reuse') {\n const { planId } = await body(req);\n const history = (await store.getDoc(KEYS.history)).value ?? [];\n const source = history.find((p) => p.id === planId);\n if (!source) throw new HttpError(404, `No saved plan \"${planId}\"`);\n\n // The plan being replaced is archived exactly as generating a new one\n // would archive it, so nothing is lost by reusing rather than rebuilding.\n const current = await store.getDoc(KEYS.currentPlan);\n if (current.value) {\n const archived = await store.hydratePlan(current.value);\n await store.updateDoc(KEYS.history, (hh) => [\n ...(hh ?? []).slice(-19), { ...archived, archivedAt: Date.now() },\n ]);\n }\n\n const fresh = reusePlan(source);\n const res = await store.putDoc(KEYS.currentPlan, fresh, current.rev);\n if (!res.ok) throw new HttpError(409, 'The plan changed while this one was being loaded. Try again.');\n return json({ ok: true, plan: { id: fresh.id, days: fresh.days, reusedFrom: fresh.reusedFrom } });\n }\n\n /* clear the current plan — archived to history, never destroyed, so the\n meals you already recorded against it are not lost with it */\n if (req.method === 'DELETE' && path === '/api/plan') {\n const current = await store.getDoc(KEYS.currentPlan);\n if (!current.value) return json({ ok: true, cleared: false });\n\n const archived = await store.hydratePlan(current.value);\n await store.updateDoc(KEYS.history, (hh) => [\n ...(hh ?? []).slice(-19), { ...archived, archivedAt: Date.now() },\n ]);\n const res = await store.putDoc(KEYS.currentPlan, null, current.rev);\n if (!res.ok) throw new HttpError(409, 'The plan changed while it was being cleared. Try again.');\n\n return json({ ok: true, cleared: true, archivedId: archived?.id ?? null });\n }\n\n /* mark a meal — the write most likely to happen from a phone, mid-aisle */\n if (req.method === 'POST' && path === '/api/meal-status') {\n const { planId, mealId, status, note = null } = await body(req);\n if (!planId || !mealId) throw new HttpError(400, 'planId and mealId are required');\n\n // A photo-verified meal was cooked. Letting it be marked skipped would\n // leave two records contradicting each other — and would hand its\n // ingredients back to the fridge as though they were still raw.\n if (status && status !== 'ate') {\n const proven = (await store.listProofs(planId)).find((p) => p.mealId === mealId && p.verdict === 'pass');\n if (proven) {\n return json({\n error: `You verified a photo of ${proven.mealName}, so it can't be marked \"${status}\". `\n + 'Clear the verification first if that was wrong.',\n mealId, verified: true,\n }, 409);\n }\n }\n\n if (status === null) await store.clearMealStatus(planId, mealId);\n else await store.setMealStatus(planId, mealId, status, { note });\n\n const plan = await store.hydratePlan((await store.getDoc(KEYS.currentPlan)).value);\n return json({ ok: true, adherence: plan ? adherence(plan) : null });\n }\n\n /* finish the shop: commit surplus and anything the plan didn't consume */\n if (req.method === 'POST' && path === '/api/shop-complete') {\n const doc = await store.getDoc(KEYS.currentPlan);\n const plan = await store.hydratePlan(doc.value);\n if (!plan) throw new HttpError(400, 'No current plan');\n\n const { byId } = await loadCatalog(plan.store);\n const shopping = { lines: plan.shopping ?? [] };\n const now = Date.now();\n\n const next = mergeStock([\n ...pruneStock(await store.listStock(), { now }),\n ...surplusToStock(shopping, byId, { shoppedOn: now }),\n ...returnToStock(plan, byId, { shoppedOn: plan.createdAt ?? now }),\n ]);\n await store.replaceStock(next);\n\n await store.updateDoc(KEYS.currentPlan, (p) => ({ ...p, shoppedAt: now }));\n return json({ ok: true, stock: ageStock(next, { now }), waste: wasteReport(next, byId, { now }) });\n }\n\n /* Throw something out. Stock could only ever be added — by a shop, a\n receipt or a returned meal — so a mis-read receipt line or a bag that\n actually went in the bin had no way out, and the next plan would keep\n building around food that isn't there. */\n /* How much of what you bought is actually left.\n *\n * The receipt records what came home; it cannot know that the soy sauce is\n * barely touched and the spinach is gone. Nobody is going to weigh a jar,\n * so this asks the only question a person can answer standing at the fridge\n * — roughly how much is left — and moves the ledger to match. What you\n * bought instead of what the plan said is fine and stays as it is: this\n * never touches a recipe, a price or a nutrition figure.\n */\n if (req.method === 'POST' && path === '/api/stock/review') {\n const { reviews } = await body(req);\n if (!Array.isArray(reviews) || !reviews.length) throw new HttpError(400, 'Expected { reviews: [...] }');\n\n const LEVELS = { gone: 0, some: 0.25, most: 0.7, all: 1 };\n const current = await store.listStock();\n const byId = new Map(current.map((e) => [String(e.id), e]));\n\n for (const r of reviews) {\n if (!(r?.level in LEVELS)) throw new HttpError(400, `level must be one of ${Object.keys(LEVELS).join(', ')}`);\n if (!byId.has(String(r?.id))) throw new HttpError(404, `No stock entry \"${r?.id}\"`);\n }\n\n const next = [];\n let emptied = 0;\n for (const e of current) {\n const r = reviews.find((x) => String(x.id) === String(e.id));\n if (!r) { next.push(e); continue; }\n const keep = LEVELS[r.level];\n if (keep === 0) { emptied++; continue; }\n // Rounded because the answer was \"about half\" — storing 137.4g would be\n // false precision dressed up as measurement.\n next.push({ ...e, grams: Math.max(1, Math.round((e.grams * keep) / 5) * 5), reviewedAt: Date.now() });\n }\n\n await store.replaceStock(next);\n return json({\n ok: true, reviewed: reviews.length, emptied,\n stock: ageStock(next, { now: Date.now() }),\n });\n }\n\n if (req.method === 'DELETE' && path.startsWith('/api/stock/')) {\n const id = decodeURIComponent(path.split('/').pop() ?? '');\n const current = await store.listStock();\n const next = current.filter((e) => String(e.id) !== id);\n if (next.length === current.length) throw new HttpError(404, `No stock entry \"${id}\"`);\n await store.replaceStock(next);\n return json({ ok: true, removed: id, stock: ageStock(next, { now: Date.now() }) });\n }\n\n /* what the next plan will be forced to use up */\n if (req.method === 'GET' && path === '/api/use-first') {\n const { settings } = await getSettings();\n const { byId } = await loadCatalog(settings.store);\n const stock = await store.listStock();\n return json({ useFirst: useFirst(stock, byId, { withinDays: 7 }) });\n }\n\n /* re-price / re-check the current plan without regenerating it */\n if (req.method === 'POST' && path === '/api/revalidate') {\n const doc = await store.getDoc(KEYS.currentPlan);\n const plan = await store.hydratePlan(doc.value);\n if (!plan) throw new HttpError(400, 'No current plan');\n const { settings } = await getSettings();\n const { byId } = await loadCatalog(plan.store);\n const r = validatePlan(plan, byId, settings);\n const shopping = buildShoppingList(r.plan, byId, {\n store: plan.store, stock: await store.listStock(),\n });\n return json({\n validation: { pass: r.pass, failures: r.failures, notes: r.notes },\n totals: r.plan.totals, shopping: shopping.lines, estCost: shopping.estCost,\n });\n }\n\n /* catalog upload — the escape hatch when scraping breaks */\n if (req.method === 'PUT' && path.startsWith('/api/catalog/')) {\n const code = path.split('/').pop();\n const file = await body(req);\n if (!Array.isArray(file?.items)) throw new HttpError(400, 'Expected { items: [...] }');\n await blob.setJSON(`mp_catalog_${code}`, file);\n invalidateCatalog();\n return json({ ok: true, store: code, items: file.items.length });\n }\n\n // Where price rows come from. Nothing scrapes yet, so this is empty —\n // point it at a scraper val, a cron job, or anything that can produce the\n // row shape in SCRAPER.md.\n if (req.method === 'GET' && path === '/api/catalog-rows') {\n const src = Deno.env.get('PRICE_SOURCE_URL');\n if (!src) return json({ rows: [], source: null });\n const res = await fetch(src, { headers: { accept: 'application/json' } });\n if (!res.ok) throw new HttpError(502, `Price source returned ${res.status}`);\n const data = await res.json();\n return json({ rows: Array.isArray(data) ? data : (data.rows ?? []), source: src });\n }\n\n /* ── refreshing the catalog ──────────────────────────────────────────── */\n\n // Accepts rows from a scraper (or anything else) and MERGES them. It can\n // change price, pack size, name, SKU and aisle; it can never touch role\n // tags, substitute groups, shelf life or the other curated fields the\n // planner is built on. See SCRAPER.md.\n if (req.method === 'POST' && path.startsWith('/api/catalog-refresh/')) {\n const code = path.split('/').pop();\n const { rows, apply = 'safe' } = await body(req);\n if (!Array.isArray(rows)) throw new HttpError(400, 'Expected { rows: [...] }');\n if (!['safe', 'all', 'dry'].includes(apply)) throw new HttpError(400, \"apply must be safe, all or dry\");\n\n const file = await blob.getJSON(`mp_catalog_${code}`);\n if (!file) throw new HttpError(400, `No catalog for \"${code}\" to refresh`);\n\n const { items, report } = mergeCatalog(file.items, rows, {\n labels: await store.listLabels(), apply,\n });\n\n if (apply !== 'dry') {\n await blob.setJSON(`mp_catalog_${code}`, { ...file, items, builtAt: Date.now(), itemCount: items.length });\n invalidateCatalog();\n }\n return json({ ok: true, store: code, ...report });\n }\n\n // The other half of the CSV round trip. catalogToCSV has existed since the\n // first build but was never wired to a route, so prices could be imported\n // and never exported. Every column parseCatalogCSV requires is emitted,\n // curated fields included, so a download-edit-upload cycle is lossless.\n if (req.method === 'GET' && path.startsWith('/api/catalog-csv/')) {\n const code = path.split('/').pop();\n const { file } = await loadCatalog(code);\n return new Response(catalogToCSV(file.items), {\n headers: {\n 'content-type': 'text/csv; charset=utf-8',\n 'content-disposition': `attachment; filename=\"catalog-${code}.csv\"`,\n },\n });\n }\n // CSV import — the permanent escape hatch for when scraping breaks (§7).\n if (req.method === 'POST' && path.startsWith('/api/catalog-csv/')) {\n const code = path.split('/').pop();\n const csv = await req.text();\n const { items, errors } = parseCatalogCSV(csv, code);\n if (!items.length) return json({ error: 'No usable rows', errors }, 400);\n await blob.setJSON(`mp_catalog_${code}`, { store: code, builtAt: Date.now(), itemCount: items.length, items });\n invalidateCatalog();\n return json({ ok: true, store: code, items: items.length, errors });\n }\n\n if (req.method === 'GET' && path.startsWith('/api/catalog/')) {\n const { file } = await loadCatalog(path.split('/').pop());\n return json({ ...file, ageDays: catalogAgeDays(file), stale: catalogAgeDays(file) > CATALOG_STALE_DAYS });\n }\n\n if (req.method === 'GET' && path === '/api/catalog-search') {\n const { settings } = await getSettings();\n const { byId } = await loadCatalog(settings.store);\n const q = (url.searchParams.get('q') || '').toLowerCase().trim();\n const tag = url.searchParams.get('tag');\n const supplements = url.searchParams.get('supplements') === '1';\n\n const hits = Object.values(byId)\n .filter((it) => !!it.supplement === supplements)\n .filter((it) => (tag ? (it.tags ?? []).includes(tag) : true))\n .filter((it) => (q ? `${it.name} ${it.substituteGroup} ${it.category}`.toLowerCase().includes(q) : true))\n .slice(0, 60)\n .map((it) => ({\n id: it.id, name: it.name, aisle: it.aisle, tags: it.tags ?? [],\n packSize: it.packSize, packUnit: it.packUnit, price: it.price,\n dailyDose: it.dailyDose, kcal: Math.round(it.per100?.kcal ?? 0),\n protein: it.per100?.protein ?? 0,\n }));\n return json({ items: hits });\n }\n\n /* store mode (§9) — one turn, then recompute and revalidate */\n if (req.method === 'POST' && path === '/api/chat') {\n const { itemId, message } = await body(req);\n const doc = await store.getDoc(KEYS.currentPlan);\n const plan = await store.hydratePlan(doc.value);\n if (!plan) throw new HttpError(400, 'No current plan');\n if (!itemId) throw new HttpError(400, 'itemId is required — store mode is always about one item');\n\n const { settings } = await getSettings();\n const { byId } = await loadCatalog(plan.store);\n\n const turn = await storeTurn({\n model: new AnthropicModel({ apiKey: Deno.env.get('ANTHROPIC_API_KEY') }),\n plan, catalog: byId, settings, itemId, message: message ?? \"can't find it\",\n store: plan.store, stock: await store.listStock(),\n });\n\n // Only persist when something actually changed, and only against the\n // revision we read — an aisle swap must not clobber a regenerate.\n if (turn.applied) {\n const res = await store.putDoc(KEYS.currentPlan, turn.plan, doc.rev);\n if (!res.ok) return json({ error: 'The plan changed while you were shopping — reload and try again.' }, 409);\n }\n\n return json({\n reply: turn.reply, action: turn.action, applied: turn.applied,\n blocked: turn.blocked, impact: turn.impact ?? [], equivalent: turn.equivalent ?? null,\n plan: turn.applied ? turn.plan : null,\n });\n }\n\n if (req.method === 'GET' && path === '/api/chips') return json({ chips: QUICK_CHIPS });\n\n /* ── proof of a cooked meal (for Vouch) ──────────────────────────────── */\n\n // Which meals can still be claimed. One pass per planned meal, so the same\n // dinner can't be photographed twice for two points.\n if (req.method === 'GET' && path === '/api/proof') {\n const plan = await store.hydratePlan((await store.getDoc(KEYS.currentPlan)).value);\n const proofs = plan ? await store.listProofs(plan.id) : [];\n return json({\n meals: claimableMeals(plan, proofs),\n proofs,\n card: proofCard(await store.latestProof(), { timeZone: TZ }),\n });\n }\n\n // Clearing a verification releases the meal — it can be photographed\n // again, and its status is no longer pinned to \"ate\".\n if (req.method === 'DELETE' && path.startsWith('/api/proof/')) {\n const mealId = path.split('/').pop();\n const plan = await store.hydratePlan((await store.getDoc(KEYS.currentPlan)).value);\n if (!plan) throw new HttpError(400, 'No current plan');\n await store.deleteProof(plan.id, mealId);\n await store.clearMealStatus(plan.id, mealId);\n return json({ ok: true, card: proofCard(await store.latestProof(), { timeZone: TZ }) });\n }\n\n if (req.method === 'POST' && path === '/api/proof/verify') {\n const { mealId, imageBase64, mediaType } = await body(req);\n if (!mealId || !imageBase64) throw new HttpError(400, 'mealId and imageBase64 are required');\n\n const doc = await store.getDoc(KEYS.currentPlan);\n const plan = await store.hydratePlan(doc.value);\n if (!plan) throw new HttpError(400, 'No current plan');\n const meal = plan.meals.find((m) => m.id === mealId);\n if (!meal) throw new HttpError(400, `No meal \"${mealId}\" in this plan`);\n\n const already = (await store.listProofs(plan.id)).find((p) => p.mealId === mealId && p.verdict === 'pass');\n if (already) {\n return json({ error: `${meal.name} has already been verified — pick a different meal.`, card: proofCard(already, { timeZone: TZ }) }, 409);\n }\n\n const { byId } = await loadCatalog(plan.store);\n const result = await verifyMealPhoto({\n model: new AnthropicModel({ apiKey: Deno.env.get('ANTHROPIC_API_KEY') }),\n meal, catalog: byId, imageBase64, mediaType, timeZone: TZ,\n });\n\n const proof = { ...result, day: meal.day, slot: meal.slot };\n await store.saveProof(plan.id, proof);\n\n // A verified photo is better evidence than a tap, so it records the meal\n // as eaten too.\n if (proof.verdict === 'pass') await store.setMealStatus(plan.id, mealId, 'ate', { note: 'photo verified' });\n\n return json({ ...proof, card: proofCard(proof, { timeZone: TZ }) });\n }\n\n /* ── your own recipes ────────────────────────────────────────────────── */\n\n if (req.method === 'GET' && path === '/api/recipes') {\n return json({ recipes: await store.listRecipes() });\n }\n\n // Map a pasted recipe onto the catalog. Returns a draft for review — a bad\n // mapping would put wrong numbers into every plan that uses it.\n if (req.method === 'POST' && path === '/api/recipes/parse') {\n const { text } = await body(req);\n if (!text || String(text).trim().length < 10) throw new HttpError(400, 'Paste the recipe first');\n const { settings } = await getSettings();\n const { byId } = await loadCatalog(settings.store);\n const raw = parseJSON(await new AnthropicModel({ apiKey: Deno.env.get('ANTHROPIC_API_KEY') })\n .complete(buildRecipeParsePrompt({\n text, slots: settings.slotsPerDay,\n candidates: selectCandidates(byId, settings),\n })));\n const out = sanitiseRecipe(raw, byId, { slots: settings.slotsPerDay });\n return json({ ...out, recipe: { ...out.recipe, sourceText: String(text).slice(0, 4000) } });\n }\n\n if (req.method === 'PUT' && path === '/api/recipes') {\n const { recipe } = await body(req);\n const { settings } = await getSettings();\n const { byId } = await loadCatalog(settings.store);\n // Hand-edited recipes go through the same checks as a parsed one.\n const checked = sanitiseRecipe(recipe, byId, { slots: settings.slotsPerDay });\n if (!checked.ok) return json({ error: 'That recipe is not usable', problems: checked.problems }, 400);\n const saved = await store.saveRecipe({\n ...checked.recipe, id: recipe.id,\n frequency: recipe.frequency ?? 'every-window',\n use: recipe.use, enabled: recipe.enabled, scalePortions: recipe.scalePortions,\n maxPerWindow: recipe.maxPerWindow, sourceText: recipe.sourceText,\n });\n return json({ ...saved, warnings: checked.warnings });\n }\n\n /* Adjust how a saved recipe is used, without touching what is in it.\n * Deliberately separate from PUT: that re-validates a whole recipe against\n * the catalog, and flipping a toggle should never be able to drop an\n * ingredient or rewrite the steps. */\n if (req.method === 'PATCH' && path.startsWith('/api/recipes/')) {\n const id = decodeURIComponent(path.split('/').pop() ?? '');\n const patch = await body(req);\n const existing = (await store.listRecipes()).find((r) => r.id === id);\n if (!existing) throw new HttpError(404, `No recipe \"${id}\"`);\n\n if (patch.use !== undefined && !Store.USE_MODES.includes(patch.use)) {\n throw new HttpError(400, `use must be one of ${Store.USE_MODES.join(', ')}`);\n }\n if (patch.frequency !== undefined && !FREQUENCIES.includes(patch.frequency)) {\n throw new HttpError(400, `frequency must be one of ${FREQUENCIES.join(', ')}`);\n }\n if (patch.servings !== undefined && !(patch.servings >= 1 && patch.servings <= 12)) {\n throw new HttpError(400, 'servings must be between 1 and 12');\n }\n if (patch.slot !== undefined) {\n const { settings } = await getSettings();\n if (!settings.slotsPerDay.includes(patch.slot)) {\n throw new HttpError(400, 'slot must be one of your meals per day');\n }\n }\n\n const next = {\n ...existing,\n use: patch.use ?? existing.use,\n frequency: patch.frequency ?? existing.frequency,\n servings: patch.servings ?? existing.servings,\n slot: patch.slot ?? existing.slot,\n scalePortions: patch.scalePortions ?? existing.scalePortions,\n maxPerWindow: patch.maxPerWindow === undefined ? existing.maxPerWindow : patch.maxPerWindow,\n };\n await store.saveRecipe(next);\n return json({ ok: true, recipe: next });\n }\n\n if (req.method === 'DELETE' && path.startsWith('/api/recipes/')) {\n await store.deleteRecipe(path.split('/').pop());\n return json({ ok: true });\n }\n\n /* ── label capture ───────────────────────────────────────────────────── */\n\n // Read a photographed panel. Deliberately does NOT save: a vision misread\n // would corrupt every plan using the product, so it comes back for review.\n if (req.method === 'POST' && path === '/api/label/read') {\n const { itemId, imageBase64, mediaType } = await body(req);\n if (!itemId || !imageBase64) throw new HttpError(400, 'itemId and imageBase64 are required');\n const { settings } = await getSettings();\n const { byId } = await loadCatalog(settings.store);\n return json(await readLabel({\n model: new AnthropicModel({ apiKey: Deno.env.get('ANTHROPIC_API_KEY') }),\n itemId, catalog: byId, imageBase64, mediaType,\n }));\n }\n\n /* ── receipts ────────────────────────────────────────────────────────────\n * What you actually carried home, which is the only unguessed record of it.\n * Read and confirm are separate steps: receipt OCR plus name matching is\n * the least reliable input this app takes, so nothing reaches the stock\n * ledger until it has been looked at. Recipes and the catalog are never\n * touched — a receipt is evidence of a purchase, not of what a food is.\n */\n if (req.method === 'POST' && path === '/api/receipt/read') {\n const { imageBase64, mediaType = 'image/jpeg' } = await body(req);\n if (!imageBase64) throw new HttpError(400, 'imageBase64 is required');\n const { settings } = await getSettings();\n const { byId } = await loadCatalog(settings.store);\n\n const raw = parseJSON(await new AnthropicModel({ apiKey: Deno.env.get('ANTHROPIC_API_KEY') })\n .completeVision({ prompt: buildReceiptPrompt(), imageBase64, mediaType }));\n const { rows, dropped } = sanitiseReceipt(raw);\n if (!rows.length) return json({ error: 'No food lines could be read off that photo', dropped: dropped.length }, 400);\n\n return json({ ok: true, ...readReceipt(rows, byId, { now: Date.now() }), unreadable: dropped.length });\n }\n\n /* commit reviewed receipt lines to stock */\n if (req.method === 'POST' && path === '/api/receipt/confirm') {\n const { entries = [] } = await body(req);\n if (!Array.isArray(entries) || !entries.length) throw new HttpError(400, 'Expected { entries: [...] }');\n const { settings } = await getSettings();\n const { byId } = await loadCatalog(settings.store);\n const now = Date.now();\n\n const additions = [];\n for (const e of entries) {\n const item = byId[e?.itemId];\n if (!item) throw new HttpError(400, `Unknown item \"${e?.itemId}\"`);\n const grams = Number(e.grams);\n if (!(grams > 0)) throw new HttpError(400, `grams must be positive for \"${e.itemId}\"`);\n additions.push({\n itemId: item.id, grams: Math.round(grams), unit: item.packUnit,\n goodFrom: now, shelfLifeDays: item.shelfLifeDays, cooked: false,\n source: 'receipt', note: e.note ?? 'from a receipt',\n });\n }\n\n const next = mergeStock([...pruneStock(await store.listStock(), { now }), ...additions]);\n await store.replaceStock(next);\n return json({ ok: true, added: additions.length, stock: ageStock(next, { now }) });\n }\n\n if (req.method === 'POST' && path === '/api/label/confirm') {\n const { itemId, per100, notes } = await body(req);\n const { settings } = await getSettings();\n const { byId } = await loadCatalog(settings.store);\n const item = byId[itemId];\n if (!item) throw new HttpError(400, `Unknown item \"${itemId}\"`);\n\n // Hand-corrected values go through the same checks as a vision read.\n const checked = sanitiseLabel({ readable: true, basis: '100g', per100 }, { item });\n if (!checked.ok) return json({ error: 'Those numbers do not check out', problems: checked.problems }, 400);\n\n await store.saveLabel({\n itemId, per100: checked.per100,\n previous: item.per100Source === 'label' ? null : item.per100,\n notes: notes ?? null,\n });\n invalidateCatalog();\n return json({ ok: true, per100: checked.per100, warnings: checked.warnings });\n }\n\n if (req.method === 'DELETE' && path.startsWith('/api/label/')) {\n await store.deleteLabel(path.split('/').pop());\n invalidateCatalog();\n return json({ ok: true });\n }\n\n if (req.method === 'GET' && path === '/api/labels') {\n const { settings } = await getSettings();\n const { byId } = await loadCatalog(settings.store);\n const plan = await store.hydratePlan((await store.getDoc(KEYS.currentPlan)).value);\n return json({\n captured: (await store.listLabels()).map((c) => ({ ...c, name: byId[c.itemId]?.name ?? c.itemId })),\n queue: captureQueue(plan, byId),\n });\n }\n\n /* ── one meal at a time ──────────────────────────────────────────────── */\n\n /* Re-fit the portions of the plan you already have.\n *\n * Pure arithmetic — no model call, no cost, a second to run. Worth having\n * on its own (targets change, supplements change), and it is the repair for\n * a plan that shipped under its protein floor because a repair round was\n * lost mid-generation. It only moves grams: no meal is swapped, renamed or\n * dropped, so a plan you liked stays the plan you liked.\n */\n if (req.method === 'POST' && path === '/api/plan/refit') {\n const doc = await store.getDoc(KEYS.currentPlan);\n const plan = await store.hydratePlan(doc.value);\n if (!plan) throw new HttpError(400, 'No current plan');\n\n const { settings } = await getSettings();\n const { byId } = await loadCatalog(plan.store ?? settings.store);\n\n // Supplements are counted against the same targets the solver aims at,\n // exactly as generation does it.\n const routine = resolveRoutine(settings.supplements ?? [], byId);\n const supp = dailyMacros(routine, byId);\n const foodTargets = {\n kcal: Math.max(0, settings.targets.kcal - supp.total.kcal),\n protein: Math.max(0, settings.targets.protein - supp.total.protein),\n carbs: Math.max(0, settings.targets.carbs - supp.total.carbs),\n fat: Math.max(0, settings.targets.fat - supp.total.fat),\n };\n const foodSettings = { ...settings, targets: foodTargets };\n\n const before = validatePlan(plan, byId, foodSettings);\n const solved = solveGrams(plan, byId, foodSettings);\n const after = validatePlan(solved.plan, byId, foodSettings);\n\n const shopping = buildShoppingList(after.plan, byId, {\n store: plan.store ?? settings.store, stock: await store.listStock(),\n });\n\n const next = {\n ...after.plan,\n shopping: shopping.lines,\n totals: {\n ...after.plan.totals,\n estCost: shopping.estCost,\n withSupplements: after.plan.totals.perDay.map((t) => ({\n day: t.day,\n kcal: Math.round(t.kcal + supp.total.kcal),\n protein: Math.round(t.protein + supp.total.protein),\n carbs: Math.round(t.carbs + supp.total.carbs),\n fat: Math.round(t.fat + supp.total.fat),\n })),\n },\n validation: {\n pass: after.pass, rounds: plan.validation?.rounds ?? 0,\n failures: after.failures, notes: after.notes, bands: after.bands,\n },\n };\n\n const put = await store.putDoc(KEYS.currentPlan, next, doc.rev);\n if (!put.ok) throw new HttpError(409, 'The plan changed while it was being re-fitted. Reload and try again.');\n\n const hard = (f) => f.filter((x) => x.kind === 'hard').length;\n return json({\n ok: true,\n changes: solved.changes.length,\n before: { pass: before.pass, hard: hard(before.failures), failures: before.failures.length },\n after: { pass: after.pass, hard: hard(after.failures), failures: after.failures.length },\n });\n }\n\n if (req.method === 'POST' && path === '/api/meal-lock') {\n const { mealId, locked } = await body(req);\n const res = await store.updateDoc(KEYS.currentPlan, (p) => {\n if (!p) throw new HttpError(400, 'No current plan');\n return { ...p, meals: p.meals.map((m) => (m.id === mealId ? { ...m, locked: !!locked } : m)) };\n });\n return json({ ok: res.ok });\n }\n\n // Regenerate a single meal (§10). Everything else is locked for the\n // duration, so one bad dinner can't cost you the week.\n if (req.method === 'POST' && path === '/api/meal-regenerate') {\n const { mealId } = await body(req);\n const doc = await store.getDoc(KEYS.currentPlan);\n const plan = await store.hydratePlan(doc.value);\n if (!plan) throw new HttpError(400, 'No current plan');\n const target = plan.meals.find((m) => m.id === mealId);\n if (!target) throw new HttpError(400, `No meal \"${mealId}\"`);\n\n const { settings } = await getSettings();\n const { byId } = await loadCatalog(plan.store);\n const candidates = selectCandidates(byId, settings, {\n favourites: new Set((await store.getDoc(KEYS.favourites)).value ?? []),\n });\n\n const failures = [{\n kind: 'band', scope: 'meal', mealId, day: target.day,\n metric: 'variety', actual: 0, target: 0, delta: 0,\n message: `Replace \"${target.name}\" (day ${target.day} ${target.slot}) with something different. Keep the same slot and a similar amount of protein.`,\n }];\n\n const raw = parseJSON(await new AnthropicModel({ apiKey: Deno.env.get('ANTHROPIC_API_KEY') })\n .complete(buildRepairPrompt({ settings, failures, meals: [target], candidates })));\n const fixed = sanitiseMeals(raw, byId, { days: plan.days, slots: settings.slotsPerDay });\n const replacement = fixed.meals.find((m) => m.id === mealId) ?? fixed.meals[0];\n if (!replacement) return json({ error: 'Nothing usable came back — try again.' }, 502);\n\n const merged = {\n ...plan,\n meals: plan.meals.map((m) => (m.id === mealId ? { ...replacement, id: mealId, locked: false } : { ...m, locked: true })),\n };\n const solved = solveGrams(merged, byId, settings);\n const checked = validatePlan(solved.plan, byId, settings);\n const restored = { ...checked.plan, meals: checked.plan.meals.map((m) => ({ ...m, locked: plan.meals.find((x) => x.id === m.id)?.locked ?? false })) };\n const shopping = buildShoppingList(restored, byId, { store: plan.store, stock: await store.listStock() });\n\n const next = {\n ...restored,\n shopping: shopping.lines,\n totals: { ...restored.totals, estCost: shopping.estCost },\n validation: { pass: checked.pass, rounds: plan.validation?.rounds ?? 0, failures: checked.failures, notes: checked.notes, bands: checked.bands },\n };\n const put = await store.putDoc(KEYS.currentPlan, next, doc.rev);\n if (!put.ok) return json({ error: 'The plan changed while that was running — reload and try again.' }, 409);\n return json({ ok: true, plan: next, rejected: fixed.rejected });\n }\n\n /* ── history, favourites, pantry ─────────────────────────────────────── */\n\n if (req.method === 'GET' && path === '/api/history') {\n const history = (await store.getDoc(KEYS.history)).value ?? [];\n // Ranked against the targets you hold NOW, not the ones in force when the\n // plan was built — you are choosing which to cook this week.\n const { settings } = await getSettings();\n return json({\n targets: settings.targets,\n plans: history.slice().reverse().map((p) => {\n const a = adherence(p);\n return {\n id: p.id, createdAt: p.createdAt, archivedAt: p.archivedAt, days: p.days,\n store: p.store, estCost: p.totals?.estCost ?? 0,\n ...summarisePlan(p, settings.targets),\n adherence: { ate: a.ate, decided: a.decided, total: a.total, rate: a.rate },\n meals: p.meals.map((m) => ({ id: m.id, day: m.day, slot: m.slot, name: m.name, status: m.status ?? 'planned' })),\n };\n }),\n });\n }\n\n if (req.method === 'PUT' && path === '/api/favourites') {\n const { itemIds } = await body(req);\n const cur = await store.getDoc(KEYS.favourites);\n await store.putDoc(KEYS.favourites, Array.isArray(itemIds) ? itemIds : [], cur.rev);\n return json({ ok: true });\n }\n\n if (req.method === 'PUT' && path === '/api/pantry') {\n const { pantry } = await body(req);\n const cur = await store.getDoc(KEYS.pantry);\n await store.putDoc(KEYS.pantry, pantry ?? {}, cur.rev);\n return json({ ok: true });\n }\n\n /* tracker export (§12) — one-way, and only what was actually eaten */\n if (req.method === 'GET' && path === '/api/export') {\n const plan = await store.hydratePlan((await store.getDoc(KEYS.currentPlan)).value);\n if (!plan) throw new HttpError(400, 'No current plan');\n const { byId } = await loadCatalog(plan.store);\n const include = url.searchParams.get('include') === 'all' ? 'all' : 'eaten';\n const out = trackerExport(plan, byId, { include });\n\n if (url.searchParams.get('format') === 'csv') {\n return new Response(trackerCSV(out), {\n headers: {\n 'content-type': 'text/csv; charset=utf-8',\n 'content-disposition': `attachment; filename=\"meals-${plan.id}.csv\"`,\n },\n });\n }\n return json(out);\n }\n\n /* read-only surface for Vouch (§12) */\n if (req.method === 'GET' && path === '/api/vouch') {\n const plan = await store.hydratePlan((await store.getDoc(KEYS.currentPlan)).value);\n if (!plan) return json({ hasPlan: false });\n const a = adherence(plan);\n const proofs = await store.listProofs(plan.id);\n return json({\n hasPlan: true,\n planId: plan.id,\n // Self-reported taps and photo-verified meals are different evidence\n // and are reported separately.\n verified: proofs.filter((p) => p.verdict === 'pass').length,\n latestCard: proofCard(await store.latestProof(), { timeZone: TZ }),\n createdAt: plan.createdAt,\n shoppedAt: plan.shoppedAt ?? null,\n days: plan.days,\n adherence: { ate: a.ate, decided: a.decided, total: a.total, rate: a.rate },\n });\n }\n\n return json({ error: `No route for ${req.method} ${path}` }, 404);\n } catch (err) {\n const status = err instanceof HttpError ? err.status : 500;\n if (status === 500) console.error(err);\n return json({ error: err.message }, status);\n }\n}\n","fileType","http",13,"parentId","createdAt",["D",1788929446489],"branchVersion",92,"label",[19],{"_33":326,"_13":327,"_37":328,"_44":-5,"_35":36,"_47":128,"_57":58,"_45":329,"_17":70,"_41":95,"_39":-5,"_60":61,"_49":-5,"_62":330,"_18":331},{"_33":90,"_13":91,"_37":92,"_44":-5,"_35":36,"_47":93,"_57":58,"_45":94,"_17":70,"_41":95,"_39":-5,"_60":61,"_49":-5,"_62":96,"_18":97},{"_33":82,"_13":83,"_37":84,"_44":-5,"_35":36,"_47":85,"_57":58,"_45":86,"_17":70,"_41":24,"_39":87,"_60":61,"_49":-5,"_62":88,"_18":89},{"_33":74,"_13":75,"_37":76,"_44":-5,"_35":36,"_47":77,"_57":58,"_45":78,"_17":70,"_41":24,"_39":79,"_60":61,"_49":-5,"_62":80,"_18":81},{"_33":65,"_13":66,"_37":67,"_44":-5,"_35":36,"_47":68,"_57":58,"_45":69,"_17":70,"_41":24,"_39":71,"_60":61,"_49":-5,"_62":72,"_18":73},{"_33":34,"_13":19,"_37":38,"_44":-5,"_35":36,"_47":48,"_57":58,"_45":59,"_17":43,"_41":42,"_39":40,"_60":61,"_49":-5,"_62":63,"_18":64},"latest",true,["D",1788929446489],"deleted",false,"children",[],[19],"f0c9632d-dbe9-4ab6-9089-9bd7e8194458","deno.json","fae8459e-a45a-11f1-8c6e-1607ee4eb77e",28,["D",1788084608832],0,"{\n \"$schema\": \"https://raw.githubusercontent.com/denoland/deno/98f62cee78e85bfc47c62ed703777c6bc8794f1c/cli/schemas/config-file.v1.json\",\n \"lock\": false,\n \"compilerOptions\": {\n \"noImplicitAny\": false,\n \"strict\": true,\n \"types\": [\"https://www.val.town/types/valtown.d.ts\"],\n \"lib\": [\n \"dom\",\n \"dom.iterable\",\n \"dom.asynciterable\",\n \"deno.ns\",\n \"deno.unstable\"\n ]\n },\n \"lint\": {\n \"include\": [\"deno:/https/esm.town/**/*\"],\n \"rules\": {\n \"exclude\": [\"no-explicit-any\"]\n }\n },\n \"node_modules_dir\": false,\n \"experimental\": {\n \"unstable-node-globals\": true,\n \"unstable-temporal\": true,\n \"unstable-worker-options\": true,\n \"unstable-sloppy-imports\": true\n }\n}",[],[66],"e3255447-eb34-4d32-8f37-7815e1a0baee","AGENTS.md","faefeaba-a45a-11f1-8401-1607ee4eb77e",29,["D",1788084608904],"You are an advanced assistant specialized in generating Val Town code.\n\n## Core Guidelines\n\n- Ask clarifying questions when requirements are ambiguous\n- Provide complete, functional solutions rather than skeleton implementations\n- Test your logic against edge cases before presenting the final solution\n- Ensure all code follows Val Town's specific platform requirements\n- If a section of code that you're working on is getting too complex, consider\n refactoring it into subcomponents\n\n## Code Standards\n\n- Generate code in TypeScript or TSX\n- Add appropriate TypeScript types and interfaces for all data structures\n- Prefer official SDKs or libraries than writing API calls directly\n- Ask the user to supply API or library documentation if you are at all unsure\n about it\n- **Never bake in secrets into the code** - always use environment variables\n- Include comments explaining complex logic (avoid commenting obvious\n operations)\n- Follow modern ES6+ conventions and functional programming practices if\n possible\n\n## Types of triggers\n\n### 1. HTTP Trigger\n\n- Create web APIs and endpoints\n- Handle HTTP requests and responses\n- Example structure:\n\n```ts\nexport default async function (req: Request) {\n return new Response(\"Hello World\");\n}\n```\n\nFiles that are HTTP triggers have http in their name like `foobar.http.tsx`\n\n### 2. Cron Triggers\n\n- Run on a schedule\n- Use cron expressions for timing\n- Example structure:\n\n```ts\nexport default async function () {\n // Scheduled task code\n}\n```\n\nFiles that are Cron triggers have cron in their name like `foobar.cron.tsx`\n\n### 3. Email Triggers\n\n- Process incoming emails\n- Handle email-based workflows\n- Example structure:\n\n```ts\nexport default async function (email: Email) {\n // Process email\n}\n```\n\nFiles that are Email triggers have email in their name like `foobar.email.tsx`\n\n## Val Town Standard Libraries\n\nVal Town provides several hosted services and utility functions.\n\n### Blob Storage\n\n```ts\nimport { blob } from \"https://esm.town/v/std/blob/main.ts\";\nawait blob.setJSON(\"myKey\", { hello: \"world\" });\nlet blobDemo = await blob.getJSON(\"myKey\");\nlet appKeys = await blob.list(\"app_\");\nawait blob.delete(\"myKey\");\n```\n\n### SQLite\n\n```ts\nimport { sqlite } from \"https://esm.town/v/std/sqlite/main.ts\";\nconst TABLE_NAME = \"todo_app_users_2\";\n// Create table - do this before usage and change table name when modifying schema\nawait sqlite.execute(`CREATE TABLE IF NOT EXISTS ${TABLE_NAME} (\n id INTEGER PRIMARY KEY AUTOINCREMENT,\n name TEXT NOT NULL\n)`);\n// Query data\nconst result = await sqlite.execute(\n `SELECT * FROM ${TABLE_NAME} WHERE id = ?`,\n [1],\n);\n```\n\n### OpenAI\n\n```ts\nimport { OpenAI } from \"https://esm.town/v/std/openai\";\nconst openai = new OpenAI();\nconst completion = await openai.chat.completions.create({\n messages: [\n { role: \"user\", content: \"Say hello in a creative way\" },\n ],\n model: \"gpt-4o-mini\",\n max_tokens: 30,\n});\n```\n\n### Email\n\n```ts\nimport { email } from \"https://esm.town/v/std/email\";\n// By default emails the owner of the val\nawait email({\n subject: \"Hi\",\n text: \"Hi\",\n html: \"

Hi

\",\n});\n```\n\n## Val Town Utility Functions\n\nVal Town provides several utility functions to help with common project tasks.\n\n### Importing Utilities\n\nAlways import utilities with version pins to avoid breaking changes:\n\n```ts\nimport {\n parseProject,\n readFile,\n serveFile,\n} from \"https://esm.town/v/std/utils@85-main/index.ts\";\n```\n\n### Available Utilities\n\n#### **serveFile** - Serve project files with proper content types\n\nFor example, in Hono:\n\n```ts\n// serve all files in frontend/ and shared/\napp.get(\"/frontend/*\", (c) => serveFile(c.req.path, import.meta.url));\napp.get(\"/shared/*\", (c) => serveFile(c.req.path, import.meta.url));\n```\n\n#### **readFile** - Read files from within the project:\n\n```ts\n// Read a file from the project\nconst fileContent = await readFile(\"/frontend/index.html\", import.meta.url);\n```\n\n#### **listFiles** - List all files in the project\n\n```ts\nconst files = await listFiles(import.meta.url);\n```\n\n#### **parseProject** - Extract information about the current project from import.meta.url\n\nThis is useful for including info for linking back to a val, ie in \"view source\"\nurls:\n\n```ts\nconst projectVal = parseProject(import.meta.url);\nconsole.log(projectVal.username); // Owner of the project\nconsole.log(projectVal.name); // Project name\nconsole.log(projectVal.version); // Version number\nconsole.log(projectVal.branch); // Branch name\nconsole.log(projectVal.links.self.project); // URL to the project page\n```\n\nHowever, it's _extremely importing_ to note that `parseProject` and other\nStandard Library utilities ONLY RUN ON THE SERVER. If you need access to this\ndata on the client, run it in the server and pass it to the client by splicing\nit into the HTML page or by making an API request for it.\n\n## Val Town Platform Specifics\n\n- **Redirects:** Use\n `return new Response(null, { status: 302, headers: { Location: \"/place/to/redirect\" }})`\n instead of `Response.redirect` which is broken\n- **Images:** Avoid external images or base64 images. Use emojis, unicode\n symbols, or icon fonts/libraries instead\n- **AI Image:** To inline generate an AI image use:\n `

`\n- **Storage:** DO NOT use the Deno KV module for storage\n- **Browser APIs:** DO NOT use the `alert()`, `prompt()`, or `confirm()` methods\n- **Weather Data:** Use open-meteo for weather data (doesn't require API keys)\n unless otherwise specified\n- **View Source:** Add a view source link by importing & using\n `import.meta.url.replace(\"esm.sh\", \"val.town)\"` (or passing this data to the\n client) and include `target=\"_top\"` attribute\n- **Error Debugging:** Add\n `` to HTML to capture\n client-side errors\n- **Error Handling:** Only use try...catch when there's a clear local\n resolution; Avoid catches that merely log or return 500s. Let errors bubble up\n with full context\n- **Environment Variables:** Use `Deno.env.get('keyname')` when you need to, but\n generally prefer APIs that don't require keys\n- **Imports:** Use `https://esm.sh` for npm and Deno dependencies to ensure\n compatibility on server and browser\n- **Storage Strategy:** Only use backend storage if explicitly required; prefer\n simple static client-side sites\n- **React Configuration:** When using React libraries, pin versions with\n `?deps=react@18.2.0,react-dom@18.2.0` and start the file with\n `/** @jsxImportSource https://esm.sh/react@18.2.0 */`\n- Ensure all React dependencies and sub-dependencies are pinned to the same\n version\n- **Styling:** Default to using TailwindCSS via\n `` unless otherwise\n specified\n\n## Project Structure and Design Patterns\n\n### Recommended Directory Structure\n\n```\n├── backend/\n│ ├── database/\n│ │ ├── migrations.ts # Schema definitions\n│ │ ├── queries.ts # DB query functions\n│ │ └── README.md\n│ └── routes/ # Route modules\n│ ├── [route].ts\n│ └── static.ts # Static file serving\n│ ├── index.ts # Main entry point\n│ └── README.md\n├── frontend/\n│ ├── components/\n│ │ ├── App.tsx\n│ │ └── [Component].tsx\n│ ├── favicon.svg\n│ ├── index.html # Main HTML template\n│ ├── index.tsx # Frontend JS entry point\n│ ├── README.md\n│ └── style.css\n├── README.md\n└── shared/\n ├── README.md\n └── utils.ts # Shared types and functions\n```\n\n### Backend (Hono) Best Practices\n\n- Hono is the recommended API framework\n- Main entry point should be `backend/index.ts`\n- **Static asset serving:** Use the utility functions to read and serve project\n files:\n ```ts\n import {\n readFile,\n serveFile,\n } from \"https://esm.town/v/std/utils@85-main/index.ts\";\n\n // serve all files in frontend/ and shared/\n app.get(\"/frontend/*\", (c) => serveFile(c.req.path, import.meta.url));\n app.get(\"/shared/*\", (c) => serveFile(c.req.path, import.meta.url));\n\n // For index.html, often you'll want to bootstrap with initial data\n app.get(\"/\", async (c) => {\n let html = await readFile(\"/frontend/index.html\", import.meta.url);\n\n // Inject data to avoid extra round-trips\n const initialData = await fetchInitialData();\n const dataScript = ``;\n\n html = html.replace(\"\", `${dataScript}`);\n return c.html(html);\n });\n ```\n- Create RESTful API routes for CRUD operations\n- Always include this snippet at the top-level Hono app to re-throwing errors to\n see full stack traces:\n ```ts\n // Unwrap Hono errors to see original error details\n app.onError((err, c) => {\n throw err;\n });\n ```\n\n### Database Patterns\n\n- Run migrations on startup or comment out for performance\n- Change table names when modifying schemas rather than altering\n- Export clear query functions with proper TypeScript typing\n\n## Common Gotchas and Solutions\n\n1. **Environment Limitations:**\n - Val Town runs on Deno in a serverless context, not Node.js\n - Code in `shared/` must work in both frontend and backend environments\n - Cannot use `Deno` keyword in shared code\n - Use `https://esm.sh` for imports that work in both environments\n\n2. **SQLite Peculiarities:**\n - Limited support for ALTER TABLE operations\n - Create new tables with updated schemas and copy data when needed\n - Always run table creation before querying\n\n3. **React Configuration:**\n - All React dependencies must be pinned to 18.2.0\n - Always include `@jsxImportSource https://esm.sh/react@18.2.0` at the top of\n React files\n - Rendering issues often come from mismatched React versions\n\n4. **File Handling:**\n - Val Town only supports text files, not binary\n - Use the provided utilities to read files across branches and forks\n - For files in the project, use `readFile` helpers\n\n5. **API Design:**\n - `fetch` handler is the entry point for HTTP vals\n - Run the Hono app with\n `export default app.fetch // This is the entry point for HTTP vals`",[],[75],"aba47ed9-295b-48d0-be61-38c03ecd0ee7",".vtignore","fae1ac48-a45a-11f1-a073-1607ee4eb77e",27,["D",1788084608820],".git\n.vscode\n.cursorrules\n.DS_Store\nnode_modules\nvendor",[],[83],"13783cce-18a7-4d07-8383-5a78cbd51537","src","ea6d22f2-a45a-11f1-a34b-1607ee4eb77e",2,["D",1788084581210],"directory",[98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122],[91],{"_33":318,"_13":319,"_37":320,"_44":92,"_35":36,"_47":321,"_57":58,"_45":322,"_17":70,"_41":24,"_39":323,"_60":61,"_49":-5,"_62":324,"_18":325},{"_33":310,"_13":311,"_37":312,"_44":92,"_35":36,"_47":313,"_57":58,"_45":314,"_17":70,"_41":24,"_39":315,"_60":61,"_49":-5,"_62":316,"_18":317},{"_33":302,"_13":303,"_37":304,"_44":92,"_35":36,"_47":305,"_57":58,"_45":306,"_17":70,"_41":24,"_39":307,"_60":61,"_49":-5,"_62":308,"_18":309},{"_33":294,"_13":295,"_37":296,"_44":92,"_35":36,"_47":297,"_57":58,"_45":298,"_17":70,"_41":24,"_39":299,"_60":61,"_49":-5,"_62":300,"_18":301},{"_33":286,"_13":287,"_37":288,"_44":92,"_35":36,"_47":289,"_57":58,"_45":290,"_17":70,"_41":24,"_39":291,"_60":61,"_49":-5,"_62":292,"_18":293},{"_33":278,"_13":279,"_37":280,"_44":92,"_35":36,"_47":281,"_57":58,"_45":282,"_17":93,"_41":24,"_39":283,"_60":61,"_49":-5,"_62":284,"_18":285},{"_33":270,"_13":271,"_37":272,"_44":92,"_35":36,"_47":273,"_57":58,"_45":274,"_17":70,"_41":24,"_39":275,"_60":61,"_49":-5,"_62":276,"_18":277},{"_33":262,"_13":263,"_37":264,"_44":92,"_35":36,"_47":265,"_57":58,"_45":266,"_17":70,"_41":24,"_39":267,"_60":61,"_49":-5,"_62":268,"_18":269},{"_33":254,"_13":255,"_37":256,"_44":92,"_35":36,"_47":257,"_57":58,"_45":258,"_17":128,"_41":24,"_39":259,"_60":61,"_49":-5,"_62":260,"_18":261},{"_33":246,"_13":247,"_37":248,"_44":92,"_35":36,"_47":249,"_57":58,"_45":250,"_17":70,"_41":24,"_39":251,"_60":61,"_49":-5,"_62":252,"_18":253},{"_33":238,"_13":239,"_37":240,"_44":92,"_35":36,"_47":241,"_57":58,"_45":242,"_17":70,"_41":24,"_39":243,"_60":61,"_49":-5,"_62":244,"_18":245},{"_33":230,"_13":231,"_37":232,"_44":92,"_35":36,"_47":233,"_57":58,"_45":234,"_17":93,"_41":24,"_39":235,"_60":61,"_49":-5,"_62":236,"_18":237},{"_33":222,"_13":223,"_37":224,"_44":92,"_35":36,"_47":225,"_57":58,"_45":226,"_17":93,"_41":24,"_39":227,"_60":61,"_49":-5,"_62":228,"_18":229},{"_33":213,"_13":214,"_37":215,"_44":92,"_35":36,"_47":216,"_57":58,"_45":217,"_17":218,"_41":24,"_39":219,"_60":61,"_49":-5,"_62":220,"_18":221},{"_33":205,"_13":206,"_37":207,"_44":92,"_35":36,"_47":208,"_57":58,"_45":209,"_17":70,"_41":24,"_39":210,"_60":61,"_49":-5,"_62":211,"_18":212},{"_33":197,"_13":198,"_37":199,"_44":92,"_35":36,"_47":200,"_57":58,"_45":201,"_17":128,"_41":24,"_39":202,"_60":61,"_49":-5,"_62":203,"_18":204},{"_33":189,"_13":190,"_37":191,"_44":92,"_35":36,"_47":192,"_57":58,"_45":193,"_17":70,"_41":24,"_39":194,"_60":61,"_49":-5,"_62":195,"_18":196},{"_33":180,"_13":181,"_37":182,"_44":92,"_35":36,"_47":183,"_57":58,"_45":184,"_17":185,"_41":24,"_39":186,"_60":61,"_49":-5,"_62":187,"_18":188},{"_33":172,"_13":173,"_37":174,"_44":92,"_35":36,"_47":175,"_57":58,"_45":176,"_17":128,"_41":24,"_39":177,"_60":61,"_49":-5,"_62":178,"_18":179},{"_33":164,"_13":165,"_37":166,"_44":92,"_35":36,"_47":167,"_57":58,"_45":168,"_17":70,"_41":24,"_39":169,"_60":61,"_49":-5,"_62":170,"_18":171},{"_33":156,"_13":157,"_37":158,"_44":92,"_35":36,"_47":159,"_57":58,"_45":160,"_17":70,"_41":24,"_39":161,"_60":61,"_49":-5,"_62":162,"_18":163},{"_33":148,"_13":149,"_37":150,"_44":92,"_35":36,"_47":151,"_57":58,"_45":152,"_17":70,"_41":24,"_39":153,"_60":61,"_49":-5,"_62":154,"_18":155},{"_33":140,"_13":141,"_37":142,"_44":92,"_35":36,"_47":143,"_57":58,"_45":144,"_17":128,"_41":24,"_39":145,"_60":61,"_49":-5,"_62":146,"_18":147},{"_33":132,"_13":133,"_37":134,"_44":92,"_35":36,"_47":135,"_57":58,"_45":136,"_17":128,"_41":24,"_39":137,"_60":61,"_49":-5,"_62":138,"_18":139},{"_33":123,"_13":124,"_37":125,"_44":92,"_35":36,"_47":126,"_57":58,"_45":127,"_17":128,"_41":24,"_39":129,"_60":61,"_49":-5,"_62":130,"_18":131},"06ebf6d2-7d7b-4e79-94ab-90f2d0ecbea8","variance.mjs","ebd990a8-a45a-11f1-945f-1607ee4eb77e",85,["D",1788236054203],1,"// Variance rail geometry.\n//\n// Shared deliberately: the display must not carry its own copy of the\n// thresholds. If the validator says day 2 missed, the rail shows a miss,\n// because both read the same numbers. This module is inlined into the\n// single-file UI at build time.\n\n// DEFAULTS ONLY — not the live thresholds. Since macro strictness became a\n// setting, the values in force come from src/strictness.mjs and travel on the\n// plan as plan.validation.bands. Nothing imports this module today (railVerdicts\n// below is inlined into the browser bundle but never called); if you wire it up\n// again, take the bands from the plan rather than from here, or the rail will\n// say \"on target\" about a day the validator has already failed.\nexport const BANDS = { kcal: 0.05, carbs: 0.15, fat: 0.15 };\n\n/** Judge the number on screen, not the float behind it. See validate.mjs. */\nexport const shown = (v) => Math.round(v);\n\n/** Banded metric: a tolerance either side of target. */\nexport function bandRail(raw, target, tol) {\n const actual = shown(raw);\n const span = target * 0.45; // rail covers target ±45%\n const pos = (v) => Math.max(0, Math.min(100, ((v - (target - span)) / (2 * span)) * 100));\n const lo = pos(target * (1 - tol));\n const hi = pos(target * (1 + tol));\n const at = pos(actual);\n const over = actual > target * (1 + tol);\n const under = actual < target * (1 - tol);\n return {\n lo, hi, at, mid: pos(target),\n miss: over || under, over, under,\n missFrom: over ? hi : at,\n missTo: over ? at : lo,\n };\n}\n\n/** Protein: a floor, not a band. Drawn differently because it IS different. */\nexport function floorRail(raw, floor) {\n const actual = shown(raw);\n const span = floor * 0.5;\n const pos = (v) => Math.max(0, Math.min(100, ((v - (floor - span)) / (2 * span)) * 100));\n return {\n at: pos(actual), mid: pos(floor),\n miss: actual < floor,\n missFrom: pos(actual), missTo: pos(floor),\n };\n}\n\n/** What the rail will show for one day. Used by the UI and by its test. */\nexport function railVerdicts(dayTotals, targets) {\n const out = {};\n for (const m of ['kcal', 'carbs', 'fat']) {\n out[m] = bandRail(dayTotals[m], targets[m], BANDS[m]).miss;\n }\n out.protein = floorRail(dayTotals.protein, targets.protein).miss;\n return out;\n}\n",[],[91,124],"3206af5e-ef06-498d-9356-e87aab63cb06","validate.mjs","ebcbfe7a-a45a-11f1-a26f-1607ee4eb77e",83,["D",1788235965828],"// Phase C — validate. Produces structured failures; never a bare boolean.\n\nimport { computePlan, gramsOf } from './compute.mjs';\nimport { parseTerms, itemMatchesTerm, parseRestrictions } from './catalog.mjs';\nimport { resolveBands, effectiveProteinFloor } from './strictness.mjs';\n\n/** Kept for callers that want the defaults; the live values come from\n * resolveBands(settings), because they now depend on the strictness setting. */\nexport const BANDS = { kcal: 0.05, carbs: 0.15, fat: 0.15 };\n\n/**\n * Compare the numbers the user is actually shown.\n *\n * 179.6g of protein against a 180g floor displays as \"180 / 180\" and fails,\n * which reads as a bug even though both halves are correct. Nutrition data\n * carries far more error than half a gram, so the validator judges the rounded\n * figure — what you see is what's checked.\n */\nexport const shown = (v) => Math.round(v);\n\nconst VARIETY = {\n relaxed: { maxNameRepeats: 3, maxProteinShare: 0.55, minDistinctVegPerDay: 0.5 },\n normal: { maxNameRepeats: 2, maxProteinShare: 0.40, minDistinctVegPerDay: 1 },\n strict: { maxNameRepeats: 1, maxProteinShare: 0.30, minDistinctVegPerDay: 1.5 },\n};\n\nconst fail = (o) => ({ day: undefined, mealId: undefined, ...o });\n\nexport function validatePlan(plan, catalog, settings) {\n const { plan: computed, exact, unresolved } = computePlan(plan, catalog);\n const targets = settings.targets;\n const failures = [];\n const notes = [];\n\n // ── hard: unresolved item ids ──────────────────────────────────────────────\n // Models hallucinate ids. This is the net.\n for (const u of unresolved) {\n failures.push(fail({\n kind: 'hard', scope: 'meal', mealId: u.mealId,\n metric: 'itemId', actual: 0, target: 0, delta: 0,\n message: `Unknown catalog item \"${u.itemId}\"`,\n }));\n }\n\n // ── hard: dislikes ─────────────────────────────────────────────────────────\n // A confirmed id list is authoritative. Free text alone is only a guess —\n // \"olives\" matches \"Olive Oil\" — so it blocks the plan but says it guessed.\n const confirmed = settings.dislikedItemIds ? new Set(settings.dislikedItemIds) : null;\n const dislikes = confirmed ? [] : parseTerms(settings.dislikes);\n if (!confirmed && dislikes.length) {\n notes.push({\n kind: 'dislikes-fuzzy',\n message: `Dislikes matched by text (${dislikes.join(', ')}). Confirm which products you actually mean — `\n + 'text matching catches near-misses like \"olives\" hitting olive oil.',\n });\n }\n for (const meal of computed.meals) {\n for (const c of meal.components || []) {\n const item = catalog[c.itemId];\n if (!item) continue;\n if (confirmed?.has(item.id)) {\n failures.push(fail({\n kind: 'hard', scope: 'meal', mealId: meal.id, day: meal.day,\n metric: 'dislikes', actual: 0, target: 0, delta: 0,\n message: `${item.name} in \"${meal.name}\" is on the do-not-use list`,\n }));\n continue;\n }\n for (const term of dislikes) {\n if (itemMatchesTerm(item, term)) {\n failures.push(fail({\n kind: 'hard', scope: 'meal', mealId: meal.id, day: meal.day,\n metric: 'dislikes', actual: 0, target: 0, delta: 0,\n message: `${item.name} in \"${meal.name}\" matches disliked \"${term}\" (unconfirmed match)`,\n }));\n }\n }\n }\n }\n\n // ── hard: restrictions we can actually check ───────────────────────────────\n const { recognised, forbids, unverified } = parseRestrictions(settings.restrictions);\n if (forbids.length) {\n for (const meal of computed.meals) {\n for (const c of meal.components || []) {\n const item = catalog[c.itemId];\n if (!item) continue;\n const hit = (item.contains || []).filter((f) => forbids.includes(f));\n if (hit.length) {\n failures.push(fail({\n kind: 'hard', scope: 'meal', mealId: meal.id, day: meal.day,\n metric: 'restrictions', actual: 0, target: 0, delta: 0,\n message: `${item.name} contains ${hit.join(', ')} — breaks ${recognised.join('/')}`,\n }));\n }\n }\n }\n notes.push({\n kind: 'restrictions-checked',\n message: `Checked against inferred ingredient flags for: ${recognised.join(', ')}. `\n + 'Flags are inferred from product type, not read from labels — confirm anything critical.',\n });\n }\n if (unverified.length) {\n notes.push({\n kind: 'restrictions-unverified',\n message: `Not machine-checked (passed to the planner as guidance only): ${unverified.join('; ')}`,\n });\n }\n\n // ── hard: protein floor. A floor, never a band. ────────────────────────────\n const floor = effectiveProteinFloor(targets, settings);\n for (const t of exact.perDay) {\n const p = shown(t.protein);\n if (p < floor) {\n failures.push(fail({\n kind: 'hard', scope: 'day', day: t.day,\n metric: 'protein', actual: p, target: targets.protein,\n delta: p - targets.protein,\n message: `Day ${t.day} protein ${p}g, ${floor - p}g under the floor`\n + (floor === targets.protein ? '' : ` of ${floor}g`),\n }));\n }\n }\n\n // ── banded: kcal, carbs, fat ───────────────────────────────────────────────\n const bands = resolveBands(settings);\n for (const t of exact.perDay) {\n for (const metric of ['kcal', 'carbs', 'fat']) {\n const target = targets[metric];\n if (!target) continue;\n const actual = shown(t[metric]);\n const drift = (actual - target) / target;\n if (Math.abs(drift) > bands[metric]) {\n failures.push(fail({\n kind: 'band', scope: 'day', day: t.day, metric,\n actual, target,\n delta: actual - target,\n message: `Day ${t.day} ${metric} ${actual} vs ${target} `\n + `(${drift > 0 ? '+' : ''}${Math.round(drift * 100)}%, band ±${Math.round(bands[metric] * 100)}%)`,\n }));\n }\n }\n }\n\n // ── variety ────────────────────────────────────────────────────────────────\n const v = VARIETY[settings.varietyStrictness || 'normal'];\n // Effort overrides variety: when the user wants minimal cooking, repeated\n // meals are the point, so name repeats stop being a failure.\n const effortOverridesVariety = settings.effortCeiling === 'minimal';\n\n if (!effortOverridesVariety) {\n const nameCounts = new Map();\n for (const m of computed.meals) {\n const k = (m.name || '').trim().toLowerCase();\n nameCounts.set(k, (nameCounts.get(k) || 0) + 1);\n }\n for (const [name, n] of nameCounts) {\n if (n > v.maxNameRepeats) {\n failures.push(fail({\n kind: 'variety', scope: 'plan', metric: 'nameRepeats',\n actual: n, target: v.maxNameRepeats, delta: n - v.maxNameRepeats,\n message: `\"${name}\" appears ${n} times (max ${v.maxNameRepeats})`,\n }));\n }\n }\n } else {\n notes.push({\n kind: 'variety-relaxed',\n message: 'Effort ceiling is minimal, so repeated meals are allowed — variety checks on meal names are off.',\n });\n }\n\n // protein concentration\n const proteinByItem = new Map();\n let totalProtein = 0;\n for (const meal of computed.meals) {\n for (const c of meal.components || []) {\n const item = catalog[c.itemId];\n if (!item?.per100) continue;\n const g = (gramsOf(item, c.grams) / 100) * item.per100.protein;\n totalProtein += g;\n if (item.roleTags.includes('protein')) {\n proteinByItem.set(c.itemId, (proteinByItem.get(c.itemId) || 0) + g);\n }\n }\n }\n if (totalProtein > 0) {\n for (const [itemId, g] of proteinByItem) {\n const share = g / totalProtein;\n if (share > v.maxProteinShare) {\n failures.push(fail({\n kind: 'variety', scope: 'plan', metric: 'proteinShare',\n actual: Math.round(share * 100), target: Math.round(v.maxProteinShare * 100),\n delta: Math.round((share - v.maxProteinShare) * 100),\n message: `${catalog[itemId].name} supplies ${Math.round(share * 100)}% of the window's protein (max ${Math.round(v.maxProteinShare * 100)}%)`,\n }));\n }\n }\n }\n\n // distinct vegetables\n const veg = new Set();\n for (const meal of computed.meals) {\n for (const c of meal.components || []) {\n const item = catalog[c.itemId];\n if (item && (item.roleTags.includes('veg') || item.roleTags.includes('green'))) veg.add(c.itemId);\n }\n }\n const minVeg = Math.ceil(plan.days * v.minDistinctVegPerDay);\n if (veg.size < minVeg) {\n failures.push(fail({\n kind: 'variety', scope: 'plan', metric: 'distinctVeg',\n actual: veg.size, target: minVeg, delta: veg.size - minVeg,\n message: `${veg.size} distinct vegetables across ${plan.days} days (want ${minVeg})`,\n }));\n }\n\n return {\n plan: computed,\n exact,\n pass: failures.length === 0,\n failures,\n notes,\n // Travels with the result so the plan can record what it was judged\n // against, and the rails on screen can draw the same thresholds instead of\n // a hardcoded copy that quietly disagrees.\n bands: { ...bands, proteinFloorAt: floor },\n counts: {\n hard: failures.filter((f) => f.kind === 'hard').length,\n band: failures.filter((f) => f.kind === 'band').length,\n variety: failures.filter((f) => f.kind === 'variety').length,\n },\n };\n}\n\n/**\n * Constraints that are categorical rather than numeric. A disliked ingredient\n * or a broken restriction is wrong by any margin; there is no \"slightly\".\n */\nexport const CATEGORICAL = new Set(['dislikes', 'restrictions', 'itemId']);\n\n/**\n * Hard failures that a change introduced or made worse.\n *\n * Counting failures isn't enough: a plan already one gram under the protein\n * floor stays \"one hard failure\" after a swap that drops it to nothing. What\n * matters is whether any specific constraint got worse, so failures are keyed\n * by what they're about and compared by how far off they are.\n */\nexport function hardRegressions(before, after) {\n const key = (f) => `${f.scope}|${f.day ?? ''}|${f.mealId ?? ''}|${f.metric}`;\n const prior = new Map();\n for (const f of before.failures) if (f.kind === 'hard') prior.set(key(f), f);\n\n const out = [];\n for (const f of after.failures) {\n if (f.kind !== 'hard') continue;\n const was = prior.get(key(f));\n if (!was) { out.push(f); continue; }\n // delta is negative for a shortfall, so a bigger shortfall is smaller.\n if (Math.abs(f.delta) > Math.abs(was.delta)) out.push(f);\n }\n return out;\n}\n\n/**\n * Regressions worth refusing a swap over.\n *\n * Categorical breaks always count. Numeric ones only count once they're big\n * enough to matter: refusing to let someone buy a different brand of pasta\n * because it costs them one gram of protein is the kind of rigidity that makes\n * an app useless in an actual supermarket, and the nutrition data isn't\n * accurate to a gram anyway.\n */\nexport function materialRegressions(before, after, { targets = {}, floorTolerance = 0.03, minGrams = 5 } = {}) {\n return hardRegressions(before, after).filter((f) => {\n if (CATEGORICAL.has(f.metric)) return true;\n const target = targets[f.metric] ?? f.target ?? 0;\n const allowed = Math.max(minGrams, target * floorTolerance);\n return Math.abs(f.delta) > allowed;\n });\n}\n",[],[91,133],"efa8c018-5226-4268-80b3-ff019a2aee4d","units.mjs","e48a1272-ac08-11f1-90c3-1607ee4eb77e",91,["D",1788929332034],"// Amounts a person can act on.\n//\n// Everything downstream of the solver is grams, because grams are what you can\n// do arithmetic with. But nobody stands in a supermarket thinking \"120g of root\n// veg\", and nobody chops \"38g of brown onion\" — they buy two carrots and chop\n// one onion. This turns the arithmetic back into the thing you actually do.\n//\n// The table is deliberately small and explicit. A guessed unit weight is worse\n// than grams: \"3 onions\" when it meant one is a wrong shopping list, whereas\n// \"150g onion\" is merely dull. Anything not listed here keeps its grams.\n\n/** Typical weight of one, for things you count rather than weigh. */\nconst COUNTABLE = {\n 'pns-carrots-1500g': { each: 70, one: 'carrot', many: 'carrots' },\n 'pns-onions-brown-1500g': { each: 150, one: 'onion', many: 'onions' },\n 'pns-onion-red-500g': { each: 130, one: 'red onion', many: 'red onions' },\n 'pns-courgette-500g': { each: 180, one: 'courgette', many: 'courgettes' },\n 'pns-tomatoes-loose-500g': { each: 90, one: 'tomato', many: 'tomatoes' },\n 'pns-potatoes-agria-3kg': { each: 150, one: 'potato', many: 'potatoes' },\n 'pns-kumara-orange-1kg': { each: 250, one: 'kūmara', many: 'kūmara' },\n 'pns-beetroot-500g': { each: 120, one: 'beetroot', many: 'beetroot' },\n 'pns-mushrooms-portobello-300g': { each: 60, one: 'portobello', many: 'portobellos' },\n 'pns-chilli-red-50g': { each: 10, one: 'chilli', many: 'chillies' },\n 'pns-bananas-1kg': { each: 120, one: 'banana', many: 'bananas' },\n 'pns-apples-royal-gala-1500g': { each: 150, one: 'apple', many: 'apples' },\n 'pns-oranges-navel-1kg': { each: 180, one: 'orange', many: 'oranges' },\n 'pns-mandarins-1kg': { each: 70, one: 'mandarin', many: 'mandarins' },\n 'pns-kiwifruit-green-1kg': { each: 90, one: 'kiwifruit', many: 'kiwifruit' },\n 'pns-pears-1kg': { each: 170, one: 'pear', many: 'pears' },\n 'pns-bread-wholemeal-700g': { each: 40, one: 'slice of wholemeal toast', many: 'slices of wholemeal toast' },\n 'pns-bread-white-700g': { each: 40, one: 'slice of white toast', many: 'slices of white toast' },\n 'pns-sourdough-loaf-680g': { each: 55, one: 'slice of sourdough', many: 'slices of sourdough' },\n};\n\n/** Sold as a bunch, bag or punnet — the pack IS the natural unit. */\nconst WHOLE_PACK = {\n 'pns-coriander-bunch-30g': 'bunch of coriander',\n 'pns-parsley-flat-30g': 'bunch of parsley',\n 'pns-basil-30g': 'bunch of basil',\n 'pns-mint-30g': 'bunch of mint',\n 'pns-spring-onion-bunch': 'bunch of spring onions',\n 'pns-kale-bunch-250g': 'bunch of kale',\n 'pns-bok-choy-300g': 'bunch of bok choy',\n 'pns-choy-sum-300g': 'bunch of choy sum',\n 'pns-spinach-baby-120g': 'bag of baby spinach',\n 'pns-cherry-tomatoes-250g': 'punnet of cherry tomatoes',\n 'pns-blueberries-125g': 'punnet of blueberries',\n 'pns-cabbage-green-half': 'half cabbage',\n};\n\n/** A thumb of ginger is a real measure; 12g of ginger is not. */\nconst HAND_MEASURE = {\n 'pns-ginger-fresh-150g': { each: 15, one: 'thumb of ginger', many: 'thumbs of ginger' },\n};\n\n/** Tins and jars. You open one, or half of one — you don't weigh out 120g. */\nconst TINNED = {\n 'pns-tomatoes-chopped-400g': 'tin of chopped tomatoes',\n 'pns-chickpeas-canned-400g': 'tin of chickpeas',\n 'pns-black-beans-canned-400g': 'tin of black beans',\n 'pns-kidney-beans-canned-400g': 'tin of kidney beans',\n 'pns-cannellini-canned-400g': 'tin of cannellini beans',\n 'pns-coconut-milk-400ml': 'tin of coconut milk',\n 'pns-tuna-springwater-185g': 'tin of tuna',\n 'pns-tuna-oliveoil-185g': 'tin of tuna',\n 'pns-tomato-paste-140g': 'tube of tomato paste',\n 'pns-tomato-paste-double-200g': 'tube of tomato paste',\n 'pns-passata-700g': 'jar of passata',\n 'pns-pasta-sauce-500g': 'jar of pasta sauce',\n};\n\n/** Dried leaves are counted, not spooned — \"½ tsp of bay leaves\" is nonsense. */\nconst LEAVES = {\n 'pns-bay-leaves-5g': { each: 0.25, one: 'bay leaf', many: 'bay leaves' },\n};\n\n/* Spoons. Dried powders and leaves are far lighter per spoon than liquid, and\n * using one figure for both turns a teaspoon of oregano into a tablespoon. */\nconst TSP_GRAMS = { dry: 2, liquid: 5, thick: 7 };\nconst SPOONABLE_ROLES = new Set(['spice', 'flavour', 'acid']);\n\nconst round1 = (n) => Math.round(n * 10) / 10;\n\n/** Nearest sensible spoon fraction — quarters below a spoon, halves above. */\nfunction spoons(amount, perTsp) {\n const tsp = amount / perTsp;\n if (tsp < 0.4) return 'a pinch';\n if (tsp < 3) {\n const q = Math.max(0.25, Math.round(tsp * 4) / 4);\n const label = q === 1 ? '1 tsp' : `${fraction(q)} tsp`;\n return label;\n }\n const tbsp = tsp / 3;\n const h = Math.max(0.5, Math.round(tbsp * 2) / 2);\n return h === 1 ? '1 tbsp' : `${fraction(h)} tbsp`;\n}\n\nfunction fraction(n) {\n const whole = Math.floor(n);\n const rest = n - whole;\n // Matched with a tolerance rather than by key: round1(0.25) is 0.3, because\n // Math.round breaks a half upward, so an exact lookup missed every quarter\n // and a quarter tin printed as \"0.3 tin\".\n const marks = [[0.25, '¼'], [0.5, '½'], [0.75, '¾']];\n const hit = marks.find(([v]) => Math.abs(rest - v) < 0.02);\n if (!hit) return String(round1(n));\n return whole ? `${whole}${hit[1]}` : hit[1];\n}\n\n/**\n * Count, rounded to something you could pick up — or nothing.\n *\n * Below about a third of one, the weight says more than the count does: \"a\n * small piece of banana\" is not an amount anybody can put in a bowl, and 40g is.\n */\nfunction countOf(amount, each) {\n const n = amount / each;\n if (n < 0.35) return null;\n return { n: Math.max(0.5, Math.round(n * 2) / 2) };\n}\n\n/**\n * A human amount for one component of a meal.\n *\n * `amount` is the component's stored quantity — a count for items sold each,\n * grams or millilitres otherwise. Returns the phrase to show and the exact\n * figure to keep beside it, because the arithmetic should stay visible.\n */\nexport function describeAmount(item, amount, role) {\n if (!item || !(amount > 0)) return null;\n const grams = item.packUnit === 'ea' ? amount * (Number(item.unitGrams) || 0) : amount;\n const exact = item.packUnit === 'ea'\n ? (grams ? `${Math.round(grams)}g` : null)\n : `${Math.round(amount)}${item.packUnit === 'ml' ? 'ml' : 'g'}`;\n\n // Sold each: the count IS the amount. \"1 celery\", \"7 eggs\".\n if (item.packUnit === 'ea') {\n const n = Math.round(amount);\n const noun = eachNoun(item, n);\n return { text: `${n} ${noun}`, exact };\n }\n\n const whole = WHOLE_PACK[item.id];\n if (whole) {\n const packs = amount / item.packSize;\n if (packs >= 0.85) {\n const n = Math.round(packs);\n return { text: n === 1 ? `1 ${whole}` : `${n} × ${whole}`, exact };\n }\n return { text: `${fraction(Math.max(0.25, Math.round(packs * 4) / 4))} ${whole}`, exact };\n }\n\n const tin = TINNED[item.id];\n if (tin) {\n const packs = amount / item.packSize;\n if (packs >= 0.85) {\n const n = Math.round(packs);\n return { text: n === 1 ? `1 ${tin}` : `${n} × ${tin}`, exact };\n }\n return { text: `${fraction(Math.max(0.25, Math.round(packs * 4) / 4))} ${tin}`, exact };\n }\n\n const leaf = LEAVES[item.id];\n if (leaf) {\n const n = Math.max(1, Math.round(amount / leaf.each));\n return { text: `${n} ${n === 1 ? leaf.one : leaf.many}`, exact };\n }\n\n const hand = HAND_MEASURE[item.id];\n if (hand) {\n const c = countOf(amount, hand.each);\n if (c) return { text: `${trimNum(c.n)} ${c.n <= 1 ? hand.one : hand.many}`, exact };\n }\n\n const countable = COUNTABLE[item.id];\n if (countable) {\n const c = countOf(amount, countable.each);\n if (c) return { text: `${trimNum(c.n)} ${c.n <= 1 ? countable.one : countable.many}`, exact };\n }\n\n // Small quantities of seasoning and oil belong in spoons.\n if (SPOONABLE_ROLES.has(role) && amount <= 25) {\n return { text: `${spoons(amount, TSP_GRAMS.dry)} ${shortName(item)}`, exact };\n }\n if (role === 'fat' && item.packUnit === 'ml' && amount <= 45) {\n return { text: `${spoons(amount, TSP_GRAMS.liquid)} ${shortName(item)}`, exact };\n }\n\n // Grams, but rounded to something a kitchen scale and a human both accept.\n // 178ml of stock is a false precision that came out of an optimiser.\n return { text: `${roundAmount(amount)}${item.packUnit === 'ml' ? 'ml' : 'g'} ${shortName(item)}`, exact };\n}\n\n/** Coarser as the number grows — nobody measures stock to the millilitre. */\nexport function roundAmount(n) {\n if (n < 20) return Math.round(n);\n if (n < 100) return Math.round(n / 5) * 5;\n if (n < 500) return Math.round(n / 10) * 10;\n return Math.round(n / 25) * 25;\n}\n\n/** \"Pams Size 7 Eggs\" -> \"eggs\"; \"Celery\" -> \"celery\". */\nfunction eachNoun(item, n) {\n const base = shortName(item);\n if (/eggs?$/i.test(base)) return n === 1 ? 'egg' : 'eggs';\n if (n === 1) return base.replace(/s$/i, '');\n return base;\n}\n\n/** Drop the brand — you are looking at a chopping board, not a shelf. */\nexport function shortName(item) {\n return String(item?.name ?? '')\n .replace(/^(Pams|Value|Woolworths|Countdown|Essentials)\\s+/i, '')\n .toLowerCase();\n}\n\nconst trimNum = (n) => (Number.isInteger(n) ? String(n) : fraction(n));\n\n/**\n * The compact descriptor the browser needs to format amounts itself.\n *\n * Sent per item alongside the catalog subset, so the table lives here and the\n * client only does the arithmetic.\n */\nexport function unitInfo(item) {\n if (!item) return null;\n const info = {};\n if (COUNTABLE[item.id]) info.count = COUNTABLE[item.id];\n if (WHOLE_PACK[item.id]) info.pack = WHOLE_PACK[item.id];\n if (HAND_MEASURE[item.id]) info.hand = HAND_MEASURE[item.id];\n info.short = shortName(item);\n return info;\n}\n\n/**\n * Sold by the piece, so the shop says \"3 carrots\" not \"1 × 1.5kg bag\".\n *\n * Deliberately NOT the same set as COUNTABLE. Bread is counted in slices when\n * you cook and bought as a loaf; potatoes come in a 3kg bag. Being countable in\n * a recipe says nothing about how the shop sells it, and conflating the two put\n * \"1½ slices of wholemeal toast\" on a shopping list.\n */\nconst LOOSE = new Set([\n 'pns-carrots-1500g', 'pns-onions-brown-1500g', 'pns-onion-red-500g',\n 'pns-courgette-500g', 'pns-tomatoes-loose-500g', 'pns-chilli-red-50g',\n 'pns-beetroot-500g', 'pns-kumara-orange-1kg', 'pns-mushrooms-portobello-300g',\n 'pns-bananas-1kg', 'pns-apples-royal-gala-1500g', 'pns-oranges-navel-1kg',\n 'pns-mandarins-1kg', 'pns-kiwifruit-green-1kg', 'pns-pears-1kg',\n // Sold singly by their nature.\n 'pns-broccoli-ea', 'pns-cauliflower-ea', 'pns-garlic-bulb-ea',\n 'pns-capsicum-red-ea', 'pns-eggplant-ea', 'pns-cucumber-telegraph-ea',\n 'pns-lettuce-cos-ea', 'pns-celery-ea', 'pns-leek-ea', 'pns-avocado-ea',\n 'pns-lemon-ea', 'pns-lime-ea', 'pns-pineapple-ea',\n]);\n\n/** What the container is called when you buy the whole thing. */\nconst PURCHASE_PACK = {\n 'pns-eggs-size7-dozen': 'dozen eggs',\n 'pns-eggs-freerange-10pk': 'pack of 10 free range eggs',\n 'pns-bread-wholemeal-700g': 'loaf of wholemeal toast bread',\n 'pns-bread-white-700g': 'loaf of white toast bread',\n 'pns-sourdough-loaf-680g': 'sourdough loaf',\n 'pns-potatoes-agria-3kg': 'bag of agria potatoes',\n};\n\nexport function isLoose(item) {\n return !!(item && LOOSE.has(item.id));\n}\n\n/**\n * What to put in the trolley.\n *\n * The shopping list used to show the pack arithmetic — \"1×1500g · need 120g ·\n * 1380g over\" — which is three numbers, none of which is the answer to \"what do\n * I pick up\". Loose produce is bought by the piece, so it says the pieces;\n * anything sold in a fixed pack says the pack. The pack maths still exists, it\n * just isn't the headline any more.\n */\nexport function describePurchase(item, line) {\n if (!item) return { text: line?.label ?? 'item', detail: null };\n\n // On a line for something sold each, requiredGrams is already a COUNT, not a\n // weight. Dividing it by the unit weight turned four heads of celery into one.\n const need = Number(line?.requiredGrams) || 0;\n const packs = Math.max(1, Number(line?.packsToBuy) || 1);\n\n // Bought by the piece — carrots, onions, celery, a lemon.\n if (isLoose(item)) {\n if (item.packUnit === 'ea') {\n const n = Math.max(1, Math.ceil(need));\n return { text: `${n} ${eachNoun(item, n)}`, detail: null };\n }\n const d = describeAmount(item, need, null);\n if (d) return { text: d.text, detail: null };\n }\n\n // Sold as a thing you pick up whole.\n const named = PURCHASE_PACK[item.id] || WHOLE_PACK[item.id] || TINNED[item.id];\n if (named) {\n return {\n text: packs === 1 ? `1 ${named}` : `${packs} × ${named}`,\n detail: null,\n };\n }\n\n // Everything else: how many packs, and how big the pack is.\n const size = `${item.packSize}${item.packUnit === 'ea' ? 'pk' : item.packUnit}`;\n return {\n text: packs === 1 ? `1 pack of ${shortName(item)}` : `${packs} packs of ${shortName(item)}`,\n detail: size,\n };\n}\n",[],[91,141],"d8d4424b-3141-4329-9397-843243e53b45","supplements.mjs","ebc3e65e-a45a-11f1-945f-1607ee4eb77e",24,["D",1788084583438],"// Supplements.\n//\n// Taken on a fixed daily dose rather than cooked into meals, but they are not\n// free: 10g of collagen is ~9g of protein and ~36 kcal. Anything with macros\n// goes through the same compute path as food, so the numbers on screen stay\n// true.\n//\n// Nothing here is dosing advice. The defaults are the amounts printed on the\n// products; changing them is the user's call.\n\nimport { gramsOf } from './compute.mjs';\n\n/**\n * Protein from collagen is not interchangeable with protein from food.\n * Collagen lacks tryptophan and is low in leucine, so counting it toward a\n * protein floor set for training overstates what you actually got. The app\n * counts it — you did eat it — but reports it separately rather than letting\n * it quietly fill the gap.\n */\nexport const INCOMPLETE_PROTEIN_GROUPS = new Set(['collagen']);\n\n/** Resolve the configured routine against the catalog. */\nexport function resolveRoutine(supplements, catalog) {\n const items = [];\n const missing = [];\n\n for (const s of supplements ?? []) {\n const item = catalog[s.itemId];\n if (!item) { missing.push(s.itemId); continue; }\n const dose = Number(s.dose ?? item.dailyDose ?? 0);\n if (!(dose > 0)) continue;\n items.push({\n itemId: item.id,\n name: item.name,\n group: item.substituteGroup,\n dose,\n unit: item.packUnit === 'ea' ? (dose === 1 ? 'tablet' : 'tablets') : 'g',\n timing: s.timing ?? null,\n incomplete: INCOMPLETE_PROTEIN_GROUPS.has(item.substituteGroup),\n per100: item.per100,\n packUnit: item.packUnit,\n });\n }\n return { items, missing };\n}\n\n/** Macros from one day of the routine. Same arithmetic as a meal. */\nexport function dailyMacros(routine, catalog) {\n const total = { kcal: 0, protein: 0, carbs: 0, fat: 0, fibre: 0 };\n const incomplete = { protein: 0 };\n\n for (const s of routine.items) {\n const item = catalog[s.itemId];\n if (!item?.per100) continue;\n const f = gramsOf(item, s.dose) / 100;\n total.kcal += item.per100.kcal * f;\n total.protein += item.per100.protein * f;\n total.carbs += item.per100.carbs * f;\n total.fat += item.per100.fat * f;\n total.fibre += (item.per100.fibre ?? 0) * f;\n if (s.incomplete) incomplete.protein += item.per100.protein * f;\n }\n return { total, incomplete };\n}\n\n/**\n * Shopping lines for the routine. A 300g tub of creatine at 5g a day lasts\n * two months, so a 3-day shop should not buy one every cycle — the pantry\n * ledger handles that, and these lines flow through it like anything else.\n */\nexport function supplementLines(routine, catalog, days, { stock = [], now = Date.now() } = {}) {\n const onHand = new Map();\n for (const e of stock) onHand.set(e.itemId, (onHand.get(e.itemId) || 0) + e.grams);\n\n return routine.items.map((s) => {\n const item = catalog[s.itemId];\n const needed = s.dose * days;\n // The ledger already holds this in the item's own unit.\n const have = onHand.get(s.itemId) || 0;\n const required = Math.max(0, needed - have);\n const packsToBuy = required === 0 ? 0 : Math.ceil(required / item.packSize);\n const daysPerPack = Math.floor(item.packSize / s.dose);\n\n return {\n id: `supp-${s.group}`,\n substituteGroup: s.group,\n primaryItemId: s.itemId,\n role: 'supplement',\n supplement: true,\n requiredGrams: Math.round(required * 10) / 10,\n requestedGrams: needed,\n fromStockGrams: Math.round(Math.min(have, needed) * 10) / 10,\n packSize: item.packSize,\n packUnit: item.packUnit,\n packsToBuy,\n surplusGrams: packsToBuy ? packsToBuy * item.packSize - required : 0,\n estCost: Math.round(packsToBuy * (item.price ?? 0) * 100) / 100,\n aisle: item.aisle,\n pickOrder: item.pickOrder,\n staple: true,\n carryForward: true,\n alreadyHave: required === 0,\n // The useful number: how long a pack lasts at this dose.\n daysPerPack,\n candidates: [{ itemId: item.id, name: item.name, packSize: item.packSize, packUnit: item.packUnit, price: item.price, delta: null }],\n };\n });\n}\n\n/**\n * Split the day's protein into food and supplement, and say when supplements\n * are carrying an outsized share of a floor set for training.\n */\nexport function proteinBreakdown(dayProtein, suppMacros, targets, { warnAbove = 0.15 } = {}) {\n const fromSupplements = Math.round(suppMacros.total.protein);\n const incomplete = Math.round(suppMacros.incomplete.protein);\n const fromFood = Math.round(dayProtein) - fromSupplements;\n const notes = [];\n\n if (incomplete > 0 && targets.protein > 0 && incomplete / targets.protein > warnAbove) {\n notes.push(\n `${incomplete}g of the day's protein is collagen, which is low in leucine and has no tryptophan. `\n + 'It counts toward the total but is not a substitute for food protein if the target is set for training.',\n );\n }\n return { fromFood, fromSupplements, incomplete, notes };\n}\n\n/** A day's routine, for the plan screen. */\nexport function dailyChecklist(routine) {\n const order = { morning: 0, 'with breakfast': 1, midday: 2, 'with dinner': 3, evening: 4 };\n return routine.items\n .slice()\n .sort((a, b) => (order[a.timing] ?? 9) - (order[b.timing] ?? 9))\n .map((s) => ({\n itemId: s.itemId,\n name: s.name,\n dose: `${s.dose}${s.unit === 'g' ? 'g' : ' ' + s.unit}`,\n timing: s.timing,\n incomplete: s.incomplete,\n }));\n}\n",[],[91,149],"28d001d2-984c-43b3-8896-e8998eb75a81","strictness.mjs","62783e6a-a5bb-11f1-8dce-1607ee4eb77e",78,["D",1788235965459],"// How close is close enough.\n//\n// The bands were fixed constants, which is fine until the targets themselves\n// are hard to hit at once. 180g of protein a day from vegetarian food costs\n// calories: the solver can hold the protein floor or the energy band, not both,\n// and which one should give is a judgement about the person, not the arithmetic.\n//\n// One definition, because there used to be three — validate.mjs, variance.mjs\n// and the inlined copy in the browser all carried their own numbers. They agreed\n// only by coincidence, and the moment they stop agreeing the rail on screen says\n// \"on target\" about a day the validator has already failed.\n\nexport const MACRO_STRICTNESS = ['loose', 'normal', 'strict'];\n\nexport const STRICTNESS = {\n // Tight enough to be worth chasing, and it will flag days most weeks.\n strict: { kcal: 0.03, carbs: 0.10, fat: 0.10, proteinFloor: 0 },\n // What the app has always done.\n normal: { kcal: 0.05, carbs: 0.15, fat: 0.15, proteinFloor: 0 },\n // For targets that fight each other. The protein floor gives a little, which\n // is the only thing that lets energy come back into band when protein is the\n // expensive constraint.\n loose: { kcal: 0.10, carbs: 0.20, fat: 0.20, proteinFloor: 0.05 },\n};\n\nexport const DEFAULT_STRICTNESS = 'normal';\n\n/** The bands in force, given the user's setting. */\nexport function resolveBands(settings) {\n return STRICTNESS[settings?.macroStrictness] ?? STRICTNESS[DEFAULT_STRICTNESS];\n}\n\n/**\n * The protein figure a day is actually judged against.\n *\n * Protein stays a floor at every setting — it is never a band, and being over\n * is never a miss. Loose only moves where the floor sits.\n */\nexport function effectiveProteinFloor(targets, settings) {\n const tol = resolveBands(settings).proteinFloor;\n return Math.round((targets?.protein ?? 0) * (1 - tol));\n}\n",[],[91,157],"217241a5-1935-4049-b367-b452869fc009","storemode.mjs","ebbddff2-a45a-11f1-a26f-1607ee4eb77e",23,["D",1788084583313],"// Store mode (§9, R11) — the chat for standing in an aisle, one-handed,\n// mildly annoyed.\n//\n// Every action it can take flows through the same compute + validate pipeline\n// as everything else, so the plan can never drift from its numbers. The model\n// suggests a swap; code decides what that does to the macros.\n\nimport { groupMembers } from './catalog.mjs';\nimport { validatePlan, materialRegressions } from './validate.mjs';\nimport { buildShoppingList, isEquivalent } from './shopping.mjs';\nimport { parseJSON } from './model.mjs';\nimport { serialiseCandidates } from './prompts.mjs';\n\nexport const QUICK_CHIPS = [\n { id: 'missing', label: \"Can't find it\" },\n { id: 'out', label: 'Out of stock' },\n { id: 'pricey', label: 'Too expensive' },\n { id: 'size', label: 'Wrong size' },\n];\n\n/**\n * Candidates to offer for a stuck item: its own substitute group first, then\n * groups that share its role.\n *\n * Role, not name, is the whole point. \"Couldn't find halloumi\" should return\n * something that survives a pan and carries protein, not another white cheese.\n */\nexport function substituteContext(item, catalog, { store, limit = 40 } = {}) {\n const sameGroup = groupMembers(catalog, item.substituteGroup, store)\n .filter((x) => x.id !== item.id);\n\n const roles = new Set(item.roleTags);\n const byRole = Object.values(catalog).filter((x) =>\n x.store === store\n && x.id !== item.id\n && x.substituteGroup !== item.substituteGroup\n && x.roleTags.some((r) => roles.has(r))\n && x.per100);\n\n // Closest macros first — a swap that barely moves the numbers is the best\n // answer available in a supermarket.\n byRole.sort((a, b) => macroDistance(item, a) - macroDistance(item, b));\n\n return [...sameGroup, ...byRole].slice(0, limit);\n}\n\nfunction macroDistance(a, b) {\n if (!a.per100 || !b.per100) return Infinity;\n const rel = (x, y) => (y === 0 ? (x === 0 ? 0 : 1) : Math.abs(x - y) / y);\n return rel(b.per100.kcal, a.per100.kcal) + rel(b.per100.protein, a.per100.protein);\n}\n\n/** Which meals use this item, and how much. The model needs this to answer well. */\nexport function itemContext(plan, itemId, catalog) {\n const item = catalog[itemId];\n const uses = [];\n for (const m of plan.meals) {\n for (const c of m.components || []) {\n if (c.itemId === itemId) uses.push({ mealId: m.id, name: m.name, day: m.day, slot: m.slot, grams: c.grams, role: c.role });\n }\n }\n return { item, uses, totalGrams: uses.reduce((s, u) => s + u.grams, 0) };\n}\n\nexport function buildStorePrompt({ settings, plan, itemId, catalog, message, store }) {\n const { item, uses, totalGrams } = itemContext(plan, itemId, catalog);\n const options = substituteContext(item, catalog, { store });\n\n return `You are helping someone standing in a supermarket aisle who has hit a\nproblem with one item on their shopping list. Be brief — they are holding a\nphone in one hand and a basket in the other.\n\nThey cannot get: ${item.name} (${item.id})\nIts role in the plan: ${item.roleTags.join(', ')}\nThey need ${totalGrams}${item.packUnit === 'ea' ? ' units' : 'g'} across these meals:\n${uses.map((u) => ` ${u.name} — day ${u.day} ${u.slot}, ${u.grams}${item.packUnit === 'ea' ? '' : 'g'} as the ${u.role}`).join('\\n')}\n\nDietary restrictions — still apply: ${settings.restrictions || 'none'}\nNever use: ${settings.dislikes || 'none'}\n\nWhat they said: ${JSON.stringify(message)}\n\nAlternatives available in this store. Substitute on FUNCTION, not on name —\npick something that does the same job in the dish:\n${serialiseCandidates(options)}\n\nReply in at most two short sentences, then propose exactly one action.\nDo NOT state any kcal or macro numbers — the app calculates and shows those.\n\nRespond with ONLY:\n{\n \"reply\": \"at most two short sentences\",\n \"action\": {\"type\": \"substitute\", \"fromItemId\": \"...\", \"toItemId\": \"...\"}\n}\n\nAction types:\n {\"type\":\"substitute\",\"fromItemId\":\"...\",\"toItemId\":\"...\"}\n {\"type\":\"adjustGrams\",\"mealId\":\"...\",\"itemId\":\"...\",\"grams\":123}\n {\"type\":\"dropComponent\",\"mealId\":\"...\",\"itemId\":\"...\"}\n {\"type\":\"none\"}\nUse \"none\" if nothing in the list is a reasonable stand-in.`;\n}\n\n/* ── actions ───────────────────────────────────────────────────────────── */\n\nconst ACTIONS = new Set(['substitute', 'adjustGrams', 'dropComponent', 'none']);\n\n/** Reject anything malformed or pointing at items and meals that don't exist. */\nexport function sanitiseAction(raw, plan, catalog) {\n const a = raw?.action;\n if (!a || !ACTIONS.has(a.type)) return { type: 'none' };\n\n if (a.type === 'substitute') {\n if (!catalog[a.fromItemId] || !catalog[a.toItemId]) return { type: 'none' };\n const used = plan.meals.some((m) => m.components.some((c) => c.itemId === a.fromItemId));\n if (!used) return { type: 'none' };\n return { type: 'substitute', fromItemId: a.fromItemId, toItemId: a.toItemId };\n }\n const meal = plan.meals.find((m) => m.id === a.mealId);\n if (!meal || !catalog[a.itemId]) return { type: 'none' };\n if (!meal.components.some((c) => c.itemId === a.itemId)) return { type: 'none' };\n\n if (a.type === 'dropComponent') return { type: 'dropComponent', mealId: a.mealId, itemId: a.itemId };\n const grams = Number(a.grams);\n if (!(grams > 0)) return { type: 'none' };\n return { type: 'adjustGrams', mealId: a.mealId, itemId: a.itemId, grams: Math.round(grams) };\n}\n\nexport function applyAction(plan, action, catalog) {\n if (action.type === 'none') return plan;\n\n const meals = plan.meals.map((m) => {\n if (m.locked) return m;\n\n if (action.type === 'substitute') {\n if (!m.components.some((c) => c.itemId === action.fromItemId)) return m;\n const from = catalog[action.fromItemId];\n const to = catalog[action.toItemId];\n return {\n ...m,\n components: m.components.map((c) => {\n if (c.itemId !== action.fromItemId) return c;\n // Keep the same real weight when the units differ: 3 eggs replaced by\n // tofu is 156g of tofu, not 3g.\n let grams = c.grams;\n if (from.packUnit === 'ea' && to.packUnit !== 'ea') grams = Math.round(c.grams * (from.unitGrams || 0));\n else if (from.packUnit !== 'ea' && to.packUnit === 'ea') grams = Math.max(1, Math.round(c.grams / (to.unitGrams || 1)));\n return { ...c, itemId: action.toItemId, grams };\n }),\n };\n }\n\n if (m.id !== action.mealId) return m;\n if (action.type === 'adjustGrams') {\n return { ...m, components: m.components.map((c) => (c.itemId === action.itemId ? { ...c, grams: action.grams } : c)) };\n }\n return { ...m, components: m.components.filter((c) => c.itemId !== action.itemId) };\n });\n\n return { ...plan, meals };\n}\n\n/**\n * Plain-language consequence of an action. Nobody in an aisle wants a table —\n * they want to know whether this is fine.\n */\nexport function describeImpact(before, after, targets) {\n const lines = [];\n for (const b of before.exact.perDay) {\n const a = after.exact.perDay.find((x) => x.day === b.day);\n if (!a) continue;\n const dK = Math.round(a.kcal) - Math.round(b.kcal);\n const dP = Math.round(a.protein) - Math.round(b.protein);\n if (dK === 0 && dP === 0) continue;\n\n const shortfall = targets.protein - Math.round(a.protein);\n lines.push({\n day: b.day,\n kcalDelta: dK,\n proteinDelta: dP,\n protein: Math.round(a.protein),\n proteinShort: shortfall > 0 ? shortfall : 0,\n text: `Day ${b.day} protein now ${Math.round(a.protein)}g`\n + (shortfall > 0 ? `, ${shortfall} under` : ' — still over the floor')\n + (dK ? ` (${dK > 0 ? '+' : ''}${dK} kcal)` : ''),\n });\n }\n return lines;\n}\n\n/**\n * One turn of store mode. The model proposes; this function decides.\n * Returns the reply, the recomputed plan, and the honest consequence.\n */\nexport async function storeTurn({\n model, plan, catalog, settings, itemId, message, store = settings.store,\n stock = [], pantry = {},\n}) {\n const item = catalog[itemId];\n if (!item) throw new Error(`Unknown item \"${itemId}\"`);\n\n const before = validatePlan(plan, catalog, settings);\n\n let raw;\n try {\n raw = parseJSON(await model.complete(buildStorePrompt({\n settings, plan, itemId, catalog, message, store,\n })));\n } catch (err) {\n return {\n reply: \"I couldn't work that one out — pick a different brand of the same thing and the numbers will follow.\",\n action: { type: 'none' }, applied: false, plan, error: err.message,\n };\n }\n\n const action = sanitiseAction(raw, plan, catalog);\n const reply = String(raw?.reply ?? '').slice(0, 400)\n || 'No good stand-in here.';\n\n if (action.type === 'none') {\n return { reply, action, applied: false, plan, impact: [], blocked: null };\n }\n\n const candidate = applyAction(plan, action, catalog);\n const after = validatePlan(candidate, catalog, settings);\n\n // A swap that breaks a hard constraint — or deepens one that was already\n // broken — is refused, and says why. Better to know in the aisle than to get\n // home to a plan that doesn't work.\n const regressed = materialRegressions(before, after, { targets: settings.targets });\n if (regressed.length) {\n return {\n reply, action, applied: false, plan, impact: [],\n blocked: regressed.slice(0, 2).map((f) => f.message),\n };\n }\n\n const shopping = buildShoppingList(after.plan, catalog, { store, stock, pantry });\n\n return {\n reply,\n action,\n applied: true,\n plan: {\n ...after.plan,\n shopping: shopping.lines,\n totals: { ...after.plan.totals, estCost: shopping.estCost },\n validation: { pass: after.pass, rounds: plan.validation?.rounds ?? 0, failures: after.failures, notes: after.notes },\n substitutions: [\n ...(plan.substitutions ?? []),\n ...(action.type === 'substitute'\n ? [{ fromItemId: action.fromItemId, toItemId: action.toItemId, at: Date.now() }]\n : []),\n ],\n },\n impact: describeImpact(before, after, settings.targets),\n // A swap can be worth taking and still leave you short. Say so rather than\n // hiding it behind \"applied\".\n stillShort: after.failures\n .filter((f) => f.kind === 'hard' && f.metric === 'protein')\n .map((f) => f.message),\n equivalent: action.type === 'substitute'\n && isEquivalent(catalog[action.fromItemId], catalog[action.toItemId]),\n blocked: null,\n };\n}\n",[],[91,165],"3b36e6c0-43a6-46a5-8488-b8ad6041eb6f","store.mjs","ebad45e8-a45a-11f1-8675-1607ee4eb77e",58,["D",1788227536888],"// Persistence.\n//\n// Val Town's own docs say blob storage is not concurrency safe — simultaneous\n// writes silently drop one. The spec's client-side write chain only serialises\n// writes from a single tab, which doesn't cover marking a meal on your phone\n// while the plan is open on a laptop, and doesn't help at all with the stock\n// ledger, which is read-modify-write.\n//\n// So: SQLite for anything mutable, with a revision on every document and a\n// compare-and-swap on every write. Blob stays for the catalog and label photos,\n// which are large and effectively write-once.\n//\n// This module takes a tiny driver interface so it can run on Val Town's sqlite\n// in production and node:sqlite in tests.\n\n/* A saved recipe is off, left to its frequency, or forced into the window.\n * These ride in the existing integer `enabled` column so no migration is\n * needed; anything written before this reads back as 'auto'. */\nconst USE_TO_INT = { off: 0, auto: 1, on: 2 };\nconst INT_TO_USE = { 0: 'off', 1: 'auto', 2: 'on' };\n//\n// driver.run(sql, params) → { changes }\n// driver.all(sql, params) → rows[]\n\nexport const SCHEMA = [\n `CREATE TABLE IF NOT EXISTS doc (\n key TEXT PRIMARY KEY,\n json TEXT NOT NULL,\n rev INTEGER NOT NULL,\n updated_at INTEGER NOT NULL\n )`,\n // Per-meal rows, deliberately not folded into the plan document. Marking one\n // meal in a supermarket must not rewrite the whole plan — that's the write\n // most likely to happen concurrently and the one that would lose the most.\n `CREATE TABLE IF NOT EXISTS meal_status (\n plan_id TEXT NOT NULL,\n meal_id TEXT NOT NULL,\n status TEXT NOT NULL,\n note TEXT,\n at INTEGER NOT NULL,\n PRIMARY KEY (plan_id, meal_id)\n )`,\n `CREATE TABLE IF NOT EXISTS stock (\n id TEXT PRIMARY KEY,\n item_id TEXT NOT NULL,\n grams REAL NOT NULL,\n unit TEXT NOT NULL DEFAULT 'g',\n good_from INTEGER NOT NULL,\n shelf_life_days INTEGER NOT NULL,\n cooked INTEGER NOT NULL DEFAULT 0,\n source TEXT,\n note TEXT\n )`,\n `CREATE INDEX IF NOT EXISTS stock_item ON stock (item_id)`,\n // Meals the user supplied. Their own row so editing one can't clobber\n // another, same reasoning as meal_status.\n `CREATE TABLE IF NOT EXISTS recipe (\n id TEXT PRIMARY KEY,\n name TEXT NOT NULL,\n slot TEXT NOT NULL,\n servings INTEGER NOT NULL DEFAULT 1,\n frequency TEXT NOT NULL DEFAULT 'every-window',\n enabled INTEGER NOT NULL DEFAULT 1,\n scale_portions INTEGER NOT NULL DEFAULT 1,\n max_per_window INTEGER,\n components TEXT NOT NULL,\n steps TEXT,\n unmatched TEXT,\n source_text TEXT,\n updated_at INTEGER NOT NULL\n )`,\n // Photo verifications. One row per planned meal, so the same dinner cannot\n // be claimed twice.\n `CREATE TABLE IF NOT EXISTS meal_proof (\n plan_id TEXT NOT NULL,\n meal_id TEXT NOT NULL,\n verdict TEXT NOT NULL,\n meal_name TEXT,\n day INTEGER,\n slot TEXT,\n identified TEXT,\n reason TEXT,\n stamp TEXT,\n at INTEGER NOT NULL,\n PRIMARY KEY (plan_id, meal_id)\n )`,\n // Nutrition read off a real packet. Kept apart from the catalog so a refresh\n // can update prices without ever overwriting a measured value.\n `CREATE TABLE IF NOT EXISTS label_capture (\n item_id TEXT PRIMARY KEY,\n id TEXT NOT NULL,\n captured_at INTEGER NOT NULL,\n per100 TEXT NOT NULL,\n previous TEXT,\n notes TEXT\n )`,\n];\n\nexport class Store {\n constructor(driver) { this.d = driver; }\n\n async init() {\n for (const sql of SCHEMA) await this.d.run(sql, []);\n }\n\n /* ── documents ─────────────────────────────────────────────────────────── */\n\n async getDoc(key) {\n const rows = await this.d.all('SELECT json, rev FROM doc WHERE key = ?', [key]);\n if (!rows.length) return { value: null, rev: 0 };\n return { value: JSON.parse(rows[0].json), rev: Number(rows[0].rev) };\n }\n\n /**\n * Write only if the document is still at `ifRev`. A caller working from a\n * stale copy is told, rather than silently overwriting whatever landed since.\n * Pass ifRev = 0 to create.\n */\n async putDoc(key, value, ifRev, { now = Date.now() } = {}) {\n const json = JSON.stringify(value);\n\n if (ifRev === 0) {\n const res = await this.d.run(\n 'INSERT INTO doc (key, json, rev, updated_at) VALUES (?, ?, 1, ?) ON CONFLICT(key) DO NOTHING',\n [key, json, now],\n );\n if (!res.changes) {\n const cur = await this.getDoc(key);\n return { ok: false, conflict: true, current: cur };\n }\n return { ok: true, rev: 1 };\n }\n\n const res = await this.d.run(\n 'UPDATE doc SET json = ?, rev = rev + 1, updated_at = ? WHERE key = ? AND rev = ?',\n [json, now, key, ifRev],\n );\n if (!res.changes) {\n const cur = await this.getDoc(key);\n return { ok: false, conflict: true, current: cur };\n }\n return { ok: true, rev: ifRev + 1 };\n }\n\n /**\n * Read, transform, write — retried on conflict. This is the shape that loses\n * data on blob storage, so it's the one that gets a real loop.\n */\n async updateDoc(key, fn, { attempts = 5, now = Date.now() } = {}) {\n for (let i = 0; i < attempts; i++) {\n const { value, rev } = await this.getDoc(key);\n const next = await fn(value);\n if (next === undefined) return { ok: true, rev, unchanged: true };\n const res = await this.putDoc(key, next, rev, { now });\n if (res.ok) return { ok: true, rev: res.rev, value: next };\n }\n throw new Error(`Could not update \"${key}\" after ${attempts} attempts — something else is writing continuously`);\n }\n\n /* ── meal status ───────────────────────────────────────────────────────── */\n\n /** One row per meal. Two meals marked at once cannot clobber each other. */\n async setMealStatus(planId, mealId, status, { note = null, at = Date.now() } = {}) {\n await this.d.run(\n `INSERT INTO meal_status (plan_id, meal_id, status, note, at) VALUES (?, ?, ?, ?, ?)\n ON CONFLICT(plan_id, meal_id) DO UPDATE SET status = excluded.status, note = excluded.note, at = excluded.at`,\n [planId, mealId, status, note, at],\n );\n return { ok: true };\n }\n\n async clearMealStatus(planId, mealId) {\n await this.d.run('DELETE FROM meal_status WHERE plan_id = ? AND meal_id = ?', [planId, mealId]);\n return { ok: true };\n }\n\n async mealStatuses(planId) {\n const rows = await this.d.all(\n 'SELECT meal_id, status, note, at FROM meal_status WHERE plan_id = ?', [planId],\n );\n return Object.fromEntries(rows.map((r) => [r.meal_id, { status: r.status, note: r.note, at: Number(r.at) }]));\n }\n\n /** Apply stored statuses onto a plan read from its document. */\n async hydratePlan(plan) {\n if (!plan) return plan;\n const statuses = await this.mealStatuses(plan.id);\n return {\n ...plan,\n meals: plan.meals.map((m) => {\n const s = statuses[m.id];\n return s ? { ...m, status: s.status, statusNote: s.note, statusAt: s.at } : m;\n }),\n };\n }\n\n /* ── stock ledger ──────────────────────────────────────────────────────── */\n\n async listStock() {\n const rows = await this.d.all('SELECT * FROM stock', []);\n return rows.map((r) => ({\n id: r.id,\n itemId: r.item_id,\n grams: Number(r.grams),\n unit: r.unit || 'g',\n goodFrom: Number(r.good_from),\n shelfLifeDays: Number(r.shelf_life_days),\n cooked: !!r.cooked,\n source: r.source,\n note: r.note,\n }));\n }\n\n /** Replace the ledger wholesale — used after a shop is committed. */\n async replaceStock(entries, { idPrefix = 's' } = {}) {\n await this.d.run('DELETE FROM stock', []);\n let i = 0;\n for (const e of entries) {\n await this.d.run(\n `INSERT INTO stock (id, item_id, grams, unit, good_from, shelf_life_days, cooked, source, note)\n VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,\n [e.id ?? `${idPrefix}-${Date.now()}-${i++}`, e.itemId, e.grams, e.unit ?? 'g', e.goodFrom,\n e.shelfLifeDays, e.cooked ? 1 : 0, e.source ?? null, e.note ?? null],\n );\n }\n return { ok: true, count: entries.length };\n }\n\n async addStock(entries, { idPrefix = 's' } = {}) {\n let i = 0;\n for (const e of entries) {\n await this.d.run(\n `INSERT INTO stock (id, item_id, grams, good_from, shelf_life_days, cooked, source, note)\n VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,\n [e.id ?? `${idPrefix}-${Date.now()}-${i++}`, e.itemId, e.grams, e.goodFrom,\n e.shelfLifeDays, e.cooked ? 1 : 0, e.source ?? null, e.note ?? null],\n );\n }\n return { ok: true, count: entries.length };\n }\n\n /* ── label captures ────────────────────────────────────────────────────── */\n\n async saveLabel({ itemId, per100, previous = null, notes = null, at = Date.now() }) {\n await this.d.run(\n `INSERT INTO label_capture (item_id, id, captured_at, per100, previous, notes)\n VALUES (?, ?, ?, ?, ?, ?)\n ON CONFLICT(item_id) DO UPDATE SET\n id = excluded.id, captured_at = excluded.captured_at,\n per100 = excluded.per100, previous = excluded.previous, notes = excluded.notes`,\n [itemId, `lc-${itemId}-${at}`, at, JSON.stringify(per100),\n previous ? JSON.stringify(previous) : null, notes],\n );\n return { ok: true };\n }\n\n async listLabels() {\n const rows = await this.d.all('SELECT * FROM label_capture', []);\n return rows.map((r) => ({\n id: r.id,\n itemId: r.item_id,\n capturedAt: Number(r.captured_at),\n per100: JSON.parse(r.per100),\n previous: r.previous ? JSON.parse(r.previous) : null,\n notes: r.notes,\n }));\n }\n\n async deleteLabel(itemId) {\n await this.d.run('DELETE FROM label_capture WHERE item_id = ?', [itemId]);\n return { ok: true };\n }\n\n /* ── meal proof ────────────────────────────────────────────────────────── */\n\n async saveProof(planId, p) {\n await this.d.run(\n `INSERT INTO meal_proof (plan_id, meal_id, verdict, meal_name, day, slot, identified, reason, stamp, at)\n VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)\n ON CONFLICT(plan_id, meal_id) DO UPDATE SET\n verdict = excluded.verdict, identified = excluded.identified,\n reason = excluded.reason, stamp = excluded.stamp, at = excluded.at`,\n [planId, p.mealId, p.verdict, p.mealName ?? null, p.day ?? null, p.slot ?? null,\n JSON.stringify(p.identified ?? []), p.reason ?? null, p.stamp ?? null, p.at],\n );\n return { ok: true };\n }\n\n async listProofs(planId) {\n const rows = await this.d.all(\n planId ? 'SELECT * FROM meal_proof WHERE plan_id = ? ORDER BY at DESC' : 'SELECT * FROM meal_proof ORDER BY at DESC',\n planId ? [planId] : [],\n );\n return rows.map((r) => ({\n planId: r.plan_id, mealId: r.meal_id, verdict: r.verdict, mealName: r.meal_name,\n day: r.day == null ? null : Number(r.day), slot: r.slot,\n identified: JSON.parse(r.identified || '[]'), reason: r.reason,\n stamp: r.stamp, at: Number(r.at),\n }));\n }\n\n async deleteProof(planId, mealId) {\n await this.d.run('DELETE FROM meal_proof WHERE plan_id = ? AND meal_id = ?', [planId, mealId]);\n return { ok: true };\n }\n\n /** The most recent verification of any meal, for the card. */\n async latestProof() {\n const [row] = await this.d.all('SELECT * FROM meal_proof ORDER BY at DESC LIMIT 1', []);\n if (!row) return null;\n return {\n planId: row.plan_id, mealId: row.meal_id, verdict: row.verdict, mealName: row.meal_name,\n day: row.day == null ? null : Number(row.day), slot: row.slot,\n identified: JSON.parse(row.identified || '[]'), reason: row.reason,\n stamp: row.stamp, at: Number(row.at),\n };\n }\n\n /* ── recipes ───────────────────────────────────────────────────────────── */\n\n /** How a saved recipe is treated when the next plan is built. */\n static get USE_MODES() { return ['off', 'auto', 'on']; }\n\n async saveRecipe(r, { now = Date.now() } = {}) {\n const id = r.id || `rc-${now}-${Math.random().toString(36).slice(2, 7)}`;\n await this.d.run(\n `INSERT INTO recipe (id, name, slot, servings, frequency, enabled, scale_portions,\n max_per_window, components, steps, unmatched, source_text, updated_at)\n VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)\n ON CONFLICT(id) DO UPDATE SET\n name = excluded.name, slot = excluded.slot, servings = excluded.servings,\n frequency = excluded.frequency, enabled = excluded.enabled,\n scale_portions = excluded.scale_portions, max_per_window = excluded.max_per_window,\n components = excluded.components, steps = excluded.steps,\n unmatched = excluded.unmatched, source_text = excluded.source_text,\n updated_at = excluded.updated_at`,\n // `enabled` carries three states, not two: 0 off, 1 let the frequency\n // decide, 2 force it into this window. Widening the existing column\n // avoids a migration, and rows written before this read back as 1 —\n // \"let the frequency decide\" — which is what they already meant.\n [id, r.name, r.slot, r.servings ?? 1, r.frequency ?? 'every-window',\n USE_TO_INT[r.use] ?? (r.enabled === false ? 0 : 1), r.scalePortions === false ? 0 : 1,\n r.maxPerWindow ?? null, JSON.stringify(r.components ?? []),\n JSON.stringify(r.steps ?? []), JSON.stringify(r.unmatched ?? []),\n r.sourceText ?? null, now],\n );\n return { ok: true, id };\n }\n\n async listRecipes() {\n const rows = await this.d.all('SELECT * FROM recipe ORDER BY updated_at DESC', []);\n return rows.map((r) => ({\n id: r.id, name: r.name, slot: r.slot,\n servings: Number(r.servings), frequency: r.frequency,\n use: INT_TO_USE[Number(r.enabled)] ?? 'auto',\n enabled: Number(r.enabled) !== 0, scalePortions: !!r.scale_portions,\n maxPerWindow: r.max_per_window == null ? null : Number(r.max_per_window),\n components: JSON.parse(r.components),\n steps: JSON.parse(r.steps || '[]'),\n unmatched: JSON.parse(r.unmatched || '[]'),\n sourceText: r.source_text,\n updatedAt: Number(r.updated_at),\n }));\n }\n\n async deleteRecipe(id) {\n await this.d.run('DELETE FROM recipe WHERE id = ?', [id]);\n return { ok: true };\n }\n}\n\nexport const KEYS = {\n settings: 'settings',\n currentPlan: 'plan_current',\n history: 'plan_history',\n favourites: 'favourites',\n pantry: 'pantry',\n};\n",[],[91,173],"3a6751c7-5bea-4617-8748-839d43e432c5","solver.mjs","eb9c074c-a45a-11f1-8099-1607ee4eb77e",89,["D",1788929069814],4,"// Phase D-0 — deterministic portion solver.\n//\n// Adjusting grams to hit macro targets is an optimisation, not a judgement\n// call. Doing it in code means the model is only asked when the COMPOSITION is\n// wrong, not when the arithmetic is. Runs before Phase D and usually removes\n// the need for it.\n\nimport { computeMeal, gramsOf } from './compute.mjs';\nimport { effectiveProteinFloor } from './strictness.mjs';\n\n/** How far a portion may move from what the planner proposed, by role. */\nconst ROLE_SCALE = {\n protein: [0.60, 1.80],\n 'carb-base': [0.50, 2.00],\n veg: [0.50, 2.00],\n green: [0.50, 2.00],\n fruit: [0.50, 2.00],\n dairy: [0.60, 1.60],\n fat: [0.50, 1.50],\n sauce: [0.75, 1.40],\n flavour: [1, 1], // seasoning quantities are not a macro lever\n acid: [1, 1],\n spice: [1, 1],\n};\n\n/** Absolute sanity bounds in grams, so nobody is served 900g of chicken. */\nconst ROLE_ABS = {\n protein: [40, 400],\n 'carb-base': [20, 350],\n veg: [30, 500],\n green: [20, 300],\n fruit: [40, 400],\n dairy: [20, 500],\n fat: [5, 80],\n sauce: [10, 200],\n};\n\nconst roleOf = (c, item) => c.role || item?.roleTags?.[0] || 'veg';\n\nfunction dayCost(t, targets, floor = targets.protein) {\n const rel = (a, b) => (a - b) / b;\n let cost = 0;\n cost += 6 * rel(t.kcal, targets.kcal) ** 2;\n cost += 1 * rel(t.carbs, targets.carbs) ** 2;\n cost += 1 * rel(t.fat, targets.fat) ** 2;\n // Protein is a floor: being under is punished hard, being over is free\n // until it gets silly.\n // Measured against the floor actually in force. On the loose setting the\n // floor sits below the target, and the solver must stop buying protein with\n // calories once it is cleared — otherwise loosening changes nothing.\n const short = Math.max(0, floor - t.protein) / Math.max(1, targets.protein);\n cost += 12 * short ** 2;\n // The quadratic alone prices a 1g shortfall at almost nothing, so the search\n // settles a gram under a floor the validator treats as pass/fail — a hard\n // failure traded away for a rounding error of kcal. A small linear term makes\n // any shortfall worth roughly seven percent of energy drift to clear. It is\n // exactly zero once the floor is met, so a compliant plan is never pushed.\n if (short > 0) cost += 1 * short;\n const wayOver = Math.max(0, t.protein - targets.protein * 1.6) / Math.max(1, targets.protein);\n cost += 1 * wayOver ** 2;\n return cost;\n}\n\nfunction dayTotals(meals, catalog) {\n const t = { kcal: 0, protein: 0, carbs: 0, fat: 0 };\n for (const m of meals) {\n const { exact } = computeMeal(m, catalog);\n t.kcal += exact.kcal; t.protein += exact.protein;\n t.carbs += exact.carbs; t.fat += exact.fat;\n }\n return t;\n}\n\n/**\n * The absolute range a component may take, in its OWN unit — a count for items\n * sold each, grams otherwise.\n *\n * ROLE_ABS is the only thing standing between a search that re-derives its\n * range each round and a portion that doubles forever. The gram path always\n * applied it; the counted path did not, so counted items ratcheted 1 → 2 → 4 →\n * 8 and a plan ended up asking for eleven whole heads of celery.\n */\nfunction absoluteBounds(item, role) {\n // No entry means no opinion. Seasonings live here — a teaspoon of bay leaves\n // is 1g, and a default floor of 10g turns it into forty leaves.\n if (!ROLE_ABS[role]) return null;\n const [absLo, absHi] = ROLE_ABS[role];\n if (item.packUnit !== 'ea') return [absLo, absHi];\n\n const each = Number(item.unitGrams) > 0 ? Number(item.unitGrams) : null;\n // Without a unit weight there is nothing to reason with, so allow a small\n // count rather than an unbounded one.\n if (!each) return [1, 6];\n return [Math.max(1, Math.floor(absLo / each)), Math.max(1, Math.floor(absHi / each))];\n}\n\n/**\n * Pull a component inside its absolute bounds.\n *\n * Not an optimisation — a value already outside the bounds must come back\n * whether or not the move happens to lower the cost, or a plan carrying\n * 5kg of celery keeps it forever because celery is nearly calorie-free and the\n * search has no reason to care.\n */\nfunction clampToBounds(item, c, role) {\n // A role the solver is not allowed to scale is not one it may quietly resize\n // either — seasoning quantities are the recipe's, not the optimiser's.\n const [loS, hiS] = ROLE_SCALE[role] ?? [0.7, 1.5];\n if (loS === 1 && hiS === 1) return c.grams;\n\n const bounds = absoluteBounds(item, role);\n if (!bounds) return c.grams;\n const next = Math.min(bounds[1], Math.max(bounds[0], c.grams));\n return item.packUnit === 'ea' ? Math.round(next) : next;\n}\n\nfunction candidateAmounts(item, c, role) {\n const [loS, hiS] = ROLE_SCALE[role] ?? [0.7, 1.5];\n if (loS === 1 && hiS === 1) return null; // fixed — don't touch\n const bounds = absoluteBounds(item, role);\n if (!bounds) return null; // no sane range to search within\n const [absLo, absHi] = bounds;\n\n if (item.packUnit === 'ea') {\n const lo = Math.max(absLo, Math.max(1, Math.floor(c.grams * loS)));\n const hi = Math.min(absHi, Math.max(lo, Math.ceil(c.grams * hiS)));\n if (hi <= lo) return null;\n const out = [];\n for (let n = lo; n <= hi; n++) out.push(n);\n return out;\n }\n\n const lo = Math.max(absLo, Math.round((c.grams * loS) / 5) * 5);\n const hi = Math.min(absHi, Math.round((c.grams * hiS) / 5) * 5);\n if (hi <= lo) return null;\n const out = [];\n for (let g = lo; g <= hi; g += 5) out.push(g);\n return out;\n}\n\n/**\n * Adjust portion grams to minimise band violations, day by day.\n * Locked meals are never touched. Returns a new plan plus a change log.\n */\nexport function solveGrams(plan, catalog, settings, { maxPasses = 12, rounds = 4 } = {}) {\n const targets = settings.targets;\n const floor = effectiveProteinFloor(targets, settings);\n const meals = plan.meals.map((m) => ({ ...m, components: m.components.map((c) => ({ ...c })) }));\n const changes = [];\n\n for (let day = 1; day <= plan.days; day++) {\n const dayMeals = meals.filter((m) => m.day === day);\n if (!dayMeals.length) continue;\n\n // Recorded before anything moves, so the change log still reports the\n // distance from what the planner actually proposed.\n const originals = new Map();\n for (const m of dayMeals) for (const c of m.components) originals.set(c, c.grams);\n\n // Bring anything already out of bounds back before optimising, including on\n // locked meals — an absurd quantity is not a preference to be respected.\n for (const m of dayMeals) {\n for (const c of m.components) {\n const item = catalog[c.itemId];\n if (!item?.per100) continue;\n c.grams = clampToBounds(item, c, roleOf(c, item));\n }\n }\n\n // candidateAmounts derives each option range from the component's CURRENT\n // grams, so one round can only move a portion within 0.6-1.8x of where the\n // planner put it. Re-deriving the ranges around the improved amounts lets\n // the search carry on where it is still paying off — which is worth 15g of\n // protein a day on a plan that would otherwise ship under the floor.\n // ROLE_ABS still caps the result absolutely, so this cannot run away.\n for (let round = 0; round < rounds; round++) {\n const adjustable = [];\n for (const m of dayMeals) {\n if (m.locked) continue;\n for (const c of m.components) {\n const item = catalog[c.itemId];\n if (!item?.per100) continue;\n const role = roleOf(c, item);\n const options = candidateAmounts(item, c, role);\n if (options) adjustable.push({ meal: m, c, item, options });\n }\n }\n if (!adjustable.length) break;\n\n let best = dayCost(dayTotals(dayMeals, catalog), targets, floor);\n let movedThisRound = false;\n\n for (let pass = 0; pass < maxPasses; pass++) {\n let improved = false;\n for (const a of adjustable) {\n const start = a.c.grams;\n let bestVal = start;\n for (const v of a.options) {\n if (v === start) continue;\n a.c.grams = v;\n const cost = dayCost(dayTotals(dayMeals, catalog), targets, floor);\n if (cost < best - 1e-9) { best = cost; bestVal = v; }\n }\n a.c.grams = bestVal;\n if (bestVal !== start) { improved = true; movedThisRound = true; }\n }\n if (!improved) break;\n }\n if (!movedThisRound) break;\n }\n\n for (const m of dayMeals) {\n for (const c of m.components) {\n const from = originals.get(c);\n if (from !== undefined && c.grams !== from) {\n const item = catalog[c.itemId];\n changes.push({\n day, mealId: m.id, itemId: c.itemId, name: item?.name ?? c.itemId,\n from, to: c.grams,\n unit: item?.packUnit === 'ea' ? 'units' : 'g',\n });\n }\n }\n }\n }\n\n return { plan: { ...plan, meals }, changes };\n}\n\nexport { gramsOf };\n",[],[91,181],"89fdf7d7-f030-4d8e-abf1-f9b8d1c12099","slots.mjs","68fdfc8e-a5b6-11f1-bce9-1607ee4eb77e",73,["D",1788233828901],"// What a slot actually means.\n//\n// Breakfast, lunch and dinner are times of day, not categories of food. Curry\n// at 8am is a normal thing to eat and the planner should be free to put it\n// there; treating them as separate cuisines only narrows the search and pushes\n// protein towards the end of the day.\n//\n// A snack is genuinely different — it is a smaller meal, not a differently\n// flavoured one — so it keeps its own share and never swaps with a main.\n\nexport const MAIN_SLOTS = ['breakfast', 'lunch', 'dinner'];\n\nexport const isMain = (slot) => MAIN_SLOTS.includes(slot);\n\n/** A snack carries about half of what a main meal carries. */\nexport const SNACK_SHARE = 0.5;\n\n/**\n * Which slots a meal written for `slot` may actually occupy, best first.\n *\n * Mains are interchangeable with each other; a snack stays a snack, because\n * moving one into a main slot would leave that meal a third of the size the\n * day needs it to be.\n */\nexport function interchangeableWith(slot, available = MAIN_SLOTS) {\n if (!isMain(slot)) return available.includes(slot) ? [slot] : [];\n // Nearest time of day first, so a dinner that overruns takes the lunch before\n // it takes the breakfast.\n const home = MAIN_SLOTS.indexOf(slot);\n const rest = MAIN_SLOTS\n .filter((s) => s !== slot && available.includes(s))\n .sort((a, b) => Math.abs(MAIN_SLOTS.indexOf(a) - home) - Math.abs(MAIN_SLOTS.indexOf(b) - home));\n return available.includes(slot) ? [slot, ...rest] : rest;\n}\n\n/** How many places a meal written for `slot` could occupy across `days`. */\nexport function capacityFor(slot, slots, days) {\n return interchangeableWith(slot, slots).length * days;\n}\n\n/**\n * How the day's macros divide across the configured slots.\n *\n * Every main gets an equal share. The old fixed weights ran breakfast 0.20 /\n * lunch 0.30 / dinner 0.35, which is the very back-loading the protein hints\n * exist to prevent — it told the model to put 36g of protein in breakfast and\n * 63g in dinner, and a day built that way cannot be fixed by portion tweaks.\n */\nexport function slotShares(slots) {\n const weight = (s) => (isMain(s) ? 1 : SNACK_SHARE);\n const total = slots.reduce((sum, s) => sum + weight(s), 0);\n if (!total) return slots.map((slot) => ({ slot, share: 0 }));\n return slots.map((slot) => ({ slot, share: weight(slot) / total }));\n}\n",[],[91,190],"c04fca95-81c9-4f6a-a8de-2585fd246d7f","shopping.mjs","eb92da28-a45a-11f1-901c-1607ee4eb77e",38,["D",1788087061138],"// Phase E — shopping consolidation. Pure arithmetic.\n\nimport { gramsOf } from './compute.mjs';\nimport { groupMembers } from './catalog.mjs';\nimport { stockByGroup, firstUseDayByGroup } from './reconcile.mjs';\n\nconst EQUIV = { kcal: 0.10, protein: 0.15 };\n\nconst perUnitPrice = (it) => (it.price ?? Infinity) / (it.packSize || 1);\n\n/** Is `cand` close enough to `primary` to swap without moving the numbers? */\nexport function isEquivalent(primary, cand) {\n const a = primary.per100, b = cand.per100;\n if (!a || !b) return false;\n const rel = (x, y) => (y === 0 ? (x === 0 ? 0 : 1) : Math.abs(x - y) / y);\n return rel(b.kcal, a.kcal) <= EQUIV.kcal && rel(b.protein, a.protein) <= EQUIV.protein;\n}\n\n/**\n * Rank substitutes for one line. Spec order is macro closeness, then price,\n * then favourites — but favourites sorted after price never actually surface,\n * so favourites are applied within the equivalent tier instead.\n */\nexport function rankCandidates(primary, catalog, { store, favourites = new Set(), limit = 3 } = {}) {\n const members = groupMembers(catalog, primary.substituteGroup, store)\n .filter((it) => it.id !== primary.id && !it.discontinued);\n\n members.sort((x, y) => {\n const ex = isEquivalent(primary, x), ey = isEquivalent(primary, y);\n if (ex !== ey) return ex ? -1 : 1;\n const fx = favourites.has(x.id), fy = favourites.has(y.id);\n if (fx !== fy) return fx ? -1 : 1;\n return perUnitPrice(x) - perUnitPrice(y);\n });\n\n return [primary, ...members].slice(0, limit);\n}\n\n/** Per-100 macro delta of a candidate vs the primary, and its daily impact. */\nexport function candidateDelta(primary, cand, requiredGrams, days) {\n if (!primary.per100 || !cand.per100) return null;\n const dK = cand.per100.kcal - primary.per100.kcal;\n const dP = cand.per100.protein - primary.per100.protein;\n return {\n kcalPer100: Math.round(dK),\n proteinPer100: Math.round(dP * 10) / 10,\n kcalPerDay: Math.round((dK * requiredGrams / 100) / Math.max(1, days)),\n equivalent: isEquivalent(primary, cand),\n };\n}\n\n/**\n * Build the shopping list.\n *\n * pantry: { [substituteGroup]: gramsOnHand } — things the user has ticked as\n * already owned. Treated as always available.\n * stock: StockEntry[] — the aged ledger (pack surplus, uneaten meals). Only\n * counted where it survives long enough to reach the day the plan needs it.\n */\nexport function buildShoppingList(plan, catalog, {\n store, favourites = new Set(), pantry = {}, stock = [], now = Date.now(),\n} = {}) {\n const fromStock = stock.length\n ? stockByGroup(stock, catalog, { firstUseDay: firstUseDayByGroup(plan, catalog), now })\n : {};\n const onHandFor = (group) => (pantry[group] || 0) + (fromStock[group] || 0);\n // 1. aggregate requirement per substitute group\n const need = new Map(); // group → { totalGrams, byItem: Map }\n for (const meal of plan.meals) {\n for (const c of meal.components || []) {\n const item = catalog[c.itemId];\n if (!item) continue;\n const g = item.packUnit === 'ea' ? c.grams : gramsOf(item, c.grams);\n const e = need.get(item.substituteGroup) || { totalGrams: 0, byItem: new Map(), unit: item.packUnit };\n e.totalGrams += g;\n e.byItem.set(item.id, (e.byItem.get(item.id) || 0) + g);\n need.set(item.substituteGroup, e);\n }\n }\n\n const lines = [];\n for (const [group, e] of need) {\n // primary = the member this plan actually leans on most\n const primaryId = [...e.byItem].sort((a, b) => b[1] - a[1])[0][0];\n const primary = catalog[primaryId];\n\n const members = groupMembers(catalog, group, store);\n const mixedUnits = new Set(members.map((m) => m.packUnit)).size > 1;\n\n // 2. subtract what's already on hand\n const onHand = onHandFor(group);\n const requiredGrams = Math.max(0, e.totalGrams - onHand);\n\n // 3–5. pack maths\n const packsToBuy = requiredGrams === 0 ? 0 : Math.ceil(requiredGrams / primary.packSize);\n const surplusGrams = packsToBuy * primary.packSize - requiredGrams;\n const estCost = Math.round(packsToBuy * (primary.price ?? 0) * 100) / 100;\n\n // 6. candidates\n const candidates = rankCandidates(primary, catalog, { store, favourites });\n\n lines.push({\n id: `line-${group}`,\n label: `${requiredGrams}${primary.packUnit === 'ea' ? '' : primary.packUnit} ${group.replace(/-/g, ' ')}`,\n role: primary.roleTags[0],\n substituteGroup: group,\n requiredGrams,\n requestedGrams: e.totalGrams,\n fromPantryGrams: Math.min(onHand, e.totalGrams),\n fromStockGrams: Math.min(fromStock[group] || 0, e.totalGrams),\n primaryItemId: primaryId,\n candidates: candidates.map((c) => ({\n itemId: c.id,\n name: c.name,\n packSize: c.packSize,\n packUnit: c.packUnit,\n price: c.price,\n delta: c.id === primaryId ? null : candidateDelta(primary, c, requiredGrams, plan.days),\n })),\n packSize: primary.packSize,\n packUnit: primary.packUnit,\n packsToBuy,\n surplusGrams,\n estCost,\n aisle: primary.aisle,\n pickOrder: primary.pickOrder,\n staple: primary.staple,\n alreadyHave: requiredGrams === 0,\n carryForward: primary.carryForward,\n warnings: mixedUnits ? [`substitute group \"${group}\" mixes pack units`] : [],\n });\n }\n\n // fresh picked last\n lines.sort((a, b) => a.pickOrder - b.pickOrder || a.aisle.localeCompare(b.aisle));\n\n const estCost = Math.round(lines.reduce((s, l) => s + l.estCost, 0) * 100) / 100;\n return { lines, estCost };\n}\n\n/**\n * Shelf-stable surplus that should reduce the next shop. Perishable surplus is\n * Phase F's problem, not the pantry's.\n */\nexport function carryForwardPantry(shopping, catalog) {\n const next = {};\n for (const line of shopping.lines) {\n const primary = catalog[line.primaryItemId];\n if (!primary?.carryForward) continue;\n if (line.surplusGrams > 0) next[line.substituteGroup] = line.surplusGrams;\n }\n return next;\n}\n",[],[91,198],"81ecc140-91aa-4745-b177-f9a837545f7e","reconcile.mjs","eb812116-a45a-11f1-b41e-1607ee4eb77e",18,["D",1788084583025],"// Reconciliation (what actually got eaten) and the stock ledger (what's left\n// in the fridge because of it).\n//\n// The point isn't the checkbox. A dinner you didn't cook means its ingredients\n// are still in your fridge and are now older than when you bought them. That\n// fact has to survive into the next cycle or the next shop buys them again.\n\nconst DAY_MS = 86400000;\n\nexport const STATUSES = ['planned', 'ate', 'ate-elsewhere', 'skipped'];\n\n/** Only 'ate' consumes the ingredients. Everything else leaves them on hand. */\nexport const CONSUMES = { planned: false, ate: true, 'ate-elsewhere': false, skipped: false };\n\n/**\n * Cooked food keeps for less time than the raw ingredients did, and the clock\n * restarts at cooking. This is a conservative default, not a lookup — it's\n * exposed so it can be changed rather than buried.\n */\nexport const COOKED_LEFTOVER_DAYS = 3;\n\nexport const daysBetween = (from, to) => Math.floor((to - from) / DAY_MS);\n\n/** Record what happened to one meal. Returns a new plan. */\nexport function setMealStatus(plan, mealId, status, { note = null, at = Date.now() } = {}) {\n if (!STATUSES.includes(status)) throw new Error(`Unknown meal status \"${status}\"`);\n let found = false;\n const meals = plan.meals.map((m) => {\n if (m.id !== mealId) return m;\n found = true;\n return { ...m, status, statusNote: note, statusAt: at };\n });\n if (!found) throw new Error(`No meal \"${mealId}\" in this plan`);\n return { ...plan, meals };\n}\n\n/**\n * Adherence. Meals still marked 'planned' are unknown, not misses — counting\n * them as failures would make every in-progress plan look terrible.\n */\nexport function adherence(plan) {\n const counts = { planned: 0, ate: 0, 'ate-elsewhere': 0, skipped: 0 };\n for (const m of plan.meals) counts[m.status ?? 'planned']++;\n\n const decided = plan.meals.length - counts.planned;\n return {\n total: plan.meals.length,\n ...counts,\n decided,\n // null rather than 0 or 100 when nothing has been recorded yet — an\n // undefined rate must not read as a real one.\n rate: decided === 0 ? null : counts.ate / decided,\n byDay: [...new Set(plan.meals.map((m) => m.day))].sort((a, b) => a - b).map((day) => {\n const ms = plan.meals.filter((m) => m.day === day);\n const d = ms.filter((m) => (m.status ?? 'planned') !== 'planned');\n return {\n day,\n ate: ms.filter((m) => m.status === 'ate').length,\n decided: d.length,\n total: ms.length,\n };\n }),\n };\n}\n\n/** Components from meals that were not eaten — still in the fridge. */\nexport function unusedComponents(plan, catalog) {\n const out = [];\n for (const m of plan.meals) {\n const status = m.status ?? 'planned';\n if (status === 'planned' || CONSUMES[status]) continue;\n for (const c of m.components || []) {\n if (!catalog[c.itemId]) continue;\n out.push({\n itemId: c.itemId,\n grams: c.grams,\n mealId: m.id,\n mealName: m.name,\n day: m.day,\n status,\n // Batched meals are cooked ahead, so a skipped one leaves cooked food,\n // not raw ingredients — different clock, shorter life.\n cooked: (m.cookDay ?? m.day) < m.day,\n cookDay: m.cookDay ?? m.day,\n });\n }\n }\n return out;\n}\n\n/**\n * Turn unused components into stock entries.\n * `shoppedOn` is the epoch ms of the shop, i.e. plan day 1.\n */\nexport function returnToStock(plan, catalog, { shoppedOn = plan.createdAt ?? Date.now() } = {}) {\n return unusedComponents(plan, catalog).map((u) => {\n const item = catalog[u.itemId];\n // Held in the item's OWN unit: counts for 'ea', grams or ml otherwise.\n // The shopping list does its pack maths in that unit too, so the ledger\n // and the list can be subtracted from each other directly.\n const grams = u.grams;\n // Raw ingredients age from the shop; cooked food ages from its cook day.\n const from = u.cooked ? shoppedOn + (u.cookDay - 1) * DAY_MS : shoppedOn;\n return {\n itemId: u.itemId,\n grams,\n unit: item.packUnit,\n goodFrom: from,\n shelfLifeDays: u.cooked ? COOKED_LEFTOVER_DAYS : item.shelfLifeDays,\n cooked: u.cooked,\n source: u.cooked ? 'cooked-not-eaten' : 'unused-ingredient',\n note: `${u.mealName} (day ${u.day}, ${u.status})`,\n };\n });\n}\n\n/** Shelf-stable surplus from the shop, as stock rather than a separate concept. */\nexport function surplusToStock(shopping, catalog, { shoppedOn = Date.now() } = {}) {\n const out = [];\n for (const line of shopping.lines) {\n if (line.surplusGrams <= 0) continue;\n const item = catalog[line.primaryItemId];\n if (!item?.carryForward) continue;\n out.push({\n itemId: item.id,\n grams: line.surplusGrams,\n unit: item.packUnit,\n goodFrom: shoppedOn,\n shelfLifeDays: item.shelfLifeDays,\n cooked: false,\n source: 'pack-surplus',\n note: `left from a ${item.packSize}${item.packUnit === 'ea' ? 'pk' : item.packUnit} pack`,\n });\n }\n return out;\n}\n\n/**\n * Quantities in this ledger are in the item's own pack unit — `unit` says\n * which. A stored 10 against a 12-pack of eggs means ten eggs, not ten grams.\n * Leaving that implicit is how a 60-tablet tub gets re-bought with 10 left.\n */\n\n/** Combine entries for the same item and age, keeping the earliest expiry. */\nexport function mergeStock(entries) {\n const byKey = new Map();\n for (const e of entries) {\n const key = `${e.itemId}|${e.cooked ? 'c' : 'r'}`;\n const prev = byKey.get(key);\n if (!prev) { byKey.set(key, { ...e }); continue; }\n prev.grams += e.grams;\n // Two batches of the same thing: the older one sets the deadline.\n if (e.goodFrom + e.shelfLifeDays * DAY_MS < prev.goodFrom + prev.shelfLifeDays * DAY_MS) {\n prev.goodFrom = e.goodFrom;\n prev.shelfLifeDays = e.shelfLifeDays;\n }\n }\n return [...byKey.values()];\n}\n\n/** Add remaining shelf life. `expired` is computed, never stored. */\nexport function ageStock(stock, { now = Date.now() } = {}) {\n return stock.map((e) => {\n const remainingDays = e.shelfLifeDays - daysBetween(e.goodFrom, now);\n return { ...e, remainingDays, expired: remainingDays < 0 };\n }).sort((a, b) => a.remainingDays - b.remainingDays);\n}\n\n/**\n * Stock available to offset a shop, keyed by substitute group.\n *\n * Stock only counts if it survives to the day the plan first needs that group.\n * Subtracting 230g of chicken that expires tomorrow from a shop that cooks it\n * on day 3 means arriving home without dinner.\n */\nexport function stockByGroup(stock, catalog, { firstUseDay = {}, now = Date.now() } = {}) {\n const out = {};\n for (const e of ageStock(stock, { now })) {\n const item = catalog[e.itemId];\n if (!item || e.expired) continue;\n const needBy = firstUseDay[item.substituteGroup] ?? 1;\n // Day 1 is shopping day, so an item needed on day N must last N-1 more days.\n if (e.remainingDays < needBy - 1) continue;\n out[item.substituteGroup] = (out[item.substituteGroup] || 0) + e.grams;\n }\n return out;\n}\n\n/** When each substitute group is first needed. Feeds stockByGroup. */\nexport function firstUseDayByGroup(plan, catalog) {\n const out = {};\n for (const m of plan.meals) {\n for (const c of m.components || []) {\n const item = catalog[c.itemId];\n if (!item) continue;\n const g = item.substituteGroup;\n out[g] = Math.min(out[g] ?? Infinity, m.day);\n }\n }\n return out;\n}\n\n/**\n * Stock that must be used in the next window or thrown away. This is what\n * Phase A gets told to build around — a deadline, not a suggestion.\n */\nexport function useFirst(stock, catalog, { now = Date.now(), withinDays = 7, minGrams = 40 } = {}) {\n return ageStock(stock, { now })\n .filter((e) => {\n const item = catalog[e.itemId];\n if (!item || e.expired || e.remainingDays > withinDays) return false;\n // A threshold in grams is meaningless for a count: one avocado matters.\n return item.packUnit === 'ea' ? e.grams >= 1 : e.grams >= minGrams;\n })\n .map((e) => ({\n itemId: e.itemId,\n name: catalog[e.itemId].name,\n grams: Math.round(e.grams),\n unit: catalog[e.itemId].packUnit,\n remainingDays: e.remainingDays,\n cooked: e.cooked,\n note: e.note,\n }));\n}\n\n/**\n * What went in the bin, and what it cost. Nobody asks for this number, which\n * is exactly why it's worth showing.\n */\nexport function wasteReport(stock, catalog, { now = Date.now() } = {}) {\n const expired = ageStock(stock, { now }).filter((e) => e.expired && catalog[e.itemId]);\n let cost = 0;\n const items = expired.map((e) => {\n const item = catalog[e.itemId];\n // e.grams is in the item's own unit, so the pack size is the right divisor\n // for both 'ea' and weighed items.\n const base = item.packSize;\n const value = item.price != null && base ? (e.grams / base) * item.price : 0;\n cost += value;\n return {\n itemId: e.itemId, name: item.name, grams: Math.round(e.grams), unit: item.packUnit,\n daysOverdue: -e.remainingDays, estValue: Math.round(value * 100) / 100, note: e.note,\n };\n });\n return { items, estCost: Math.round(cost * 100) / 100 };\n}\n\n/** Drop expired entries once they've been reported. */\nexport function pruneStock(stock, { now = Date.now() } = {}) {\n return ageStock(stock, { now }).filter((e) => !e.expired).map(({ remainingDays, expired, ...e }) => e);\n}\n\n/** Display quantity in the unit the entry is actually held in. */\nexport function formatQty(entry) {\n return entry.unit === 'ea'\n ? `${Math.round(entry.grams)}`\n : `${Math.round(entry.grams)}${entry.unit ?? 'g'}`;\n}\n",[],[91,206],"232cfc76-3f90-400a-85fa-1a2048ca26c8","recipes.mjs","eb7bca40-a45a-11f1-8c7a-1607ee4eb77e",75,["D",1788233828985],3,"// Recipes you supply.\n//\n// The spec's non-goal was a recipe *database* — meals generated rather than\n// curated. This is the other thing: meals you already know you want, pinned\n// into the plan so the generator works around them.\n//\n// A recipe is only usable once every ingredient resolves to a catalog item\n// with a quantity. Free text can't be costed, shopped for, or validated, so\n// the model maps it and you confirm — then code owns it, like everything else.\n\nimport { computeMeal } from './compute.mjs';\nimport { parseJSON } from './model.mjs';\nimport { interchangeableWith } from './slots.mjs';\nimport { serialiseCandidates } from './prompts.mjs';\n\nexport const FREQUENCIES = ['every-window', 'weekly', 'sometimes'];\n\n/**\n * How many times a recipe should appear in a window of `days`.\n *\n * `use` overrides the frequency rather than replacing it: 'off' means never,\n * 'on' means at least once even when the frequency would have skipped this\n * window (a \"sometimes\" recipe in a 3-day window, say), and 'auto' — the\n * default, and what every recipe saved before this setting existed does — just\n * follows the frequency.\n */\nexport function timesInWindow(recipe, days) {\n const use = recipe.use ?? (recipe.enabled === false ? 'off' : 'auto');\n if (use === 'off') return 0;\n\n const cap = recipe.maxPerWindow ?? Infinity;\n let times;\n switch (recipe.frequency) {\n case 'every-window': times = Math.min(cap, 1); break;\n case 'weekly': times = Math.min(cap, Math.max(1, Math.round(days / 7))); break;\n case 'sometimes': times = Math.min(cap, days >= 5 ? 1 : 0); break;\n default: times = 0;\n }\n // A forced recipe still respects an explicit cap — asking for it and capping\n // it at zero is a contradiction the user has to resolve, not one to guess at.\n if (use === 'on' && cap >= 1) times = Math.max(1, times);\n return times;\n}\n\nexport function buildRecipeParsePrompt({ text, candidates, slots }) {\n return `Someone has pasted a recipe they cook. Map it onto a fixed catalog so\nthe app can cost it and count its macros.\n\nTheir recipe:\n\"\"\"\n${String(text).slice(0, 4000)}\n\"\"\"\n\nYou may ONLY use items from this catalog. Reference them by exact id:\n${serialiseCandidates(candidates)}\n\nRules:\n- Match on what the ingredient DOES in the dish. If the recipe says \"sharp\n cheddar\" and the catalog has mild cheddar, that is the match.\n- Convert every quantity to grams, or to a COUNT for items whose pack unit is\n \"ea\". \"1 onion\" is 1 if onions are sold by the each, otherwise about 150g.\n- Quantities are for ONE serving. If the recipe serves four, divide by four and\n set \"servings\" to 4.\n- Leave out anything with no reasonable match rather than substituting\n something unrelated. List those under \"unmatched\".\n- Do NOT output kcal, protein, carb or fat numbers. They are calculated for you.\n\nRespond with ONLY:\n{\n \"name\": \"short meal name\",\n \"slot\": one of ${JSON.stringify(slots)},\n \"servings\": 1,\n \"components\": [{\"itemId\": \"exact-id\", \"grams\": 150, \"role\": \"protein\"}],\n \"steps\": [\"short imperative step\"],\n \"unmatched\": [\"ingredient the catalog has nothing for\"]\n}`;\n}\n\nconst RECIPE_ROLES = new Set([\n 'protein', 'carb-base', 'green', 'veg', 'fruit',\n 'fat', 'dairy', 'flavour', 'acid', 'sauce', 'spice',\n]);\n\n/**\n * Validate a parsed recipe. Nothing is saved on the strength of the model's\n * output — this returns a draft for review, with the problems named.\n */\nexport function sanitiseRecipe(raw, catalog, { slots = [] } = {}) {\n const problems = [];\n const unmatched = (Array.isArray(raw?.unmatched) ? raw.unmatched : [])\n .map((u) => String(u).slice(0, 80)).slice(0, 20);\n\n const components = [];\n for (const c of Array.isArray(raw?.components) ? raw.components : []) {\n const item = catalog[c?.itemId];\n if (!item) { unmatched.push(`unknown item \"${c?.itemId}\"`); continue; }\n if (item.supplement) { unmatched.push(`${item.name} is a supplement, not an ingredient`); continue; }\n const grams = Number(c?.grams);\n if (!(grams > 0)) { unmatched.push(`${item.name} had no usable quantity`); continue; }\n components.push({\n itemId: item.id,\n grams: item.packUnit === 'ea' ? Math.max(1, Math.round(grams)) : Math.round(grams),\n role: RECIPE_ROLES.has(c?.role) ? c.role : item.roleTags[0],\n });\n }\n\n if (!components.length) problems.push('Nothing in the recipe matched the catalog.');\n\n const servings = Math.max(1, Math.min(12, Math.round(Number(raw?.servings) || 1)));\n const slot = slots.includes(raw?.slot) ? raw.slot : (slots[0] ?? 'dinner');\n\n const draft = {\n name: String(raw?.name ?? 'My recipe').slice(0, 80),\n slot,\n servings,\n components,\n steps: (Array.isArray(raw?.steps) ? raw.steps : []).map((s) => String(s).slice(0, 300)).slice(0, 20),\n unmatched,\n frequency: 'every-window',\n scalePortions: true,\n };\n\n // Worth flagging rather than blocking: a dish with no protein at all is\n // usually a mapping miss, not a real recipe.\n const warnings = [];\n if (!components.some((c) => c.role === 'protein')) {\n warnings.push('No ingredient came through as the protein. Check the mapping before saving.');\n }\n if (unmatched.length) {\n warnings.push(`${unmatched.length} ingredient(s) had no catalog match and are not counted.`);\n }\n\n return { ok: problems.length === 0, problems, warnings, recipe: draft };\n}\n\n/** Macros for one serving. Same arithmetic as any other meal. */\nexport function recipeMacros(recipe, catalog) {\n const { exact } = computeMeal({ components: recipe.components }, catalog);\n return exact;\n}\n\n/**\n * Turn saved recipes into meals placed in the window.\n *\n * Placement is deterministic: spread across days, respecting the recipe's\n * slot. A recipe that serves 4 becomes 4 meals sharing one batch group, cooked\n * on the first of them — the existing batch machinery already handles that.\n */\nexport function placeRecipes(recipes, { days, slots }) {\n const meals = [];\n const taken = new Set(); // `${day}:${slot}`\n const skipped = [];\n const overflow = [];\n\n const wanted = recipes\n // 'off' is now handled inside timesInWindow, which returns 0 for it.\n .filter((r) => r.components?.length)\n .map((r) => ({ recipe: r, times: timesInWindow(r, days) }))\n .filter((x) => x.times > 0)\n // Bigger batches placed first: they need consecutive-ish room.\n .sort((a, b) => (b.recipe.servings ?? 1) - (a.recipe.servings ?? 1));\n\n for (const { recipe, times } of wanted) {\n const slot = slots.includes(recipe.slot) ? recipe.slot : slots[0];\n const servings = Math.max(1, recipe.servings ?? 1);\n // Mains are interchangeable, so a four-serving dinner can run across the\n // dinners and then take a lunch, instead of leaving portions spare. Its own\n // slot is always filled first; a snack never borrows a main slot.\n const usable = interchangeableWith(slot, slots);\n\n for (let n = 0; n < times; n++) {\n const free = [];\n for (const sl of usable) {\n for (let d = 1; d <= days; d++) if (!taken.has(`${d}:${sl}`)) free.push({ day: d, slot: sl });\n }\n if (!free.length) {\n skipped.push({ name: recipe.name, reason: `no free ${usable.join('/')} slot left in this window` });\n break;\n }\n\n // A batch bigger than the window still gets cooked. Dropping a recipe you\n // explicitly asked for, because the pot outlasts the shop, is the worse\n // answer — the spare portions are simply not scheduled, and what happens\n // to them is yours to decide.\n const fits = Math.min(servings, free.length);\n if (fits < servings) {\n overflow.push({\n name: recipe.name, slot, servings, placed: fits, spare: servings - fits,\n note: `serves ${servings}, and ${fits} ${usable.join(\"/\")} slot(s) were free — `\n + `${servings - fits} portion(s) spare`,\n });\n }\n\n // Spread rather than clump, unless it's a batch — those want to be near\n // each other so the cooked food is eaten while it lasts.\n const chosen = servings > 1\n ? free.slice(0, fits)\n : [free[Math.floor(((n + 1) / (times + 1)) * free.length)] ?? free[0]];\n\n const batchGroup = servings > 1 ? `recipe-${recipe.id}-${n}` : null;\n for (const { day, slot: at } of chosen) {\n taken.add(`${day}:${at}`);\n meals.push({\n id: `recipe-${recipe.id}-${day}-${at}`,\n day,\n slot: at,\n name: recipe.name,\n components: recipe.components.map((c) => ({ ...c })),\n steps: recipe.steps ?? [],\n batchGroup,\n locked: recipe.scalePortions === false,\n fromRecipe: recipe.id,\n });\n }\n }\n }\n\n return { meals, taken, skipped, overflow };\n}\n\n/**\n * What's left for the generator once pinned recipes are placed: which slots\n * are free each day, and what macro budget remains.\n *\n * This is the compute-then-ask rule again. Working out the remaining budget in\n * code and handing it over beats asking a model to plan \"around\" something.\n */\nexport function remainingBudget({ placed, days, slots, targets, catalog }) {\n const perDay = [];\n for (let d = 1; d <= days; d++) {\n const fixed = placed.filter((m) => m.day === d);\n const used = { kcal: 0, protein: 0, carbs: 0, fat: 0 };\n for (const m of fixed) {\n const { exact } = computeMeal(m, catalog);\n used.kcal += exact.kcal; used.protein += exact.protein;\n used.carbs += exact.carbs; used.fat += exact.fat;\n }\n perDay.push({\n day: d,\n freeSlots: slots.filter((s) => !fixed.some((m) => m.slot === s)),\n fixed: fixed.map((m) => ({ slot: m.slot, name: m.name })),\n remaining: {\n kcal: Math.max(0, Math.round(targets.kcal - used.kcal)),\n protein: Math.max(0, Math.round(targets.protein - used.protein)),\n carbs: Math.max(0, Math.round(targets.carbs - used.carbs)),\n fat: Math.max(0, Math.round(targets.fat - used.fat)),\n },\n });\n }\n return perDay;\n}\n\n/** The block of the ideation prompt that describes what is already fixed. */\nexport function fixedMealsBlock(budget) {\n const withFixed = budget.filter((d) => d.fixed.length);\n if (!withFixed.length) return '';\n\n return `\nSome meals are already decided and must NOT be changed or repeated. Plan only\nthe remaining slots, and stay inside the remaining budget for each day:\n\n${budget.map((d) => ` Day ${d.day}: `\n + (d.fixed.length ? `already has ${d.fixed.map((f) => `${f.name} (${f.slot})`).join(', ')}. ` : '')\n + (d.freeSlots.length\n ? `Plan ${d.freeSlots.join(', ')} — about ${d.remaining.kcal} kcal and ${d.remaining.protein}g protein left.`\n : 'Nothing left to plan.')).join('\\n')}\n`;\n}\n",[],[91,214],"801f079b-0f60-4a9c-8a59-c797d1bdb7c4","receipt.mjs","3b51717e-a59f-11f1-b72d-1607ee4eb77e",62,["D",1788228271158],"// Reading a supermarket receipt into stock.\n//\n// A receipt says what you actually bought — which is the only record that is\n// not a guess. The plan says what you were told to buy; the shopping list says\n// what it costed; neither knows you skipped the fish or grabbed a second bag of\n// rice. Stock read off a receipt is what the next plan should build on.\n//\n// This never touches the catalog. A receipt is evidence of a purchase, not of\n// what a food *is* — no prices, no nutrition, no pack sizes are learned here.\n// That separation is the same one catalog-merge.mjs draws, for the same reason.\n\nimport { matchRows, normaliseName } from './catalog-merge.mjs';\n\n/** Receipts abbreviate hard: \"PAMS CHKN BRST SKINLESS 1KG\". Say so. */\nexport function buildReceiptPrompt() {\n return `Read this supermarket receipt and list every FOOD line item.\n\nReturn ONLY a JSON array, no prose and no markdown fence:\n\n[{\"name\": \"...\", \"qty\": 1, \"price\": 13.99}]\n\nRules:\n- \"name\" — expand obvious supermarket abbreviations into ordinary words\n (CHKN BRST -> Chicken Breast, T/MATO -> Tomato, W/MEAL -> Wholemeal).\n Keep the brand and the pack size if they are printed.\n- \"qty\" — how many of that item were bought. A line like \"2 @ $3.50\" is qty 2.\n A weighed item priced per kg is qty 1.\n- \"price\" — the line total actually charged, in dollars, as a number.\n- Skip non-food lines entirely: bags, discounts, loyalty points, subtotals,\n totals, EFTPOS and change.\n- If a line is unreadable, leave it out rather than guessing at it.`;\n}\n\n/** Only the fields we asked for, only where they are the right shape. */\nexport function sanitiseReceipt(raw) {\n const rows = [];\n const dropped = [];\n for (const r of Array.isArray(raw) ? raw : []) {\n const name = typeof r?.name === 'string' ? r.name.trim() : '';\n if (!name) { dropped.push(r); continue; }\n const qty = Number(r?.qty);\n const price = Number(r?.price);\n rows.push({\n name,\n qty: Number.isFinite(qty) && qty > 0 ? qty : 1,\n price: Number.isFinite(price) && price >= 0 ? price : null,\n });\n }\n return { rows, dropped };\n}\n\nconst tokens = (s) => normaliseName(s).split(' ').filter(Boolean);\n\n/**\n * Word-order-insensitive fallback for receipt lines only.\n *\n * The catalog says \"Pams Size 7 Eggs\"; a receipt says \"PAMS EGGS SIZE 7\". Those\n * normalise to different strings, so matchRows — which compares normalised\n * names exactly — misses them. It is right to be strict: there a bad match\n * writes a wrong price into the catalog. Here a bad match adds the wrong food\n * to a stock list that is reviewed before it is committed, so a looser rule\n * pays. It still refuses anything it cannot call cleanly.\n */\nexport function tokenMatch(rowName, items) {\n const want = new Set(tokens(rowName));\n if (!want.size) return { match: null, close: [] };\n\n const scored = [];\n for (const it of items) {\n const have = new Set(tokens(it.name));\n if (!have.size) continue;\n let shared = 0;\n for (const t of have) if (want.has(t)) shared++;\n if (!shared) continue;\n scored.push({ item: it, score: shared / new Set([...want, ...have]).size, coverage: shared / have.size });\n }\n scored.sort((a, b) => b.score - a.score);\n\n const best = scored[0];\n if (!best) return { match: null, close: [], candidates: [] };\n\n // Anything with real word overlap stays on the table for the pack-size check\n // below, even if it is not confident enough to accept on names alone.\n const candidates = scored.filter((s) => s.score >= 0.34);\n // Every word of the catalog name present, or a strong overall overlap.\n const confident = best.coverage === 1 || best.score >= 0.6;\n // Two plausible answers is not an answer — \"Size 6\" vs \"Size 7\" eggs must not\n // be decided by a coin toss.\n const close = scored.filter((s) => best.score - s.score < 0.15);\n\n if (confident && close.length === 1) return { match: best, close: [], candidates };\n return { match: null, close: close.length > 1 ? close : [], candidates };\n}\n\n/**\n * The pack size printed on a receipt line, in grams or millilitres.\n *\n * normaliseName strips sizes before matching, which is right for names but\n * throws away the one thing that separates \"Broccoli\" from \"Pams Frozen\n * Broccoli Florets 750g\". Read it off the raw line instead.\n */\nexport function sizeFromName(name) {\n const m = String(name ?? '').match(/(\\d+(?:\\.\\d+)?)\\s*(kg|g|l|ml)\\b/i);\n if (!m) return null;\n const n = Number(m[1]);\n if (!Number.isFinite(n) || n <= 0) return null;\n const unit = m[2].toLowerCase();\n return { amount: unit === 'kg' || unit === 'l' ? n * 1000 : n, metric: unit === 'l' || unit === 'ml' };\n}\n\n/** Break a tie with the printed pack size, but only if exactly one candidate fits. */\nexport function sizeTiebreak(rowName, close) {\n const size = sizeFromName(rowName);\n if (!size) return null;\n const fits = close.filter((c) => {\n const it = c.item;\n if (it.packUnit === 'ea') return false;\n return Math.abs(Number(it.packSize) - size.amount) < 1;\n });\n return fits.length === 1 ? fits[0] : null;\n}\n\n/**\n * How many grams one pack of an item is.\n *\n * `ea` packs count in units, so a 12-pack of eggs is 12 x unitGrams — using\n * packSize directly would put 12 grams of egg in the fridge.\n */\nexport function packGrams(item) {\n if (!item) return null;\n if (item.packUnit === 'ea') {\n const each = Number(item.unitGrams);\n return Number.isFinite(each) && each > 0 ? item.packSize * each : null;\n }\n const size = Number(item.packSize);\n return Number.isFinite(size) && size > 0 ? size : null;\n}\n\n/**\n * Match receipt lines to catalog items and propose stock entries.\n *\n * Nothing is committed here. Receipt OCR plus name matching is the least\n * reliable input this app takes, so the result is a proposal for a human to\n * look at — matched lines say how they matched, and everything else is\n * reported rather than dropped.\n */\nexport function readReceipt(rows, catalog, { now = Date.now() } = {}) {\n const items = Object.values(catalog);\n const { matched, unmatched, ambiguous, seenIds } = matchRows(items, rows);\n\n // Second pass over what exact-name matching could not place.\n const taken = new Set(seenIds);\n const stillUnmatched = [];\n const tied = [];\n for (const row of unmatched) {\n const pool = items.filter((it) => !taken.has(it.id));\n const { match, close, candidates } = tokenMatch(row.name, pool);\n\n // A printed pack size that fits exactly one candidate is strong evidence —\n // strong enough to settle a tie, and to rescue a name match that was not\n // confident on words alone (\"Broccoli Frozen 750g\" against a catalog that\n // calls it \"Pams Frozen Broccoli Florets\").\n const hit = match ?? sizeTiebreak(row.name, candidates);\n if (hit) {\n taken.add(hit.item.id);\n matched.push({\n item: hit.item,\n row,\n how: match ? `words ${Math.round(hit.score * 100)}%` : 'words + pack size',\n });\n continue;\n }\n // Report a tie as a tie. Calling it \"not in the catalog\" would be a lie —\n // it is in there twice.\n if (close.length > 1) tied.push({ row, candidates: close.map((c) => c.item.id) });\n else stillUnmatched.push(row);\n }\n ambiguous.push(...tied);\n\n const entries = [];\n const unusable = [];\n\n for (const { item, row, how } of matched) {\n const per = packGrams(item);\n if (!per) {\n // An 'ea' item with no unitGrams cannot be weighed. Say which, rather\n // than silently adding nothing.\n unusable.push({ name: row.name, itemId: item.id, reason: 'no weight per pack in the catalog' });\n continue;\n }\n entries.push({\n itemId: item.id,\n name: item.name,\n grams: Math.round(per * row.qty),\n unit: item.packUnit,\n goodFrom: now,\n shelfLifeDays: item.shelfLifeDays,\n cooked: false,\n source: 'receipt',\n note: `${row.qty} x ${item.packSize}${item.packUnit === 'ea' ? 'pk' : item.packUnit} from a receipt`,\n how,\n receiptName: row.name,\n });\n }\n\n return {\n entries,\n unusable,\n // Named so the client can show them as \"we could not place these\" rather\n // than pretending the receipt was fully understood.\n unmatched: stillUnmatched.map((r) => ({ name: r.name, qty: r.qty, price: r.price, key: normaliseName(r.name) })),\n // matchRows reports candidates as ids; name them so the choice is readable.\n // The pack size is part of the name here — the whole reason two items tie\n // is usually that they are the same product in two sizes, and offering\n // \"Pams Premium Beef Mince / Pams Premium Beef Mince\" is no choice at all.\n ambiguous: ambiguous.map((a) => ({\n name: a.row?.name ?? null,\n qty: a.row?.qty ?? 1,\n candidates: (a.candidates ?? []).map((id) => {\n const it = catalog[id];\n if (!it) return { id, name: id };\n return { id, name: `${it.name} ${it.packSize}${it.packUnit === 'ea' ? 'pk' : it.packUnit}` };\n }),\n })),\n counts: {\n lines: rows.length,\n matched: entries.length,\n unmatched: stillUnmatched.length,\n ambiguous: ambiguous.length,\n },\n };\n}\n",[],[91,223],"faba2522-4340-48c2-b818-dd5ef5f68f9a","prompts.mjs","eb61fe6c-a45a-11f1-83cf-1607ee4eb77e",76,["D",1788233829124],"// Prompt construction + candidate selection.\n// Everything numeric here is computed in code and handed to the model.\n// The model is never asked to work out a quantity it could get wrong.\n\nimport { parseTerms, itemMatchesTerm, parseRestrictions } from './catalog.mjs';\nimport { slotShares, MAIN_SLOTS } from './slots.mjs';\n\n/** Rough cost per 100g/ml, so \"cheap\" means cheap per unit, not per pack. */\nfunction pricePer100(it) {\n if (it.price == null) return Infinity;\n const base = it.packUnit === 'ea' ? it.packSize * (it.unitGrams || 0) : it.packSize;\n return base ? (it.price / base) * 100 : Infinity;\n}\n\nconst QUOTAS = {\n protein: 40, 'carb-base': 25, veg: 30, green: 12, fruit: 12,\n dairy: 18, fat: 15, sauce: 15, flavour: 10, acid: 5, spice: 20,\n};\n\n/**\n * Choose 150–250 catalog items to show the model. Sending the whole catalog\n * wastes context and measurably worsens id accuracy.\n *\n * Excluded items are removed here rather than forbidden in prose — the model\n * can't reach for what it can't see.\n */\nexport function selectCandidates(catalog, settings, { favourites = new Set() } = {}) {\n const store = settings.store;\n // Supplements are dosed daily, not cooked. Showing them here is how you end\n // up with creatine in a stir fry.\n const all = Object.values(catalog).filter((it) => it.store === store && it.per100 && !it.supplement && !it.discontinued);\n\n const { forbids } = parseRestrictions(settings.restrictions);\n const disliked = settings.dislikedItemIds\n ? new Set(settings.dislikedItemIds)\n : null;\n const dislikeTerms = disliked ? [] : parseTerms(settings.dislikes);\n\n const excluded = (it) => {\n if (disliked?.has(it.id)) return true;\n if (dislikeTerms.some((t) => itemMatchesTerm(it, t))) return true;\n if (forbids.length && (it.contains || []).some((f) => forbids.includes(f))) return true;\n return false;\n };\n\n const pool = all.filter((it) => !excluded(it));\n const picked = new Map();\n const take = (it) => picked.set(it.id, it);\n\n // must-includes and favourites are non-negotiable\n for (const term of parseTerms(settings.mustInclude)) {\n for (const it of pool) if (itemMatchesTerm(it, term)) take(it);\n }\n for (const it of pool) if (favourites.has(it.id)) take(it);\n // Explicitly chosen products beat anything a keyword search would guess at.\n for (const id of settings.wantedItemIds ?? []) if (catalog[id] && !excluded(catalog[id])) take(catalog[id]);\n\n // seasoning is cheap to include and expensive to be missing\n for (const it of pool) {\n if (it.staple && it.roleTags.some((r) => ['spice', 'flavour', 'acid'].includes(r))) take(it);\n }\n\n // cheapest N per role\n for (const [role, quota] of Object.entries(QUOTAS)) {\n pool.filter((it) => it.roleTags.includes(role))\n .sort((a, b) => pricePer100(a) - pricePer100(b))\n .slice(0, quota)\n .forEach(take);\n }\n\n return [...picked.values()];\n}\n\n/** One compact line per item. Field order is fixed and stated in the prompt. */\nexport function serialiseCandidates(items) {\n return items.map((it) => {\n const p = it.per100;\n const size = `${it.packSize}${it.packUnit === 'ea' ? 'ea' : it.packUnit}`;\n const unit = it.packUnit === 'ea' ? ` (1 unit ≈ ${it.unitGrams}g)` : '';\n return `${it.id} | ${it.name} | ${size}${unit} | ${Math.round(p.kcal)}kcal `\n + `P${p.protein} C${p.carbs} F${p.fat} | ${it.roleTags.join(',')} | keeps ${it.shelfLifeDays}d`;\n }).join('\\n');\n}\n\n/**\n * Per-slot protein hints. The daily total alone lets a model build a plan that\n * back-loads protein into dinner and leaves breakfast at 8g — technically on\n * target, miserable in practice, and unfixable by portion tweaks afterwards.\n */\nexport function proteinHints(settings) {\n return slotShares(settings.slotsPerDay).map(({ slot, share }) => ({\n slot,\n protein: Math.round((settings.targets.protein * share) / 5) * 5,\n }));\n}\n\n/**\n * Slots are times of day, not cuisines.\n *\n * Left unsaid, a model writes cereal for breakfast and a roast for dinner, and\n * the day's protein ends up wherever the \"dinner food\" is. Saying plainly that\n * the main slots are interchangeable widens the search and is also simply true\n * of how the person eats.\n */\nexport function slotGuidance(settings) {\n const mains = settings.slotsPerDay.filter((s) => MAIN_SLOTS.includes(s));\n const hasSnack = settings.slotsPerDay.some((s) => !MAIN_SLOTS.includes(s));\n if (mains.length < 2) return '';\n\n return `${mains.join(', ')} are all FULL MEALS of about the same size, and they are\ninterchangeable — they are times of day, not categories of food. A curry, a\nstir fry or a rice bowl at ${mains[0]} is entirely normal and often preferred.\nDo not reserve \"breakfast foods\" for breakfast.${hasSnack ? `\nA snack is the exception: it is a genuinely smaller meal, roughly half the size\nof a main, and should not be swapped with one.` : ''}`;\n}\n\nconst NO_NUMBERS = `You do NOT calculate calories or macros — that is done for you afterwards.\nNever output kcal, protein, carbs or fat numbers. Any you include will be discarded.`;\n\n/** Products the user has explicitly asked for, as a named list for the prompt. */\nexport function wantedList(settings, catalog) {\n return (settings.wantedItemIds ?? [])\n .map((id) => catalog[id])\n .filter(Boolean)\n .map((it) => `${it.id} — ${it.name}${it.tags?.includes('gut-friendly') ? ' (gut-friendly)' : ''}`);\n}\n\nexport function buildIdeationPrompt({ settings, days, candidates, useFirst = [], wanted = [], fixed = '' }) {\n const hints = proteinHints(settings)\n .map((h) => ` ${h.slot}: aim for roughly ${h.protein}g protein`).join('\\n');\n\n // A deadline, not a preference. Food already bought and about to spoil is\n // the strongest constraint in the whole prompt.\n const leftovers = useFirst.length ? `\nALREADY IN THE FRIDGE — build meals around these before anything else.\nThey are paid for and will be thrown away if unused:\n${useFirst.map((u) => ` ${u.itemId} — ${u.grams}g of ${u.name}`\n + `${u.cooked ? ' (already cooked)' : ''}, must be eaten within ${u.remainingDays} day${u.remainingDays === 1 ? '' : 's'}`).join('\\n')}\nUse each of these on or before the day it runs out.\n` : '';\n\n return `You plan meals for one person. You choose foods and portion sizes.\n${NO_NUMBERS}\n\nDays to plan: ${days}\nMeal slots each day: ${settings.slotsPerDay.join(', ')}\n${slotGuidance(settings)}\n${fixed}\nCooking effort ceiling: ${settings.effortCeiling}\nAvailable equipment: ${settings.equipment.join(', ') || 'basic stovetop and oven'}\n\nDaily protein target is ${settings.targets.protein}g — demanding, so spread it\nacross the day rather than loading it into dinner:\n${hints}\n\nDietary restrictions — every meal MUST comply: ${settings.restrictions || 'none'}\nFoods they dislike — NEVER use these: ${settings.dislikes || 'none'}\nFoods they want to eat often — use these where they fit: ${settings.mustInclude || 'no preference'}\n${wanted.length ? `\nThey have specifically asked for these products. Work them into the week —\neach one at least once across ${days} days, more where it fits naturally:\n${wanted.map((w) => ` ${w}`).join('\\n')}\n` : ''}\nGoals and philosophy: ${settings.philosophy || 'balanced and practical'}\n${leftovers}\nYou may ONLY use items from this catalog. Reference them by exact id:\n${serialiseCandidates(candidates)}\n\nRespond with ONLY this JSON, no prose and no markdown fences:\n{\n \"meals\": [\n {\n \"day\": 1,\n \"slot\": \"dinner\",\n \"name\": \"short meal name\",\n \"components\": [{\"itemId\": \"exact-id-from-catalog\", \"grams\": 150, \"role\": \"protein\"}],\n \"steps\": [\"short imperative step\"],\n \"batchGroup\": null\n }\n ]\n}\n\nFor items with packUnit \"ea\", \"grams\" means the COUNT of units, not a weight.\n${settings.effortCeiling === 'minimal'\n ? 'Effort is minimal: repeat meals across days and use batchGroup heavily. Repetition is wanted here.'\n : 'Aim for high variety — avoid repeating the same meal or the same protein on consecutive days.'}\nPortion sizes should be realistic for one adult.`;\n}\n\nexport function buildRepairPrompt({ settings, failures, meals, candidates }) {\n const problems = failures.map((f) =>\n `- ${f.message}${f.metric && f.actual != null ? ` [${f.metric}: ${f.actual} vs ${f.target}, off by ${f.delta}]` : ''}`,\n ).join('\\n');\n\n return `A meal plan was checked against targets and missed. Fix it with the\nsmallest possible change.\n${NO_NUMBERS}\n\nDaily targets: ${settings.targets.kcal} kcal, ${settings.targets.protein}g protein, ${settings.targets.carbs}g carbs, ${settings.targets.fat}g fat\n\nProblems found:\n${problems}\n\nPortion sizes have ALREADY been optimised automatically, so these problems\ncannot be fixed by resizing alone — the composition itself needs to change.\n\nCurrent meals for the affected days only:\n${JSON.stringify(meals.map(({ id, day, slot, name, components, steps, batchGroup }) =>\n ({ id, day, slot, name, components, steps, batchGroup })), null, 1)}\n\nCatalog items you may use (same rules as before):\n${serialiseCandidates(candidates)}\n\nAllowed changes, in order of preference:\n1. Swap one component for another in the same role\n2. Add a component to an existing meal\n3. Replace one whole meal (only if 1 and 2 cannot work)\n\nDo NOT restructure the plan. Do NOT change meals not listed above.\nKeep each meal's \"id\" exactly as given.\n\nRespond with ONLY: {\"meals\": [ ...corrected meal objects, same shape... ]}`;\n}\n\n/**\n * Phase F — placement. The surplus has already been found, measured and dated\n * in code; the model is only asked where it goes. Freezable surplus never\n * reaches here (that's a freezer bag, not a meal-planning problem).\n */\nexport function buildPlacementPrompt({ settings, surplus, meals, candidates }) {\n return `The shop for this plan leaves ingredients that will spoil before the\nnext shop. Use them up.\n${NO_NUMBERS}\n\nSurplus to place — these amounts are already measured, don't recalculate them:\n${surplus.map((s) => ` ${s.itemId} — ${s.grams}g of ${s.name}, keeps ${s.shelfLifeDays} days`).join('\\n')}\n\nDietary restrictions — still apply: ${settings.restrictions || 'none'}\nNever use: ${settings.dislikes || 'none'}\n\nCurrent meals:\n${JSON.stringify(meals.map(({ id, day, slot, name, components, steps, batchGroup }) =>\n ({ id, day, slot, name, components, steps, batchGroup })), null, 1)}\n\nCatalog items you may use:\n${serialiseCandidates(candidates)}\n\nIncrease portions of these ingredients in meals that already contain them, or\nadd them to meals where they fit, or add one extra flex meal. Use each surplus\non or before the day it runs out. Keep every meal \"id\" exactly as given; a new\nflex meal may have a new id.\n\nRespond with ONLY: {\"meals\": [ ...updated meal objects, same shape... ], \"notes\": [\"...\"]}`;\n}\n\n/**\n * Phase G-2 — prep prose. Cook days, batch groups and freeze flags are all\n * computed; the model writes words, never schedule logic.\n */\nexport function buildPrepPrompt({ settings, plan, batches, perDay, freezeOnArrival, freezePortions = [], catalog }) {\n const name = (id) => catalog[id]?.name ?? id;\n const meal = (m) => `${m.name} (day ${m.day} ${m.slot}): `\n + m.components.map((c) => `${c.grams}${catalog[c.itemId]?.packUnit === 'ea' ? '' : 'g'} ${name(c.itemId)}`).join(', ');\n\n return `Write the prep notes for a meal plan. The schedule below is already\nworked out — do not change which day anything is cooked on, and do not output\nany kcal or macro numbers.\n\nCooking effort ceiling: ${settings.effortCeiling}\nEquipment: ${settings.equipment.join(', ') || 'basic stovetop and oven'}\n\n${batches.length ? `Batch sessions — cook once, portion out:\n${batches.map((b) => ` Day ${b.cookDay}, group \"${b.batchGroup}\":\\n`\n + b.meals.map((m) => ` ${m.name} — eaten day ${m.eatDay} ${m.slot}`).join('\\n')).join('\\n')}\n` : 'No batch cooking in this plan.\\n'}\n${freezeOnArrival.length ? `Freeze on the day you shop:\n${freezeOnArrival.map((f) => ` ${f.name} — ${f.reason}`).join('\\n')}\n` : ''}${freezePortions.length ? `Portion and freeze straight after cooking:\n${freezePortions.map((f) => ` ${f.name} — ${f.reason}`).join('\\n')}\n` : ''}\nAll meals by day:\n${perDay.map((d) => `Day ${d.day}:\\n${d.meals.map((m) => ' ' + meal(m)).join('\\n')}`).join('\\n')}\n\nWrite, for each batch session, a title and an ordered list of steps covering the\norder of operations, what to cook once and portion out, and what to leave until\nthe day it's eaten. Then for each day, a short list of steps for what actually\nhas to happen that day — assume anything batched is already done.\n\nKeep steps short and imperative. Respond with ONLY:\n{\n \"batchSessions\": [{\"day\": 1, \"title\": \"short title\", \"steps\": [\"step\", \"...\"]}],\n \"perDay\": [{\"day\": 1, \"steps\": [\"step\", \"...\"]}]\n}`;\n}\n",[],[91,231],"4e654697-7da7-4b51-8369-0dfae7dea54f","plansummary.mjs","dc8d9436-a5aa-11f1-9ae8-1607ee4eb77e",64,["D",1788228868832],"// Summarising a saved plan well enough to choose between saved plans.\n//\n// Generating a plan costs a model call and several minutes. Once one exists it\n// is worth keeping and worth re-using, which means being able to see at a\n// glance what it does to your macros — and to rank plans by how close they land\n// to what you are aiming at.\n\n/** Average day of a plan, supplements included where the plan recorded them. */\nexport function planMacros(plan) {\n const days = plan?.totals?.withSupplements?.length\n ? plan.totals.withSupplements\n : (plan?.totals?.perDay ?? []);\n if (!days.length) return null;\n\n const sum = { kcal: 0, protein: 0, carbs: 0, fat: 0 };\n for (const d of days) {\n for (const k of Object.keys(sum)) sum[k] += Number(d[k]) || 0;\n }\n const out = {};\n for (const k of Object.keys(sum)) out[k] = Math.round(sum[k] / days.length);\n return out;\n}\n\n/**\n * How far a plan sits from your targets, as a mean deviation in percent.\n * Lower is closer; 0 would be every macro on target every day.\n *\n * Protein is measured as a floor, not a band — the app treats being over on\n * protein as fine everywhere else, and a ranking that punished it would sort\n * good plans below mediocre ones.\n */\nexport function planFit(plan, targets) {\n const days = plan?.totals?.withSupplements?.length\n ? plan.totals.withSupplements\n : (plan?.totals?.perDay ?? []);\n if (!days.length || !targets) return null;\n\n let total = 0;\n let n = 0;\n for (const d of days) {\n for (const k of ['kcal', 'protein', 'carbs', 'fat']) {\n const target = Number(targets[k]);\n if (!(target > 0)) continue;\n const actual = Number(d[k]) || 0;\n const deviation = k === 'protein'\n ? Math.max(0, (target - actual) / target)\n : Math.abs(actual - target) / target;\n total += deviation;\n n++;\n }\n }\n return n ? Math.round((total / n) * 1000) / 10 : null;\n}\n\n/** One row for the plan picker. */\nexport function summarisePlan(plan, targets) {\n return {\n macros: planMacros(plan),\n fit: planFit(plan, targets),\n targets: targets ?? null,\n };\n}\n\n/**\n * Turn a saved plan back into a fresh current plan.\n *\n * A new id matters: meal statuses are keyed by plan id, so re-using a plan\n * under its old id would inherit every \"ate it\" from the last time it ran.\n * Anything recording what happened to the old plan is dropped for the same\n * reason — this is the same food, not the same week.\n */\nexport function reusePlan(plan, { now = Date.now() } = {}) {\n const fresh = {\n ...plan,\n id: `plan-${now}`,\n createdAt: now,\n reusedFrom: plan.id,\n meals: (plan.meals ?? []).map((m) => {\n const { status, statusNote, statusAt, ...rest } = m;\n return rest;\n }),\n };\n delete fresh.archivedAt;\n delete fresh.shoppedAt;\n return fresh;\n}\n",[],[91,239],"3e87ae4d-0ebb-4a69-9330-16e36c754dfa","perishable.mjs","eb55b03a-a45a-11f1-b598-1607ee4eb77e",14,["D",1788084582733],"// Phase G-1 — perishability and cook scheduling (code).\n// Phase F, discovery half — find the surplus that will spoil (code).\n//\n// The model is good at PLACEMENT and bad at DISCOVERY. Everything discoverable\n// by arithmetic is discovered here and handed over as a fact.\n\nimport { gramsOf } from './compute.mjs';\nimport { COOKED_LEFTOVER_DAYS } from './reconcile.mjs';\n\n/**\n * When each item is first needed, and whether it survives that long.\n *\n * Day 1 is shopping day: an item used on day 1 has been owned for 0 days, so\n * an item with shelfLifeDays = 2 is fine on day 3 and gone by day 4.\n */\nexport function perishability(plan, catalog) {\n const earliest = new Map();\n const latest = new Map();\n\n for (const meal of plan.meals) {\n // A raw ingredient is used on the day it is COOKED, not the day it is\n // eaten. Telling someone to freeze chicken that gets roasted on day 1\n // because a portion is eaten on day 4 is the wrong advice entirely.\n const d = meal.cookDay ?? (meal.batchGroup\n ? Math.min(...plan.meals.filter((m) => m.batchGroup === meal.batchGroup).map((m) => m.day))\n : meal.day);\n for (const c of meal.components || []) {\n if (!catalog[c.itemId]) continue;\n earliest.set(c.itemId, Math.min(earliest.get(c.itemId) ?? Infinity, d));\n latest.set(c.itemId, Math.max(latest.get(c.itemId) ?? 0, d));\n }\n }\n\n const freezeOnArrival = [];\n const moveEarlier = [];\n const items = [];\n\n for (const [itemId, firstDay] of earliest) {\n const item = catalog[itemId];\n const lastDay = latest.get(itemId);\n const daysOwnedAtLastUse = lastDay - 1;\n const survives = daysOwnedAtLastUse < item.shelfLifeDays;\n\n const entry = {\n itemId,\n name: item.name,\n firstDay,\n lastDay,\n shelfLifeDays: item.shelfLifeDays,\n useByDay: item.shelfLifeDays + 1, // last day it's still good\n survives,\n freezable: item.freezable,\n };\n items.push(entry);\n\n if (!survives) {\n if (item.freezable) {\n freezeOnArrival.push({\n ...entry,\n reason: `keeps ${item.shelfLifeDays} days but needed on day ${lastDay}`,\n });\n } else {\n moveEarlier.push({\n ...entry,\n reason: `keeps ${item.shelfLifeDays} days, won't survive to day ${lastDay}, and doesn't freeze`,\n latestSafeDay: item.shelfLifeDays,\n });\n }\n }\n }\n\n // Cooked food runs on its own clock. A batch cooked on day 1 and eaten on\n // day 5 is a four-day-old portion, whatever the raw ingredient's shelf life\n // was — so the later portions want freezing, not the shopping.\n const freezePortions = [];\n const groups = new Map();\n for (const m of plan.meals) {\n if (!m.batchGroup) continue;\n const g = groups.get(m.batchGroup) ?? { cookDay: Infinity, meals: [] };\n g.cookDay = Math.min(g.cookDay, m.cookDay ?? m.day);\n g.meals.push(m);\n groups.set(m.batchGroup, g);\n }\n for (const [batchGroup, g] of groups) {\n const late = g.meals\n .filter((m) => m.day - g.cookDay > COOKED_LEFTOVER_DAYS)\n .sort((a, b) => a.day - b.day);\n if (!late.length) continue;\n freezePortions.push({\n batchGroup,\n name: late[0].name,\n cookDay: g.cookDay,\n days: late.map((m) => m.day),\n reason: `cooked day ${g.cookDay}; the portion${late.length === 1 ? '' : 's'} for day `\n + `${late.map((m) => m.day).join(' and ')} would be over ${COOKED_LEFTOVER_DAYS} days old`,\n });\n }\n\n return {\n items: items.sort((a, b) => a.firstDay - b.firstDay),\n freezeOnArrival,\n moveEarlier,\n freezePortions,\n };\n}\n\n/**\n * Cook day per meal. A batchGroup is cooked once, on the earliest day any\n * member is eaten.\n */\nexport function cookSchedule(plan) {\n const groupDay = new Map();\n for (const m of plan.meals) {\n if (!m.batchGroup) continue;\n groupDay.set(m.batchGroup, Math.min(groupDay.get(m.batchGroup) ?? Infinity, m.day));\n }\n\n const meals = plan.meals.map((m) => ({\n mealId: m.id,\n name: m.name,\n eatDay: m.day,\n slot: m.slot,\n batchGroup: m.batchGroup,\n cookDay: m.batchGroup ? groupDay.get(m.batchGroup) : m.day,\n }));\n\n const batches = [...groupDay].map(([group, day]) => ({\n batchGroup: group,\n cookDay: day,\n meals: meals.filter((m) => m.batchGroup === group).sort((a, b) => a.eatDay - b.eatDay),\n })).sort((a, b) => a.cookDay - b.cookDay);\n\n return { meals, batches };\n}\n\n/**\n * Phase F, discovery. Surplus worth acting on: enough to matter, and it will\n * spoil before the next shop.\n *\n * Split by what the user should actually DO. 845g of leftover chicken from a\n * 1kg pack is not a meal-planning problem — it's a freezer bag. Only surplus\n * that can't be frozen needs the model to find it a home, which keeps Phase F's\n * prompt small and its job real.\n *\n * Shelf-stable surplus is not raised at all — carryForwardPantry() already\n * rolls that into the next cycle.\n */\nexport function findSpoilingSurplus(shopping, catalog, days, { minGrams = 80 } = {}) {\n const place = [];\n const freeze = [];\n\n for (const line of shopping.lines) {\n if (line.surplusGrams < minGrams) continue;\n const item = catalog[line.primaryItemId];\n if (!item || item.carryForward) continue;\n if (item.shelfLifeDays >= days + 2) continue;\n\n const entry = {\n itemId: item.id,\n name: item.name,\n surplusGrams: line.surplusGrams,\n shelfLifeDays: item.shelfLifeDays,\n freezable: item.freezable,\n substituteGroup: line.substituteGroup,\n };\n (item.freezable ? freeze : place).push(entry);\n }\n\n const bySize = (a, b) => b.surplusGrams - a.surplusGrams;\n place.sort(bySize);\n freeze.sort(bySize);\n\n // `all` keeps the flat view for anything that just wants the total picture.\n return { place, freeze, all: [...place, ...freeze].sort(bySize) };\n}\n\n/** Total grams of an item the plan actually uses — for the prep sheet. */\nexport function itemUsage(plan, catalog) {\n const usage = new Map();\n for (const meal of plan.meals) {\n for (const c of meal.components || []) {\n const item = catalog[c.itemId];\n if (!item) continue;\n const g = gramsOf(item, c.grams);\n const e = usage.get(c.itemId) ?? { itemId: c.itemId, name: item.name, grams: 0, meals: [] };\n e.grams += g;\n e.meals.push({ mealId: meal.id, day: meal.day, name: meal.name, grams: g });\n usage.set(c.itemId, e);\n }\n }\n return [...usage.values()].sort((a, b) => b.grams - a.grams);\n}\n",[],[91,247],"20a7209a-569d-45fe-a284-a5bb3b5d7b75","model.mjs","eb4da75a-a45a-11f1-a34b-1607ee4eb77e",70,["D",1788229222799],"// Model access + response sanitising.\n//\n// Two jobs: get text back, and refuse to trust it. Everything a model returns\n// passes through sanitiseMeals() before it touches the plan.\n\nconst MEAL_ROLES = new Set([\n 'protein', 'carb-base', 'green', 'veg', 'fruit',\n 'fat', 'dairy', 'flavour', 'acid', 'sauce', 'spice',\n]); // deliberately no 'supplement' — those are dosed, not cooked\n\nexport class AnthropicModel {\n // 8000 was not enough: a repair round returning corrected meals for a full\n // window was truncated mid-JSON, and generate.mjs treats a failed repair as\n // fatal to the loop — so one cut-off reply cost the plan its last repair\n // round and shipped it with protein still under the floor.\n constructor({ apiKey = process.env.ANTHROPIC_API_KEY, model = 'claude-sonnet-4-6', maxTokens = 16000 } = {}) {\n if (!apiKey) throw new Error('No API key. Set ANTHROPIC_API_KEY (server-side only — never ship it to the client).');\n Object.assign(this, { apiKey, model, maxTokens });\n }\n\n /** Text + image. Used for reading a photographed nutrition panel. */\n async completeVision({ prompt, imageBase64, mediaType = 'image/jpeg' }) {\n return this.#send([{\n role: 'user',\n content: [\n { type: 'image', source: { type: 'base64', media_type: mediaType, data: imageBase64 } },\n { type: 'text', text: prompt },\n ],\n }]);\n }\n\n async complete(prompt) {\n return this.#send([{ role: 'user', content: prompt }]);\n }\n\n async #send(messages) {\n const res = await fetch('https://api.anthropic.com/v1/messages', {\n method: 'POST',\n headers: {\n 'content-type': 'application/json',\n 'x-api-key': this.apiKey,\n 'anthropic-version': '2023-06-01',\n },\n body: JSON.stringify({ model: this.model, max_tokens: this.maxTokens, messages }),\n });\n if (!res.ok) throw new Error(`Anthropic API ${res.status}: ${(await res.text()).slice(0, 300)}`);\n const data = await res.json();\n\n // A response cut off at max_tokens is invalid JSON that looks like a\n // parsing bug. Name the real cause instead.\n if (data.stop_reason === 'max_tokens') {\n throw new Error(\n `The model's reply was cut off at ${this.maxTokens} tokens. `\n + 'Try a shorter shopping window, or raise maxTokens.',\n );\n }\n\n return (data.content || []).filter((b) => b.type === 'text').map((b) => b.text).join('');\n }\n}\n\n/** Models add markdown fences even when told not to. Strip before parsing. */\nexport function parseJSON(text) {\n let t = String(text ?? '').trim();\n t = t.replace(/^```(?:json)?\\s*/i, '').replace(/\\s*```$/, '').trim();\n const start = t.search(/[[{]/);\n if (start > 0) t = t.slice(start);\n try {\n return JSON.parse(t);\n } catch (err) {\n throw new Error(`Model did not return valid JSON: ${err.message}. Got: ${t.slice(0, 200)}`);\n }\n}\n\n/**\n * Take only the fields we asked for, and only where they resolve.\n *\n * Any `computed`, `kcal`, `protein`, `carbs` or `fat` a model volunteers is\n * dropped on the floor here — not merged, not compared, not logged as truth.\n * Unknown item ids are collected as rejects rather than quietly skipped.\n */\nexport function sanitiseMeals(raw, catalog, { days, slots, idPrefix = 'm' } = {}) {\n const meals = [];\n const rejected = [];\n const list = Array.isArray(raw?.meals) ? raw.meals : [];\n\n list.forEach((m, i) => {\n const day = Number(m?.day);\n if (!Number.isInteger(day) || day < 1 || (days && day > days)) {\n rejected.push({ reason: 'bad day', meal: m?.name ?? `#${i}`, value: m?.day });\n return;\n }\n const slot = String(m?.slot ?? '').toLowerCase();\n if (slots && !slots.includes(slot)) {\n rejected.push({ reason: 'unknown slot', meal: m?.name ?? `#${i}`, value: m?.slot });\n return;\n }\n\n const components = [];\n for (const c of Array.isArray(m?.components) ? m.components : []) {\n const item = catalog[c?.itemId];\n if (!item) {\n rejected.push({ reason: 'unknown itemId', meal: m?.name ?? `#${i}`, value: c?.itemId });\n continue;\n }\n const grams = Number(c?.grams);\n if (!(grams > 0)) {\n rejected.push({ reason: 'bad grams', meal: m?.name ?? `#${i}`, value: c?.grams });\n continue;\n }\n components.push({\n itemId: item.id,\n grams: item.packUnit === 'ea' ? Math.max(1, Math.round(grams)) : Math.round(grams),\n role: MEAL_ROLES.has(c?.role) ? c.role : item.roleTags[0],\n });\n }\n if (!components.length) {\n rejected.push({ reason: 'no usable components', meal: m?.name ?? `#${i}` });\n return;\n }\n\n meals.push({\n id: typeof m?.id === 'string' && m.id ? m.id : `${idPrefix}-d${day}-${slot}-${i}`,\n day,\n slot,\n name: String(m?.name ?? 'Meal').slice(0, 80),\n components,\n steps: (Array.isArray(m?.steps) ? m.steps : []).map((s) => String(s).slice(0, 300)).slice(0, 12),\n batchGroup: typeof m?.batchGroup === 'string' ? m.batchGroup : null,\n locked: false,\n // computed is written by computePlan and nowhere else\n });\n });\n\n return { meals, rejected };\n}\n\n/**\n * Prep prose. Strings only, and the days must be ones the plan actually has —\n * a model inventing \"day 8\" would render as an empty section.\n */\nexport function sanitisePrep(raw, { days }) {\n const clean = (arr, cap) => (Array.isArray(arr) ? arr : [])\n .map((s) => String(s).slice(0, 300)).filter(Boolean).slice(0, cap);\n const validDay = (d) => Number.isInteger(Number(d)) && Number(d) >= 1 && Number(d) <= days;\n\n return {\n batchSessions: (Array.isArray(raw?.batchSessions) ? raw.batchSessions : [])\n .filter((b) => validDay(b?.day))\n .map((b) => ({\n day: Number(b.day),\n title: String(b?.title ?? 'Batch session').slice(0, 80),\n steps: clean(b?.steps, 20),\n }))\n .filter((b) => b.steps.length)\n .slice(0, 10),\n perDay: (Array.isArray(raw?.perDay) ? raw.perDay : [])\n .filter((d) => validDay(d?.day))\n .map((d) => ({ day: Number(d.day), steps: clean(d?.steps, 15) }))\n .filter((d) => d.steps.length)\n .slice(0, days),\n };\n}\n",[],[91,255],"17f39552-76d1-48f7-864c-d05e415292dd","mealproof.mjs","eb6f6c0a-a45a-11f1-82d9-1607ee4eb77e",16,["D",1788084582734],"// Proof that you cooked a planned meal.\n//\n// This app does not talk to Beeminder or to Vouch. It answers one question —\n// \"is this the meal the plan asked for?\" — and shows a datestamped card. You\n// screenshot the card into Vouch, which does the verifying-and-posting it\n// already does for every other goal.\n//\n// The proof standard is Vouch's: forging should cost about as much as doing\n// the thing. Here that means cooking something that passes the check.\n\nimport { parseJSON } from './model.mjs';\n\n/** A card older than this shouldn't be accepted as today's proof. */\nexport const CARD_VALID_HOURS = 24;\n\nconst pad = (n) => String(n).padStart(2, '0');\n\n/** Local-time stamp, written out so it survives being screenshotted. */\nexport function stampFor(ms, timeZone = 'Pacific/Auckland') {\n const d = new Date(ms);\n const parts = new Intl.DateTimeFormat('en-NZ', {\n timeZone, year: 'numeric', month: 'short', day: '2-digit',\n hour: '2-digit', minute: '2-digit', hour12: false,\n }).formatToParts(d).reduce((a, p) => ((a[p.type] = p.value), a), {});\n return `${parts.day} ${parts.month} ${parts.year}, ${parts.hour}:${parts.minute}`;\n}\n\nexport function buildMealPhotoPrompt({ meal, catalog }) {\n const named = (meal.components ?? []).map((c) => {\n const item = catalog[c.itemId];\n if (!item) return null;\n const qty = item.packUnit === 'ea' ? `${c.grams}` : `${c.grams}g`;\n return { name: item.name, qty, role: c.role };\n }).filter(Boolean);\n\n const main = named.filter((c) => ['protein', 'carb-base'].includes(c.role));\n const rest = named.filter((c) => !['protein', 'carb-base'].includes(c.role));\n\n return `Someone is proving they cooked a specific planned meal. Judge whether\nthe photograph plausibly shows THAT meal.\n\nThe meal: ${meal.name}\nMain components, which should be visibly present:\n${main.map((c) => ` ${c.qty} ${c.name} (the ${c.role})`).join('\\n') || ' (none identified)'}\nAlso in the recipe:\n${rest.map((c) => ` ${c.qty} ${c.name}`).join('\\n') || ' (nothing else)'}\n\nHow to judge:\n- The MAIN components must be identifiable in the photo. If the meal is chicken\n and rice and you cannot see anything resembling chicken, that is a fail.\n- Be reasonable about everything else. Home cooking does not look like the\n recipe photo. Sauces hide things, portions vary, plating is untidy, and small\n ingredients such as oil, spices or herbs will not be visible at all. None of\n that is a fail.\n- Judge the food, not the photography. Bad lighting, a phone shadow or a messy\n table are irrelevant.\n- Fail it if the photo shows something clearly different (a takeaway container,\n a completely different dish), shows no food at all, or is a photo of a screen\n or another photograph.\n\nFirst list what food you can actually identify, then decide. Do not decide\nfirst and justify afterwards.\n\nRespond with ONLY:\n{\n \"identified\": [\"what you can actually see\"],\n \"missing\": [\"main components you cannot see\"],\n \"verdict\": \"pass\" or \"fail\",\n \"reason\": \"one short sentence\"\n}`;\n}\n\n/**\n * Trust the verdict only when it is consistent with what the model says it\n * saw. A \"pass\" that also reports the protein missing is a contradiction, and\n * a model that names no food at all has not really looked.\n */\nexport function sanitiseVerdict(raw, { meal, catalog }) {\n const identified = (Array.isArray(raw?.identified) ? raw.identified : [])\n .map((x) => String(x).slice(0, 80)).slice(0, 20);\n const missing = (Array.isArray(raw?.missing) ? raw.missing : [])\n .map((x) => String(x).slice(0, 80)).slice(0, 20);\n const reason = String(raw?.reason ?? '').slice(0, 300);\n\n const mainCount = (meal.components ?? [])\n .filter((c) => ['protein', 'carb-base'].includes(c.role) && catalog[c.itemId]).length;\n\n let verdict = raw?.verdict === 'pass' ? 'pass' : 'fail';\n let overridden = null;\n\n if (verdict === 'pass' && identified.length === 0) {\n verdict = 'fail';\n overridden = 'The check passed without naming any food it could see.';\n } else if (verdict === 'pass' && mainCount > 0 && missing.length >= mainCount) {\n verdict = 'fail';\n overridden = 'The check passed while reporting every main component missing.';\n }\n\n return { verdict, identified, missing, reason, overridden };\n}\n\n/**\n * One verification. Returns a verdict; saving it is the caller's job.\n * `now` is injectable so the card's stamp is testable.\n */\nexport async function verifyMealPhoto({\n model, meal, catalog, imageBase64, mediaType = 'image/jpeg',\n now = Date.now(), timeZone,\n}) {\n const raw = parseJSON(await model.completeVision({\n prompt: buildMealPhotoPrompt({ meal, catalog }),\n imageBase64,\n mediaType,\n }));\n const checked = sanitiseVerdict(raw, { meal, catalog });\n return { ...checked, mealId: meal.id, mealName: meal.name, at: now, stamp: stampFor(now, timeZone) };\n}\n\n/**\n * The card Vouch screenshots.\n *\n * Two things make it worth anything: a visible timestamp, so an old screenshot\n * can be spotted, and the meal's identity, so the same dinner can't be claimed\n * twice. Both are Vouch's existing conventions, not new ones.\n */\nexport function proofCard(proof, { now = Date.now(), timeZone } = {}) {\n if (!proof) {\n return {\n state: 'none',\n verdict: 'No meal verified yet',\n detail: 'Photograph a meal from the plan to get a card.',\n };\n }\n const ageHours = (now - proof.at) / 3600000;\n const stale = ageHours > CARD_VALID_HOURS;\n\n return {\n state: proof.verdict === 'pass' ? (stale ? 'stale' : 'pass') : 'fail',\n // The line Vouch reads. Kept literal and stable — it is an interface.\n verdict: proof.verdict === 'pass' ? 'MEAL VERIFIED' : 'NOT VERIFIED',\n mealName: proof.mealName,\n day: proof.day ?? null,\n slot: proof.slot ?? null,\n stamp: proof.stamp ?? stampFor(proof.at, timeZone),\n at: proof.at,\n ageHours: Math.floor(ageHours),\n stale,\n identified: proof.identified ?? [],\n reason: proof.reason ?? '',\n note: stale\n ? `This card is ${Math.floor(ageHours)} hours old. Verify today's meal for a fresh one.`\n : null,\n };\n}\n\n/** Which meals can still be claimed — one pass per planned meal. */\nexport function claimableMeals(plan, proofs) {\n const done = new Set(proofs.filter((p) => p.verdict === 'pass').map((p) => p.mealId));\n return (plan?.meals ?? []).map((m) => ({\n id: m.id,\n day: m.day,\n slot: m.slot,\n name: m.name,\n claimed: done.has(m.id),\n }));\n}\n",[],[91,263],"7c6d9b53-5e96-497d-84ed-f3d82ab5180f","labels.mjs","eb3530f8-a45a-11f1-b7e1-1607ee4eb77e",12,["D",1788084582518],"// Label capture.\n//\n// The catalog ships with estimated nutrition for branded goods. When you buy\n// something, photograph the panel and the real numbers replace the guess for\n// that product, permanently.\n//\n// Captures live outside the catalog and are applied as an overlay at load\n// time. A catalog refresh can update prices and pack sizes without ever\n// overwriting a value read off an actual packet.\n\nimport { parseJSON } from './model.mjs';\n\n/** NZ/AU panels declare per 100g AND per serving. We want per 100g. */\nexport const LABEL_PROMPT = `This is a photograph of a nutrition information panel\nfrom a New Zealand or Australian food package.\n\nRead the \"per 100g\" or \"per 100mL\" column — NOT the per-serving column. If only\na per-serving column exists, say so rather than converting it.\n\nNew Zealand labels declare CARBOHYDRATE excluding fibre, with dietary fibre\nlisted separately. Report them the same way: \"carbs\" is available carbohydrate,\n\"fibre\" is separate. Report energy in kilocalories — if the panel only gives\nkilojoules, divide by 4.184.\n\nRespond with ONLY this JSON, no prose and no markdown fences:\n{\n \"readable\": true,\n \"per100\": {\"kcal\": 0, \"protein\": 0, \"carbs\": 0, \"fat\": 0, \"fibre\": 0},\n \"basis\": \"100g\",\n \"packSize\": null,\n \"packUnit\": null,\n \"notes\": \"anything unclear or unreadable\"\n}\n\nSet \"readable\" to false if you cannot see a per-100 column clearly. Do not\nguess: a wrong number here silently corrupts every meal plan that uses this\nproduct. If a value is genuinely absent from the panel, use 0 and say so in\nnotes.`;\n\n// Number(null) is 0 and Number('') is 0, so a missing value would silently\n// become zero — the exact corruption this whole module exists to prevent.\nconst labelNum = (v) => {\n if (v === null || v === undefined || v === '') return null;\n const n = Number(v);\n return Number.isFinite(n) && n >= 0 ? Math.round(n * 10) / 10 : null;\n};\n\n/**\n * Validate a vision read before it is allowed anywhere near the catalog.\n * Anything that fails here is returned for the user to correct by hand.\n */\nexport function sanitiseLabel(raw, { item } = {}) {\n const problems = [];\n\n if (raw?.readable === false) {\n return { ok: false, problems: [String(raw?.notes || 'The panel could not be read clearly.')] };\n }\n\n const p = raw?.per100 ?? {};\n const per100 = {\n kcal: labelNum(p.kcal), protein: labelNum(p.protein),\n carbs: labelNum(p.carbs), fat: labelNum(p.fat), fibre: labelNum(p.fibre) ?? 0,\n };\n for (const k of ['kcal', 'protein', 'carbs', 'fat']) {\n if (per100[k] === null) problems.push(`${k} missing or not a number`);\n }\n if (problems.length) return { ok: false, problems, per100 };\n\n // Nothing edible is over 900 kcal/100g (pure fat is 900).\n if (per100.kcal > 950) problems.push(`${per100.kcal} kcal per 100g is not possible`);\n for (const k of ['protein', 'carbs', 'fat', 'fibre']) {\n if (per100[k] > 100) problems.push(`${per100[k]}g of ${k} in 100g is not possible`);\n }\n\n // Same Atwater check the catalog build uses. A misread digit usually breaks it.\n const atwater = 4 * per100.protein + 4 * per100.carbs + 9 * per100.fat + 2 * per100.fibre;\n const drift = per100.kcal >= 40 ? Math.abs(atwater - per100.kcal) / per100.kcal : 0;\n if (drift > 0.30) {\n problems.push(\n `energy and macros disagree — ${per100.kcal} kcal stated, macros work out to ~${Math.round(atwater)}. Check the numbers.`,\n );\n }\n\n const basisOk = !raw?.basis || /100\\s*(g|ml)/i.test(String(raw.basis));\n if (!basisOk) problems.push(`read from \"${raw.basis}\" rather than a per-100 column`);\n\n // A large move from the existing estimate is worth a second look, not a block.\n const warnings = [];\n if (item?.per100 && item.per100.kcal > 0) {\n const shift = Math.abs(per100.kcal - item.per100.kcal) / item.per100.kcal;\n if (shift > 0.3) {\n warnings.push(`${Math.round(shift * 100)}% different from the current estimate of ${Math.round(item.per100.kcal)} kcal`);\n }\n }\n\n return {\n ok: problems.length === 0,\n problems,\n warnings,\n per100,\n basis: raw?.basis ?? null,\n packSize: labelNum(raw?.packSize),\n packUnit: ['g', 'ml', 'ea'].includes(raw?.packUnit) ? raw.packUnit : null,\n notes: raw?.notes ? String(raw.notes).slice(0, 300) : null,\n };\n}\n\n/** Ask the model to read a photographed panel. Nothing is saved here. */\nexport async function readLabel({ model, itemId, catalog, imageBase64, mediaType = 'image/jpeg' }) {\n const item = catalog[itemId];\n if (!item) throw new Error(`Unknown item \"${itemId}\"`);\n\n const raw = parseJSON(await model.completeVision({\n prompt: `${LABEL_PROMPT}\\n\\nFor context, this should be: ${item.name} (${item.packSize}${item.packUnit === 'ea' ? ' units' : item.packUnit}).`,\n imageBase64,\n mediaType,\n }));\n\n return { itemId, item: { id: item.id, name: item.name }, ...sanitiseLabel(raw, { item }) };\n}\n\n/**\n * Apply confirmed captures over a catalog.\n * Only the nutrition is overridden — name, price and pack size stay with the\n * catalog, so a refresh keeps working.\n */\nexport function applyLabels(catalog, captures) {\n if (!captures?.length) return catalog;\n const out = { ...catalog };\n for (const cap of captures) {\n const item = out[cap.itemId];\n if (!item) continue;\n out[cap.itemId] = {\n ...item,\n per100: { ...cap.per100 },\n per100Source: 'label',\n per100CapturedAt: cap.capturedAt,\n labelCaptureId: cap.id,\n };\n }\n return out;\n}\n\n/**\n * Which products are most worth photographing next: estimated nutrition,\n * ordered by how much of the plan leans on them.\n */\nexport function captureQueue(plan, catalog, { limit = 10 } = {}) {\n const grams = new Map();\n for (const m of plan?.meals ?? []) {\n for (const c of m.components ?? []) {\n const item = catalog[c.itemId];\n if (!item || item.per100Source !== 'estimate') continue;\n grams.set(c.itemId, (grams.get(c.itemId) || 0) + c.grams);\n }\n }\n return [...grams.entries()]\n .sort((a, b) => b[1] - a[1])\n .slice(0, limit)\n .map(([itemId, q]) => {\n const item = catalog[itemId];\n // kcal at stake still needs real grams, even where the quantity is a count.\n const realGrams = item.packUnit === 'ea' ? q * (item.unitGrams || 0) : q;\n return {\n itemId,\n name: item.name,\n grams: Math.round(q),\n unit: item.packUnit,\n kcalAtStake: Math.round((realGrams / 100) * item.per100.kcal),\n };\n });\n}\n",[],[91,271],"0da524ef-df29-4544-b15c-0a2a93094138","generate.mjs","eb2918ae-a45a-11f1-b7e1-1607ee4eb77e",79,["D",1788235965487],"// Phase A + D orchestration.\n//\n// A (model) → D-0 (code) → B/C (code) → D (model), max 3 rounds.\n// The plan that comes out carries the validator's actual verdict, never a\n// nicer one.\n\nimport {\n selectCandidates, buildIdeationPrompt, buildRepairPrompt,\n buildPlacementPrompt, buildPrepPrompt, wantedList,\n} from './prompts.mjs';\nimport { parseJSON, sanitiseMeals, sanitisePrep } from './model.mjs';\nimport { perishability, cookSchedule, findSpoilingSurplus } from './perishable.mjs';\nimport {\n resolveRoutine, dailyMacros, supplementLines, proteinBreakdown, dailyChecklist,\n} from './supplements.mjs';\nimport { placeRecipes, remainingBudget, fixedMealsBlock } from './recipes.mjs';\nimport { solveGrams } from './solver.mjs';\nimport { validatePlan, hardRegressions } from './validate.mjs';\nimport { buildShoppingList } from './shopping.mjs';\nimport { useFirst as expiringStock, surplusToStock, mergeStock, wasteReport, pruneStock } from './reconcile.mjs';\n\nexport const MAX_ROUNDS = 3;\n\nconst PHASES = {\n ideate: 'choosing meals',\n solve: 'sizing portions',\n validate: 'checking macros',\n repair: 'adjusting',\n shop: 'building the list',\n leftovers: 'using up leftovers',\n prep: 'writing the prep sheet',\n};\n\nexport async function generatePlan({\n model, catalog, settings, days,\n favourites = new Set(), pantry = {}, stock = [], recipes = [], now = Date.now(),\n onPhase = () => {},\n}) {\n const candidates = selectCandidates(catalog, settings, { favourites });\n const wanted = wantedList(settings, catalog);\n\n // Supplements are taken daily whatever the plan is, and some carry real\n // macros. Their contribution is known before ideation, so the food targets\n // are adjusted down rather than the day quietly overshooting.\n const routine = resolveRoutine(settings.supplements, catalog);\n const supp = dailyMacros(routine, catalog);\n const foodSettings = supp.total.kcal > 0 || supp.total.protein > 0\n ? { ...settings, targets: {\n kcal: Math.max(0, Math.round(settings.targets.kcal - supp.total.kcal)),\n protein: Math.max(0, Math.round(settings.targets.protein - supp.total.protein)),\n carbs: Math.max(0, Math.round(settings.targets.carbs - supp.total.carbs)),\n fat: Math.max(0, Math.round(settings.targets.fat - supp.total.fat)),\n } }\n : settings;\n // Food already bought and about to spoil outranks every other preference.\n const useFirst = expiringStock(stock, catalog, { now, withinDays: days + 1 });\n if (candidates.length < 20) {\n throw new Error(`Only ${candidates.length} catalog items survived the filters — restrictions or dislikes are excluding almost everything.`);\n }\n\n // Meals you supplied are placed before anything is generated, and the budget\n // left over is worked out here rather than described to the model in prose.\n const placement = placeRecipes(recipes, { days, slots: settings.slotsPerDay });\n const budget = remainingBudget({\n placed: placement.meals, days, slots: settings.slotsPerDay,\n targets: foodSettings.targets, catalog,\n });\n const everySlotFixed = budget.every((d) => d.freeSlots.length === 0);\n\n // ── Phase A ────────────────────────────────────────────────────────────────\n onPhase(PHASES.ideate, { round: 0 });\n // If your own recipes fill the whole window there is nothing to generate.\n let first = { meals: [], rejected: [] };\n if (!everySlotFixed) {\n const ideation = parseJSON(await model.complete(buildIdeationPrompt({\n settings: foodSettings, days, candidates, useFirst, wanted,\n fixed: fixedMealsBlock(budget),\n })));\n first = sanitiseMeals(ideation, catalog, { days, slots: settings.slotsPerDay });\n\n if (!first.meals.length) {\n throw new Error(`The planner returned nothing usable (${first.rejected.length} rejected items).`);\n }\n }\n\n // A generated meal never displaces one of yours.\n const fixedSlots = new Set(placement.meals.map((m) => `${m.day}:${m.slot}`));\n const generated = first.meals.filter((m) => !fixedSlots.has(`${m.day}:${m.slot}`));\n\n let plan = {\n id: `plan-${Date.now()}`,\n createdAt: Date.now(),\n days,\n store: settings.store,\n targets: settings.targets,\n meals: [...placement.meals, ...generated],\n substitutions: [],\n };\n\n const log = [];\n const rejected = [...first.rejected];\n let result = null;\n let rounds = 0;\n\n // ── D-0 → C → D loop ───────────────────────────────────────────────────────\n for (let round = 1; round <= MAX_ROUNDS; round++) {\n rounds = round;\n\n onPhase(PHASES.solve, { round });\n const solved = solveGrams(plan, catalog, foodSettings);\n plan = solved.plan;\n\n onPhase(PHASES.validate, { round });\n result = validatePlan(plan, catalog, foodSettings);\n plan = result.plan;\n log.push({\n round,\n adjustments: solved.changes.length,\n hard: result.counts.hard,\n band: result.counts.band,\n variety: result.counts.variety,\n });\n\n if (result.pass) break;\n if (round === MAX_ROUNDS) break;\n\n // Only failures a model can act on. Anything D-0 could have fixed, it has.\n const actionable = result.failures.filter((f) => f.kind !== 'variety' || f.scope === 'plan');\n if (!actionable.length) break;\n\n const affectedDays = new Set(actionable.filter((f) => f.day).map((f) => f.day));\n const affectedMealIds = new Set(actionable.filter((f) => f.mealId).map((f) => f.mealId));\n const affected = plan.meals.filter(\n (m) => !m.locked && (affectedDays.has(m.day) || affectedMealIds.has(m.id)),\n );\n if (!affected.length) break;\n\n onPhase(PHASES.repair, { round });\n let repairedRaw;\n try {\n repairedRaw = parseJSON(await model.complete(buildRepairPrompt({\n settings: foodSettings, failures: actionable, meals: affected, candidates,\n })));\n } catch (err) {\n log.push({ round, error: `repair round failed: ${err.message}` });\n break;\n }\n\n const repaired = sanitiseMeals(repairedRaw, catalog, { days, slots: settings.slotsPerDay });\n rejected.push(...repaired.rejected);\n\n // Merge by id, and ONLY for meals we asked about. A repair round that\n // returns an unrelated meal does not get to rewrite it.\n const allowed = new Set(affected.map((m) => m.id));\n const patch = new Map(repaired.meals.filter((m) => allowed.has(m.id)).map((m) => [m.id, m]));\n if (!patch.size) {\n log.push({ round, error: 'repair returned no meals matching the ones sent' });\n break;\n }\n plan = {\n ...plan,\n meals: plan.meals.map((m) => (patch.has(m.id) && !m.locked\n ? { ...patch.get(m.id), locked: m.locked }\n : m)),\n };\n }\n\n // ── Phase E ────────────────────────────────────────────────────────────────\n onPhase(PHASES.shop, { round: rounds });\n let shopping = buildShoppingList(result.plan, catalog,\n { store: settings.store, favourites, pantry, stock, now });\n\n // ── Phase F ────────────────────────────────────────────────────────────────\n // Discovery is arithmetic and already done. The model only places what code\n // found, and only the part that can't simply be frozen.\n let spoiling = findSpoilingSurplus(shopping, catalog, days);\n const placementNotes = [];\n\n if (spoiling.place.length) {\n onPhase(PHASES.leftovers, { round: rounds });\n try {\n const raw = parseJSON(await model.complete(buildPlacementPrompt({\n settings: foodSettings, surplus: spoiling.place,\n meals: result.plan.meals.filter((m) => !m.locked), candidates,\n })));\n const placed = sanitiseMeals(raw, catalog, { days, slots: settings.slotsPerDay, idPrefix: 'flex' });\n rejected.push(...placed.rejected);\n\n if (placed.meals.length) {\n const byId = new Map(placed.meals.map((m) => [m.id, m]));\n const merged = result.plan.meals.map(\n (m) => (byId.has(m.id) && !m.locked ? { ...byId.get(m.id), locked: m.locked } : m));\n for (const m of placed.meals) if (!merged.some((x) => x.id === m.id)) merged.push(m);\n\n const candidatePlan = solveGrams({ ...result.plan, meals: merged }, catalog, foodSettings).plan;\n const after = validatePlan(candidatePlan, catalog, foodSettings);\n\n // Using up leftovers must not break the plan, or deepen a break it\n // already had. If it would, keep the plan and let the food spoil — a\n // broken plan is the worse outcome.\n if (hardRegressions(result, after).length === 0) {\n result = after;\n shopping = buildShoppingList(result.plan, catalog,\n { store: settings.store, favourites, pantry, stock, now });\n spoiling = findSpoilingSurplus(shopping, catalog, days);\n for (const n of Array.isArray(raw?.notes) ? raw.notes.slice(0, 5) : []) {\n placementNotes.push(String(n).slice(0, 200));\n }\n } else {\n log.push({ round: rounds, note: 'leftover placement rejected — it broke a hard constraint' });\n }\n }\n } catch (err) {\n log.push({ round: rounds, error: `leftover placement failed: ${err.message}` });\n }\n }\n\n // ── Phase G ────────────────────────────────────────────────────────────────\n // Supplement lines are built after the final shopping list so they see the\n // same stock ledger — a tub of creatine lasts months and must not be\n // re-bought every cycle.\n const suppLines = supplementLines(routine, catalog, days, { stock, now });\n\n const perish = perishability(result.plan, catalog);\n const schedule = cookSchedule(result.plan);\n const perDay = [];\n for (let d = 1; d <= days; d++) {\n perDay.push({ day: d, meals: result.plan.meals.filter((m) => m.day === d) });\n }\n\n let prep = { batchSessions: [], perDay: [] };\n try {\n onPhase(PHASES.prep, { round: rounds });\n prep = sanitisePrep(parseJSON(await model.complete(buildPrepPrompt({\n settings, plan: result.plan, batches: schedule.batches, perDay,\n freezeOnArrival: perish.freezeOnArrival, freezePortions: perish.freezePortions, catalog,\n }))), { days });\n } catch (err) {\n // Prose is the least important output here. Losing it must not lose the plan.\n log.push({ round: rounds, error: `prep sheet failed: ${err.message}` });\n }\n\n const hard = result.failures.filter((f) => f.kind === 'hard');\n const band = result.failures.filter((f) => f.kind === 'band');\n const variety = result.failures.filter((f) => f.kind === 'variety');\n\n return {\n plan: {\n ...result.plan,\n shopping: [...shopping.lines, ...suppLines],\n totals: {\n ...result.plan.totals,\n estCost: Math.round((shopping.estCost + suppLines.reduce((t, l) => t + l.estCost, 0)) * 100) / 100,\n // What the day actually adds up to, food plus supplements.\n withSupplements: result.plan.totals.perDay.map((t) => ({\n day: t.day,\n kcal: Math.round(t.kcal + supp.total.kcal),\n protein: Math.round(t.protein + supp.total.protein),\n carbs: Math.round(t.carbs + supp.total.carbs),\n fat: Math.round(t.fat + supp.total.fat),\n })),\n },\n recipes: {\n placed: placement.meals.map((m) => ({ id: m.id, day: m.day, slot: m.slot, name: m.name, fromRecipe: m.fromRecipe })),\n skipped: placement.skipped,\n overflow: placement.overflow ?? [],\n },\n // What was actually configured, so a past plan exports correctly even\n // after the routine changes.\n supplementsTaken: settings.supplements ?? [],\n supplements: {\n checklist: dailyChecklist(routine),\n daily: {\n kcal: Math.round(supp.total.kcal), protein: Math.round(supp.total.protein),\n carbs: Math.round(supp.total.carbs), fat: Math.round(supp.total.fat),\n fibre: Math.round(supp.total.fibre),\n },\n foodTargets: foodSettings.targets,\n fullTargets: settings.targets,\n breakdown: proteinBreakdown(\n (result.plan.totals.perDay[0]?.protein ?? 0) + supp.total.protein, supp, settings.targets),\n missing: routine.missing,\n },\n prep: {\n ...prep,\n freezeOnArrival: perish.freezeOnArrival,\n freezePortions: perish.freezePortions,\n moveEarlier: perish.moveEarlier,\n freezeSurplus: spoiling.freeze,\n stillSpoiling: spoiling.place,\n cookDays: schedule.meals,\n notes: placementNotes,\n },\n validation: {\n pass: result.pass,\n rounds,\n failures: result.failures,\n notes: result.notes,\n // What it was judged against, so the rails draw the same thresholds.\n bands: result.bands,\n },\n },\n // A hard failure means the plan is not fit to use. Say so; don't ship it\n // behind a green tick.\n // Usable means \"you could shop from this\". A hard failure or a wildly\n // out-of-band plan is not.\n usable: hard.length === 0 && !buildBanner({ pass: result.pass, hard, band, variety, rounds }).wild,\n banner: buildBanner({ pass: result.pass, hard, band, variety, rounds }),\n log,\n rejected,\n candidateCount: candidates.length,\n useFirst,\n // What this shop leaves behind, ready to be carried into the next one.\n nextStock: mergeStock([...pruneStock(stock, { now }), ...surplusToStock(shopping, catalog, { shoppedOn: now })]),\n waste: wasteReport(stock, catalog, { now }),\n };\n}\n\nfunction buildBanner({ pass, hard, band, variety, rounds }) {\n const r = `${rounds} round${rounds === 1 ? '' : 's'}`;\n if (pass) return { level: 'ok', message: `Plan meets every target (${r}).` };\n\n if (hard.length) {\n return {\n level: 'error',\n message: `Couldn't build a usable plan after ${r} — ${hard.length} constraint${hard.length === 1 ? '' : 's'} still broken.`,\n detail: hard.map((f) => f.message),\n };\n }\n if (band.length) {\n // A band miss is shippable — but \"Day 1 kcal +84%\" is not a near miss, it's\n // a different plan. Past a doubling of the band, say so rather than\n // presenting it as the closest fit found.\n const worst = Math.max(...band.map((f) => Math.abs(f.delta) / Math.max(1, f.target)));\n const wild = worst > 0.30;\n return {\n level: wild ? 'error' : 'warn',\n message: wild\n ? `This plan is a long way off after ${r} — the worst day misses by ${Math.round(worst * 100)}%. Worth regenerating.`\n : `Closest fit found after ${r}. ${band.length} target${band.length === 1 ? '' : 's'} missed:`,\n detail: band.map((f) => f.message),\n wild,\n };\n }\n // Variety only. Every macro target is met, so don't imply otherwise —\n // saying \"0 targets missed\" while showing a warning is worse than silence.\n return {\n level: 'warn',\n message: `Every macro target met. ${variety.length} variety note${variety.length === 1 ? '' : 's'}:`,\n detail: variety.map((f) => f.message),\n };\n}\n",[],[91,279],"3551996d-554e-4213-9fcb-67e475c0a29e","export.mjs","eb1d1c98-a45a-11f1-82d9-1607ee4eb77e",10,["D",1788084582352],"// §12 — one-way export to the existing calorie tracker.\n//\n// This app plans forward; the tracker records backward. The export converts\n// planned meals into log entries so a day's food doesn't have to be retyped.\n//\n// It exports what was PLANNED, and says which meals were actually confirmed.\n// Silently logging food that was never eaten would corrupt the tracker with\n// this app's optimism.\n\nimport { computeMeal } from './compute.mjs';\nimport { resolveRoutine, dailyMacros } from './supplements.mjs';\n\nconst iso = (ms) => new Date(ms).toISOString().slice(0, 10);\n\n/**\n * @param include 'all' — every meal, marked with its status\n * 'eaten' — only meals confirmed as eaten\n */\nexport function trackerExport(plan, catalog, {\n include = 'eaten', startDate = plan.createdAt, supplements = plan.supplementsTaken ?? null,\n} = {}) {\n const days = new Map();\n let skipped = 0;\n\n for (const meal of plan.meals) {\n const status = meal.status ?? 'planned';\n if (include === 'eaten' && status !== 'ate') { skipped++; continue; }\n\n const { exact } = computeMeal(meal, catalog);\n const date = iso(startDate + (meal.day - 1) * 86400000);\n if (!days.has(date)) days.set(date, []);\n\n days.get(date).push({\n name: meal.name,\n qty: 1,\n unitLabel: 'serving',\n kcal: Math.round(exact.kcal),\n protein: Math.round(exact.protein),\n carbs: Math.round(exact.carbs),\n fat: Math.round(exact.fat),\n slot: meal.slot,\n status,\n // Estimated nutrition travels with the entry rather than being laundered\n // into the tracker as fact.\n estimated: meal.components.some((c) => catalog[c.itemId]?.per100Source === 'estimate'),\n });\n }\n\n // Supplements are eaten too. Leaving them out means the tracker under-counts\n // by exactly what they contribute — 9g of protein a day, silently.\n const routine = resolveRoutine(supplements ?? [], catalog);\n const suppMacros = dailyMacros(routine, catalog);\n let supplementDays = 0;\n\n if (routine.items.length && (suppMacros.total.kcal > 0 || suppMacros.total.protein > 0)) {\n for (const [, items] of days) {\n items.push({\n name: routine.items.map((s) => s.name).join(' + '),\n qty: 1, unitLabel: 'daily supplements',\n kcal: Math.round(suppMacros.total.kcal),\n protein: Math.round(suppMacros.total.protein),\n carbs: Math.round(suppMacros.total.carbs),\n fat: Math.round(suppMacros.total.fat),\n slot: 'supplement', status: 'ate', estimated: false,\n // Flagged so the tracker doesn't read collagen as food protein.\n incompleteProtein: Math.round(suppMacros.incomplete.protein) || 0,\n });\n supplementDays++;\n }\n }\n\n const entries = [...days.entries()]\n .sort(([a], [b]) => a.localeCompare(b))\n .map(([date, items]) => ({ date, entries: items }));\n\n return {\n source: 'meal-planner',\n exportedAt: Date.now(),\n planId: plan.id,\n include,\n days: entries,\n counts: {\n exported: entries.reduce((s, d) => s + d.entries.length, 0),\n excluded: skipped,\n total: plan.meals.length,\n supplementDays,\n },\n note: include === 'eaten'\n ? 'Only meals confirmed as eaten. Unrecorded meals are excluded rather than assumed.'\n : 'Every planned meal, each tagged with what actually happened to it.',\n };\n}\n\n/** Same data as CSV, for a tracker that would rather have a spreadsheet. */\nexport function trackerCSV(exported) {\n const rows = [['date', 'slot', 'name', 'qty', 'unit', 'kcal', 'protein_g', 'carbs_g', 'fat_g', 'status', 'estimated', 'incomplete_protein_g']];\n for (const day of exported.days) {\n for (const e of day.entries) {\n rows.push([day.date, e.slot, e.name, e.qty, e.unitLabel, e.kcal, e.protein, e.carbs, e.fat, e.status, e.estimated ? 'yes' : 'no', e.incompleteProtein ?? 0]);\n }\n }\n return rows.map((r) => r.map((v) => {\n const s = String(v);\n return /[\",\\n]/.test(s) ? `\"${s.replace(/\"/g, '\"\"')}\"` : s;\n }).join(',')).join('\\n');\n}\n",[],[91,287],"d88dbd50-20dd-44f4-83dd-459007f7b62b","csv.mjs","eb17a844-a45a-11f1-9fa2-1607ee4eb77e",9,["D",1788084582286],"// CSV catalog import — the permanent escape hatch (§7).\n//\n// When scraping breaks or a price is wrong, the app must still work from a\n// spreadsheet. Rows that don't parse are reported, not silently dropped, and a\n// bad row never takes the whole import down.\n\nconst REQUIRED = ['id', 'name', 'category', 'aisle', 'packSize', 'packUnit', 'kcal', 'protein', 'carbs', 'fat', 'shelfLifeDays', 'roleTags', 'substituteGroup'];\n\nconst ROLE_TAGS = new Set([\n 'protein', 'carb-base', 'green', 'veg', 'fruit',\n 'fat', 'dairy', 'flavour', 'acid', 'sauce', 'spice', 'supplement',\n]);\n\nconst PICK_ORDER = { Pantry: 1, Bakery: 2, Butchery: 3, Seafood: 4, Chilled: 5, Produce: 6, Frozen: 7 };\n\n/** RFC4180-ish: quoted fields, doubled quotes, embedded commas and newlines. */\nexport function parseCSV(text) {\n const rows = [];\n let row = [];\n let field = '';\n let quoted = false;\n\n for (let i = 0; i < text.length; i++) {\n const ch = text[i];\n if (quoted) {\n if (ch === '\"') {\n if (text[i + 1] === '\"') { field += '\"'; i++; } else quoted = false;\n } else field += ch;\n continue;\n }\n if (ch === '\"') { quoted = true; continue; }\n if (ch === ',') { row.push(field); field = ''; continue; }\n if (ch === '\\r') continue;\n if (ch === '\\n') { row.push(field); rows.push(row); row = []; field = ''; continue; }\n field += ch;\n }\n if (field !== '' || row.length) { row.push(field); rows.push(row); }\n return rows.filter((r) => r.some((c) => c.trim() !== ''));\n}\n\nconst csvNum = (v) => {\n if (v === null || v === undefined || String(v).trim() === '') return null;\n const n = Number(String(v).replace(/[$,]/g, ''));\n return Number.isFinite(n) ? n : null;\n};\nconst csvBool = (v) => /^(1|true|yes|y)$/i.test(String(v ?? '').trim());\n\nexport function parseCatalogCSV(text, store) {\n const rows = parseCSV(text);\n const errors = [];\n if (!rows.length) return { items: [], errors: ['The file is empty'] };\n\n const header = rows[0].map((h) => h.trim());\n const missing = REQUIRED.filter((r) => !header.includes(r));\n if (missing.length) return { items: [], errors: [`Missing column(s): ${missing.join(', ')}`] };\n\n const idx = Object.fromEntries(header.map((h, i) => [h, i]));\n const at = (row, key) => (idx[key] === undefined ? '' : (row[idx[key]] ?? '').trim());\n const items = [];\n const seen = new Set();\n const now = Date.now();\n\n rows.slice(1).forEach((row, n) => {\n const line = n + 2;\n const bad = (msg) => errors.push(`Row ${line}: ${msg}`);\n\n const id = at(row, 'id');\n if (!id) return bad('no id');\n if (seen.has(id)) return bad(`duplicate id \"${id}\"`);\n\n const packUnit = at(row, 'packUnit');\n if (!['g', 'ml', 'ea'].includes(packUnit)) return bad(`packUnit must be g, ml or ea (got \"${packUnit}\")`);\n\n const packSize = csvNum(at(row, 'packSize'));\n if (!(packSize > 0)) return bad('packSize must be a positive number');\n\n const per100 = {\n kcal: csvNum(at(row, 'kcal')), protein: csvNum(at(row, 'protein')),\n carbs: csvNum(at(row, 'carbs')), fat: csvNum(at(row, 'fat')), fibre: csvNum(at(row, 'fibre')) ?? 0,\n };\n for (const k of ['kcal', 'protein', 'carbs', 'fat']) {\n if (per100[k] === null || per100[k] < 0) return bad(`${k} missing or negative`);\n }\n\n const roleTags = at(row, 'roleTags').split(/[|;]/).map((r) => r.trim()).filter(Boolean);\n if (!roleTags.length) return bad('no roleTags');\n const badRole = roleTags.find((r) => !ROLE_TAGS.has(r));\n if (badRole) return bad(`unknown roleTag \"${badRole}\"`);\n\n const substituteGroup = at(row, 'substituteGroup');\n if (!substituteGroup) return bad('no substituteGroup');\n\n const shelfLifeDays = csvNum(at(row, 'shelfLifeDays'));\n if (!(shelfLifeDays > 0)) return bad('shelfLifeDays must be a positive number');\n\n const unitGrams = csvNum(at(row, 'unitGrams'));\n if (packUnit === 'ea' && !(unitGrams > 0)) return bad(\"packUnit 'ea' needs unitGrams\");\n\n if (csvBool(at(row, 'supplement')) && !(csvNum(at(row, 'dailyDose')) > 0)) {\n return bad('a supplement needs a dailyDose');\n }\n\n const aisle = at(row, 'aisle');\n seen.add(id);\n items.push({\n id, name: at(row, 'name'), brand: at(row, 'brand') || null,\n store, storeSku: at(row, 'storeSku') || null,\n category: at(row, 'category'), aisle,\n pickOrder: PICK_ORDER[aisle] ?? 99,\n packSize, packUnit,\n price: csvNum(at(row, 'price')),\n priceSource: at(row, 'price') ? 'store' : 'estimate',\n per100,\n // Imported nutrition is treated as a stated figure, not a measured one,\n // unless the file says it came off a label.\n per100Source: at(row, 'per100Source') === 'label' ? 'label'\n : at(row, 'per100Source') === 'reference' ? 'reference' : 'estimate',\n per100CapturedAt: null, labelCaptureId: null,\n unitGrams: packUnit === 'ea' ? unitGrams : null,\n shelfLifeDays,\n freezable: csvBool(at(row, 'freezable')),\n staple: csvBool(at(row, 'staple')),\n carryForward: at(row, 'carryForward') ? csvBool(at(row, 'carryForward')) : shelfLifeDays >= 60,\n roleTags, substituteGroup,\n contains: at(row, 'contains').split(/[|;]/).map((c) => c.trim()).filter(Boolean),\n containsSource: 'stated',\n tags: at(row, 'tags').split(/[|;]/).map((t) => t.trim()).filter(Boolean),\n supplement: csvBool(at(row, 'supplement')),\n dailyDose: csvNum(at(row, 'dailyDose')),\n updatedAt: now,\n });\n });\n\n return { items, errors };\n}\n\n/** Export the current catalog so it can be edited and imported back. */\nexport function catalogToCSV(items) {\n const cols = ['id', 'name', 'brand', 'category', 'aisle', 'packSize', 'packUnit', 'price',\n 'kcal', 'protein', 'carbs', 'fat', 'fibre', 'per100Source', 'unitGrams',\n 'shelfLifeDays', 'freezable', 'staple', 'carryForward', 'roleTags', 'substituteGroup', 'contains',\n 'tags', 'supplement', 'dailyDose'];\n const esc = (v) => {\n const s = v === null || v === undefined ? '' : String(v);\n return /[\",\\n]/.test(s) ? `\"${s.replace(/\"/g, '\"\"')}\"` : s;\n };\n const rows = [cols.join(',')];\n for (const i of items) {\n rows.push([\n i.id, i.name, i.brand, i.category, i.aisle, i.packSize, i.packUnit, i.price,\n i.per100?.kcal, i.per100?.protein, i.per100?.carbs, i.per100?.fat, i.per100?.fibre,\n i.per100Source, i.unitGrams, i.shelfLifeDays,\n i.freezable ? 'yes' : 'no', i.staple ? 'yes' : 'no', i.carryForward ? 'yes' : 'no',\n (i.roleTags ?? []).join('|'), i.substituteGroup, (i.contains ?? []).join('|'),\n (i.tags ?? []).join('|'), i.supplement ? 'yes' : 'no', i.dailyDose,\n ].map(esc).join(','));\n }\n return rows.join('\\n');\n}\n",[],[91,295],"4de1d0e4-4c73-4ff8-a792-d5d6a005cdbb","compute.mjs","eaea6e42-a45a-11f1-891f-1607ee4eb77e",6,["D",1788084582037],"// Phase B — compute. The ONLY place macros are calculated.\n// Anything a model claimed about numbers is discarded here, not merged.\n\nconst ZERO = () => ({ kcal: 0, protein: 0, carbs: 0, fat: 0, fibre: 0 });\n\nconst add = (a, b, f = 1) => {\n a.kcal += b.kcal * f;\n a.protein += b.protein * f;\n a.carbs += b.carbs * f;\n a.fat += b.fat * f;\n a.fibre += (b.fibre || 0) * f;\n return a;\n};\n\nexport const roundMacros = (m) => ({\n kcal: Math.round(m.kcal),\n protein: Math.round(m.protein),\n carbs: Math.round(m.carbs),\n fat: Math.round(m.fat),\n});\n\n/**\n * Actual grams for a component amount.\n * For packUnit 'ea', `amount` is a COUNT of units, not a weight.\n */\nexport function gramsOf(item, amount) {\n if (!item) return 0;\n return item.packUnit === 'ea' ? amount * (item.unitGrams || 0) : amount;\n}\n\n/** Exact (unrounded) macros for one meal, plus any component ids that didn't resolve. */\nexport function computeMeal(meal, catalog) {\n const exact = ZERO();\n const unresolved = [];\n for (const c of meal.components || []) {\n const item = catalog[c.itemId];\n if (!item) { unresolved.push(c.itemId); continue; }\n if (!item.per100) { unresolved.push(c.itemId); continue; }\n add(exact, item.per100, gramsOf(item, c.grams) / 100);\n }\n return { exact, unresolved };\n}\n\n/**\n * Compute a whole plan. Returns a NEW plan with computed macros written by this\n * function only, plus exact figures for the validator to work from.\n * Rounding happens once, at the display boundary — per-day totals are summed\n * from exact meal values so they never drift from the meals they contain.\n */\nexport function computePlan(plan, catalog) {\n const byMeal = new Map();\n const unresolved = [];\n\n const meals = (plan.meals || []).map((meal) => {\n const { exact, unresolved: u } = computeMeal(meal, catalog);\n byMeal.set(meal.id, exact);\n for (const id of u) unresolved.push({ mealId: meal.id, itemId: id });\n // Overwrite, never merge: a model-supplied `computed` is discarded here.\n return { ...meal, computed: roundMacros(exact) };\n });\n\n const perDayExact = [];\n for (let d = 1; d <= plan.days; d++) {\n const t = ZERO();\n for (const m of meals) if (m.day === d) add(t, byMeal.get(m.id));\n perDayExact.push({ day: d, ...t });\n }\n\n const overallExact = ZERO();\n for (const t of perDayExact) add(overallExact, t);\n\n return {\n plan: {\n ...plan,\n meals,\n totals: {\n perDay: perDayExact.map((t) => ({ day: t.day, ...roundMacros(t) })),\n overall: roundMacros(overallExact),\n estCost: plan.totals?.estCost ?? 0,\n },\n },\n exact: { byMeal, perDay: perDayExact, overall: overallExact },\n unresolved,\n };\n}\n",[],[91,303],"0fd87aa2-a090-4173-b317-f2cd365ef39b","catalog.mjs","eaeea2fa-a45a-11f1-8d94-1607ee4eb77e",7,["D",1788084582048],"// Catalog access + free-text parsing.\n\nexport function indexCatalog(catalogFile) {\n const byId = Object.create(null);\n for (const it of catalogFile.items) byId[it.id] = it;\n return byId;\n}\n\nexport function groupMembers(catalog, group, store) {\n return Object.values(catalog).filter(\n (it) => it.substituteGroup === group && (!store || it.store === store),\n );\n}\n\n/** Split free text (\"mushrooms, coriander; olives\") into lowercase terms. */\nexport function parseTerms(text) {\n if (!text) return [];\n return String(text)\n .split(/[,;\\n]/)\n .map((t) => t.trim().toLowerCase())\n .filter((t) => t.length > 1);\n}\n\n/**\n * Does a catalog item match a free-text term? Matches on name, substitute group\n * and category, with naive singularisation so \"mushrooms\" catches \"Mushroom\".\n *\n * This is a SUGGESTION engine, not a decision engine. \"olives\" matches \"Olive\n * Oil\" and no amount of stemming fixes that — the fix is resolveDislikes()\n * below, which turns fuzzy terms into a concrete list the user confirms.\n */\nexport function itemMatchesTerm(item, term) {\n const t = term.toLowerCase().trim();\n // Try every plausible stem rather than picking one: \"olives\" → oliv/olive/olives,\n // \"boxes\" → box/boxe/boxes. Guessing a single stem silently drops matches.\n const stems = new Set([t]);\n if (t.endsWith('es')) stems.add(t.slice(0, -2));\n if (t.endsWith('s')) stems.add(t.slice(0, -1));\n const hay = `${item.name} ${item.substituteGroup} ${item.category}`.toLowerCase().replace(/-/g, ' ');\n const esc = (s) => s.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n for (const s of stems) {\n if (s.length < 3) continue;\n if (new RegExp(`\\\\b${esc(s)}(s|es)?\\\\b`, 'i').test(hay)) return true;\n }\n return false;\n}\n\n/**\n * Turn free-text dislikes into concrete candidate items for the user to\n * confirm. Fuzzy matching decides what to SHOW; the user decides what counts.\n */\nexport function resolveDislikes(text, catalog, { store } = {}) {\n return parseTerms(text).map((term) => ({\n term,\n matches: Object.values(catalog)\n .filter((it) => (!store || it.store === store) && itemMatchesTerm(it, term))\n .map((it) => ({ id: it.id, name: it.name, substituteGroup: it.substituteGroup })),\n }));\n}\n\n/**\n * Diet patterns we can actually check against inferred `contains` flags.\n * Anything not in here stays free text for the model and is reported as\n * unverified — the validator never claims to have checked what it can't.\n */\nexport const DIET_RULES = [\n { label: 'vegan', match: /\\bvegan\\b/i, forbids: ['meat', 'fish', 'shellfish', 'dairy', 'egg'] },\n { label: 'vegetarian', match: /\\bvegetarian\\b/i, forbids: ['meat', 'fish', 'shellfish'] },\n { label: 'pescatarian', match: /\\bpescatarian\\b/i, forbids: ['meat'] },\n { label: 'dairy-free', match: /\\b(dairy[- ]free|no dairy|lactose)\\b/i, forbids: ['dairy'] },\n { label: 'gluten-free', match: /\\b(gluten[- ]free|no gluten|coeliac|celiac)\\b/i, forbids: ['gluten'] },\n { label: 'nut-free', match: /\\b(nut[- ]free|no nuts|nut allergy)\\b/i, forbids: ['nuts'] },\n { label: 'sesame-free', match: /\\b(sesame[- ]free|no sesame)\\b/i, forbids: ['sesame'] },\n { label: 'egg-free', match: /\\b(egg[- ]free|no eggs?)\\b/i, forbids: ['egg'] },\n { label: 'soy-free', match: /\\b(soy[- ]free|no soy)\\b/i, forbids: ['soy'] },\n { label: 'shellfish-free', match: /\\b(shellfish[- ]free|no shellfish)\\b/i, forbids: ['shellfish'] },\n { label: 'no-pork', match: /\\b(no pork|pork[- ]free|halal|kosher)\\b/i, forbids: ['pork'] },\n];\n\nexport function parseRestrictions(text) {\n const raw = String(text || '');\n const recognised = DIET_RULES.filter((r) => r.match.test(raw));\n const forbids = [...new Set(recognised.flatMap((r) => r.forbids))];\n // Clauses that matched nothing we can check.\n const unverified = parseTerms(raw).filter(\n (clause) => !recognised.some((r) => r.match.test(clause)),\n );\n return { recognised: recognised.map((r) => r.label), forbids, unverified };\n}\n",[],[91,311],"9fff084a-783a-49fb-b8bf-4d698267be84","catalog-merge.mjs","b067d18c-a460-11f1-8b54-1607ee4eb77e",33,["D",1788087060848],"// Merging a refresh into the catalog.\n//\n// A scraper can see a product page. It cannot see that penne belongs to the\n// substitute group \"short-pasta\", that chicken thigh keeps three days, or that\n// kimchi is gut-friendly. Those are judgements, hand-made once, and the whole\n// planner is built on them.\n//\n// So a refresh is a MERGE, never a replacement. It may change what a shop\n// knows — price, pack size, name, SKU, aisle — and must not touch anything the\n// catalog knows about food.\n\n/** Fields a refresh is allowed to change. Everything else is protected. */\nexport const REFRESHABLE = new Set([\n 'name', 'brand', 'price', 'storeSku', 'category', 'aisle', 'packSize', 'packUnit', 'unitGrams',\n]);\n\n/**\n * Curated by hand, unreachable from a product page, and load-bearing for\n * planning. A refresh that overwrote these would quietly wreck the app.\n */\nexport const PROTECTED = new Set([\n 'roleTags', 'substituteGroup', 'shelfLifeDays', 'freezable', 'staple',\n 'carryForward', 'tags', 'contains', 'containsSource', 'supplement', 'dailyDose', 'pickOrder',\n]);\n\n/**\n * Nutrition precedence. A photographed panel beats everything; a scraped panel\n * beats a guess but not reference data for a whole food, which does not vary\n * by brand.\n */\nexport const PER100_RANK = { label: 4, reference: 3, scraped: 2, estimate: 1 };\n\n/** Loose enough to survive \"Pams Penne 500g\" vs \"Penne\", strict enough to be useful. */\nexport function normaliseName(s) {\n return String(s ?? '')\n .toLowerCase()\n .replace(/\\d+\\s*(g|kg|ml|l|ea|pk|pack)\\b/g, ' ') // sizes live in packSize\n .replace(/[^a-z0-9]+/g, ' ')\n .trim();\n}\n\n/**\n * Match scraped rows to catalog items. SKU first — it is the only identifier\n * that survives a rename. Name matching is a fallback and is reported so a\n * human can see what it guessed.\n */\nexport function matchRows(items, rows) {\n const bySku = new Map();\n const byName = new Map();\n for (const it of items) {\n if (it.storeSku) bySku.set(String(it.storeSku), it);\n const key = normaliseName(it.name);\n if (!byName.has(key)) byName.set(key, []);\n byName.get(key).push(it);\n }\n\n const matched = [];\n const unmatched = [];\n const ambiguous = [];\n const seen = new Set();\n\n for (const row of rows) {\n if (row?.storeSku && bySku.has(String(row.storeSku))) {\n const it = bySku.get(String(row.storeSku));\n matched.push({ item: it, row, how: 'sku' });\n seen.add(it.id);\n continue;\n }\n const candidates = byName.get(normaliseName(row?.name)) ?? [];\n if (candidates.length === 1) {\n matched.push({ item: candidates[0], row, how: 'name' });\n seen.add(candidates[0].id);\n } else if (candidates.length > 1) {\n ambiguous.push({ row, candidates: candidates.map((c) => c.id) });\n } else {\n unmatched.push(row);\n }\n }\n\n return { matched, unmatched, ambiguous, seenIds: seen };\n}\n\n/** A change big enough that it is more likely a scrape bug than a real move. */\nfunction suspicious(field, before, after) {\n if (before == null || after == null) return null;\n if (field === 'price') {\n const ratio = after / before;\n if (ratio > 3) return `price ${before} → ${after} (${ratio.toFixed(1)}× — unit price read as pack price?)`;\n if (ratio < 0.34) return `price ${before} → ${after} (${(1 / ratio).toFixed(1)}× cheaper — pack price read as unit price?)`;\n }\n if (field === 'packSize' && before !== after) {\n // Pack size drives pack counts, surplus and the stock ledger. A real change\n // is possible, but it is worth a look rather than a silent apply.\n return `pack size ${before} → ${after} — changes pack maths, surplus and carried stock`;\n }\n if (field === 'packUnit' && before !== after) {\n return `pack unit ${before} → ${after} — counts and weights are not interchangeable`;\n }\n return null;\n}\n\n/**\n * Merge a refresh into a catalog.\n *\n * @param items current catalog items\n * @param rows scraped rows: { storeSku?, name, price?, packSize?, packUnit?, per100?, ... }\n * @param labels confirmed label captures, so a refresh can never beat a packet\n * @param apply 'safe' applies everything except suspicious changes;\n * 'all' applies those too; 'dry' applies nothing.\n * @param minMatch fraction of the catalog a refresh must account for before it\n * is trusted. A scrape that dies half way through looks\n * identical to a supermarket discontinuing half its range, and\n * the second one is not what happened.\n */\nexport function mergeCatalog(items, rows, { labels = [], apply = 'safe', minMatch = 0.6 } = {}) {\n const labelled = new Set(labels.filter((l) => l.per100).map((l) => l.itemId));\n const { matched, unmatched, ambiguous, seenIds } = matchRows(items, rows);\n\n // A partial refresh is still useful for the prices it did find; it just must\n // not be read as \"everything it missed is gone\".\n const refreshable = items.filter((it) => !it.supplement);\n const coverage = refreshable.length ? matched.length / refreshable.length : 1;\n const thin = coverage < minMatch;\n\n const changes = [];\n const flagged = [];\n const byId = new Map(items.map((it) => [it.id, { ...it }]));\n\n for (const { item, row, how } of matched) {\n const target = byId.get(item.id);\n\n for (const field of REFRESHABLE) {\n if (!(field in row) || row[field] == null) continue;\n const before = target[field];\n const after = row[field];\n if (before === after) continue;\n\n const warn = suspicious(field, before, after);\n const change = { id: item.id, name: item.name, field, before, after, how, warn };\n\n if (warn && apply !== 'all') { flagged.push(change); continue; }\n if (apply === 'dry') { changes.push({ ...change, applied: false }); continue; }\n\n target[field] = after;\n if (field === 'price') target.priceSource = 'store';\n changes.push({ ...change, applied: true });\n }\n\n // Nutrition only improves, never degrades — and never beats a real packet.\n if (row.per100 && !labelled.has(item.id)) {\n const incoming = row.per100Source ?? 'scraped';\n if ((PER100_RANK[incoming] ?? 0) > (PER100_RANK[target.per100Source] ?? 0)) {\n if (apply !== 'dry') {\n target.per100 = { ...target.per100, ...row.per100 };\n target.per100Source = incoming;\n }\n changes.push({ id: item.id, name: item.name, field: 'per100', how,\n before: target.per100Source, after: incoming, applied: apply !== 'dry' });\n }\n }\n\n if (apply !== 'dry') {\n target.updatedAt = Date.now();\n target.discontinued = false;\n }\n }\n\n // Products the refresh did not mention. Marked, never deleted — a current\n // plan or a stock entry may still reference them, and deleting would leave\n // dangling ids everywhere.\n const missing = [];\n for (const [id, it] of byId) {\n if (seenIds.has(id) || it.supplement) continue;\n missing.push({ id, name: it.name });\n if (apply !== 'dry' && !thin) it.discontinued = true;\n }\n\n return {\n items: [...byId.values()],\n report: {\n apply,\n coverage: Math.round(coverage * 100) / 100,\n thin,\n thinNote: thin\n ? `Only ${Math.round(coverage * 100)}% of the catalog was accounted for, so nothing was `\n + 'marked discontinued — a refresh that stopped early looks the same as a range being cut.'\n : null,\n matched: matched.length,\n bySku: matched.filter((m) => m.how === 'sku').length,\n byName: matched.filter((m) => m.how === 'name').length,\n changes,\n flagged,\n // New products are never added automatically: without roleTags and a\n // substitute group they are unusable, and guessing those is the one\n // thing a scraper cannot do.\n unmatched: unmatched.slice(0, 100).map((r) => ({ name: r.name, storeSku: r.storeSku ?? null, price: r.price ?? null })),\n unmatchedCount: unmatched.length,\n ambiguous,\n missing,\n protectedFields: [...PROTECTED],\n },\n };\n}\n\n/** Discontinued items stay resolvable but stop being planned with. */\nexport function isPlannable(item) {\n return !item.discontinued;\n}\n",[],[91,319],"8b73580c-8619-4b4b-830c-c39cdd08dbf5","client","ea3d34b6-a45a-11f1-9160-1607ee4eb77e",["D",1788084580897],[332,333,334,335],[327],{"_33":362,"_13":363,"_37":364,"_44":328,"_35":36,"_47":365,"_57":58,"_45":366,"_17":43,"_41":341,"_39":367,"_60":61,"_49":-5,"_62":368,"_18":369},{"_33":353,"_13":354,"_37":355,"_44":328,"_35":36,"_47":356,"_57":58,"_45":357,"_17":358,"_41":341,"_39":359,"_60":61,"_49":-5,"_62":360,"_18":361},{"_33":345,"_13":346,"_37":347,"_44":328,"_35":36,"_47":348,"_57":58,"_45":349,"_17":128,"_41":341,"_39":350,"_60":61,"_49":-5,"_62":351,"_18":352},{"_33":336,"_13":337,"_37":338,"_44":328,"_35":36,"_47":339,"_57":58,"_45":340,"_17":93,"_41":341,"_39":342,"_60":61,"_49":-5,"_62":343,"_18":344},"4b03083a-acaf-469a-8c60-db888c8a769a","index.ts","eab9f316-a45a-11f1-891f-1607ee4eb77e",31,["D",1788085783422],"script","// GENERATED. Rebuild with: node scripts/build-deploy.mjs\nimport { PART as P1 } from './app1.ts';\nimport { PART as P2 } from './app2.ts';\nimport { CSS } from './css.ts';\n\n// Split only because of the 80,000-character file limit — it is one script.\nexport const APP_JS = P1 + P2;\n\nexport const CLIENT_HTML = `\n\n\n\n\n\nMeal planner\n\n\n\n\n\n\n\n

\n\n\n`;\n\nexport { CSS };\n",[],[327,337],"b127eb0a-19b1-4dad-806f-2b92642e3430","css.ts","eb065c7e-a45a-11f1-9fa2-1607ee4eb77e",32,["D",1788086166594],"// GENERATED. Edit ui/styles.mjs and ui/client-css.mjs instead.\nexport const CSS = \"\\n@import url('https://fonts.googleapis.com/css2?family=Zen+Kaku+Gothic+New:wght@400;500;700&family=IBM+Plex+Mono:wght@400;600&family=DotGothic16&display=swap');\\n\\n.app{\\n --washi:#E4E7E1; --panel:#EFF1EC; --line:#CFD5CE;\\n --sumi:#262C31; --muted:#7B848A; --ai:#3F5E82; --kincha:#9C6B34;\\n background:var(--washi); color:var(--sumi); min-height:100%;\\n font-family:'Zen Kaku Gothic New',system-ui,sans-serif; font-size:16px; line-height:1.5;\\n padding:0 0 84px; margin:0 auto; max-width:560px;\\n}\\n.app *{box-sizing:border-box}\\n.app b,.app .amt,.app .need,.app .day-num,.app .rail-nums,.app .tally b{\\n font-family:'IBM Plex Mono',ui-monospace,monospace; font-variant-numeric:tabular-nums;\\n}\\n.app :focus-visible{outline:2px solid var(--ai); outline-offset:2px}\\n\\n.top{padding:20px 18px 12px}\\n.eyebrow{font-family:'DotGothic16',monospace; font-size:12px; letter-spacing:.12em;\\n text-transform:uppercase; color:var(--muted); margin:0 0 2px}\\n.title{font-size:23px; font-weight:700; margin:0; letter-spacing:-.01em}\\n\\n.banner{margin:12px 18px 0; padding:11px 13px; border-radius:3px; font-size:14px;\\n background:var(--panel); border-left:3px solid var(--kincha)}\\n.banner.ok{border-left-color:var(--line)}\\n.banner p{margin:0 0 4px; font-weight:500}\\n.banner ul{margin:6px 0 0; padding-left:16px; color:var(--muted); font-size:13px}\\n.banner li{margin:2px 0}\\n\\n.card{background:var(--panel); margin:12px 12px 0; padding:15px 16px; border-radius:4px}\\n.card-title{font-size:12px; font-weight:700; letter-spacing:.09em; text-transform:uppercase;\\n color:var(--muted); margin:0 0 12px}\\n.hint{font-size:13px; color:var(--muted); margin:-4px 0 12px}\\n\\n/* days */\\n.days{display:flex; gap:8px; padding:14px 12px 0}\\n.day{flex:1; border:1px solid var(--line); background:transparent; border-radius:3px;\\n padding:9px 0; cursor:pointer; color:var(--muted)}\\n.day-num{font-family:'DotGothic16',monospace; font-size:19px}\\n.day-on{background:var(--sumi); border-color:var(--sumi); color:var(--washi)}\\n\\n/* the variance rail — the one thing that must never lie */\\n.rail{margin:0 0 16px}\\n.rail:last-child{margin-bottom:2px}\\n.rail-head{display:flex; justify-content:space-between; align-items:baseline; margin:0 0 6px}\\n.rail-name{font-size:13px; color:var(--muted)}\\n.rail-nums{font-size:13px; color:var(--muted)}\\n.rail-nums b{font-size:15px; color:var(--sumi); font-weight:600}\\n.slash{opacity:.45; padding:0 2px}\\n.miss-delta{font-style:normal; color:var(--kincha); font-weight:600; margin-left:8px}\\n.ok-delta{font-style:normal; color:var(--muted); margin-left:8px; opacity:.7}\\n.track{position:relative; height:16px; background:var(--washi); border-radius:2px; overflow:hidden}\\n.band{position:absolute; top:0; bottom:0; background:#DBE0DA}\\n.floor-zone{position:absolute; top:0; bottom:0; left:0;\\n background:repeating-linear-gradient(135deg,#DBE0DA 0 5px,var(--washi) 5px 10px)}\\n.miss-span{position:absolute; top:0; bottom:0; background:var(--kincha); opacity:.28}\\n.tick{position:absolute; top:0; bottom:0; width:1px; background:var(--muted); opacity:.65}\\n.marker{position:absolute; top:2px; width:3px; height:12px; margin-left:-1.5px; background:var(--sumi)}\\n.marker-miss{background:var(--kincha); width:4px; margin-left:-2px}\\n.rail-note{font-size:11px; color:var(--muted); margin-top:5px; opacity:.75}\\n\\n/* meals */\\n.meal-head{display:flex; justify-content:space-between; gap:12px; align-items:flex-start}\\n.slot{font-family:'DotGothic16',monospace; font-size:11px; letter-spacing:.1em;\\n text-transform:uppercase; color:var(--muted); display:block}\\n.meal-name{font-size:17px; font-weight:700; margin:2px 0 0}\\n.meal-macros{text-align:right; white-space:nowrap}\\n.meal-macros b{display:block; font-size:16px; font-weight:600}\\n.meal-macros span{font-family:'IBM Plex Mono',monospace; font-size:11px; color:var(--muted)}\\n.cooked-note{font-size:12px; color:var(--kincha); margin:8px 0 0}\\n.components{list-style:none; margin:12px 0 0; padding:0; border-top:1px solid var(--line)}\\n.components li{display:flex; gap:10px; padding:5px 0; font-size:14px; border-bottom:1px solid var(--line)}\\n.components li:last-child{border-bottom:0}\\n.amt{font-size:13px; color:var(--muted); white-space:nowrap}\\n.components .amt{min-width:52px; text-align:right; color:var(--sumi)}\\n.ing{flex:1}\\n.est{color:var(--kincha); font-size:10px; margin-left:3px; cursor:help}\\n.steps{margin:10px 0 0; padding-left:17px; font-size:13px; color:var(--muted)}\\n.steps li{margin:3px 0}\\n\\n/* tally */\\n.tally-row{display:flex; justify-content:space-between; align-items:baseline; margin-bottom:6px; font-size:14px}\\n.tally-row span{color:var(--muted)}\\n.tally b{font-size:18px; font-weight:600}\\n.of{font-size:12px; color:var(--muted); margin-left:6px; font-weight:400}\\n.bar{height:3px; background:var(--washi); margin-top:8px; border-radius:2px; overflow:hidden}\\n.bar-fill{height:100%; background:var(--ai); transition:width .18s ease}\\n\\n.cupboard{border:1px dashed var(--line); background:transparent}\\n.staples{list-style:none; margin:0; padding:0}\\n.staples li{display:flex; justify-content:space-between; gap:12px; padding:6px 0;\\n font-size:14px; border-bottom:1px solid var(--line)}\\n.staples li:last-child{border-bottom:0}\\n\\n/* shopping lines */\\n.lines{list-style:none; margin:0; padding:0}\\n.line{border-bottom:1px solid var(--line); padding:4px 0}\\n.line:last-child{border-bottom:0}\\n.line-main{display:flex; gap:12px; align-items:flex-start; padding:8px 0; cursor:pointer}\\n.line-main input{width:22px; height:22px; margin:1px 0 0; accent-color:var(--ai); flex:none; cursor:pointer}\\n.line-body{flex:1; min-width:0}\\n.line-top{display:flex; justify-content:space-between; gap:10px; font-size:15px}\\n.line-top .amt{color:var(--sumi); font-weight:600}\\n.line-sub{display:flex; flex-wrap:wrap; gap:8px; align-items:center; margin-top:3px}\\n.need{font-size:12px; color:var(--muted)}\\n.chip{font-family:'IBM Plex Mono',monospace; font-size:11px; padding:1px 6px;\\n border-radius:2px; background:var(--washi); color:var(--muted)}\\n.chip-carry{color:var(--ai)}\\n.chip-freeze{background:var(--kincha); color:var(--panel)}\\n.done .line-body{opacity:.4}\\n.done .ing{text-decoration:line-through}\\n\\n.alts{margin:0 0 8px 34px; padding:3px 9px; font-size:12px; cursor:pointer;\\n background:transparent; border:1px solid var(--line); border-radius:2px; color:var(--ai);\\n font-family:'Zen Kaku Gothic New',sans-serif}\\n.cands{list-style:none; margin:0 0 10px 34px; padding:0}\\n.cands li{margin:4px 0}\\n.cand{display:flex; justify-content:space-between; gap:10px; width:100%; text-align:left;\\n padding:8px 10px; background:var(--washi); border:1px solid transparent; border-radius:3px;\\n cursor:pointer; font-size:14px; font-family:inherit; color:var(--sumi)}\\n.cand-on{border-color:var(--ai)}\\n.cand-meta{display:flex; flex-direction:column; align-items:flex-end; gap:1px; white-space:nowrap}\\n.tag{font-style:normal; font-size:11px; color:var(--muted)}\\n.tag-miss{color:var(--kincha); font-family:'IBM Plex Mono',monospace}\\n\\n.prep-meal{padding:10px 0; border-bottom:1px solid var(--line)}\\n.prep-meal:last-child{border-bottom:0}\\n.prep-meal .ing{font-weight:500; font-size:15px}\\n\\n/* meal status */\\n.status{display:flex; gap:6px; margin-top:12px; padding-top:11px; border-top:1px solid var(--line)}\\n.st{flex:1; padding:8px 4px; font-size:12px; cursor:pointer; border-radius:2px;\\n background:transparent; border:1px solid var(--line); color:var(--muted);\\n font-family:'Zen Kaku Gothic New',sans-serif}\\n.st-on{background:var(--sumi); border-color:var(--sumi); color:var(--washi)}\\n.from{display:block; font-size:11px; color:var(--muted); margin-top:1px}\\n.days{display:block; font-size:11px; color:var(--muted); font-weight:400}\\n.days-tight{color:var(--kincha)}\\n.staples .amt{text-align:right}\\n\\n/* tabs */\\n.tabs{position:fixed; bottom:0; left:0; right:0; display:flex; background:var(--panel);\\n border-top:1px solid var(--line); max-width:560px; margin:0 auto}\\n.tab{flex:1; padding:14px 0 16px; min-width:0; background:transparent; border:0; cursor:pointer;\\n font-family:'DotGothic16',monospace; font-size:13px; letter-spacing:.08em;\\n text-transform:uppercase; color:var(--muted)}\\n.tab-on{color:var(--sumi); box-shadow:inset 0 2px 0 var(--ai)}\\n.legend{font-size:11px; color:var(--muted); padding:16px 18px 0; opacity:.8}\\n\\n@media (prefers-reduced-motion:reduce){.app *{transition:none!important}}\\n \\n\\n.primary{width:100%; margin-top:12px; padding:13px; border:0; border-radius:3px; cursor:pointer;\\n background:var(--ai); color:var(--panel); font-size:15px; font-weight:500;\\n font-family:'Zen Kaku Gothic New',sans-serif}\\n.primary:disabled{opacity:.5; cursor:default}\\n.field{display:block; margin-bottom:12px}\\n.field > span{display:block; font-size:12px; color:var(--muted); margin-bottom:5px}\\n.field input,.field textarea{width:100%; padding:9px 10px; border:1px solid var(--line);\\n border-radius:3px; background:var(--washi); color:var(--sumi); font-size:15px;\\n font-family:'IBM Plex Mono',monospace; resize:vertical}\\n.field textarea{font-family:'Zen Kaku Gothic New',sans-serif; font-size:14px}\\n.grid{display:grid; grid-template-columns:1fr 1fr; gap:0 12px}\\n.seg{display:flex; flex-wrap:wrap; gap:6px}\\n.segb{flex:1; min-width:74px; padding:9px 6px; font-size:12px; cursor:pointer; border-radius:2px;\\n background:transparent; border:1px solid var(--line); color:var(--muted);\\n font-family:'Zen Kaku Gothic New',sans-serif}\\n.segb-on{background:var(--sumi); border-color:var(--sumi); color:var(--washi)}\\n.tab{font-size:11px}\\n\\n.pick{display:flex; justify-content:space-between; width:100%; gap:10px; padding:11px 2px;\\n background:transparent; border:0; border-bottom:1px solid var(--line); cursor:pointer;\\n font-family:'Zen Kaku Gothic New',sans-serif; font-size:15px; color:var(--sumi); text-align:left}\\n.msg{padding:12px 14px}\\n.msg-me{background:transparent; border:1px dashed var(--line)}\\n.msg-text{margin:0; font-size:15px}\\n.blocked{margin:8px 0 0; padding-left:16px; font-size:13px; color:var(--kincha)}\\n.applied{display:flex; flex-wrap:wrap; gap:8px; align-items:center; margin-top:9px}\\n.impact{font-family:'IBM Plex Mono',monospace; font-size:11px; color:var(--muted)}\\n.chips{display:flex; flex-wrap:wrap; gap:7px}\\n.chipb{flex:1; min-width:110px; padding:12px 8px; font-size:14px; cursor:pointer; border-radius:3px;\\n background:var(--washi); border:1px solid var(--line); color:var(--sumi);\\n font-family:'Zen Kaku Gothic New',sans-serif}\\n.chipb:disabled{opacity:.5}\\n\\na.segb{text-align:center; text-decoration:none; line-height:1.6}\\n\\n.mealtools{display:flex; gap:8px; margin-top:9px}\\n.alts-on{background:var(--sumi); color:var(--washi); border-color:var(--sumi)}\\n.shoot{font-size:12px; color:var(--ai); cursor:pointer; white-space:nowrap; padding:4px 9px;\\n border:1px solid var(--line); border-radius:2px}\\n.shoot input{display:none}\\n\\n.chipb-on{background:var(--sumi); color:var(--washi); border-color:var(--sumi)}\\n.dosebox{display:flex; gap:6px; align-items:center}\\n.dosebox input{width:64px; padding:5px 7px; border:1px solid var(--line); border-radius:2px;\\n background:var(--washi); color:var(--sumi); font-family:'IBM Plex Mono',monospace; font-size:13px}\\n.dosebox select{padding:5px 6px; border:1px solid var(--line); border-radius:2px;\\n background:var(--washi); color:var(--sumi); font-size:12px;\\n font-family:'Zen Kaku Gothic New',sans-serif}\\n.caution{color:var(--kincha); border-left:2px solid var(--kincha); padding-left:9px; margin-top:10px}\\n\\n.qty{width:58px; padding:4px 6px; border:1px solid var(--line); border-radius:2px;\\n background:var(--washi); color:var(--sumi); font-family:'IBM Plex Mono',monospace; font-size:13px}\\n.components li .alts{margin:0}\\n\\n/* The card is a screenshot target: high contrast, unambiguous, timestamped. */\\n.proofcard{margin:12px 12px 0; padding:26px 18px; border-radius:4px; text-align:center;\\n background:var(--panel); border:2px solid var(--line)}\\n.proofcard-pass{background:var(--sumi); border-color:var(--sumi)}\\n.proofcard-fail{border-color:var(--kincha)}\\n.proofcard-stale{border-color:var(--kincha); border-style:dashed}\\n.proof-verdict{font-family:'DotGothic16',monospace; font-size:26px; letter-spacing:.06em;\\n margin:0; color:var(--sumi)}\\n.proofcard-pass .proof-verdict{color:var(--washi)}\\n.proofcard-fail .proof-verdict{color:var(--kincha)}\\n.proof-meal{font-size:17px; font-weight:700; margin:12px 0 0}\\n.proofcard-pass .proof-meal{color:var(--washi)}\\n.proof-when{font-size:12px; color:var(--muted); margin:3px 0 0; text-transform:uppercase; letter-spacing:.08em}\\n.proof-stamp{font-family:'IBM Plex Mono',monospace; font-size:15px; margin:14px 0 0; color:var(--muted)}\\n.proofcard-pass .proof-stamp{color:var(--washi); opacity:.85}\\n.proof-note{font-size:12px; color:var(--kincha); margin:10px 0 0}\\n\\n.verified-row{display:flex; justify-content:space-between; align-items:center}\\n.verified-tag{font-size:13px; color:var(--ai); font-weight:500}\\n\\n.tab{font-size:12px}\\n.back{background:transparent; border:0; padding:0 0 4px; cursor:pointer; color:var(--ai);\\n font-family:'Zen Kaku Gothic New',sans-serif; font-size:13px}\\n.wide{width:100%; margin-top:12px; padding:10px}\\n/* The day picker is

. A later .days rule (the days-left\\n label on shopping lines) overrode display:flex, so the buttons bunched up\\n instead of spanning the card. Scope by element to win on specificity. */\\nnav.days{display:flex; gap:8px}\\nnav.days .day{flex:1; min-height:54px; padding:0; border-radius:4px}\\nnav.days .day-num{font-size:26px; line-height:54px}\\n\";\n",[],[327,346],"ec07d0e2-11c3-4460-9d76-dfa9975e2202","app2.ts","eaa6b42c-a45a-11f1-95c7-1607ee4eb77e",94,["D",1788929446615],11,"// GENERATED part 2 of 2. Edit ui/client-app.js instead.\nexport const PART = \"cooking. Some batching, no repeated meal names beyond the variety setting.'\\n : 'Happy to cook: more involved meals and more variety across the week.'}\\n

\\n Variety\\n

${['relaxed', 'normal', 'strict'].map((v) => h`\\n `)}

\\n \\n Macro strictness\\n

${['loose', 'normal', 'strict'].map((v) => h`\\n `)}

\\n \\n

\\n ${(s.macroStrictness || 'normal') === 'strict'\\n ? 'Energy within ±3%, carbs and fat within ±10%, and the full protein target as a hard floor. Expect days to be flagged.'\\n : (s.macroStrictness || 'normal') === 'loose'\\n ? 'Energy within ±10%, carbs and fat within ±20%, and the protein floor drops 5% (to '\\n + Math.round(s.targets.protein * 0.95) + 'g). Use this when the targets fight each other — a high protein floor on a '\\n + 'restricted diet is bought with calories, and something has to give.'\\n : 'Energy within ±5%, carbs and fat within ±15%, and the full protein target as a hard floor.'}\\n

\\n Meals per day\\n

${['breakfast', 'lunch', 'dinner', 'snack'].map((v) => h`\\n `)}

\\n \\n \\n\\n

\\n \\n

\\n\\n

\\n

Catalog

\\n

\\n ${catalog && catalog.ageDays != null\\n ? `Prices are ${catalog.ageDays} day${catalog.ageDays === 1 ? '' : 's'} old.`\\n : 'No catalog loaded.'}\\n ${catalog && catalog.stale ? ' They may have moved.' : ''}\\n

\\n

\\n \\n \\n ${catalog && h`Catalog CSV`}\\n

\\n ${refresh && h`

\\n

\\n ${refresh.error\\n ? refresh.error\\n : `${refresh.matched} matched \\\\u00b7 ${(refresh.changes || []).filter((c) => c.applied).length} changed`\\n + `${refresh.flagged && refresh.flagged.length ? ' \\\\u00b7 ' + refresh.flagged.length + ' held back' : ''}`\\n + `${refresh.unmatchedCount ? ' \\\\u00b7 ' + refresh.unmatchedCount + ' new' : ''}`}\\n

\\n ${(refresh.flagged || []).length > 0 && h`

${f.name}: ${f.warn}

`}\\n

\\n A refresh only changes prices, pack sizes and names. Roles, substitute groups, shelf\\n life and the gut-friendly tags are curated by hand and are never touched.\\n

\\n

\\n\\n

\\n

Send to the tracker

\\n

Per-meal kcal, protein, carbs and fat, dated, with supplements counted in.\\n Estimated numbers are flagged rather than passed off as read off a packet.

\\n

\\n Eaten · CSV\\n Eaten · JSON\\n

\\n

Eaten-only is the honest record.\\n The whole plan is there if you log ahead.

\\n

\\n Whole plan · CSV\\n Whole plan · JSON\\n

\\n

\\n `;\\n}\\n\\n/**\\n * Photograph a receipt, check what it found, then put it in the fridge.\\n *\\n * Read and commit are deliberately two steps. Receipt OCR plus name matching is\\n * the least reliable input this app takes, and a wrong line here quietly\\n * changes what the next plan thinks you own — so it is shown before it counts.\\n * Nothing here touches recipes, prices or nutrition.\\n */\\nfunction ReceiptScreen() {\\n const [busy, setBusy] = useState(false);\\n const [read, setRead] = useState(null);\\n const [drop, setDrop] = useState({});\\n const [done, setDone] = useState(null);\\n const [error, setError] = useState(null);\\n\\n const shoot = async (file) => {\\n setBusy(true); setError(null); setDone(null); setRead(null); setDrop({});\\n try {\\n const b64 = await new Promise((resolve, reject) => {\\n const r = new FileReader();\\n r.onload = () => resolve(String(r.result).split(',')[1]);\\n r.onerror = () => reject(new Error('Could not read that image'));\\n r.readAsDataURL(file);\\n });\\n setRead(await api('/api/receipt/read', {\\n method: 'POST',\\n body: { imageBase64: b64, mediaType: file.type || 'image/jpeg' },\\n }));\\n } catch (err) { setError(err.message); }\\n finally { setBusy(false); }\\n };\\n\\n const commit = async () => {\\n setBusy(true); setError(null);\\n try {\\n const entries = read.entries\\n .filter((e) => !drop[e.itemId])\\n .map((e) => ({ itemId: e.itemId, grams: e.grams, note: e.note }));\\n if (!entries.length) throw new Error('Nothing left to add.');\\n const r = await api('/api/receipt/confirm', { method: 'POST', body: { entries } });\\n setDone(r.added); setRead(null);\\n } catch (err) { setError(err.message); }\\n finally { setBusy(false); }\\n };\\n\\n const keeping = read ? read.entries.filter((e) => !drop[e.itemId]).length : 0;\\n\\n return h`<>\\n

\\n

Receipt

\\n

What you actually carried home. It only stocks the fridge —\\n your recipes, prices and nutrition figures are left alone.

\\n ${busy && !read ? 'Reading…' : 'Photograph a receipt'}\\n { if (e.target.files[0]) shoot(e.target.files[0]); }} />\\n \\n

\\n\\n ${done !== null && h`

In the fridge

\\n

${done} item${done === 1 ? '' : 's'} added.\\n The next plan will be built to use them up first.

`}\\n\\n ${error && h`

Didn’t work

\\n

${error}

`}\\n\\n ${read && h`<>\\n

\\n

Found ${read.counts.matched} of ${read.counts.lines} lines

\\n

Untick anything it got wrong. Quantities come from the catalog’s\\n pack size, so check the weights look right.

\\n

\\n \\n setDrop((d) => ({ ...d, [e.itemId]: !d[e.itemId] }))} />\\n \\n ${e.name}\\n ${e.grams}g\\n \\n ${e.receiptName}\\n ${e.how}\\n \\n \\n \\n

\\n \\n

\\n\\n ${read.unmatched.length > 0 && h`

\\n

Not in the catalog

\\n

Left out rather than guessed at. Add them in the aisle screen if you need them counted.

\\n

\\n ${u.name}${u.qty > 1 ? u.qty + '×' : ''}

\\n

`}\\n\\n ${read.ambiguous.length > 0 && h`

\\n

Too close to call

\\n

More than one catalog item fits these, so none was chosen.

\\n

\\n ${a.name}\\n ${a.candidates.map((c) => c.name).join(' / ')}

\\n

`}\\n\\n ${read.unusable.length > 0 && h`

\\n

No weight recorded

\\n

Matched, but the catalog has no weight per pack, so they cannot be stocked.

\\n

\\n ${u.name}${u.reason}

\\n

`}\\n `}\\n `;\\n}\\n\\nfunction Empty({ title, body }) {\\n return h`

${title}

\\n

${body}

`;\\n}\\n\\n/* ── shell ────────────────────────────────────────────────────────────── */\\n\\n// Five tabs, chosen by how often you'd actually press them in a cycle.\\n// Everything else is configuration or review and lives behind \\\"more\\\" — a\\n// thirteen-tab bar is 29px per tab on a phone, which is no bar at all.\\nconst TABS = [['plan', 'plan'], ['shop', 'shop'], ['proof', 'proof'], ['prep', 'prep'], ['more', 'more']];\\n\\nconst MORE = [\\n ['new', 'New plan', 'Build the next few days'],\\n ['fridge', 'Fridge', 'Say what is left before you shop again'],\\n ['receipt', 'Receipt', 'Photograph a receipt so the fridge knows what you actually bought'],\\n ['store', 'In the aisle', 'Stuck on an item while shopping'],\\n ['recipes', 'My recipes', 'Meals you want in the plan'],\\n ['wanted', 'Foods I want', 'Ingredients to work in, gut-friendly and otherwise'],\\n ['supps', 'Supplements', 'Daily doses, counted in your macros'],\\n ['labels', 'Nutrition panels', 'Replace estimated numbers with the real ones'],\\n ['history', 'Past plans', 'Previous shops and how closely you followed them'],\\n ['setup', 'Settings', 'Targets, store, restrictions, effort and variety'],\\n];\\n\\nfunction MoreScreen({ go }) {\\n return h`

\\n

Everything else

\\n

\\n \\n

\\n

`;\\n}\\n\\nfunction LockScreen({ onUnlock, error, busy }) {\\n const [pin, setPin] = useState('');\\n return h`

\\n

Locked

\\n

Meal planner

\\n

\\n PIN\\n setPin(e.target.value)}\\n onKeyDown=${(e) => e.key === 'Enter' && pin && onUnlock(pin)} />\\n \\n ${error && h`

${error}

`}\\n

Asked once per device.

\\n

`;\\n}\\n\\nfunction App() {\\n const [state, setState] = useState(null);\\n const [locked, setLocked] = useState(null);\\n const [pinError, setPinError] = useState(null);\\n const [tab, setTab] = useState('plan');\\n const [phases, setPhases] = useState([]);\\n const [busy, setBusy] = useState(false);\\n const [saving, setSaving] = useState(false);\\n const [error, setError] = useState(null);\\n const [useFirstList, setUseFirstList] = useState([]);\\n const [history, setHistory] = useState(null);\\n const [labels, setLabels] = useState(null);\\n const [busyMeal, setBusyMeal] = useState(null);\\n const [recipes, setRecipes] = useState(null);\\n const [proof, setProof] = useState(null);\\n const [refresh, setRefresh] = useState(null);\\n\\n const unlock = async (pin) => {\\n setSaving(true); setPinError(null);\\n try { await api('/api/auth', { method: 'POST', body: { pin } }); setLocked(false); }\\n catch { setPinError('That PIN was not right.'); }\\n finally { setSaving(false); }\\n };\\n\\n const load = useCallback(async () => {\\n try {\\n const gate = await api('/api/auth').catch(() => ({ required: false, authed: true }));\\n if (gate.required && !gate.authed) { setLocked(true); return; }\\n setLocked(false);\\n const s = await api('/api/state');\\n setState(s);\\n if (!s.plan) setTab('new');\\n const uf = await api('/api/use-first').catch(() => ({ useFirst: [] }));\\n setUseFirstList(uf.useFirst || []);\\n api('/api/history').then((r) => setHistory(r.plans)).catch(() => setHistory([]));\\n api('/api/labels').then(setLabels).catch(() => setLabels({ captured: [], queue: [] }));\\n api('/api/recipes').then((r) => setRecipes(r.recipes)).catch(() => setRecipes([]));\\n api('/api/proof').then(setProof).catch(() => setProof({ meals: [], proofs: [], card: { state: 'none', verdict: 'No meal verified yet' } }));\\n } catch (err) { setError(err.message); }\\n }, []);\\n\\n useEffect(() => { load(); }, [load]);\\n useEffect(() => { if (locked === false && !state) load(); }, [locked]);\\n\\n const onStatus = (mealId, status) => {\\n // Optimistic: the tap should feel instant in an aisle with bad signal.\\n setState((s) => ({ ...s, plan: { ...s.plan,\\n meals: s.plan.meals.map((m) => (m.id === mealId ? { ...m, status: status || undefined } : m)) } }));\\n serialise(async () => {\\n try {\\n const r = await api('/api/meal-status', { method: 'POST',\\n body: { planId: state.plan.id, mealId, status } });\\n setState((s) => ({ ...s, adherence: r.adherence }));\\n } catch (err) { setError(err.message); load(); }\\n });\\n };\\n\\n const onLock = (mealId, locked) => {\\n setState((s) => ({ ...s, plan: { ...s.plan,\\n meals: s.plan.meals.map((m) => (m.id === mealId ? { ...m, locked } : m)) } }));\\n serialise(() => api('/api/meal-lock', { method: 'POST', body: { mealId, locked } })\\n .catch((err) => { setError(err.message); load(); }));\\n };\\n\\n const onRegenerate = async (mealId) => {\\n setBusyMeal(mealId); setError(null);\\n try { await api('/api/meal-regenerate', { method: 'POST', body: { mealId } }); await load(); }\\n catch (err) { setError(err.message); }\\n finally { setBusyMeal(null); }\\n };\\n\\n const onReadLabel = async (itemId, imageBase64, mediaType) => {\\n try { return await api('/api/label/read', { method: 'POST', body: { itemId, imageBase64, mediaType } }); }\\n catch (err) { return { ok: false, problems: [err.message], per100: {} }; }\\n };\\n\\n const onConfirmLabel = async (itemId, per100) => {\\n setSaving(true);\\n try {\\n const r = await api('/api/label/confirm', { method: 'POST', body: { itemId, per100 } });\\n setLabels(await api('/api/labels'));\\n await load();\\n return r;\\n } catch (err) { return { ok: false, error: err.message }; }\\n finally { setSaving(false); }\\n };\\n\\n const onForgetLabel = async (itemId) => {\\n try { await api('/api/label/' + itemId, { method: 'DELETE' }); setLabels(await api('/api/labels')); await load(); }\\n catch (err) { setError(err.message); }\\n };\\n\\n const verifiedIds = new Set(((proof && proof.proofs) || [])\\n .filter((p) => p.verdict === 'pass').map((p) => p.mealId));\\n\\n const onRemoveStock = async (id) => {\\n setSaving(true); setError(null);\\n try { await api('/api/stock/' + encodeURIComponent(id), { method: 'DELETE' }); await load(); }\\n catch (err) { setError(err.message); }\\n finally { setSaving(false); }\\n };\\n\\n // \\\"About half the soy sauce\\\" is the most precise answer anyone actually has.\\n const onReviewStock = async (review) => {\\n const reviews = Object.entries(review)\\n .filter(([, level]) => level)\\n .map(([id, level]) => ({ id, level }));\\n if (!reviews.length) return;\\n setSaving(true); setError(null);\\n try { await api('/api/stock/review', { method: 'POST', body: { reviews } }); await load(); }\\n catch (err) { setError(err.message); }\\n finally { setSaving(false); }\\n };\\n\\n const onReusePlan = async (planId) => {\\n setSaving(true); setError(null);\\n try {\\n await api('/api/plan/reuse', { method: 'POST', body: { planId } });\\n await load();\\n setTab('plan');\\n } catch (err) { setError(err.message); }\\n finally { setSaving(false); }\\n };\\n\\n const onClearPlan = async () => {\\n setSaving(true); setError(null);\\n try {\\n await api('/api/plan', { method: 'DELETE' });\\n await load();\\n setTab('plan');\\n } catch (err) { setError(err.message); }\\n finally { setSaving(false); }\\n };\\n\\n const onClearProof = async (mealId) => {\\n try {\\n await api('/api/proof/' + mealId, { method: 'DELETE' });\\n setProof(await api('/api/proof'));\\n await load();\\n } catch (err) { setError(err.message); }\\n };\\n\\n // Rows come from whatever scrapes the supermarket — see SCRAPER.md. With\\n // none supplied this reports what a refresh would do, which is also the\\n // honest answer when no scraper is wired up yet.\\n const onRefreshCatalog = async (apply) => {\\n setSaving(true); setRefresh(null);\\n try {\\n const rows = await api('/api/catalog-rows').then((r) => r.rows).catch(() => []);\\n if (!rows.length) {\\n setRefresh({ error: 'No price source is connected yet. See SCRAPER.md for how to add one.' });\\n return;\\n }\\n setRefresh(await api('/api/catalog-refresh/' + settings.store, { method: 'POST', body: { rows, apply } }));\\n await load();\\n } catch (err) { setRefresh({ error: err.message }); }\\n finally { setSaving(false); }\\n };\\n\\n const onVerifyMeal = async (mealId, imageBase64, mediaType) => {\\n setSaving(true);\\n try {\\n const r = await api('/api/proof/verify', { method: 'POST', body: { mealId, imageBase64, mediaType } });\\n setProof(await api('/api/proof'));\\n await load();\\n return r;\\n } catch (err) { return { error: err.message }; }\\n finally { setSaving(false); }\\n };\\n\\n const onParseRecipe = async (text) => {\\n setSaving(true);\\n try { return await api('/api/recipes/parse', { method: 'POST', body: { text } }); }\\n catch (err) { return { error: err.message }; }\\n finally { setSaving(false); }\\n };\\n\\n const onSaveRecipe = async (recipe) => {\\n setSaving(true);\\n try {\\n const r = await api('/api/recipes', { method: 'PUT', body: { recipe } });\\n setRecipes((await api('/api/recipes')).recipes);\\n return r;\\n } catch (err) { return { ok: false, error: err.message }; }\\n finally { setSaving(false); }\\n };\\n\\n // PATCH, not PUT: PUT re-validates a whole recipe against the catalog, and\\n // changing how often you cook something must never be able to drop one of\\n // its ingredients.\\n const onPatchRecipe = async (id, patch) => {\\n setSaving(true); setError(null);\\n try {\\n await api('/api/recipes/' + encodeURIComponent(id), { method: 'PATCH', body: patch });\\n setRecipes((await api('/api/recipes')).recipes);\\n } catch (err) { setError(err.message); }\\n finally { setSaving(false); }\\n };\\n\\n const onUseRecipe = (id, use) => onPatchRecipe(id, { use });\\n\\n const onDeleteRecipe = async (id) => {\\n try { await api('/api/recipes/' + id, { method: 'DELETE' }); setRecipes((await api('/api/recipes')).recipes); }\\n catch (err) { setError(err.message); }\\n };\\n\\n const onGenerate = async (days, bought = null) => {\\n setBusy(true); setPhases([]); setError(null);\\n // Val Town shuts a worker down 10s after the last request it RECEIVES.\\n // Bytes we stream out do not reset that timer, so generation was being\\n // killed at ~11s and the plan lost before it could be saved. A cheap\\n // request every 4s keeps the worker up until we are done.\\n const keepalive = setInterval(() => { fetch('/api/auth').catch(() => {}); }, 4000);\\n try {\\n const res = await fetch('/api/plan', {\\n method: 'POST', headers: { 'content-type': 'application/json' },\\n body: JSON.stringify({ days, bought }),\\n });\\n if (!res.ok) throw new Error((await res.json().catch(() => ({}))).error || 'Request failed');\\n\\n const reader = res.body.getReader();\\n const decoder = new TextDecoder();\\n let buf = '';\\n let finished = false;\\n for (;;) {\\n const { value, done } = await reader.read();\\n if (done) break;\\n buf += decoder.decode(value, { stream: true });\\n const lines = buf.split('\\\\n');\\n buf = lines.pop();\\n for (const line of lines) {\\n if (!line.trim()) continue;\\n const ev = JSON.parse(line);\\n if (ev.type === 'phase') setPhases((p) => [...p, { phase: ev.phase, round: ev.round }]);\\n if (ev.type === 'error') throw new Error(ev.error);\\n if (ev.type === 'done') { finished = true; await load(); setTab('plan'); }\\n }\\n }\\n if (!finished) throw new Error('The connection dropped before the plan was finished, so nothing was saved. Try again.');\\n } catch (err) { setError(err.message); }\\n finally { clearInterval(keepalive); setBusy(false); }\\n };\\n\\n const onSave = async (settings) => {\\n setSaving(true);\\n try {\\n await api('/api/settings', { method: 'PUT', body: { settings, rev: state.settingsRev } });\\n await load();\\n } catch (err) { setError(err.message); }\\n finally { setSaving(false); }\\n };\\n\\n const onShopComplete = async () => {\\n setBusy(true);\\n try { await api('/api/shop-complete', { method: 'POST', body: {} }); await load(); setTab('fridge'); }\\n catch (err) { setError(err.message); }\\n finally { setBusy(false); }\\n };\\n\\n if (locked) return h`<${LockScreen} onUnlock=${unlock} error=${pinError} busy=${saving} />`;\\n\\n if (!state) {\\n return h`

\\n

Meal planner

\\n ${error && h``}

`;\\n }\\n\\n const { plan, items, settings, stock } = state;\\n\\n return h`

\\n

${settings.store === 'pns' ? \\\"Pak'nSave\\\" : 'Woolworths'}${plan ? ' · ' + plan.days + ' days' : ''}

\\n ${!['plan', 'shop', 'proof', 'prep', 'more'].includes(tab) && h`\\n `}\\n

${tab === 'setup' ? 'Settings' : tab === 'new' ? 'New plan'\\n : tab === 'store' ? 'In the aisle' : 'This week’s plan'}

\\n

\\n\\n ${state.catalog.stale && h``}\\n ${error && h``}\\n ${tab === 'plan' && plan && h`<${Banner} validation=${plan.validation} />`}\\n\\n ${tab === 'plan' && h`<${PlanScreen} plan=${plan} items=${items} onStatus=${onStatus}\\n onLock=${onLock} onRegenerate=${onRegenerate} onClearProof=${onClearProof}\\n busyMeal=${busyMeal} verified=${verifiedIds} />`}\\n ${tab === 'shop' && h`<${ShopScreen} plan=${plan} items=${items} onShopComplete=${onShopComplete}\\n onAisle=${() => setTab('store')} busy=${busy} />`}\\n ${tab === 'more' && h`<${MoreScreen} go=${setTab} />`}\\n ${tab === 'store' && h`<${StoreScreen} plan=${plan} items=${items} onReload=${load} />`}\\n ${tab === 'fridge' && h`<${FridgeScreen} stock=${stock} items=${items} adherence=${state.adherence}\\n useFirstList=${useFirstList} onReviewStock=${onReviewStock} busy=${saving} />`}\\n ${tab === 'prep' && h`<${PrepScreen} plan=${plan} />`}\\n ${tab === 'history' && h`<${HistoryScreen} history=${history} />`}\\n ${tab === 'proof' && h`<${ProofScreen} proof=${proof} onVerify=${onVerifyMeal} busy=${saving} />`}\\n ${tab === 'recipes' && h`<${RecipesScreen} recipes=${recipes} items=${items} slots=${settings.slotsPerDay}\\n onParse=${onParseRecipe} onSave=${onSaveRecipe} onDelete=${onDeleteRecipe}\\n onPatch=${onPatchRecipe} onUse=${onUseRecipe} busy=${saving} />`}\\n ${tab === 'supps' && h`<${SupplementsScreen} settings=${settings} plan=${plan} onSave=${onSave} saving=${saving} />`}\\n ${tab === 'wanted' && h`<${WantedScreen} settings=${settings} onSave=${onSave} saving=${saving} />`}\\n ${tab === 'labels' && h`<${LabelsScreen} labels=${labels} items=${items}\\n onRead=${onReadLabel} onConfirm=${onConfirmLabel} onForget=${onForgetLabel} busy=${saving} />`}\\n ${tab === 'new' && h`<${NewPlanScreen} onGenerate=${onGenerate} phases=${phases} busy=${busy}\\n error=${error} plan=${plan} onClearPlan=${onClearPlan}\\n recipes=${recipes} onUse=${onUseRecipe} history=${history} onReusePlan=${onReusePlan}\\n slots=${settings.slotsPerDay} />`}\\n ${tab === 'receipt' && h`<${ReceiptScreen} />`}\\n ${tab === 'setup' && h`<${SetupScreen} settings=${settings} onSave=${onSave} saving=${saving}\\n catalog=${state.catalog} onRefreshCatalog=${onRefreshCatalog} refresh=${refresh} />`}\\n\\n

≈ marks nutrition estimated from product type rather than read off a packet.

\\n\\n \\n

`;\\n}\\n\\nReactDOM.createRoot(document.getElementById('root')).render(h`<${App} />`);\";\n",[],[327,354],"f0755d39-b278-4dac-b366-218bb7115eab","app1.ts","eaca98ba-a45a-11f1-8830-1607ee4eb77e",93,["D",1788929446552],"// GENERATED part 1 of 2. Edit ui/client-app.js instead.\nexport const PART = \"// The browser app. Plain JS + htm — no build step in the browser, no JSX\\n// transpiler to download before first paint on a phone in a supermarket.\\n// Assembled into valtown/client.ts by scripts/build-client.mjs.\\n\\nconst { useState, useEffect, useMemo, useCallback } = React;\\nconst h = htm.bind(React.createElement);\\n\\n// Variance rail geometry.\\n//\\n// Shared deliberately: the display must not carry its own copy of the\\n// thresholds. If the validator says day 2 missed, the rail shows a miss,\\n// because both read the same numbers. This module is inlined into the\\n// single-file UI at build time.\\n\\n// Defaults only. The live thresholds depend on the macro strictness setting and\\n// travel on the plan as plan.validation.bands — a rail drawn from a stale local\\n// copy would say \\\"on target\\\" about a day the validator has already failed.\\nconst BANDS = { kcal: 0.05, carbs: 0.15, fat: 0.15 };\\nconst bandsOf = (plan) => (plan && plan.validation && plan.validation.bands) || BANDS;\\n\\n/** Judge the number on screen, not the float behind it. See validate.mjs. */\\nconst shown = (v) => Math.round(v);\\n\\n/** Banded metric: a tolerance either side of target. */\\nfunction bandRail(raw, target, tol) {\\n const actual = shown(raw);\\n const span = target * 0.45; // rail covers target ±45%\\n const pos = (v) => Math.max(0, Math.min(100, ((v - (target - span)) / (2 * span)) * 100));\\n const lo = pos(target * (1 - tol));\\n const hi = pos(target * (1 + tol));\\n const at = pos(actual);\\n const over = actual > target * (1 + tol);\\n const under = actual < target * (1 - tol);\\n return {\\n lo, hi, at, mid: pos(target),\\n miss: over || under, over, under,\\n missFrom: over ? hi : at,\\n missTo: over ? at : lo,\\n };\\n}\\n\\n/** Protein: a floor, not a band. Drawn differently because it IS different. */\\nfunction floorRail(raw, floor) {\\n const actual = shown(raw);\\n const span = floor * 0.5;\\n const pos = (v) => Math.max(0, Math.min(100, ((v - (floor - span)) / (2 * span)) * 100));\\n return {\\n at: pos(actual), mid: pos(floor),\\n miss: actual < floor,\\n missFrom: pos(actual), missTo: pos(floor),\\n };\\n}\\n\\n/** What the rail will show for one day. Used by the UI and by its test. */\\nfunction railVerdicts(dayTotals, targets) {\\n const out = {};\\n for (const m of ['kcal', 'carbs', 'fat']) {\\n out[m] = bandRail(dayTotals[m], targets[m], BANDS[m]).miss;\\n }\\n out.protein = floorRail(dayTotals.protein, targets.protein).miss;\\n return out;\\n}\\n\\n/* ── api ──────────────────────────────────────────────────────────────── */\\n\\n// The client-side write chain from the spec. The server's compare-and-swap is\\n// what actually protects the data; this just stops us racing ourselves.\\nlet chain = Promise.resolve();\\nconst serialise = (fn) => (chain = chain.then(fn, fn));\\n\\n// Val Town shuts a worker down ~10s after the last request it RECEIVES, and\\n// that clock is not reset by a request still being served. Anything that calls\\n// the model — reading a receipt, a nutrition panel, parsing a recipe, verifying\\n// a photo — can outlive it, especially with a 3MB photo from a phone camera.\\n// A cheap request every 4s while anything is in flight keeps the worker up.\\n// Plan generation streams and holds its own keepalive; this covers the rest.\\nlet inFlight = 0;\\nlet keepWarm = null;\\nfunction holdWorker() {\\n if (++inFlight === 1) {\\n keepWarm = setInterval(() => { fetch('/api/auth').catch(() => {}); }, 4000);\\n }\\n}\\nfunction releaseWorker() {\\n if (--inFlight <= 0) {\\n inFlight = 0;\\n clearInterval(keepWarm);\\n keepWarm = null;\\n }\\n}\\n\\nasync function api(path, opts = {}) {\\n holdWorker();\\n try {\\n const res = await fetch(path, {\\n ...opts,\\n headers: opts.body ? { 'content-type': 'application/json' } : undefined,\\n body: opts.body ? JSON.stringify(opts.body) : undefined,\\n });\\n const data = await res.json().catch(() => ({}));\\n if (!res.ok) throw new Error(data.error || ('Request failed: ' + res.status));\\n return data;\\n } finally {\\n releaseWorker();\\n }\\n}\\n\\n/* ── shared bits ──────────────────────────────────────────────────────── */\\n\\nconst money = (n) => '$' + (n ?? 0).toFixed(2);\\nconst signed = (n) => (n >= 0 ? '+' : '') + Math.round(n);\\n\\nfunction Rail({ metric, actual, target, bands = BANDS, floorAt }) {\\n const isFloor = metric === 'protein';\\n // On the loose setting the floor sits below the target, so the rail is drawn\\n // against the floor actually in force rather than the target.\\n const floor = isFloor && floorAt ? floorAt : target;\\n const r = isFloor ? floorRail(actual, floor) : bandRail(actual, target, bands[metric]);\\n const delta = Math.round(actual - target);\\n const unit = metric === 'kcal' ? '' : 'g';\\n\\n return h`

\\n

\\n ${metric === 'kcal' ? 'energy' : metric}\\n \\n ${Math.round(actual)}/${target}${unit}\\n ${signed(delta)}${unit}\\n \\n

\\n

\\n ${isFloor\\n ? h`

`\\n : h`

`}\\n ${r.miss && h`

`}\\n

\\n

\\n ${isFloor && h`

floor — under is never “close enough”

`}\\n

`;\\n}\\n\\nfunction Banner({ validation }) {\\n if (!validation) return null;\\n const hard = validation.failures.filter((f) => f.kind === 'hard');\\n const band = validation.failures.filter((f) => f.kind === 'band');\\n const shown = [...hard, ...band];\\n return h``;\\n}\\n\\n/* ── screens ──────────────────────────────────────────────────────────── */\\n\\nconst STATUS_LABEL = { ate: 'ate it', 'ate-elsewhere': 'ate out', skipped: 'skipped' };\\n\\n// verified/onClearProof/busyMeal are passed by the shell but were missing from\\n// this signature, so the first plan to render threw ReferenceError: verified is\\n// not defined — a blank screen the moment a plan actually existed.\\nfunction PlanScreen({ plan, items, onStatus, verified, onClearProof, busyMeal }) {\\n const [day, setDay] = useState(1);\\n if (!plan) return h`<${Empty} title=\\\"No plan yet\\\" body=\\\"Head to New plan to build one.\\\" />`;\\n\\n const totals = plan.totals.perDay.find((t) => t.day === day) || plan.totals.perDay[0];\\n const supp = plan.supplements;\\n // The rail is measured against the FULL target, so it has to show the full\\n // day — food plus whatever the supplements contribute.\\n const withSupps = (plan.totals.withSupplements || []).find((t) => t.day === totals.day) || totals;\\n const meals = plan.meals.filter((m) => m.day === totals.day);\\n\\n return h`<>\\n \\n\\n

\\n

Against target

\\n ${['kcal', 'protein', 'carbs', 'fat'].map((m) => h`\\n <${Rail} key=${m} metric=${m} actual=${totals[m]} target=${plan.targets[m]}\\n bands=${bandsOf(plan)} floorAt=${bandsOf(plan).proteinFloorAt} />`)}\\n ${bandsOf(plan).proteinFloorAt != null && bandsOf(plan).proteinFloorAt < plan.targets.protein\\n && h`

\\n Macro strictness is loose, so the protein floor sits at\\n ${bandsOf(plan).proteinFloorAt}g rather than ${plan.targets.protein}g.

`}\\n

\\n\\n ${(((plan.recipes || {}).overflow) || []).length > 0 && h`

\\n

Cooked more than the plan uses

\\n

The batch is bigger than the window, so these portions aren’t\\n scheduled anywhere. Freeze them, eat them off-plan, or stretch the window next time —\\n the macros above count only the portions that are scheduled.

\\n

\\n ${o.name}\\n ${o.spare} spare${o.placed} of ${o.servings} used\\n

\\n

`}\\n\\n ${(((plan.recipes || {}).skipped) || []).length > 0 && h`

\\n

Your recipes that didn’t fit

\\n

Asked for, but there was no room left at all — another recipe had\\n already taken every slot of that meal.

\\n

${s.name} — ${s.reason}

\\n

`}\\n\\n ${meals.map((m) => h`\\n

\\n

\\n ${m.slot}\\n

${m.name}

\\n

\\n ${m.computed.kcal}\\n P${m.computed.protein} C${m.computed.carbs} F${m.computed.fat}\\n

\\n

\\n\\n ${m.batch && !m.batch.cooking\\n ? h`

\\n A portion of the batch cooked on day ${m.batch.cookDay}. Take it out of the\\n fridge — there is nothing to cook and nothing to buy for it.

`\\n : h`<>\\n ${m.batch && m.batch.cooking && h`

\\n Cook this once — it makes ${m.batch.portions} portions, eaten across\\n ${m.batch.portions} ${m.batch.portions === 1 ? 'meal' : 'meals'}.\\n The amounts below are for the whole pot.

`}\\n\\n

\\n ${d ? d.text : ((it.packUnit === 'ea' ? c.grams : c.grams + (it.packUnit || 'g')) + ' ' + (it.name || c.itemId))}${it.estimated && h`^≈`}\\n ${d && d.exact && h`${d.exact}`}\\n

\\n\\n

${s}

\\n `}\\n\\n ${verified.has(m.id)\\n ? h`

\\n \\\\u2713 photo verified\\n \\n

`\\n : h`

\\n ${['ate', 'ate-elsewhere', 'skipped'].map((k) => h`\\n `)}\\n

`}\\n\\n

\\n \\n \\n

\\n

`)}\\n `;\\n}\\n\\nfunction ShopScreen({ plan, items, onShopComplete, onAisle, busy }) {\\n const [picked, setPicked] = useState(() => new Set());\\n const [open, setOpen] = useState(null);\\n if (!plan) return h`<${Empty} title=\\\"No plan yet\\\" body=\\\"Build a plan and the list appears here.\\\" />`;\\n\\n const toggle = (id) => setPicked((p) => {\\n const n = new Set(p); n.has(id) ? n.delete(id) : n.add(id); return n;\\n });\\n\\n const staples = plan.shopping.filter((l) => l.staple);\\n const fresh = plan.shopping.filter((l) => !l.staple);\\n const freshCost = fresh.reduce((s, l) => s + l.estCost, 0);\\n const left = fresh.filter((l) => !picked.has(l.id)).reduce((s, l) => s + l.estCost, 0);\\n\\n const aisles = [];\\n for (const l of fresh) {\\n const last = aisles[aisles.length - 1];\\n if (last && last[0] === l.aisle) last[1].push(l);\\n else aisles.push([l.aisle, [l]]);\\n }\\n\\n return h`<>\\n

\\n

picked\\n ${picked.size}/${fresh.length}

\\n

left to buy\\n ${money(left)}of ${money(freshCost)}

\\n

\\n ${picked.size === fresh.length && fresh.length > 0 && h`\\n `}\\n \\n

\\n\\n ${staples.length > 0 && h`

\\n

Check the cupboard first

\\n

Staples. Buying them all would add\\n ${money(staples.reduce((s, l) => s + l.estCost, 0))}.

\\n

\\n ${l.substituteGroup.replace(/-/g, ' ')}\\n ${l.requiredGrams}${l.packUnit === 'ea' ? '' : l.packUnit}\\n

\\n

`}\\n\\n ${aisles.map(([aisle, lines]) => h`

\\n

${aisle}

\\n

\\n \\n toggle(l.id)} />\\n \\n \\n ${l.buy ? l.buy.text : (primary.name || l.primaryItemId)}\\n ${money(l.estCost)}\\n \\n \\n ${primary.name || l.primaryItemId}${l.buy && l.buy.detail ? ' · ' + l.buy.detail : ''}\\n ${l.fromStockGrams > 0 && h`some already in the fridge`}\\n ${l.carryForward && l.surplusGrams > 0 && h`keeps for next time`}\\n \\n \\n \\n ${l.candidates.length > 1 && h`\\n `}\\n ${isOpen && h`
- \\n ${c.name || ci.name}\\n \\n ${c.packSize}${c.packUnit === 'ea' ? 'pk' : c.packUnit}${c.price != null ? ' · ' + money(c.price) : ''}\\n ${!c.delta\\n ? h`planned`\\n : c.delta.equivalent\\n ? h`same numbers`\\n : h`${signed(c.delta.kcalPerDay)} kcal/day`}\\n \\n
`}\\n

\\n

`)}\\n `;\\n}\\n\\nfunction PrepScreen({ plan }) {\\n if (!plan || !plan.prep) return h`<${Empty} title=\\\"No prep sheet\\\" body=\\\"It's written when a plan is generated.\\\" />`;\\n const { prep } = plan;\\n return h`<>\\n ${prep.freezeSurplus && prep.freezeSurplus.length > 0 && h`

\\n

Straight in the freezer

\\n

Bigger packs than the plan needs. Portion and freeze on shopping day.

\\n

\\n ${f.name}${f.surplusGrams}g

\\n

`}\\n\\n ${prep.freezePortions && prep.freezePortions.length > 0 && h`

\\n

Portion and freeze after cooking

\\n

\\n ${f.name}${f.reason}

\\n

`}\\n\\n ${prep.freezeOnArrival && prep.freezeOnArrival.length > 0 && h`

\\n

Freeze on arrival

\\n

\\n ${f.name}${f.reason}

\\n

`}\\n\\n ${prep.batchSessions.map((b, i) => h`

\\n

Day ${b.day} · ${b.title}

\\n

${s}

\\n

`)}\\n\\n ${prep.perDay.map((d) => h`

\\n

Day ${d.day}

\\n

${s}

\\n

`)}\\n\\n ${prep.notes && prep.notes.length > 0 && h`

\\n

Leftovers

\\n

${n}

\\n

`}\\n `;\\n}\\n\\n// The only question anyone can answer standing at an open fridge.\\nconst REVIEW_LEVELS = [\\n ['gone', 'all gone'],\\n ['some', 'a bit left'],\\n ['most', 'most left'],\\n ['all', 'untouched'],\\n];\\n\\nfunction FridgeScreen({ stock, items, adherence, useFirstList, onReviewStock, busy }) {\\n const total = adherence && adherence.decided;\\n const [review, setReview] = useState({});\\n const answered = Object.values(review).filter(Boolean).length;\\n return h`<>\\n ${adherence && h`

\\n

ate as planned\\n ${adherence.ate}/${total || 0}

\\n

\\n ${adherence.planned} meal${adherence.planned === 1 ? '' : 's'} not recorded — counted as unknown, not as misses.\\n

\\n

`}\\n\\n ${useFirstList && useFirstList.length > 0 && h`

\\n

Next plan gets built around these

\\n

Paid for, and gone if the next window doesn’t use them.

\\n

\\n ${u.name}\\n ${u.grams}${u.unit === 'ea' ? '' : (u.unit || 'g')}${u.remainingDays <= 0 ? 'use today' : u.remainingDays + 'd left'}\\n

\\n

`}\\n\\n

\\n

What’s left?

\\n ${stock.length === 0\\n ? h`

Nothing carried over. It fills up when you photograph a receipt, mark meals, or finish a shop.

`\\n : h`<>\\n

Go through this before you shop again. Nobody weighs a jar of\\n soy sauce, so just say roughly how much is left — the next plan builds around\\n your answers. Buying something other than what the plan said is fine; it\\n changes nothing but this list.

\\n ${stock.map((e) => {\\n const it = items[e.itemId] || {};\\n const chosen = review[e.id];\\n return h`

\\n

\\n ${it.name || e.itemId}\\n ${Math.round(e.grams)}${e.unit === 'ea' ? '' : (e.unit || 'g')} · ${e.note || e.source}\\n \\n ${e.expired ? 'expired' : e.remainingDays <= 0 ? 'use today' : e.remainingDays + 'd left'}\\n

\\n

\\n ${REVIEW_LEVELS.map(([v, label]) => h`\\n `)}\\n

\\n

`;\\n })}\\n \\n `}\\n

\\n `;\\n}\\n\\nfunction StoreScreen({ plan, items, onReload }) {\\n const [itemId, setItemId] = useState(null);\\n const [log, setLog] = useState([]);\\n const [busy, setBusy] = useState(false);\\n const [text, setText] = useState('');\\n\\n if (!plan) return h`<${Empty} title=\\\"No plan yet\\\" body=\\\"Store mode works on the current plan.\\\" />`;\\n\\n const lines = plan.shopping.filter((l) => !l.staple);\\n\\n const ask = async (message) => {\\n if (!itemId || busy) return;\\n setBusy(true); setText('');\\n setLog((l) => [...l, { me: true, text: message }]);\\n try {\\n const r = await api('/api/chat', { method: 'POST', body: { itemId, message } });\\n setLog((l) => [...l, {\\n text: r.reply, applied: r.applied, blocked: r.blocked,\\n impact: r.impact, equivalent: r.equivalent, action: r.action,\\n }]);\\n if (r.applied) await onReload();\\n } catch (err) {\\n setLog((l) => [...l, { text: err.message, error: true }]);\\n } finally { setBusy(false); }\\n };\\n\\n if (!itemId) {\\n return h`

\\n

What's the problem with?

\\n

Pick the item you're stuck on. I'll only change that one.

\\n

\\n \\n

\\n

`;\\n }\\n\\n const item = items[itemId] || {};\\n return h`<>\\n

\\n

\\n ${item.name || itemId}\\n \\n

\\n

\\n\\n ${log.map((m, i) => h`

\\n

${m.text}

\\n ${m.blocked && m.blocked.length > 0 && h`

${b}

`}\\n ${m.applied && h`

\\n ${m.equivalent ? 'same numbers' : 'swapped'}\\n ${(m.impact || []).map((im, j) => h`${im.text}`)}\\n

`}\\n

`)}\\n\\n

\\n

\\n ${[\\\"Can't find it\\\", 'Out of stock', 'Too expensive', 'Wrong size'].map((c) => h`\\n `)}\\n

\\n \\n setText(e.target.value)}\\n onKeyDown=${(e) => e.key === 'Enter' && text.trim() && ask(text.trim())} />\\n \\n ${busy && h`

Thinking…

`}\\n

\\n `;\\n}\\n\\nfunction HistoryScreen({ history }) {\\n if (!history) return h`<${Empty} title=\\\"Loading\\\" body=\\\"Fetching past plans.\\\" />`;\\n if (!history.length) {\\n return h`<${Empty} title=\\\"No past plans\\\"\\n body=\\\"Plans are archived here when you generate a new one, with whatever you recorded against them.\\\" />`;\\n }\\n return h`<>${history.map((p) => h`

\\n

\\n ${p.days}-day plan\\n ${new Date(p.createdAt).toDateString()}\\n ${money(p.estCost)}\\n

\\n

\\n ate as planned\\n ${p.adherence.rate === null ? '\\\\u2014' : Math.round(p.adherence.rate * 100) + '%'}\\n ${p.adherence.ate}/${p.adherence.decided || 0} recorded\\n

\\n

\\n ${m.name}day ${m.day} ${m.slot}\\n ${STATUS_LABEL[m.status] || m.status}

\\n

`)}`;\\n}\\n\\nfunction LabelsScreen({ labels, items, onRead, onConfirm, onForget, busy }) {\\n const [draft, setDraft] = useState(null);\\n const [target, setTarget] = useState(null);\\n\\n if (!labels) return h`<${Empty} title=\\\"Loading\\\" body=\\\"Checking which products need a photo.\\\" />`;\\n\\n const pick = async (file, itemId) => {\\n const b64 = await new Promise((resolve, reject) => {\\n const r = new FileReader();\\n r.onload = () => resolve(String(r.result).split(',')[1]);\\n r.onerror = () => reject(new Error('Could not read that image'));\\n r.readAsDataURL(file);\\n });\\n setTarget(itemId);\\n setDraft(await onRead(itemId, b64, file.type || 'image/jpeg'));\\n };\\n\\n return h`<>\\n

\\n

Why this matters

\\n

\\n Branded products ship with estimated nutrition. Photograph the panel once and the real\\n numbers replace the guess for good \\\\u2014 a catalog refresh never overwrites them.\\n

\\n

\\n\\n ${draft && h`

\\n

Check before saving

\\n

${(items[target] || {}).name || target}

\\n ${draft.ok === false && h`

${x}

`}\\n ${(draft.warnings || []).length > 0 && h`

${w}

`}\\n

\\n ${['kcal', 'protein', 'carbs', 'fat'].map((k) => h`\\n ${k} per 100g\\n setDraft({ ...draft, per100: { ...draft.per100, [k]: Number(e.target.value) } })} />\\n `)}\\n

\\n \\n \\n

`}\\n\\n ${labels.queue.length > 0 && h`

\\n

Worth photographing next

\\n

Estimated, and the plan leans on them hardest.

\\n

\\n ${q.name}${q.grams}${q.unit === 'ea' ? '' : (q.unit || 'g')} this plan \\\\u00b7 ~${q.kcalAtStake} kcal riding on the estimate\\n photo\\n e.target.files[0] && pick(e.target.files[0], q.itemId)} />\\n \\n

\\n

`}\\n\\n

\\n

Read off a packet

\\n ${labels.captured.length === 0\\n ? h`

Nothing yet.

`\\n : h`

\\n ${c.name}\\n ${Math.round(c.per100.kcal)} kcal \\\\u00b7 P${c.per100.protein}${c.previous ? ' \\\\u00b7 was ' + Math.round(c.previous.kcal) : ''}\\n \\n

`}\\n

\\n `;\\n}\\n\\n/** Shared picker: search the catalog, tap to add or remove. */\\nfunction ItemPicker({ selected, onChange, supplements = false, tags = [], placeholder }) {\\n const [q, setQ] = useState('');\\n const [tag, setTag] = useState(null);\\n const [hits, setHits] = useState([]);\\n const [loading, setLoading] = useState(false);\\n\\n const search = useCallback(async (query, t) => {\\n setLoading(true);\\n try {\\n const params = new URLSearchParams();\\n if (query) params.set('q', query);\\n if (t) params.set('tag', t);\\n if (supplements) params.set('supplements', '1');\\n const r = await api('/api/catalog-search?' + params.toString());\\n setHits(r.items);\\n } catch { setHits([]); } finally { setLoading(false); }\\n }, [supplements]);\\n\\n useEffect(() => { search(q, tag); }, [q, tag, search]);\\n\\n const chosen = new Set(selected.map((x) => (typeof x === 'string' ? x : x.itemId)));\\n\\n return h`

\\n ${tags.length > 0 && h`

\\n ${[[null, 'everything'], ...tags].map(([t, label]) => h`\\n `)}\\n

`}\\n \\n setQ(e.target.value)} />\\n \\n ${loading && h`

searching\\\\u2026

`}\\n

\\n \\n
nothing matches

\\n

`;\\n}\\n\\nfunction SupplementsScreen({ settings, plan, onSave, saving }) {\\n const list = settings.supplements || [];\\n const setList = (next) => onSave({ ...settings, supplements: next });\\n\\n const toggle = (item, already) => setList(already\\n ? list.filter((x) => x.itemId !== item.id)\\n : [...list, { itemId: item.id, dose: item.dailyDose ?? 1, timing: null }]);\\n\\n const supp = plan?.supplements;\\n\\n return h`<>\\n ${supp && supp.checklist.length > 0 && h`

\\n

Every day

\\n

\\n ${c.name}${c.timing ? h`${c.timing}` : null}\\n ${c.dose}

\\n ${(supp.daily.kcal > 0 || supp.daily.protein > 0) && h`

\\n Adds ${supp.daily.kcal} kcal and ${supp.daily.protein}g protein a day.\\n Food targets are set ${supp.fullTargets.protein - supp.foodTargets.protein}g lower to match,\\n so the day still lands on ${supp.fullTargets.protein}g.\\n

`}\\n ${(supp.breakdown.notes || []).map((n, i) => h`

${n}

`)}\\n

`}\\n\\n

\\n

Your supplements

\\n ${list.length === 0\\n ? h`

None yet. Anything you add is bought with the shop and counted in the day's macros.

`\\n : h`

\\n ${x.itemId.replace(/^\\\\w+-/, '').replace(/-/g, ' ')}\\n \\n setList(list.map((y) => (y.itemId === x.itemId ? { ...y, dose: Number(e.target.value) } : y)))} />\\n \\n \\n \\n

`}\\n

\\n Doses default to what's printed on the product. Changing them is up to you \\\\u2014 this app\\n plans food, it doesn't advise on supplements.\\n

\\n

\\n\\n

\\n

Add a supplement

\\n <${ItemPicker} selected=${list} onChange=${toggle} supplements=${true}\\n placeholder=\\\"creatine, collagen, multivitamin\\\\u2026\\\" />\\n

\\n `;\\n}\\n\\nfunction WantedScreen({ settings, onSave, saving }) {\\n const ids = settings.wantedItemIds || [];\\n const toggle = (item, already) => onSave({\\n ...settings,\\n wantedItemIds: already ? ids.filter((x) => x !== item.id) : [...ids, item.id],\\n });\\n\\n return h`<>\\n

\\n

Foods you want in the plan

\\n

\\n Each of these gets worked into the week at least once. Restrictions still win \\\\u2014\\n anything you can't eat stays out even if you pick it.\\n

\\n

\\n\\n ${ids.length > 0 && h`

\\n

${ids.length} chosen

\\n

\\n ${id.replace(/^\\\\w+-/, '').replace(/-/g, ' ')}\\n \\n

\\n

`}\\n\\n

\\n

Find foods

\\n <${ItemPicker} selected=${ids} onChange=${toggle}\\n tags=${[['gut-friendly', 'gut-friendly'], ['fermented', 'fermented'], ['prebiotic', 'prebiotic'], ['high-fibre', 'high fibre']]}\\n placeholder=\\\"kefir, kimchi, oats\\\\u2026\\\" />\\n

\\n `;\\n}\\n\\nconst FREQ_LABEL = {\\n 'every-window': 'every shop',\\n weekly: 'about weekly',\\n sometimes: 'now and then',\\n};\\n\\n// 'auto' is not \\\"on\\\" — it hands the decision to the frequency above, which may\\n// legitimately skip a short window. 'on' overrides that for this plan.\\nconst MAIN_SLOTS = ['breakfast', 'lunch', 'dinner'];\\nconst USE_LABEL = { auto: 'app decides', on: 'on', off: 'off' };\\nconst useOf = (r) => r.use ?? (r.enabled === false ? 'off' : 'auto');\\n\\n/** The three-state control, shared by the recipe list and the new-plan screen. */\\nfunction UseSeg({ recipe, onUse, busy }) {\\n const current = useOf(recipe);\\n return h`

${Object.entries(USE_LABEL).map(([v, label]) => h`\\n `)}

`;\\n}\\n\\nfunction RecipesScreen({ recipes, items, slots, onParse, onSave, onDelete, onPatch, onUse, busy }) {\\n const [text, setText] = useState('');\\n const [draft, setDraft] = useState(null);\\n const [error, setError] = useState(null);\\n const [confirmDelete, setConfirmDelete] = useState(null);\\n\\n if (!recipes) return h`<${Empty} title=\\\"Loading\\\" body=\\\"Fetching your recipes.\\\" />`;\\n\\n const parse = async () => {\\n setError(null);\\n const out = await onParse(text);\\n if (out.error) { setError(out.error); return; }\\n setDraft(out);\\n };\\n\\n const saveDraft = async () => {\\n const r = await onSave(draft.recipe);\\n if (r && r.ok) { setDraft(null); setText(''); }\\n else if (r) setError((r.problems || [r.error]).join('; '));\\n };\\n\\n const setD = (patch) => setDraft({ ...draft, recipe: { ...draft.recipe, ...patch } });\\n\\n return h`<>\\n

\\n

Paste a recipe

\\n

\\n It gets mapped onto real products so it can be costed and counted. You check the\\n mapping before it's saved \\\\u2014 anything the catalog can't match is left out rather\\n than swapped for something else.\\n

\\n \\n \\n \\n \\n ${error && h`

${error}

`}\\n

\\n\\n ${draft && h`

\\n

Check before saving

\\n name\\n setD({ name: e.target.value })} />\\n\\n which meal\\n

${slots.map((sl) => h`\\n `)}

\\n\\n how often\\n

${Object.entries(FREQ_LABEL).map(([f, label]) => h`\\n `)}

\\n\\n

\\n servings it makes\\n setD({ servings: Number(e.target.value) })} />\\n portions\\n

\\n \\n \\n

\\n

\\n ${draft.recipe.servings > 1 && h`

\\n Cooked once and eaten across ${draft.recipe.servings} days.

`}\\n\\n ${(draft.warnings || []).length > 0 && h`

${w}

`}\\n\\n

Ingredients, one serving

\\n

\\n setD({ components: draft.recipe.components.map((x, j) =>\\n (j === i ? { ...x, grams: Number(e.target.value) } : x)) })} />\\n ${(items[c.itemId] || {}).name || c.itemId}\\n \\n

\\n\\n ${draft.recipe.unmatched.length > 0 && h`

\\n

Not counted

\\n

No catalog match, so these are left out of the macros and the list.

\\n

${u}

\\n

`}\\n\\n \\n \\n

`}\\n\\n

\\n

Your recipes

\\n ${recipes.length === 0\\n ? h`

None yet. Anything saved here is placed into the plan first, and the rest is generated around it.

`\\n : recipes.map((r) => h`

\\n

\\n ${r.name}\\n ${r.slot}${r.servings > 1 ? ' \\\\u00b7 serves ' + r.servings : ''}${r.scalePortions ? '' : ' \\\\u00b7 exact portions'}\\n \\n

\\n\\n ${confirmDelete === r.id\\n ? h``\\n : h`<>\\n use it\\n <${UseSeg} recipe=${r} onUse=${onUse} busy=${busy} />\\n how often\\n

${Object.entries(FREQ_LABEL).map(([f, label]) => h`\\n `)}

\\n which meal\\n

${slots.map((sl) => h`\\n `)}

\\n

\\n servings it makes\\n {\\n const n = Number(e.target.value);\\n if (n >= 1 && n <= 12) onPatch(r.id, { servings: n });\\n }} />\\n portions\\n

\\n \\n \\n

\\n

\\n ${useOf(r) === 'on' && r.frequency === 'sometimes' && h`

\\n Forced in, so it appears even in a short window that \\\\u201cnow and then\\\\u201d would skip.

`}\\n `}\\n

`)}\\n

\\n app decides follows \\\\u201chow often\\\\u201d. on forces it into the next plan even\\n when the frequency would skip it. off leaves it out entirely.

\\n

\\n `;\\n}\\n\\nfunction ProofScreen({ proof, onVerify, busy }) {\\n const [pick, setPick] = useState(null);\\n const [result, setResult] = useState(null);\\n const [error, setError] = useState(null);\\n\\n if (!proof) return h`<${Empty} title=\\\"Loading\\\" body=\\\"Fetching the plan.\\\" />`;\\n\\n const card = result ? result.card : proof.card;\\n const open = proof.meals.filter((m) => !m.claimed);\\n\\n const shoot = async (file, mealId) => {\\n setError(null);\\n const b64 = await new Promise((resolve, reject) => {\\n const r = new FileReader();\\n r.onload = () => resolve(String(r.result).split(',')[1]);\\n r.onerror = () => reject(new Error('Could not read that photo'));\\n r.readAsDataURL(file);\\n });\\n const out = await onVerify(mealId, b64, file.type || 'image/jpeg');\\n if (out.error) { setError(out.error); return; }\\n setResult(out);\\n setPick(null);\\n };\\n\\n return h`<>\\n

\\n

${card.verdict}

\\n ${card.mealName && h`

${card.mealName}

`}\\n ${card.day && h`

day ${card.day} \\\\u00b7 ${card.slot}

`}\\n

${card.stamp || card.detail}

\\n ${card.note && h`

${card.note}

`}\\n

\\n\\n ${card.state === 'pass' && h`

\\n

\\n Screenshot the card above and submit it to Vouch. The timestamp is what makes it\\n today’s proof rather than an old screenshot.\\n

\\n

`}\\n\\n ${result && result.identified && result.identified.length > 0 && h`

\\n

What the check saw

\\n

${x}

\\n ${result.reason && h`

${result.reason}

`}\\n ${result.overridden && h`

${result.overridden}

`}\\n

`}\\n\\n ${error && h`

${error}

`}\\n\\n

\\n

Photograph a meal

\\n

\\n Pick the meal you actually cooked. Each one can only be verified once, so a good\\n dinner can’t be claimed twice.\\n

\\n ${open.length === 0\\n ? h`

Every meal in this plan has been verified.

`\\n : h`

\\n \\n ${m.name}day ${m.day} \\\\u00b7 ${m.slot}\\n ${busy && pick === m.id ? 'checking\\\\u2026' : 'photo'}\\n { if (e.target.files[0]) { setPick(m.id); shoot(e.target.files[0], m.id); } }} />\\n \\n \\n

`}\\n

\\n\\n ${proof.proofs.length > 0 && h`

\\n

Verified this plan

\\n

\\n ${p2.mealName}${p2.stamp || ''}\\n ${p2.verdict === 'pass' ? '\\\\u2713' : '\\\\u2717'}\\n

\\n

`}\\n `;\\n}\\n\\n/** Closest to target first — that is the only ordering worth defaulting to. */\\nfunction byFit(a, b) {\\n if (a.fit == null && b.fit == null) return (b.createdAt || 0) - (a.createdAt || 0);\\n if (a.fit == null) return 1;\\n if (b.fit == null) return -1;\\n return a.fit - b.fit;\\n}\\n\\nfunction NewPlanScreen({ onGenerate, phases, busy, error, plan, onClearPlan, recipes, onUse,\\n history, onReusePlan, slots }) {\\n const [days, setDays] = useState(3);\\n // Only worth asking when there is a plan you might have shopped for already.\\n const askBought = !!plan && !plan.shoppedAt;\\n const [bought, setBought] = useState(null);\\n const [confirmClear, setConfirmClear] = useState(false);\\n return h`<>\\n ${askBought && h`

\\n

The plan you are replacing

\\n

Did you buy the food for it? If you did, it goes into the fridge\\n and the next plan is built to eat it rather than to buy it again.

\\n

\\n ${[['no', 'Never shopped'], ['yes', 'Already bought it']].map(([v, label]) => h`\\n `)}\\n

\\n

`}\\n\\n

\\n

Shopping window

\\n \\n \\n ${!busy && askBought && bought === null && h`

\\n Answer the question above first — it decides whether the old shop is counted as food you have.

`}\\n ${!busy && h`

\\n Takes 2–4 minutes. Replaces the current plan; the old one is archived with whatever you recorded against it.

`}\\n

\\n\\n ${(history || []).length > 0 && h`

\\n

Or cook one you already have

\\n

Costs nothing and takes a second — no model call. Closest to your\\n current targets first; the percentage is the average daily miss across energy,\\n protein, carbs and fat.

\\n ${[...history].sort(byFit).slice(0, 8).map((p) => h`

\\n

\\n ${p.days}-day plan\\n ${new Date(p.createdAt).toLocaleDateString()}${p.estCost ? ' · ' + money(p.estCost) : ''}\\n \\n ${p.fit == null ? 'no totals' : 'within ' + p.fit + '%'}\\n

\\n ${p.macros && h`

\\n ${p.macros.kcal} kcal · P${p.macros.protein} C${p.macros.carbs} F${p.macros.fat} a day

`}\\n \\n

`)}\\n

`}\\n\\n ${(recipes || []).length > 0 && h`

\\n

Your recipes in this plan

\\n

“app decides” follows the recipe’s own frequency, which can skip a\\n short window. Set one to on to have it placed regardless.

\\n ${recipes.map((r) => {\\n // A batch needs one slot per serving. Breakfast, lunch and dinner are\\n // interchangeable, so a 4-serving dinner fits a 2-day window; a snack\\n // can only use snack slots. Worth saying now, not after a 3-minute wait.\\n const perDay = MAIN_SLOTS.includes(r.slot)\\n ? (slots || []).filter((s) => MAIN_SLOTS.includes(s)).length\\n : 1;\\n const capacity = Math.max(1, perDay) * days;\\n const tooBig = useOf(r) !== 'off' && (r.servings ?? 1) > capacity;\\n return h`

\\n ${r.name}\\n ${r.slot} · ${FREQ_LABEL[r.frequency] || r.frequency}${r.servings > 1 ? ' · serves ' + r.servings : ''}\\n

\\n <${UseSeg} recipe=${r} onUse=${onUse} busy=${busy} />\\n

\\n ${tooBig && h`

\\n Serves ${r.servings} but this window only has room for ${capacity}, so it is cooked\\n anyway and ${r.servings - capacity} portion(s) end up spare.

`}\\n

`;\\n })}\\n

`}\\n\\n ${plan && !busy && h`

\\n

Clear the current plan

\\n

Leaves you with no plan at all, rather than building a new one.\\n It is archived to Past plans with whatever you recorded against it, and the\\n fridge is left exactly as it is.

\\n ${confirmClear\\n ? h`

\\n \\n \\n

`\\n : h``}\\n

`}\\n\\n ${phases.length > 0 && h`

\\n

Progress

\\n

\\n ${p.phase}${p.round ? ' · round ' + p.round : ''}\\n ${i === phases.length - 1 && busy ? '…' : '✓'}\\n

\\n

`}\\n\\n ${error && h`

Didn’t work

\\n

${error}

`}\\n `;\\n}\\n\\nfunction SetupScreen({ settings, onSave, saving, catalog, onRefreshCatalog, refresh }) {\\n const [s, setS] = useState(settings);\\n useEffect(() => setS(settings), [settings]);\\n const set = (k, v) => setS((c) => ({ ...c, [k]: v }));\\n const setTarget = (k, v) => setS((c) => ({ ...c, targets: { ...c.targets, [k]: Number(v) || 0 } }));\\n\\n const field = (label, key, placeholder) => h`\\n ${label}\\n \\n `;\\n\\n return h`<>\\n

\\n

Daily targets

\\n

\\n ${['kcal', 'protein', 'carbs', 'fat'].map((k) => h`\\n ${k === 'kcal' ? 'energy' : k}\\n setTarget(k, e.target.value)} />\\n `)}\\n

\\n

\\n\\n

\\n

Store

\\n

\\n ${[['pns', \\\"Pak'nSave\\\"], ['ww', 'Woolworths']].map(([v, label]) => h`\\n `)}\\n

\\n

Switching store re-plans — the two carry different stock.

\\n

\\n\\n

\\n

Food

\\n ${field('Restrictions', 'restrictions', 'vegetarian, gluten-free…')}\\n ${field('Never use', 'dislikes', 'olives, coriander…')}\\n ${field('Use often', 'mustInclude', 'eggs, salmon…')}\\n ${field('Goals', 'philosophy', 'max variety, gut-friendly…')}\\n

\\n\\n

\\n

Cooking

\\n How much cooking\\n

${['minimal', 'moderate', 'happy-to-cook'].map((v) => h`\\n `)}

\\n \\n

\\n ${s.effortCeiling === 'minimal'\\n ? 'Repeats are the point: the same lunch several days running is allowed, batch cooking is favoured, and variety checks on meal names switch off.'\\n : s.effortCeiling === 'moderate'\\n ? 'Everyday \";\n",[],[327,363],"5876531c-b2c3-4c1f-93ee-8f8dac9edcf9",["D",1788084579215],"deletedAt","legacyEnvVars","privacy","public","httpPrivacy","description","","imageUrl","userId","ac016058-4dff-4268-a58d-c6377cb09a13","pinnedFileId","pinPreview","pinMigrated","screenshotVersion","likeCount","orgId","019f1fab-a2bc-73b7-aa9b-5a23f068d628","tursoName","tursoHostname","tursoMeasuredAt","pinned","userPerm","r","valPerm","blobPerm","rw","emailPerm","sqlitePerm","projectPerm","telemetryPerm","user",{"_11":12,"_424":420},"org",{"_11":12,"_417":418,"_419":420,"_380":381,"_421":422,"_423":61},"branch",{"_17":356,"_13":16,"_33":36,"_409":370,"_410":-5,"_411":-5,"_412":-5,"_413":-5,"_414":-5,"_415":14,"_416":12},"isOwned","projectId","forkedBranchId","forkedBranchVersion","forkedProjectPrivacy","forkedProjectId","forkedProjectOrgId","projectName","userHandle","displayName","waka waka","avatar","https://lh3.googleusercontent.com/a/ACg8ocIfPhdrpGDjFrYHrMnU190pz133j3MwBQZnU7s6gdFpOCob2Q=s96-c","tier","free","canRestrictVals","profileImageUrl","adoptOrgId",{"_33":370,"_13":14,"_45":560,"_372":-5,"_373":61,"_374":375,"_376":375,"_377":378,"_379":-5,"_380":381,"_382":38,"_383":58,"_384":-5,"_385":-5,"_386":70,"_387":388,"_389":-5,"_390":-5,"_391":-5,"_392":-5,"_393":394,"_395":394,"_396":397,"_398":397,"_399":397,"_400":394,"_401":394,"_402":561,"_404":562,"_406":563,"_408":61},[455,460,486,487,488,489],"files",[455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489],"counts",{"_446":70,"_447":128,"_448":70,"_32":449,"_450":451},[],{"_33":34,"_35":36,"_37":38,"_13":19,"_39":40,"_41":42,"_17":43,"_44":-5,"_45":444,"_47":48,"_49":-5,"_18":445},"upstreamProject","upstreamBranch","emptyEnvVars","flags",[],"hasHttpFiles","grants","orgs","customDomains",{},["D",1788929446489],[19],"pulls","branches","forks",{"_452":93,"_454":70},"connections",{"_452":70,"_453":70},"count","unfilledCount","emptyCount",{"_33":326,"_13":327,"_37":328,"_44":-5,"_35":36,"_47":128,"_57":58,"_45":329,"_17":70,"_41":95,"_39":-5,"_60":61,"_49":-5,"_62":558,"_18":559},{"_33":362,"_13":363,"_37":364,"_44":328,"_35":36,"_47":365,"_57":58,"_45":366,"_17":43,"_41":341,"_39":367,"_60":61,"_49":-5,"_62":556,"_18":557},{"_33":353,"_13":354,"_37":355,"_44":328,"_35":36,"_47":356,"_57":58,"_45":357,"_17":358,"_41":341,"_39":359,"_60":61,"_49":-5,"_62":554,"_18":555},{"_33":345,"_13":346,"_37":347,"_44":328,"_35":36,"_47":348,"_57":58,"_45":349,"_17":128,"_41":341,"_39":350,"_60":61,"_49":-5,"_62":552,"_18":553},{"_33":336,"_13":337,"_37":338,"_44":328,"_35":36,"_47":339,"_57":58,"_45":340,"_17":93,"_41":341,"_39":342,"_60":61,"_49":-5,"_62":550,"_18":551},{"_33":90,"_13":91,"_37":92,"_44":-5,"_35":36,"_47":93,"_57":58,"_45":94,"_17":70,"_41":95,"_39":-5,"_60":61,"_49":-5,"_62":548,"_18":549},{"_33":318,"_13":319,"_37":320,"_44":92,"_35":36,"_47":321,"_57":58,"_45":322,"_17":70,"_41":24,"_39":323,"_60":61,"_49":-5,"_62":546,"_18":547},{"_33":310,"_13":311,"_37":312,"_44":92,"_35":36,"_47":313,"_57":58,"_45":314,"_17":70,"_41":24,"_39":315,"_60":61,"_49":-5,"_62":544,"_18":545},{"_33":302,"_13":303,"_37":304,"_44":92,"_35":36,"_47":305,"_57":58,"_45":306,"_17":70,"_41":24,"_39":307,"_60":61,"_49":-5,"_62":542,"_18":543},{"_33":294,"_13":295,"_37":296,"_44":92,"_35":36,"_47":297,"_57":58,"_45":298,"_17":70,"_41":24,"_39":299,"_60":61,"_49":-5,"_62":540,"_18":541},{"_33":286,"_13":287,"_37":288,"_44":92,"_35":36,"_47":289,"_57":58,"_45":290,"_17":70,"_41":24,"_39":291,"_60":61,"_49":-5,"_62":538,"_18":539},{"_33":278,"_13":279,"_37":280,"_44":92,"_35":36,"_47":281,"_57":58,"_45":282,"_17":93,"_41":24,"_39":283,"_60":61,"_49":-5,"_62":536,"_18":537},{"_33":270,"_13":271,"_37":272,"_44":92,"_35":36,"_47":273,"_57":58,"_45":274,"_17":70,"_41":24,"_39":275,"_60":61,"_49":-5,"_62":534,"_18":535},{"_33":262,"_13":263,"_37":264,"_44":92,"_35":36,"_47":265,"_57":58,"_45":266,"_17":70,"_41":24,"_39":267,"_60":61,"_49":-5,"_62":532,"_18":533},{"_33":254,"_13":255,"_37":256,"_44":92,"_35":36,"_47":257,"_57":58,"_45":258,"_17":128,"_41":24,"_39":259,"_60":61,"_49":-5,"_62":530,"_18":531},{"_33":246,"_13":247,"_37":248,"_44":92,"_35":36,"_47":249,"_57":58,"_45":250,"_17":70,"_41":24,"_39":251,"_60":61,"_49":-5,"_62":528,"_18":529},{"_33":238,"_13":239,"_37":240,"_44":92,"_35":36,"_47":241,"_57":58,"_45":242,"_17":70,"_41":24,"_39":243,"_60":61,"_49":-5,"_62":526,"_18":527},{"_33":230,"_13":231,"_37":232,"_44":92,"_35":36,"_47":233,"_57":58,"_45":234,"_17":93,"_41":24,"_39":235,"_60":61,"_49":-5,"_62":524,"_18":525},{"_33":222,"_13":223,"_37":224,"_44":92,"_35":36,"_47":225,"_57":58,"_45":226,"_17":93,"_41":24,"_39":227,"_60":61,"_49":-5,"_62":522,"_18":523},{"_33":213,"_13":214,"_37":215,"_44":92,"_35":36,"_47":216,"_57":58,"_45":217,"_17":218,"_41":24,"_39":219,"_60":61,"_49":-5,"_62":520,"_18":521},{"_33":205,"_13":206,"_37":207,"_44":92,"_35":36,"_47":208,"_57":58,"_45":209,"_17":70,"_41":24,"_39":210,"_60":61,"_49":-5,"_62":518,"_18":519},{"_33":197,"_13":198,"_37":199,"_44":92,"_35":36,"_47":200,"_57":58,"_45":201,"_17":128,"_41":24,"_39":202,"_60":61,"_49":-5,"_62":516,"_18":517},{"_33":189,"_13":190,"_37":191,"_44":92,"_35":36,"_47":192,"_57":58,"_45":193,"_17":70,"_41":24,"_39":194,"_60":61,"_49":-5,"_62":514,"_18":515},{"_33":180,"_13":181,"_37":182,"_44":92,"_35":36,"_47":183,"_57":58,"_45":184,"_17":185,"_41":24,"_39":186,"_60":61,"_49":-5,"_62":512,"_18":513},{"_33":172,"_13":173,"_37":174,"_44":92,"_35":36,"_47":175,"_57":58,"_45":176,"_17":128,"_41":24,"_39":177,"_60":61,"_49":-5,"_62":510,"_18":511},{"_33":164,"_13":165,"_37":166,"_44":92,"_35":36,"_47":167,"_57":58,"_45":168,"_17":70,"_41":24,"_39":169,"_60":61,"_49":-5,"_62":508,"_18":509},{"_33":156,"_13":157,"_37":158,"_44":92,"_35":36,"_47":159,"_57":58,"_45":160,"_17":70,"_41":24,"_39":161,"_60":61,"_49":-5,"_62":506,"_18":507},{"_33":148,"_13":149,"_37":150,"_44":92,"_35":36,"_47":151,"_57":58,"_45":152,"_17":70,"_41":24,"_39":153,"_60":61,"_49":-5,"_62":504,"_18":505},{"_33":140,"_13":141,"_37":142,"_44":92,"_35":36,"_47":143,"_57":58,"_45":144,"_17":128,"_41":24,"_39":145,"_60":61,"_49":-5,"_62":502,"_18":503},{"_33":132,"_13":133,"_37":134,"_44":92,"_35":36,"_47":135,"_57":58,"_45":136,"_17":128,"_41":24,"_39":137,"_60":61,"_49":-5,"_62":500,"_18":501},{"_33":123,"_13":124,"_37":125,"_44":92,"_35":36,"_47":126,"_57":58,"_45":127,"_17":128,"_41":24,"_39":129,"_60":61,"_49":-5,"_62":498,"_18":499},{"_33":82,"_13":83,"_37":84,"_44":-5,"_35":36,"_47":85,"_57":58,"_45":86,"_17":70,"_41":24,"_39":87,"_60":61,"_49":-5,"_62":496,"_18":497},{"_33":74,"_13":75,"_37":76,"_44":-5,"_35":36,"_47":77,"_57":58,"_45":78,"_17":70,"_41":24,"_39":79,"_60":61,"_49":-5,"_62":494,"_18":495},{"_33":65,"_13":66,"_37":67,"_44":-5,"_35":36,"_47":68,"_57":58,"_45":69,"_17":70,"_41":24,"_39":71,"_60":61,"_49":-5,"_62":492,"_18":493},{"_33":34,"_13":19,"_37":38,"_44":-5,"_35":36,"_47":48,"_57":58,"_45":59,"_17":43,"_41":42,"_39":40,"_60":61,"_49":-5,"_62":490,"_18":491},[],[19],[],[66],[],[75],[],[83],[],[91,124],[],[91,133],[],[91,141],[],[91,149],[],[91,157],[],[91,165],[],[91,173],[],[91,181],[],[91,190],[],[91,198],[],[91,206],[],[91,214],[],[91,223],[],[91,231],[],[91,239],[],[91,247],[],[91,255],[],[91,263],[],[91,271],[],[91,279],[],[91,287],[],[91,295],[],[91,303],[],[91,311],[],[91,319],[461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485],[91],[],[327,337],[],[327,346],[],[327,354],[],[327,363],[456,457,458,459],[327],["D",1788084579215],{"_11":12,"_424":420},{"_11":12,"_417":418,"_419":420,"_380":381,"_421":422,"_423":61},{"_17":356,"_13":16,"_33":36,"_409":370,"_410":-5,"_411":-5,"_412":-5,"_413":-5,"_414":-5,"_415":14,"_416":12},"ctx",{"_402":-5,"_441":597,"_598":599,"_600":601,"_602":61,"_603":61,"_604":61,"_605":58,"_606":-5,"_607":-7,"_608":-7,"_609":70,"_610":61,"_611":61,"_612":-5,"_613":61,"_614":61,"_615":61,"_616":-5},"ENV",{"_568":569,"_570":571,"_572":16,"_573":574,"_575":576,"_577":578,"_579":580,"_581":582,"_583":584,"_585":586,"_587":588,"_589":590,"_591":592,"_593":594,"_595":596},"REACT_APP_SENTRY_DSN","https://586020d86f05489db63a554690acf1e9@o1398359.ingest.sentry.io/6724499","RENDER_GIT_COMMIT","e87eb04e707cf64e7e532c8e8ec395f209e17f15","RENDER_GIT_BRANCH","POSTHOG_API_TOKEN","phc_nmoyuAkStEZuUp69rYlg1DZgrIt19Gx0Y4Hwf8tGgJP","POSTHOG_API_HOST","https://wart.val.town","WEB_API_TEMPLATE","https://{val}.web.val.run","APP_URL","https://www.val.town","MODULE_URL","https://esm.town","VANITY_WEB_API_TEMPLATE","https://{label}.val.run/","DENOLS_URL","https://lsp.val.town","NODE_ENV","production","CLOUDFLARE_TURNSTILE_SITE_KEY","0x4AAAAAACtaIZJH7s9rBMZ6","GOOGLE_CLIENT_ID","875989696899-jtsqkhlbdv5jrlsk8631p7ipjg3c6o62.apps.googleusercontent.com","STRIPE_PUBLISHABLE_KEY","pk_live_51N2zvWEpZTTLipIkVEwXrUG9AT0yeOOEYxszarZT1jpsZV58Ly6wlg3SltZpHN26CUalOBmUSY7adQRQiSkCZz2500qSXNkf8Y","API_URL","https://api.val.town",[],"preferencesKeybindings","default","preferencesTheme","light","preferencesFixers","preferencesCopilot","preferencesSelectionAi","preferencesCloseBrackets","preferencesChatPanelState","preferencesDprint","preferencesDenofmt","notificationCount","flagDenols","isBusinessOrgMember","businessOrgHandle","isBusinessOrgAdmin","isHigherTownieTier","navCollapsed","currentOrgId"]