update htmx to latest in 2.x branch

Cargo.lock

@@ -1772,7 +1772,7 @@ checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
 
 [[package]]
 name = "sustenance"
-version = "0.2.0"
+version = "0.4.0"
 dependencies = [
  "argon2",
  "async-trait",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sustenance"
-version = "0.2.0"
+version = "0.4.0"
 edition = "2024"
 
 [dependencies]

e2e/tests/add-meal.spec.ts

@@ -52,3 +52,47 @@ test("the add-meal picker closes when clicking outside", async ({ page }) => {
   await page.mouse.click(10, 10);
   await expect(picker).toHaveCount(0);
 });
+
+test("a meal added to a list is shown in the meals panel", async ({ page }) => {
+  await registerAndLogin(page, "alice@example.com");
+  await createMealWithIngredients(page, "Spaghetti Bolognese", [
+    { name: "Penne", quantity: "500g" },
+    { name: "Tomato", quantity: "2" },
+  ]);
+  await createList(page, "Weekly shop");
+
+  await page.click(".add-meal-button");
+  const picker = page.locator(".meal-picker-backdrop");
+  await picker.locator(".meal-picker-button").filter({ hasText: "Spaghetti Bolognese" }).click();
+
+  // The meal appears in the "Meals on this list" panel.
+  const panel = page.locator("#list-meals-panel");
+  await expect(panel).toBeVisible();
+  await expect(panel.locator(".list-meal-row").filter({ hasText: "Spaghetti Bolognese" })).toBeVisible();
+});
+
+test("removing a meal from a list removes its ingredients", async ({ page }) => {
+  await registerAndLogin(page, "alice@example.com");
+  await createMealWithIngredients(page, "Spaghetti Bolognese", [
+    { name: "Penne", quantity: "500g" },
+    { name: "Tomato", quantity: "2" },
+  ]);
+  await createList(page, "Weekly shop");
+
+  await page.click(".add-meal-button");
+  const picker = page.locator(".meal-picker-backdrop");
+  await picker.locator(".meal-picker-button").filter({ hasText: "Spaghetti Bolognese" }).click();
+
+  await expect(page.locator(".item-row").filter({ hasText: "Penne" })).toBeVisible();
+  await expect(page.locator(".item-row").filter({ hasText: "Tomato" })).toBeVisible();
+
+  // Remove the meal from the list.
+  const panel = page.locator("#list-meals-panel");
+  const row = panel.locator(".list-meal-row").filter({ hasText: "Spaghetti Bolognese" });
+  await row.locator(".list-meal-remove-button").click();
+
+  // The meal's ingredients are removed from the list.
+  await expect(page.locator(".item-row").filter({ hasText: "Penne" })).toHaveCount(0);
+  await expect(page.locator(".item-row").filter({ hasText: "Tomato" })).toHaveCount(0);
+  await expect(row).toHaveCount(0);
+});

e2e/tests/archive.spec.ts

@@ -0,0 +1,83 @@
+import { expect } from "@playwright/test";
+import { test } from "../fixtures";
+import { registerAndLogin, createList, addItem } from "../helpers";
+
+test("a user can archive a list and it moves to the archive page", async ({ page }) => {
+  await registerAndLogin(page, "alice@example.com");
+  await createList(page, "Weekly shop");
+
+  // Archive from the list page.
+  await page.click('button:has-text("Archive")');
+
+  // Lands back on the lists page; the list is no longer shown.
+  await expect(page).toHaveURL(/\/lists/);
+  await expect(page.locator(".list-card").filter({ hasText: "Weekly shop" })).toHaveCount(0);
+
+  // The archived list is reachable from the archive page.
+  await page.goto("/archive");
+  await expect(page.locator(".list-card").filter({ hasText: "Weekly shop" })).toBeVisible();
+});
+
+test("the lists frame links to the archive page", async ({ page }) => {
+  await registerAndLogin(page, "alice@example.com");
+  await createList(page, "Weekly shop");
+  await page.goto("/lists");
+
+  await page.click('a.archive-link');
+  await expect(page).toHaveURL(/\/archive/);
+});
+
+test("an archived list is read-only", async ({ page }) => {
+  await registerAndLogin(page, "alice@example.com");
+  await createList(page, "Weekly shop");
+  await addItem(page, "Apple");
+  await page.click('button:has-text("Archive")');
+
+  // Open the archived list directly.
+  await page.goto("/archive");
+  await page.locator(".list-card").filter({ hasText: "Weekly shop" }).click();
+  await expect(page).toHaveURL(/\/lists\/\d+/);
+
+  // The item is still visible.
+  await expect(page.locator(".item-row").filter({ hasText: "Apple" })).toBeVisible();
+
+  // No mutation UI is present.
+  await expect(page.locator("#add-item-form")).toHaveCount(0);
+  await expect(page.locator(".item-actions-button")).toHaveCount(0);
+  await expect(page.locator(".check-form")).toHaveCount(0);
+  await expect(page.locator('button:has-text("+ Add meal")')).toHaveCount(0);
+});
+
+test("a user can restore an archived list and edit it again", async ({ page }) => {
+  await registerAndLogin(page, "alice@example.com");
+  await createList(page, "Weekly shop");
+  await addItem(page, "Apple");
+  await page.click('button:has-text("Archive")');
+
+  // Open the archived list and restore it.
+  await page.goto("/archive");
+  await page.locator(".list-card").filter({ hasText: "Weekly shop" }).click();
+  await page.click('button:has-text("Restore")');
+
+  // Back on the lists page, the list is active again.
+  await expect(page).toHaveURL(/\/lists/);
+  await expect(page.locator(".list-card").filter({ hasText: "Weekly shop" })).toBeVisible();
+
+  // The list is editable again.
+  await page.locator(".list-card").filter({ hasText: "Weekly shop" }).click();
+  await expect(page.locator("#add-item-form")).toBeVisible();
+  await addItem(page, "Banana");
+  await expect(page.locator(".item-row").filter({ hasText: "Banana" })).toBeVisible();
+});
+
+test("the archive page shows the list name and created date", async ({ page }) => {
+  await registerAndLogin(page, "alice@example.com");
+  await createList(page, "Weekly shop");
+  await page.click('button:has-text("Archive")');
+
+  await page.goto("/archive");
+  const card = page.locator(".list-card").filter({ hasText: "Weekly shop" });
+  await expect(card).toBeVisible();
+  // The card shows a created date (e.g. "Created 7 Aug 2026").
+  await expect(card.locator("small")).toContainText("Created");
+});

e2e/tests/lists.spec.ts

@@ -84,6 +84,8 @@ test("a user can add a category", async ({ page }) => {
   await registerAndLogin(page, "alice@example.com");
   await createList(page, "Weekly shop");
 
+  // Categories are managed from the main lists page.
+  await page.goto("/lists");
   await page.fill("#category-name", "Bakery");
   await page.click("#add-category-button");
 

e2e/tests/meals.spec.ts

@@ -32,6 +32,7 @@ test("a user can delete a meal", async ({ page }) => {
   await registerAndLogin(page, "alice@example.com");
   await createMeal(page, "Spaghetti Bolognese", "");
 
+  page.on("dialog", (dialog) => dialog.accept());
   await page.click('button:has-text("Delete")');
   await expect(page).toHaveURL(/\/meals$/);
   await expect(page.locator(".list-card").filter({ hasText: "Spaghetti Bolognese" })).toHaveCount(0);

migrations/20240103000000_list_meals.sql

@@ -0,0 +1,12 @@
+CREATE TABLE list_meals (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    list_id INTEGER NOT NULL REFERENCES lists(id) ON DELETE CASCADE,
+    meal_id INTEGER REFERENCES meals(id) ON DELETE SET NULL,
+    name TEXT NOT NULL,
+    created_at INTEGER NOT NULL
+);
+
+ALTER TABLE items ADD COLUMN list_meal_id INTEGER REFERENCES list_meals(id) ON DELETE CASCADE;
+
+CREATE INDEX list_meals_list_idx ON list_meals(list_id);
+CREATE INDEX items_list_meal_idx ON items(list_meal_id);

migrations/20240104000000_archive_lists.sql

@@ -0,0 +1 @@
+ALTER TABLE lists ADD COLUMN archived_at INTEGER;

src/domain.rs

@@ -31,6 +31,9 @@ pub struct Passkey {
     pub user_id: i64,
     pub credential_id: String,
     pub credential: String,
+    /// WebAuthn sign counter, persisted for future cloned-authenticator
+    /// detection. Not currently read by application logic.
+    #[allow(dead_code)]
     pub counter: i64,
 }
 
@@ -45,6 +48,10 @@ pub struct GroceryList {
     pub id: i64,
     pub name: String,
     pub revision: i64,
+    /// Unix timestamp of when the list was created.
+    pub created_at: i64,
+    /// Unix timestamp of when the list was archived; `None` when active.
+    pub archived_at: Option<i64>,
 }
 
 #[derive(Clone, Debug)]
@@ -89,6 +96,18 @@ pub struct MealIngredient {
     pub category_id: Option<i64>,
 }
 
+#[derive(Clone, Debug)]
+pub struct ListMeal {
+    pub id: i64,
+    /// The catalog meal this instance came from; `None` once the meal is deleted.
+    #[allow(dead_code)]
+    pub meal_id: Option<i64>,
+    pub name: String,
+    /// When the meal was added to the list.
+    #[allow(dead_code)]
+    pub created_at: i64,
+}
+
 #[derive(Clone, Debug)]
 pub struct PresenceUser {
     pub user_id: i64,

src/http.rs

@@ -14,6 +14,7 @@ use axum::{
     routing::{get, post},
 };
 use futures_util::{SinkExt, StreamExt};
+use maud::PreEscaped;
 use serde::{Deserialize, de::DeserializeOwned};
 use thiserror::Error;
 use tower_http::trace::{DefaultMakeSpan, DefaultOnResponse, TraceLayer};
@@ -52,6 +53,8 @@ pub enum AppError {
     BadRequest(String),
     #[error("not found")]
     NotFound,
+    #[error("list is archived")]
+    Archived,
 }
 
 impl IntoResponse for AppError {
@@ -71,6 +74,10 @@ impl IntoResponse for AppError {
                 StatusCode::NOT_FOUND,
                 views::error_page("404", "That page could not be found."),
             ),
+            AppError::Archived => status_html_response(
+                StatusCode::CONFLICT,
+                views::error_page("409", "This list is archived and cannot be modified."),
+            ),
         }
     }
 }
@@ -95,7 +102,10 @@ pub fn build_router(state: AppState) -> Router {
         )
         .route("/account/password", post(change_password))
         .route("/lists", get(lists_page).post(create_list))
+        .route("/archive", get(archive_page))
         .route("/lists/{list_id}", get(list_page))
+        .route("/lists/{list_id}/archive", post(archive_list))
+        .route("/lists/{list_id}/unarchive", post(unarchive_list))
         .route("/lists/{list_id}/items", post(add_item))
         .route("/lists/{list_id}/items/{item_id}/check", post(check_item))
         .route("/lists/{list_id}/items/{item_id}/edit", post(edit_item))
@@ -105,7 +115,10 @@ pub fn build_router(state: AppState) -> Router {
         .route("/meals", get(meals_page).post(create_meal))
         .route("/meals/new", get(new_meal_page))
         .route("/meals/categories", post(create_meal_category))
-        .route("/meals/categories/{category_id}/delete", post(delete_meal_category))
+        .route(
+            "/meals/categories/{category_id}/delete",
+            post(delete_meal_category),
+        )
         .route("/meals/{meal_id}", get(meal_page))
         .route("/meals/{meal_id}/edit", post(edit_meal))
         .route("/meals/{meal_id}/delete", post(delete_meal))
@@ -119,6 +132,10 @@ pub fn build_router(state: AppState) -> Router {
             post(delete_ingredient),
         )
         .route("/lists/{list_id}/add-meal", post(add_meal_to_list))
+        .route(
+            "/lists/{list_id}/meals/{list_meal_id}/remove",
+            post(remove_meal_from_list),
+        )
         .route("/lists/{list_id}/stream", get(list_stream))
         .route("/invite/{token}", get(invitation_page))
         .route("/invite/{token}/accept", post(accept_invitation))
@@ -485,7 +502,10 @@ async fn change_password(
     };
 
     if form.new_password != form.confirm_password {
-        return Ok(render(Some("New password and confirmation do not match."), false));
+        return Ok(render(
+            Some("New password and confirmation do not match."),
+            false,
+        ));
     }
 
     state
@@ -583,13 +603,28 @@ async fn lists_page(
     user: CurrentUser,
 ) -> Result<Response, AppError> {
     let lists = state.lists.list_summaries().await?;
+    let archived = state.lists.list_archived_summaries().await?;
+    let categories = state.lists.categories().await?;
     Ok(html_response(views::lists_page(
         &user.session.user,
         &lists,
+        archived.len(),
+        &categories,
         &user.session.csrf_token,
     )))
 }
 
+async fn archive_page(
+    State(state): State<AppState>,
+    user: CurrentUser,
+) -> Result<Response, AppError> {
+    let archived_lists = state.lists.list_archived_summaries().await?;
+    Ok(html_response(views::archive_page(
+        &user.session.user,
+        &archived_lists,
+    )))
+}
+
 async fn create_list(
     State(state): State<AppState>,
     user: CurrentUser,
@@ -614,17 +649,43 @@ async fn list_page(
     let access = require_list(&state, list_id).await?;
     let items = state.lists.items(list_id).await?;
     let categories = state.lists.categories().await?;
+    let list_meals = state.meals.list_meals_on_list(list_id).await?;
     let presence = state.realtime.presence(list_id).await;
     Ok(html_response(views::list_page(
         &user.session.user,
         &access,
         &items,
         &categories,
+        &list_meals,
         &presence,
         &user.session.csrf_token,
     )))
 }
 
+async fn archive_list(
+    State(state): State<AppState>,
+    user: CurrentUser,
+    Path(list_id): Path<i64>,
+    LoggedForm(form): LoggedForm<CsrfForm>,
+) -> Result<Response, AppError> {
+    verify_csrf(&user, &form.csrf)?;
+    require_list(&state, list_id).await?;
+    state.lists.archive_list(list_id).await?;
+    Ok(Redirect::to("/lists").into_response())
+}
+
+async fn unarchive_list(
+    State(state): State<AppState>,
+    user: CurrentUser,
+    Path(list_id): Path<i64>,
+    LoggedForm(form): LoggedForm<CsrfForm>,
+) -> Result<Response, AppError> {
+    verify_csrf(&user, &form.csrf)?;
+    require_list(&state, list_id).await?;
+    state.lists.unarchive_list(list_id).await?;
+    Ok(Redirect::to("/lists").into_response())
+}
+
 async fn add_item(
     State(state): State<AppState>,
     user: CurrentUser,
@@ -632,7 +693,7 @@ async fn add_item(
     LoggedForm(form): LoggedForm<ItemForm>,
 ) -> Result<Response, AppError> {
     verify_csrf(&user, &form.csrf)?;
-    require_list(&state, list_id).await?;
+    require_mutable_list(&state, list_id).await?;
     let name = form.name.trim().to_owned();
     let quantity = form.quantity.trim().to_owned();
     let note = form.note.trim().to_owned();
@@ -656,7 +717,7 @@ async fn check_item(
     LoggedForm(form): LoggedForm<CheckForm>,
 ) -> Result<Response, AppError> {
     verify_csrf(&user, &form.csrf)?;
-    require_list(&state, list_id).await?;
+    require_mutable_list(&state, list_id).await?;
     let checked = match form.checked.as_str() {
         "1" | "true" => true,
         "0" | "false" => false,
@@ -676,7 +737,7 @@ async fn edit_item(
     LoggedForm(form): LoggedForm<ItemForm>,
 ) -> Result<Response, AppError> {
     verify_csrf(&user, &form.csrf)?;
-    require_list(&state, list_id).await?;
+    require_mutable_list(&state, list_id).await?;
     let name = form.name.trim().to_owned();
     if name.is_empty() || name.chars().count() > 120 {
         return Err(AppError::BadRequest(
@@ -704,7 +765,7 @@ async fn delete_item(
     LoggedForm(form): LoggedForm<CsrfForm>,
 ) -> Result<Response, AppError> {
     verify_csrf(&user, &form.csrf)?;
-    require_list(&state, list_id).await?;
+    require_mutable_list(&state, list_id).await?;
     state.lists.delete_item(list_id, item_id).await?;
     list_fragment_response(&state, &user, list_id).await
 }
@@ -942,11 +1003,26 @@ async fn add_meal_to_list(
     LoggedForm(form): LoggedForm<AddMealForm>,
 ) -> Result<Response, AppError> {
     verify_csrf(&user, &form.csrf)?;
-    require_list(&state, list_id).await?;
+    require_mutable_list(&state, list_id).await?;
     state.meals.add_meal_to_list(form.meal_id, list_id).await?;
     list_fragment_response(&state, &user, list_id).await
 }
 
+async fn remove_meal_from_list(
+    State(state): State<AppState>,
+    user: CurrentUser,
+    Path((list_id, list_meal_id)): Path<(i64, i64)>,
+    LoggedForm(form): LoggedForm<CsrfForm>,
+) -> Result<Response, AppError> {
+    verify_csrf(&user, &form.csrf)?;
+    require_mutable_list(&state, list_id).await?;
+    state
+        .meals
+        .remove_meal_from_list(list_id, list_meal_id)
+        .await?;
+    list_fragment_response(&state, &user, list_id).await
+}
+
 async fn create_invitation(
     State(state): State<AppState>,
     user: CurrentUser,
@@ -1111,11 +1187,16 @@ async fn websocket_snapshot(
     let access = require_list(state, list_id).await?;
     let items = state.lists.items(list_id).await?;
     let categories = state.lists.categories().await?;
-    Ok(
-        views::live_list_fragments(&access, &items, &categories, &user.session.csrf_token)
-            .into_string()
-            + &views::presence_panel(presence, true).into_string(),
+    let list_meals = state.meals.list_meals_on_list(list_id).await?;
+    Ok(views::live_list_fragments(
+        &access,
+        &items,
+        &categories,
+        &list_meals,
+        &user.session.csrf_token,
     )
+    .into_string()
+        + &views::presence_panel(presence, true).into_string())
 }
 
 async fn websocket_list_update(
@@ -1126,10 +1207,15 @@ async fn websocket_list_update(
     let access = require_list(state, list_id).await?;
     let items = state.lists.items(list_id).await?;
     let categories = state.lists.categories().await?;
-    Ok(
-        views::live_list_fragments(&access, &items, &categories, &user.session.csrf_token)
-            .into_string(),
+    let list_meals = state.meals.list_meals_on_list(list_id).await?;
+    Ok(views::live_list_fragments(
+        &access,
+        &items,
+        &categories,
+        &list_meals,
+        &user.session.csrf_token,
     )
+    .into_string())
 }
 
 async fn list_fragment_response(
@@ -1140,12 +1226,26 @@ async fn list_fragment_response(
     let access = require_list(state, list_id).await?;
     let items = state.lists.items(list_id).await?;
     let categories = state.lists.categories().await?;
-    Ok(html_response(views::list_items_fragment(
-        &access,
-        &items,
-        &categories,
-        &user.session.csrf_token,
-        false,
+    let list_meals = state.meals.list_meals_on_list(list_id).await?;
+    let editable = access.archived_at.is_none();
+    Ok(html_response(PreEscaped(
+        views::list_items_fragment(
+            &access,
+            &items,
+            &categories,
+            &user.session.csrf_token,
+            false,
+            editable,
+        )
+        .into_string()
+            + &views::list_meals_panel(
+                &list_meals,
+                list_id,
+                &user.session.csrf_token,
+                true,
+                editable,
+            )
+            .into_string(),
     )))
 }
 
@@ -1160,6 +1260,19 @@ async fn require_list(
         .ok_or(AppError::NotFound)
 }
 
+/// Like [`require_list`], but also rejects archived lists so they stay
+/// immutable until restored.
+async fn require_mutable_list(
+    state: &AppState,
+    list_id: i64,
+) -> Result<crate::domain::GroceryList, AppError> {
+    let list = require_list(state, list_id).await?;
+    if list.archived_at.is_some() {
+        return Err(AppError::Archived);
+    }
+    Ok(list)
+}
+
 async fn optional_user(
     state: &AppState,
     headers: &HeaderMap,

src/main.rs

@@ -19,7 +19,7 @@ use tracing::{info, warn};
 use crate::http::{AppState, build_router};
 use crate::hub::InMemoryHub;
 use crate::ports::{
-    CategoryRepository, InvitationRepository, ItemRepository, ListRepository,
+    CategoryRepository, InvitationRepository, ItemRepository, ListMealRepository, ListRepository,
     MealCategoryRepository, MealIngredientRepository, MealRepository, PasskeyRepository,
     PasswordHasher, RealtimeNotifier, SessionRepository, TokenGenerator, UserRepository,
 };
@@ -27,8 +27,9 @@ use crate::security::{Argon2PasswordHasher, RandomTokenGenerator};
 use crate::services::{AuthService, InvitationService, ListService, MealService, RegistrationMode};
 use crate::sqlite::{
     SqliteCategoryRepository, SqliteDatabase, SqliteInvitationRepository, SqliteItemRepository,
-    SqliteListRepository, SqliteMealCategoryRepository, SqliteMealIngredientRepository,
-    SqliteMealRepository, SqlitePasskeyRepository, SqliteSessionRepository, SqliteUserRepository,
+    SqliteListMealRepository, SqliteListRepository, SqliteMealCategoryRepository,
+    SqliteMealIngredientRepository, SqliteMealRepository, SqlitePasskeyRepository,
+    SqliteSessionRepository, SqliteUserRepository,
 };
 use crate::webauthn::{AppWebauthnConfig, WebAuthnService};
 
@@ -74,6 +75,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let lists: Arc<dyn ListRepository> = Arc::new(SqliteListRepository);
     let categories: Arc<dyn CategoryRepository> = Arc::new(SqliteCategoryRepository);
     let items: Arc<dyn ItemRepository> = Arc::new(SqliteItemRepository);
+    let list_meals: Arc<dyn ListMealRepository> = Arc::new(SqliteListMealRepository);
     let meals: Arc<dyn MealRepository> = Arc::new(SqliteMealRepository);
     let meal_ingredients: Arc<dyn MealIngredientRepository> =
         Arc::new(SqliteMealIngredientRepository);
@@ -111,6 +113,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         Arc::clone(&meal_categories),
         Arc::clone(&lists),
         Arc::clone(&items),
+        Arc::clone(&list_meals),
         Arc::clone(&realtime),
     ));
 

src/ports.rs

@@ -2,8 +2,8 @@ use async_trait::async_trait;
 use sqlx::SqliteConnection;
 
 use crate::domain::{
-    Category, DomainResult, GroceryList, Item, Meal, MealCategory, MealIngredient, Passkey,
-    PresenceUser, SessionUser, User,
+    Category, DomainResult, GroceryList, Item, ListMeal, Meal, MealCategory, MealIngredient,
+    Passkey, PresenceUser, SessionUser, User,
 };
 
 /// Repositories take `&mut SqliteConnection` (which a `Transaction` derefs to),
@@ -88,6 +88,10 @@ pub trait SessionRepository: Send + Sync {
 #[async_trait]
 pub trait ListRepository: Send + Sync {
     async fn list_summaries(&self, txn: &mut SqliteConnection) -> DomainResult<Vec<GroceryList>>;
+    async fn list_archived_summaries(
+        &self,
+        txn: &mut SqliteConnection,
+    ) -> DomainResult<Vec<GroceryList>>;
     async fn create_list(
         &self,
         txn: &mut SqliteConnection,
@@ -98,6 +102,12 @@ pub trait ListRepository: Send + Sync {
         txn: &mut SqliteConnection,
         list_id: i64,
     ) -> DomainResult<Option<GroceryList>>;
+    async fn set_archived(
+        &self,
+        txn: &mut SqliteConnection,
+        list_id: i64,
+        archived: bool,
+    ) -> DomainResult<()>;
 }
 
 #[async_trait]
@@ -113,6 +123,9 @@ pub struct NewItem {
     pub quantity: String,
     pub note: String,
     pub category_id: Option<i64>,
+    /// When set, links this item to the `list_meals` row it came from, so the
+    /// item is removed together with that meal instance.
+    pub list_meal_id: Option<i64>,
 }
 
 #[async_trait]
@@ -158,6 +171,28 @@ pub trait ItemRepository: Send + Sync {
     ) -> DomainResult<i64>;
 }
 
+#[async_trait]
+pub trait ListMealRepository: Send + Sync {
+    async fn list_meals(
+        &self,
+        txn: &mut SqliteConnection,
+        list_id: i64,
+    ) -> DomainResult<Vec<ListMeal>>;
+    async fn add_meal(
+        &self,
+        txn: &mut SqliteConnection,
+        list_id: i64,
+        meal_id: i64,
+        name: String,
+    ) -> DomainResult<i64>;
+    async fn remove_meal(
+        &self,
+        txn: &mut SqliteConnection,
+        list_id: i64,
+        list_meal_id: i64,
+    ) -> DomainResult<i64>;
+}
+
 #[async_trait]
 pub trait InvitationRepository: Send + Sync {
     async fn create_invitation(

src/services.rs

@@ -1,10 +1,10 @@
 use std::sync::Arc;
 
 use crate::domain::{
-    DomainError, DomainResult, GroceryList, Item, Meal, MealCategory, SessionUser, User,
+    DomainError, DomainResult, GroceryList, Item, ListMeal, Meal, MealCategory, SessionUser, User,
 };
 use crate::ports::{
-    CategoryRepository, InvitationRepository, ItemRepository, ListRepository,
+    CategoryRepository, InvitationRepository, ItemRepository, ListMealRepository, ListRepository,
     MealCategoryRepository, MealIngredientRepository, MealRepository, NewItem, PasswordHasher,
     RealtimeNotifier, SessionRepository, TokenGenerator, UserRepository,
 };
@@ -199,6 +199,13 @@ impl ListService {
             .await
     }
 
+    pub async fn list_archived_summaries(&self) -> DomainResult<Vec<GroceryList>> {
+        let lists = Arc::clone(&self.lists);
+        self.db
+            .run(move |txn| Box::pin(async move { lists.list_archived_summaries(txn).await }))
+            .await
+    }
+
     pub async fn create_list(&self, name: String) -> DomainResult<GroceryList> {
         let lists = Arc::clone(&self.lists);
         self.db
@@ -213,6 +220,20 @@ impl ListService {
             .await
     }
 
+    pub async fn archive_list(&self, list_id: i64) -> DomainResult<()> {
+        let lists = Arc::clone(&self.lists);
+        self.db
+            .run(move |txn| Box::pin(async move { lists.set_archived(txn, list_id, true).await }))
+            .await
+    }
+
+    pub async fn unarchive_list(&self, list_id: i64) -> DomainResult<()> {
+        let lists = Arc::clone(&self.lists);
+        self.db
+            .run(move |txn| Box::pin(async move { lists.set_archived(txn, list_id, false).await }))
+            .await
+    }
+
     pub async fn items(&self, list_id: i64) -> DomainResult<Vec<Item>> {
         let items = Arc::clone(&self.items);
         self.db
@@ -318,6 +339,7 @@ pub struct MealService {
     meal_categories: Arc<dyn MealCategoryRepository>,
     lists: Arc<dyn ListRepository>,
     items: Arc<dyn ItemRepository>,
+    list_meals: Arc<dyn ListMealRepository>,
     realtime: Arc<dyn RealtimeNotifier>,
 }
 
@@ -329,6 +351,7 @@ impl MealService {
         meal_categories: Arc<dyn MealCategoryRepository>,
         lists: Arc<dyn ListRepository>,
         items: Arc<dyn ItemRepository>,
+        list_meals: Arc<dyn ListMealRepository>,
         realtime: Arc<dyn RealtimeNotifier>,
     ) -> Self {
         Self {
@@ -338,6 +361,7 @@ impl MealService {
             meal_categories,
             lists,
             items,
+            list_meals,
             realtime,
         }
     }
@@ -351,9 +375,9 @@ impl MealService {
         let meals = Arc::clone(&self.meals);
         self.db
             .run(move |txn| {
-                Box::pin(async move {
-                    meals.create_meal(txn, name, description, category_id).await
-                })
+                Box::pin(
+                    async move { meals.create_meal(txn, name, description, category_id).await },
+                )
             })
             .await
     }
@@ -411,7 +435,9 @@ impl MealService {
         let meal_categories = Arc::clone(&self.meal_categories);
         self.db
             .run(move |txn| {
-                Box::pin(async move { meal_categories.delete_meal_category(txn, category_id).await })
+                Box::pin(
+                    async move { meal_categories.delete_meal_category(txn, category_id).await },
+                )
             })
             .await
     }
@@ -486,11 +512,12 @@ impl MealService {
     }
 
     /// Expands a meal's ingredients into items on a list in one unit of work,
-    /// bumping the list revision exactly once.
+    /// recording the meal on the list and bumping the list revision exactly once.
     pub async fn add_meal_to_list(&self, meal_id: i64, list_id: i64) -> DomainResult<i64> {
         let meals = Arc::clone(&self.meals);
         let lists = Arc::clone(&self.lists);
         let items = Arc::clone(&self.items);
+        let list_meals = Arc::clone(&self.list_meals);
         let revision = self
             .db
             .run(move |txn| {
@@ -502,6 +529,9 @@ impl MealService {
                     if lists.get_list(txn, list_id).await?.is_none() {
                         return Err(DomainError::NotFound);
                     }
+                    let list_meal_id = list_meals
+                        .add_meal(txn, list_id, meal.id, meal.name.clone())
+                        .await?;
                     let new_items = meal
                         .ingredients
                         .into_iter()
@@ -510,6 +540,7 @@ impl MealService {
                             quantity: ingredient.quantity,
                             note: ingredient.note,
                             category_id: ingredient.category_id,
+                            list_meal_id: Some(list_meal_id),
                         })
                         .collect();
                     items.add_items_bulk(txn, list_id, new_items).await
@@ -519,6 +550,32 @@ impl MealService {
         self.realtime.publish_list_changed(list_id, revision).await;
         Ok(revision)
     }
+
+    /// Lists the meals that have been added to a list, most recent first.
+    pub async fn list_meals_on_list(&self, list_id: i64) -> DomainResult<Vec<ListMeal>> {
+        let list_meals = Arc::clone(&self.list_meals);
+        self.db
+            .run(move |txn| Box::pin(async move { list_meals.list_meals(txn, list_id).await }))
+            .await
+    }
+
+    /// Removes a meal instance from a list, deleting the items that came from it
+    /// and bumping the list revision exactly once.
+    pub async fn remove_meal_from_list(
+        &self,
+        list_id: i64,
+        list_meal_id: i64,
+    ) -> DomainResult<i64> {
+        let list_meals = Arc::clone(&self.list_meals);
+        let revision = self
+            .db
+            .run(move |txn| {
+                Box::pin(async move { list_meals.remove_meal(txn, list_id, list_meal_id).await })
+            })
+            .await?;
+        self.realtime.publish_list_changed(list_id, revision).await;
+        Ok(revision)
+    }
 }
 
 pub struct InvitationService {

src/sqlite.rs

@@ -7,11 +7,11 @@ use sha2::{Digest, Sha256};
 use sqlx::{Connection, Row, SqliteConnection, SqlitePool, sqlite::SqliteConnectOptions};
 
 use crate::domain::{
-    Category, DomainError, DomainResult, GroceryList, Item, Meal, MealCategory, MealIngredient,
-    Passkey, SessionUser, User,
+    Category, DomainError, DomainResult, GroceryList, Item, ListMeal, Meal, MealCategory,
+    MealIngredient, Passkey, SessionUser, User,
 };
 use crate::ports::{
-    CategoryRepository, InvitationRepository, ItemRepository, ListRepository,
+    CategoryRepository, InvitationRepository, ItemRepository, ListMealRepository, ListRepository,
     MealCategoryRepository, MealIngredientRepository, MealRepository, NewItem, PasskeyRepository,
     SessionRepository, UserRepository,
 };
@@ -130,15 +130,13 @@ async fn seed_default_meal_categories(pool: &SqlitePool) -> DomainResult<()> {
         return Ok(());
     }
     for (position, category_name) in DEFAULT_MEAL_CATEGORIES.iter().enumerate() {
-        sqlx::query(
-            "INSERT INTO meal_categories (name, position, created_at) VALUES (?1, ?2, ?3)",
-        )
-        .bind(category_name)
-        .bind(position as i64)
-        .bind(now())
-        .execute(pool)
-        .await
-        .map_err(db_error)?;
+        sqlx::query("INSERT INTO meal_categories (name, position, created_at) VALUES (?1, ?2, ?3)")
+            .bind(category_name)
+            .bind(position as i64)
+            .bind(now())
+            .execute(pool)
+            .await
+            .map_err(db_error)?;
     }
     Ok(())
 }
@@ -444,8 +442,9 @@ pub struct SqliteListRepository;
 impl ListRepository for SqliteListRepository {
     async fn list_summaries(&self, txn: &mut SqliteConnection) -> DomainResult<Vec<GroceryList>> {
         let rows = sqlx::query(
-            "SELECT l.id, l.name, l.revision
+            "SELECT l.id, l.name, l.revision, l.created_at, l.archived_at
              FROM lists l
+             WHERE l.archived_at IS NULL
              ORDER BY l.created_at DESC",
         )
         .fetch_all(&mut *txn)
@@ -457,6 +456,33 @@ impl ListRepository for SqliteListRepository {
                 id: row.get(0),
                 name: row.get(1),
                 revision: row.get(2),
+                created_at: row.get(3),
+                archived_at: row.get(4),
+            })
+            .collect())
+    }
+
+    async fn list_archived_summaries(
+        &self,
+        txn: &mut SqliteConnection,
+    ) -> DomainResult<Vec<GroceryList>> {
+        let rows = sqlx::query(
+            "SELECT l.id, l.name, l.revision, l.created_at, l.archived_at
+             FROM lists l
+             WHERE l.archived_at IS NOT NULL
+             ORDER BY l.archived_at DESC, l.created_at DESC",
+        )
+        .fetch_all(&mut *txn)
+        .await
+        .map_err(db_error)?;
+        Ok(rows
+            .into_iter()
+            .map(|row| GroceryList {
+                id: row.get(0),
+                name: row.get(1),
+                revision: row.get(2),
+                created_at: row.get(3),
+                archived_at: row.get(4),
             })
             .collect())
     }
@@ -481,6 +507,8 @@ impl ListRepository for SqliteListRepository {
             id: list_id,
             name,
             revision: 0,
+            created_at: now(),
+            archived_at: None,
         })
     }
 
@@ -490,7 +518,7 @@ impl ListRepository for SqliteListRepository {
         list_id: i64,
     ) -> DomainResult<Option<GroceryList>> {
         let row = sqlx::query(
-            "SELECT l.id, l.name, l.revision
+            "SELECT l.id, l.name, l.revision, l.created_at, l.archived_at
              FROM lists l
              WHERE l.id = ?1",
         )
@@ -502,8 +530,36 @@ impl ListRepository for SqliteListRepository {
             id: row.get(0),
             name: row.get(1),
             revision: row.get(2),
+            created_at: row.get(3),
+            archived_at: row.get(4),
         }))
     }
+
+    async fn set_archived(
+        &self,
+        txn: &mut SqliteConnection,
+        list_id: i64,
+        archived: bool,
+    ) -> DomainResult<()> {
+        let result = if archived {
+            sqlx::query("UPDATE lists SET archived_at = ?1 WHERE id = ?2")
+                .bind(now())
+                .bind(list_id)
+                .execute(&mut *txn)
+                .await
+                .map_err(db_error)?
+        } else {
+            sqlx::query("UPDATE lists SET archived_at = NULL WHERE id = ?1")
+                .bind(list_id)
+                .execute(&mut *txn)
+                .await
+                .map_err(db_error)?
+        };
+        if result.rows_affected() == 0 {
+            return Err(DomainError::NotFound);
+        }
+        Ok(())
+    }
 }
 
 #[derive(Clone, Copy)]
@@ -642,8 +698,8 @@ impl ItemRepository for SqliteItemRepository {
             ensure_category(txn, item.category_id).await?;
             sqlx::query(
                 "INSERT INTO items
-                 (list_id, name, quantity, note, category_id, checked, version, position, created_at, updated_at)
-                 VALUES (?1, ?2, ?3, ?4, ?5, 0, 1, ?6, ?7, ?7)",
+                 (list_id, name, quantity, note, category_id, checked, version, position, list_meal_id, created_at, updated_at)
+                 VALUES (?1, ?2, ?3, ?4, ?5, 0, 1, ?6, ?7, ?8, ?8)",
             )
             .bind(list_id)
             .bind(&item.name)
@@ -651,6 +707,7 @@ impl ItemRepository for SqliteItemRepository {
             .bind(&item.note)
             .bind(item.category_id)
             .bind(position)
+            .bind(item.list_meal_id)
             .bind(now)
             .execute(&mut *txn)
             .await
@@ -740,6 +797,83 @@ impl ItemRepository for SqliteItemRepository {
     }
 }
 
+#[derive(Clone, Copy)]
+pub struct SqliteListMealRepository;
+
+#[async_trait]
+impl ListMealRepository for SqliteListMealRepository {
+    async fn list_meals(
+        &self,
+        txn: &mut SqliteConnection,
+        list_id: i64,
+    ) -> DomainResult<Vec<ListMeal>> {
+        let rows = sqlx::query(
+            "SELECT id, meal_id, name, created_at
+             FROM list_meals
+             WHERE list_id = ?1
+             ORDER BY created_at ASC, id ASC",
+        )
+        .bind(list_id)
+        .fetch_all(&mut *txn)
+        .await
+        .map_err(db_error)?;
+        Ok(rows
+            .into_iter()
+            .map(|row| ListMeal {
+                id: row.get(0),
+                meal_id: row.get(1),
+                name: row.get(2),
+                created_at: row.get(3),
+            })
+            .collect())
+    }
+
+    async fn add_meal(
+        &self,
+        txn: &mut SqliteConnection,
+        list_id: i64,
+        meal_id: i64,
+        name: String,
+    ) -> DomainResult<i64> {
+        sqlx::query(
+            "INSERT INTO list_meals (list_id, meal_id, name, created_at)
+             VALUES (?1, ?2, ?3, ?4)",
+        )
+        .bind(list_id)
+        .bind(meal_id)
+        .bind(&name)
+        .bind(now())
+        .execute(&mut *txn)
+        .await
+        .map_err(db_error)?;
+        let id = sqlx::query("SELECT last_insert_rowid()")
+            .fetch_one(&mut *txn)
+            .await
+            .map_err(db_error)?
+            .get::<i64, _>(0);
+        Ok(id)
+    }
+
+    async fn remove_meal(
+        &self,
+        txn: &mut SqliteConnection,
+        list_id: i64,
+        list_meal_id: i64,
+    ) -> DomainResult<i64> {
+        let changed = sqlx::query("DELETE FROM list_meals WHERE id = ?1 AND list_id = ?2")
+            .bind(list_meal_id)
+            .bind(list_id)
+            .execute(&mut *txn)
+            .await
+            .map_err(db_error)?
+            .rows_affected();
+        if changed == 0 {
+            return Err(DomainError::NotFound);
+        }
+        bump_revision(txn, list_id).await
+    }
+}
+
 #[derive(Clone, Copy)]
 pub struct SqliteInvitationRepository;
 
@@ -833,11 +967,12 @@ impl MealCategoryRepository for SqliteMealCategoryRepository {
         txn: &mut SqliteConnection,
         name: String,
     ) -> DomainResult<i64> {
-        let position: i64 = sqlx::query("SELECT COALESCE(MAX(position), -1) + 1 FROM meal_categories")
-            .fetch_one(&mut *txn)
-            .await
-            .map_err(db_error)?
-            .get(0);
+        let position: i64 =
+            sqlx::query("SELECT COALESCE(MAX(position), -1) + 1 FROM meal_categories")
+                .fetch_one(&mut *txn)
+                .await
+                .map_err(db_error)?
+                .get(0);
         let result = sqlx::query(
             "INSERT INTO meal_categories (name, position, created_at)
              VALUES (?1, ?2, ?3)",
@@ -1181,14 +1316,8 @@ const DEFAULT_CATEGORIES: &[&str] = &[
     "Household",
 ];
 
-const DEFAULT_MEAL_CATEGORIES: &[&str] = &[
-    "Beef",
-    "Chicken",
-    "Pasta",
-    "Sandwiches",
-    "Salads",
-    "Soups",
-];
+const DEFAULT_MEAL_CATEGORIES: &[&str] =
+    &["Beef", "Chicken", "Pasta", "Sandwiches", "Salads", "Soups"];
 
 fn hash_secret(secret: &str) -> Vec<u8> {
     let mut hasher = Sha256::new();
@@ -1537,6 +1666,85 @@ mod tests {
         assert_eq!(ids, vec![first.id, second.id]);
     }
 
+    #[tokio::test]
+    async fn archiving_a_list_hides_it_from_summaries() {
+        let db = setup().await;
+        let list = create_list(&db, "Weekly shop").await;
+        let lists = SqliteListRepository;
+
+        let list_id = list.id;
+        db.run(move |txn| {
+            let lists = lists.clone();
+            Box::pin(async move { lists.set_archived(txn, list_id, true).await })
+        })
+        .await
+        .unwrap();
+
+        let summaries = db
+            .run(move |txn| {
+                let lists = lists.clone();
+                Box::pin(async move { lists.list_summaries(txn).await })
+            })
+            .await
+            .unwrap();
+        assert!(summaries.is_empty());
+
+        let archived = db
+            .run(move |txn| {
+                let lists = lists.clone();
+                Box::pin(async move { lists.list_archived_summaries(txn).await })
+            })
+            .await
+            .unwrap();
+        assert_eq!(archived.len(), 1);
+        assert_eq!(archived[0].id, list.id);
+        assert!(archived[0].archived_at.is_some());
+    }
+
+    #[tokio::test]
+    async fn unarchiving_a_list_restores_it_to_summaries() {
+        let db = setup().await;
+        let list = create_list(&db, "Weekly shop").await;
+        let lists = SqliteListRepository;
+
+        let list_id = list.id;
+        db.run(move |txn| {
+            let lists = lists.clone();
+            Box::pin(async move { lists.set_archived(txn, list_id, true).await })
+        })
+        .await
+        .unwrap();
+        db.run(move |txn| {
+            let lists = lists.clone();
+            Box::pin(async move { lists.set_archived(txn, list_id, false).await })
+        })
+        .await
+        .unwrap();
+
+        let summaries = db
+            .run(move |txn| {
+                let lists = lists.clone();
+                Box::pin(async move { lists.list_summaries(txn).await })
+            })
+            .await
+            .unwrap();
+        assert_eq!(summaries.len(), 1);
+        assert!(summaries[0].archived_at.is_none());
+    }
+
+    #[tokio::test]
+    async fn archiving_a_missing_list_fails() {
+        let db = setup().await;
+        let lists = SqliteListRepository;
+        let result = db
+            .run(move |txn| {
+                let lists = lists.clone();
+                Box::pin(async move { lists.set_archived(txn, 9999, true).await })
+            })
+            .await;
+        assert!(result.is_err());
+    }
+
     #[tokio::test]
     async fn get_list_returns_list_or_none() {
         let db = setup().await;
@@ -1609,7 +1817,10 @@ mod tests {
     async fn meal_categories_are_seeded_with_defaults() {
         let db = setup().await;
         let categories = get_meal_categories(&db).await;
-        let names = categories.iter().map(|c| c.name.as_str()).collect::<Vec<_>>();
+        let names = categories
+            .iter()
+            .map(|c| c.name.as_str())
+            .collect::<Vec<_>>();
         assert!(names.contains(&"Beef"));
         assert!(names.contains(&"Chicken"));
         assert!(names.contains(&"Pasta"));
@@ -1626,7 +1837,9 @@ mod tests {
             .run(move |txn| {
                 let categories = categories.clone();
                 Box::pin(async move {
-                    categories.create_meal_category(txn, "Breakfast".into()).await
+                    categories
+                        .create_meal_category(txn, "Breakfast".into())
+                        .await
                 })
             })
             .await
@@ -1643,9 +1856,7 @@ mod tests {
         let result = db
             .run(move |txn| {
                 let categories = categories.clone();
-                Box::pin(async move {
-                    categories.create_meal_category(txn, "Beef".into()).await
-                })
+                Box::pin(async move { categories.create_meal_category(txn, "Beef".into()).await })
             })
             .await;
         assert!(matches!(result, Err(DomainError::Conflict)));
@@ -1659,7 +1870,9 @@ mod tests {
             .run(move |txn| {
                 let categories = categories.clone();
                 Box::pin(async move {
-                    categories.create_meal_category(txn, "Breakfast".into()).await
+                    categories
+                        .create_meal_category(txn, "Breakfast".into())
+                        .await
                 })
             })
             .await
@@ -1670,7 +1883,13 @@ mod tests {
             let meals = meals.clone();
             Box::pin(async move {
                 meals
-                    .update_meal(txn, meal.id, "Pancakes".into(), String::new(), Some(category_id))
+                    .update_meal(
+                        txn,
+                        meal.id,
+                        "Pancakes".into(),
+                        String::new(),
+                        Some(category_id),
+                    )
                     .await
             })
         })
@@ -1767,12 +1986,14 @@ mod tests {
                 quantity: "500g".into(),
                 note: String::new(),
                 category_id: None,
+                list_meal_id: None,
             },
             NewItem {
                 name: "Tomato".into(),
                 quantity: "2".into(),
                 note: String::new(),
                 category_id: None,
+                list_meal_id: None,
             },
         ];
         let revision = db
@@ -2162,7 +2383,13 @@ mod tests {
             let meals = meals.clone();
             Box::pin(async move {
                 meals
-                    .update_meal(txn, meal.id, "Pasta al pomodoro".into(), "desc".into(), None)
+                    .update_meal(
+                        txn,
+                        meal.id,
+                        "Pasta al pomodoro".into(),
+                        "desc".into(),
+                        None,
+                    )
                     .await
             })
         })
@@ -2332,6 +2559,118 @@ mod tests {
         assert!(matches!(result, Err(DomainError::NotFound)));
     }
 
+    // ---- ListMealRepository ----
+
+    async fn add_meal_to_list(db: &SqliteDatabase, list_id: i64, meal: &Meal) -> ListMeal {
+        let list_meals = SqliteListMealRepository;
+        let name = meal.name.clone();
+        let meal_id = meal.id;
+        let id = db
+            .run(move |txn| {
+                let list_meals = list_meals.clone();
+                Box::pin(async move { list_meals.add_meal(txn, list_id, meal_id, name).await })
+            })
+            .await
+            .unwrap();
+        ListMeal {
+            id,
+            meal_id: Some(meal.id),
+            name: meal.name.clone(),
+            created_at: 0,
+        }
+    }
+
+    #[tokio::test]
+    async fn list_meals_returns_meals_added_to_a_list() {
+        let db = setup().await;
+        let list = create_list(&db, "Weekly shop").await;
+        let meal = create_meal(&db, "Pasta").await;
+        add_meal_to_list(&db, list.id, &meal).await;
+
+        let list_meals = SqliteListMealRepository;
+        let meals = db
+            .run(move |txn| {
+                let list_meals = list_meals.clone();
+                Box::pin(async move { list_meals.list_meals(txn, list.id).await })
+            })
+            .await
+            .unwrap();
+        assert_eq!(meals.len(), 1);
+        assert_eq!(meals[0].name, "Pasta");
+        assert_eq!(meals[0].meal_id, Some(meal.id));
+    }
+
+    #[tokio::test]
+    async fn removing_a_meal_deletes_its_items_and_bumps_revision() {
+        let db = setup().await;
+        let list = create_list(&db, "Weekly shop").await;
+        let meal = create_meal(&db, "Pasta").await;
+        add_ingredient(&db, meal.id, "Penne", None).await;
+        add_ingredient(&db, meal.id, "Tomato", None).await;
+        let list_meal = add_meal_to_list(&db, list.id, &meal).await;
+
+        let items = SqliteItemRepository;
+        let ingredients = SqliteMealIngredientRepository;
+        let ingredient_rows = db
+            .run(move |txn| {
+                let ingredients = ingredients.clone();
+                Box::pin(async move { ingredients.ingredients_for_meal(txn, meal.id).await })
+            })
+            .await
+            .unwrap();
+        let new_items = ingredient_rows
+            .into_iter()
+            .map(|ingredient| NewItem {
+                name: ingredient.name,
+                quantity: ingredient.quantity,
+                note: ingredient.note,
+                category_id: ingredient.category_id,
+                list_meal_id: Some(list_meal.id),
+            })
+            .collect();
+        db.run(move |txn| {
+            let items = items.clone();
+            Box::pin(async move { items.add_items_bulk(txn, list.id, new_items).await })
+        })
+        .await
+        .unwrap();
+        assert_eq!(get_items(&db, list.id).await.len(), 2);
+
+        let list_meals = SqliteListMealRepository;
+        let revision = db
+            .run(move |txn| {
+                let list_meals = list_meals.clone();
+                Box::pin(async move { list_meals.remove_meal(txn, list.id, list_meal.id).await })
+            })
+            .await
+            .unwrap();
+        assert_eq!(revision, 2);
+
+        let meals = db
+            .run(move |txn| {
+                let list_meals = list_meals.clone();
+                Box::pin(async move { list_meals.list_meals(txn, list.id).await })
+            })
+            .await
+            .unwrap();
+        assert!(meals.is_empty());
+        assert!(get_items(&db, list.id).await.is_empty());
+    }
+
+    #[tokio::test]
+    async fn removing_an_unknown_meal_from_a_list_fails() {
+        let db = setup().await;
+        let list = create_list(&db, "Weekly shop").await;
+        let list_meals = SqliteListMealRepository;
+        let result = db
+            .run(move |txn| {
+                let list_meals = list_meals.clone();
+                Box::pin(async move { list_meals.remove_meal(txn, list.id, 9999).await })
+            })
+            .await;
+        assert!(matches!(result, Err(DomainError::NotFound)));
+    }
+
     // ---- PasskeyRepository ----
 
     #[tokio::test]

src/views.rs

@@ -3,7 +3,9 @@ use pulldown_cmark::{Options, Parser, html as cmark_html};
 
 use crate::{
     domain::PresenceUser,
-    domain::{Category, GroceryList, Item, Meal, MealCategory, MealIngredient, Passkey, User},
+    domain::{
+        Category, GroceryList, Item, ListMeal, Meal, MealCategory, MealIngredient, Passkey, User,
+    },
 };
 
 pub fn login_page(error: Option<&str>, invite: Option<&str>) -> Markup {
@@ -168,7 +170,13 @@ pub fn account_page(
     )
 }
 
-pub fn lists_page(user: &User, lists: &[GroceryList], csrf_token: &str) -> Markup {
+pub fn lists_page(
+    user: &User,
+    lists: &[GroceryList],
+    archived_count: usize,
+    categories: &[Category],
+    csrf_token: &str,
+) -> Markup {
     page(
         "Your lists",
         Some(user),
@@ -176,7 +184,7 @@ pub fn lists_page(user: &User, lists: &[GroceryList], csrf_token: &str) -> Marku
             div class="page-heading" {
                 div {
                     p class="eyebrow" { "SHARED LISTS" }
-                    h1 { "Grocery lists" }
+                    h1 class="page-title" { "Grocery lists" }
                     p class="lede" { "Everything you need, in one place." }
                 }
             }
@@ -185,6 +193,7 @@ pub fn lists_page(user: &User, lists: &[GroceryList], csrf_token: &str) -> Marku
                     div class="panel-heading" {
                         h2 { "Lists" }
                         span class="count-badge" { (lists.len()) }
+                        a class="archive-link" href="/archive" { "Archived " span class="count-badge" { (archived_count) } " →" }
                     }
                     @if lists.is_empty() {
                         div class="empty-state" {
@@ -215,6 +224,7 @@ pub fn lists_page(user: &User, lists: &[GroceryList], csrf_token: &str) -> Marku
                         button class="button button-primary" type="submit" { "Create list" }
                     }
                 }
+                (categories_panel(categories, csrf_token, false))
                 section id="sharing" class="panel sharing-panel" {
                     div class="panel-heading" { h2 { "Invite someone" } }
                     p { "Create a one-time invite link so a new person can join." }
@@ -234,6 +244,49 @@ pub fn lists_page(user: &User, lists: &[GroceryList], csrf_token: &str) -> Marku
     )
 }
 
+pub fn archive_page(user: &User, archived_lists: &[GroceryList]) -> Markup {
+    page(
+        "Archive",
+        Some(user),
+        html! {
+            div class="page-heading" {
+                div {
+                    p class="eyebrow" { "ARCHIVE" }
+                    h1 class="page-title" { "Archived lists" }
+                    p class="lede" { "Past lists, kept for reference." }
+                }
+                a class="button button-quiet" href="/lists" { "← Back to lists" }
+            }
+            section class="panel" {
+                div class="panel-heading" {
+                    h2 { "Archive" }
+                    span class="count-badge" { (archived_lists.len()) }
+                }
+                @if archived_lists.is_empty() {
+                    div class="empty-state" {
+                        div class="empty-mark" { "🗄" }
+                        h3 { "Nothing archived yet" }
+                        p { "Archive a list and it will show up here." }
+                    }
+                } @else {
+                    div class="list-cards" {
+                        @for list in archived_lists {
+                            a class="list-card archived-list-card" href=(format!("/lists/{}", list.id)) {
+                                span class="list-card-icon" { "🗄" }
+                                span class="list-card-copy" {
+                                    strong { (list.name) }
+                                    small { "Created " (format_date(list.created_at)) }
+                                }
+                                span class="list-card-arrow" { "→" }
+                            }
+                        }
+                    }
+                }
+            }
+        },
+    )
+}
+
 pub fn meals_page(
     user: &User,
     meals: &[Meal],
@@ -247,7 +300,7 @@ pub fn meals_page(
             div class="page-heading" {
                 div {
                     p class="eyebrow" { "MEAL LIBRARY" }
-                    h1 { "Meals" }
+                    h1 class="page-title" { "Meals" }
                     p class="lede" { "Save a meal and add its ingredients to any list." }
                 }
                 a class="button button-primary" href="/meals/new" { "New meal" }
@@ -491,13 +544,6 @@ pub fn meal_page(
         html! {
             div class="page-heading" {
                 a class="back-link" href="/meals" { "← All meals" }
-                div class="list-topbar-actions" {
-                    button type="button" class="button button-small button-quiet" onclick="document.getElementById('meal-edit-modal').showModal()" { "Edit" }
-                    form method="post" action=(format!("/meals/{}/delete", meal.id)) {
-                        input type="hidden" name="csrf" value=(csrf_token);
-                        button class="danger-link" type="submit" { "Delete" }
-                    }
-                }
             }
             dialog id="meal-edit-modal" class="item-modal" {
                 div class="item-modal-card" {
@@ -537,6 +583,13 @@ pub fn meal_page(
                             p class="eyebrow" { "MEAL" }
                             h1 { (meal.name) @if let Some(category_name) = meal_category_name(meal, meal_categories) { span class="meal-category-label" { "(" (category_name) ")" } } }
                         }
+                        div class="list-topbar-actions" {
+                            button type="button" class="button button-small button-quiet" onclick="document.getElementById('meal-edit-modal').showModal()" { "Edit" }
+                            form method="post" action=(format!("/meals/{}/delete", meal.id)) onsubmit="return confirm('Delete this meal and its ingredients? This cannot be undone.')" {
+                                input type="hidden" name="csrf" value=(csrf_token);
+                                button class="danger-link bordered-delete" type="submit" { "Delete" }
+                            }
+                        }
                     }
                     @if meal.description.is_empty() {
                         p class="muted" { "No description." }
@@ -704,6 +757,13 @@ mod tests {
         assert!(html.contains("<strong>"), "expected <strong>, got: {html}");
         assert!(html.contains("<em>"), "expected <em>, got: {html}");
     }
+
+    #[test]
+    fn format_date_renders_human_readable_date() {
+        // 2026-08-07T00:00:00Z in Unix seconds.
+        let ts = 1_786_060_800;
+        assert_eq!(format_date(ts), "7 Aug 2026");
+    }
 }
 
 pub fn list_page(
@@ -711,6 +771,7 @@ pub fn list_page(
     list: &GroceryList,
     items: &[Item],
     categories: &[Category],
+    list_meals: &[ListMeal],
     presence: &[PresenceUser],
     csrf_token: &str,
 ) -> Markup {
@@ -722,9 +783,11 @@ pub fn list_page(
                 a class="back-link" href="/lists" { "← All lists" }
                 div class="list-topbar-actions" {
                     span class="live-pill" { span class="live-dot" {} "Live" }
-                    button class="button button-small add-meal-button" hx-get=(format!("/meals?picker={}", list.id)) hx-target="#meal-picker" hx-swap="innerHTML" { "+ Add meal" }
                 }
             }
+            @if let Some(ts) = list.archived_at {
+                div class="archived-banner" { "This list was archived on " (format_date(ts)) "." }
+            }
             div id="meal-picker" class="meal-picker" {}
             div class="list-layout" {
                 section class="panel list-panel" {
@@ -734,12 +797,25 @@ pub fn list_page(
                             h1 { (list.name) }
                             p class="list-meta" { (items.iter().filter(|item| !item.checked).count()) " items to get" }
                         }
+                        div class="list-topbar-actions" {
+                            @if list.archived_at.is_some() {
+                                form method="post" action=(format!("/lists/{}/unarchive", list.id)) {
+                                    input type="hidden" name="csrf" value=(csrf_token);
+                                    button class="button button-small button-quiet" type="submit" { "Restore" }
+                                }
+                            } @else {
+                                form method="post" action=(format!("/lists/{}/archive", list.id)) {
+                                    input type="hidden" name="csrf" value=(csrf_token);
+                                    button class="button button-small button-quiet" type="submit" { "Archive" }
+                                }
+                            }
+                        }
                     }
-                    (list_content_fragment(list, items, categories, csrf_token, false))
+                    (list_content_fragment(list, items, categories, csrf_token, false, list.archived_at.is_none()))
                 }
                 aside class="side-column" {
+                    (list_meals_panel(list_meals, list.id, csrf_token, false, list.archived_at.is_none()))
                     (presence_panel(presence, false))
-                    (categories_panel(categories, csrf_token, false))
                     section class="panel tip-panel" {
                         span class="tip-label" { "TIP" }
                         p { "Check items off as you go. Everyone viewing this list will see it instantly." }
@@ -757,17 +833,18 @@ pub fn list_content_fragment(
     categories: &[Category],
     csrf_token: &str,
     out_of_band: bool,
+    editable: bool,
 ) -> Markup {
     if out_of_band {
         html! {
             div id="list-content" hx-swap-oob="outerHTML" {
-                (list_content(list, items, categories, csrf_token))
+                (list_content(list, items, categories, csrf_token, editable))
             }
         }
     } else {
         html! {
             div id="list-content" {
-                (list_content(list, items, categories, csrf_token))
+                (list_content(list, items, categories, csrf_token, editable))
             }
         }
     }
@@ -778,26 +855,29 @@ fn list_content(
     items: &[Item],
     categories: &[Category],
     csrf_token: &str,
+    editable: bool,
 ) -> Markup {
     html! {
-        form
-            id="add-item-form"
-            class="add-item-form"
-            hx-post=(format!("/lists/{}/items", list.id))
-            hx-target="#list-items"
-            hx-swap="outerHTML"
-            hx-on::after-request="if (event.detail.successful) this.reset()"
-        {
-            input type="hidden" name="csrf" value=(csrf_token);
-            label class="sr-only" for="item-name" { "Item name" }
-            input id="item-name" name="name" type="text" maxlength="120" placeholder="Add an item..." autocomplete="off" required;
-            select id="item-category" name="category_id" aria-label="Category" {
-                (category_options(categories, None))
+        @if editable {
+            form
+                id="add-item-form"
+                class="add-item-form"
+                hx-post=(format!("/lists/{}/items", list.id))
+                hx-target="#list-items"
+                hx-swap="outerHTML"
+                hx-on::after-request="if (event.detail.successful) this.reset()"
+            {
+                input type="hidden" name="csrf" value=(csrf_token);
+                label class="sr-only" for="item-name" { "Item name" }
+                input id="item-name" name="name" type="text" maxlength="120" placeholder="Add an item..." autocomplete="off" required;
+                select id="item-category" name="category_id" aria-label="Category" {
+                    (category_options(categories, None))
+                }
+                input id="item-quantity" name="quantity" type="text" maxlength="40" placeholder="Qty" aria-label="Quantity";
+                button id="add-item-button" class="button button-primary add-button" type="submit" { "+ Add" }
             }
-            input id="item-quantity" name="quantity" type="text" maxlength="40" placeholder="Qty" aria-label="Quantity";
-            button id="add-item-button" class="button button-primary add-button" type="submit" { "+ Add" }
         }
-        (list_items_fragment(list, items, categories, csrf_token, false))
+        (list_items_fragment(list, items, categories, csrf_token, false, editable))
     }
 }
 
@@ -807,23 +887,29 @@ pub fn list_items_fragment(
     categories: &[Category],
     csrf_token: &str,
     out_of_band: bool,
+    editable: bool,
 ) -> Markup {
     if out_of_band {
         html! {
             div id="list-items" class="items" data-revision=(list.revision) hx-swap-oob="outerHTML" {
-                (list_items_content(items, categories, csrf_token))
+                (list_items_content(items, categories, csrf_token, editable))
             }
         }
     } else {
         html! {
             div id="list-items" class="items" data-revision=(list.revision) {
-                (list_items_content(items, categories, csrf_token))
+                (list_items_content(items, categories, csrf_token, editable))
             }
         }
     }
 }
 
-fn list_items_content(items: &[Item], categories: &[Category], csrf_token: &str) -> Markup {
+fn list_items_content(
+    items: &[Item],
+    categories: &[Category],
+    csrf_token: &str,
+    editable: bool,
+) -> Markup {
     html! {
         @if items.is_empty() {
             div class="empty-items" {
@@ -834,7 +920,7 @@ fn list_items_content(items: &[Item], categories: &[Category], csrf_token: &str)
         } @else {
             div class="item-list" {
                 @for group in item_groups(items, categories) {
-                    (category_group(&group.0, &group.1, categories, csrf_token))
+                    (category_group(&group.0, &group.1, categories, csrf_token, editable))
                 }
             }
         }
@@ -868,32 +954,37 @@ fn category_group(
     items: &[&Item],
     categories: &[Category],
     csrf_token: &str,
+    editable: bool,
 ) -> Markup {
     html! {
         section class="category-group" {
             h2 class="category-heading" { (name) }
             @for item in items {
-                (item_row(item, categories, csrf_token))
+                (item_row(item, categories, csrf_token, editable))
             }
         }
     }
 }
 
-fn item_row(item: &Item, categories: &[Category], csrf_token: &str) -> Markup {
+fn item_row(item: &Item, categories: &[Category], csrf_token: &str, editable: bool) -> Markup {
     let next_checked = if item.checked { "0" } else { "1" };
     html! {
         article class=(if item.checked { "item-row is-checked" } else { "item-row" }) id=(format!("item-{}", item.id)) data-version=(item.version) {
-            form
-                class="check-form"
-                hx-post=(format!("/lists/{}/items/{}/check", item.list_id, item.id))
-                hx-target="#list-items"
-                hx-swap="outerHTML"
-            {
-                input type="hidden" name="csrf" value=(csrf_token);
-                input type="hidden" name="checked" value=(next_checked);
-                button id=(format!("item-check-{}", item.id)) class="check-button" type="submit" aria-label=(if item.checked { "Mark unchecked" } else { "Mark complete" }) {
-                    @if item.checked { "✓" } @else { "" }
+            @if editable {
+                form
+                    class="check-form"
+                    hx-post=(format!("/lists/{}/items/{}/check", item.list_id, item.id))
+                    hx-target="#list-items"
+                    hx-swap="outerHTML"
+                {
+                    input type="hidden" name="csrf" value=(csrf_token);
+                    input type="hidden" name="checked" value=(next_checked);
+                    button id=(format!("item-check-{}", item.id)) class="check-button" type="submit" aria-label=(if item.checked { "Mark unchecked" } else { "Mark complete" }) {
+                        @if item.checked { "✓" } @else { "" }
+                    }
                 }
+            } @else if item.checked {
+                span class="check-button check-button-static" { "✓" }
             }
             label class="item-copy" for=(format!("item-check-{}", item.id)) {
                 @if !item.quantity.is_empty() {
@@ -904,39 +995,41 @@ fn item_row(item: &Item, categories: &[Category], csrf_token: &str) -> Markup {
                     small { (item.note) }
                 }
             }
-            button type="button" class="item-actions-button" aria-label="Item actions" onclick=(format!("document.getElementById('item-edit-{}').showModal()", item.id)) { "•••" }
-            dialog id=(format!("item-edit-{}", item.id)) class="item-modal" {
-                div class="item-modal-card" {
-                    div class="item-modal-header" {
-                        h3 { (item.name) }
-                        button type="button" class="meal-picker-close" aria-label="Close" onclick="this.closest('dialog').close()" { "✕" }
-                    }
-                    form
-                        hx-post=(format!("/lists/{}/items/{}/edit", item.list_id, item.id))
-                        hx-target="#list-items"
-                        hx-swap="outerHTML"
-                        class="stack"
-                    {
-                        input type="hidden" name="csrf" value=(csrf_token);
-                        label { "Name" }
-                        input id=(format!("item-edit-name-{}", item.id)) name="name" value=(item.name) maxlength="120" required;
-                        label { "Category" }
-                        select id=(format!("item-edit-category-{}", item.id)) name="category_id" {
-                            (category_options(categories, item.category_id))
+            @if editable {
+                button type="button" class="item-actions-button" aria-label="Item actions" onclick=(format!("document.getElementById('item-edit-{}').showModal()", item.id)) { "•••" }
+                dialog id=(format!("item-edit-{}", item.id)) class="item-modal" {
+                    div class="item-modal-card" {
+                        div class="item-modal-header" {
+                            h3 { (item.name) }
+                            button type="button" class="meal-picker-close" aria-label="Close" onclick="this.closest('dialog').close()" { "✕" }
+                        }
+                        form
+                            hx-post=(format!("/lists/{}/items/{}/edit", item.list_id, item.id))
+                            hx-target="#list-items"
+                            hx-swap="outerHTML"
+                            class="stack"
+                        {
+                            input type="hidden" name="csrf" value=(csrf_token);
+                            label { "Name" }
+                            input id=(format!("item-edit-name-{}", item.id)) name="name" value=(item.name) maxlength="120" required;
+                            label { "Category" }
+                            select id=(format!("item-edit-category-{}", item.id)) name="category_id" {
+                                (category_options(categories, item.category_id))
+                            }
+                            label { "Quantity" }
+                            input id=(format!("item-edit-quantity-{}", item.id)) name="quantity" value=(item.quantity) maxlength="40";
+                            label { "Note" }
+                            input id=(format!("item-edit-note-{}", item.id)) name="note" value=(item.note) maxlength="120";
+                            button id=(format!("item-edit-save-{}", item.id)) class="button button-primary" type="submit" { "Save" }
+                        }
+                        form
+                            hx-post=(format!("/lists/{}/items/{}/delete", item.list_id, item.id))
+                            hx-target="#list-items"
+                            hx-swap="outerHTML"
+                        {
+                            input type="hidden" name="csrf" value=(csrf_token);
+                            button id=(format!("item-edit-delete-{}", item.id)) class="button button-danger" type="submit" { "Remove item" }
                         }
-                        label { "Quantity" }
-                        input id=(format!("item-edit-quantity-{}", item.id)) name="quantity" value=(item.quantity) maxlength="40";
-                        label { "Note" }
-                        input id=(format!("item-edit-note-{}", item.id)) name="note" value=(item.note) maxlength="120";
-                        button id=(format!("item-edit-save-{}", item.id)) class="button button-primary" type="submit" { "Save" }
-                    }
-                    form
-                        hx-post=(format!("/lists/{}/items/{}/delete", item.list_id, item.id))
-                        hx-target="#list-items"
-                        hx-swap="outerHTML"
-                    {
-                        input type="hidden" name="csrf" value=(csrf_token);
-                        button id=(format!("item-edit-delete-{}", item.id)) class="button button-danger" type="submit" { "Remove item" }
                     }
                 }
             }
@@ -1006,11 +1099,64 @@ pub fn live_list_fragments(
     list: &GroceryList,
     items: &[Item],
     categories: &[Category],
+    list_meals: &[ListMeal],
     csrf_token: &str,
 ) -> Markup {
+    let editable = list.archived_at.is_none();
     html! {
-        (list_content_fragment(list, items, categories, csrf_token, true))
-        (categories_panel(categories, csrf_token, true))
+        (list_items_fragment(list, items, categories, csrf_token, true, editable))
+        (list_meals_panel(list_meals, list.id, csrf_token, true, editable))
+    }
+}
+
+pub fn list_meals_panel(
+    list_meals: &[ListMeal],
+    list_id: i64,
+    csrf_token: &str,
+    out_of_band: bool,
+    editable: bool,
+) -> Markup {
+    let panel = html! {
+        div class="panel-heading" {
+            h2 { "Meals on this list" }
+            span class="count-badge" { (list_meals.len()) }
+        }
+        @if list_meals.is_empty() {
+            p class="muted" { "No meals added yet." }
+        } @else {
+            div class="list-meals" {
+                @for meal in list_meals {
+                    div class="list-meal-row" {
+                        span class="list-meal-icon" { "🍽" }
+                        span class="list-meal-name" { (meal.name) }
+                        @if editable {
+                            form
+                                hx-post=(format!("/lists/{}/meals/{}/remove", list_id, meal.id))
+                                hx-target="#list-items"
+                                hx-swap="outerHTML"
+                                class="list-meal-remove"
+                            {
+                                input type="hidden" name="csrf" value=(csrf_token);
+                                button type="submit" class="list-meal-remove-button" aria-label=(format!("Remove {} from list", meal.name)) { "✕" }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        @if editable {
+            button class="button button-small add-meal-button" hx-get=(format!("/meals?picker={}", list_id)) hx-target="#meal-picker" hx-swap="innerHTML" { "+ Add meal" }
+        }
+    };
+
+    if out_of_band {
+        html! {
+            section id="list-meals-panel" class="panel list-meals-panel" hx-swap-oob="outerHTML" { (panel) }
+        }
+    } else {
+        html! {
+            section id="list-meals-panel" class="panel list-meals-panel" { (panel) }
+        }
     }
 }
 
@@ -1098,6 +1244,31 @@ pub fn invite_result(url: &str) -> Markup {
     }
 }
 
+/// Formats a Unix timestamp as a human-readable date (e.g. "7 Aug 2026").
+fn format_date(timestamp: i64) -> String {
+    let days = timestamp.div_euclid(86_400);
+    let (y, m, d) = civil_from_days(days);
+    const MONTHS: [&str; 12] = [
+        "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
+    ];
+    format!("{} {} {}", d, MONTHS[(m - 1) as usize], y)
+}
+
+/// Converts a count of days since the Unix epoch into a (year, month, day)
+/// civil date using Howard Hinnant's `civil_from_days` algorithm.
+fn civil_from_days(z: i64) -> (i64, i64, i64) {
+    let z = z + 719_468;
+    let era = z.div_euclid(146_097);
+    let doe = z.rem_euclid(146_097);
+    let yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365;
+    let y = yoe + era * 400;
+    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
+    let mp = (5 * doy + 2) / 153;
+    let d = doy - (153 * mp + 2) / 5 + 1;
+    let m = if mp < 10 { mp + 3 } else { mp - 9 };
+    (if m <= 2 { y + 1 } else { y }, m, d)
+}
+
 pub fn error_page(status: &str, message: &str) -> Markup {
     page(
         status,
@@ -1122,10 +1293,10 @@ fn page(title: &str, user: Option<&User>, content: Markup) -> Markup {
                 meta name="viewport" content="width=device-width, initial-scale=1";
                 title { (title) " · Sustenance" }
                 link rel="stylesheet" href="/static/style.css";
-                script src="https://unpkg.com/htmx.org@2.0.4" {}
-                script src="https://unpkg.com/htmx-ext-ws@2.0.2/ws.js" {}
+                script src="https://unpkg.com/htmx.org@2.0.10" {}
+                script src="https://unpkg.com/htmx-ext-ws@2.0.4/ws.js" {}
             }
-            body {
+            body hx-boost="true" {
                 header class="site-header" {
                     a class="brand" href="/lists" { span class="brand-mark" { "S" } "Sustenance" }
                     @if let Some(user) = user {

static/style.css

@@ -67,9 +67,12 @@ h3 { margin-bottom: 6px; font-size: 1rem; }
 .muted { color: var(--muted); }
 
 .page-heading { display: flex; justify-content: space-between; align-items: end; margin-bottom: 34px; }
+.page-heading h1.page-title { font-size: clamp(1.6rem, 3.2vw, 2.3rem); }
 .dashboard-grid { display: grid; grid-template-columns: minmax(0, 1.5fr) minmax(260px, .8fr); gap: 22px; align-items: start; }
 .panel { padding: 26px; border: 1px solid rgba(221, 225, 210, .9); border-radius: 24px; background: rgba(255, 253, 248, .88); box-shadow: var(--shadow); }
 .panel-heading { display: flex; justify-content: space-between; align-items: center; gap: 12px; margin-bottom: 22px; }
+.archive-link { margin-left: auto; color: var(--muted); font-size: .78rem; font-weight: 700; text-decoration: none; }
+.archive-link:hover { color: var(--deep-sage); }
 .count-badge { display: inline-grid; place-items: center; min-width: 27px; height: 27px; padding: 0 8px; border-radius: 99px; color: var(--deep-sage); background: #e8f0e1; font-size: .78rem; font-weight: 800; }
 .stack { display: grid; gap: 9px; }
 .stack label { color: var(--muted); font-size: .82rem; font-weight: 700; }
@@ -99,12 +102,18 @@ textarea:focus { border-color: var(--deep-sage); box-shadow: 0 0 0 4px rgba(85,
 .list-card-copy { display: grid; flex: 1; gap: 2px; }
 .list-card-copy small { color: var(--muted); font-size: .75rem; }
 .list-card-arrow { color: var(--muted); font-size: 1.25rem; }
+.archived-list-card { opacity: .72; }
+.archived-list-card .list-card-icon { color: var(--muted); background: #eef0ea; }
+.archived-list-card .list-card-copy { align-items: flex-start; }
+.archived-list-card form { margin-left: auto; }
+.archived-banner { margin-bottom: 18px; padding: 11px 14px; border: 1px solid var(--line); border-radius: 12px; color: var(--muted); background: #f1f3ec; font-size: .82rem; font-weight: 700; }
 .empty-state { padding: 35px 18px 24px; text-align: center; color: var(--muted); }
 .empty-mark { display: grid; place-items: center; width: 50px; height: 50px; margin: 0 auto 15px; border-radius: 18px; color: var(--deep-sage); background: #edf3e8; font-size: 1.8rem; }
 .empty-state h3 { color: var(--ink); }
 
 .auth-card { width: min(100%, 480px); margin: 7vh auto 0; padding: clamp(27px, 6vw, 54px); border: 1px solid var(--line); border-radius: 28px; background: rgba(255, 253, 248, .9); box-shadow: var(--shadow); }
 .auth-card .button { margin-top: 11px; }
+#passkey-login { width: 100%; }
 .auth-divider { display: flex; align-items: center; gap: 12px; margin: 20px 0 4px; color: var(--muted); font-size: .8rem; }
 .auth-divider::before, .auth-divider::after { content: ""; flex: 1; height: 1px; background: var(--line); }
 .passkey-list { display: grid; gap: 8px; margin-bottom: 16px; }
@@ -150,6 +159,8 @@ textarea:focus { border-color: var(--deep-sage); box-shadow: 0 0 0 4px rgba(85,
 .check-form { flex: 0 0 auto; }
 .check-button { display: grid; place-items: center; width: 28px; height: 28px; padding: 0; border: 2px solid #c8d6c1; border-radius: 9px; color: #fff; background: transparent; cursor: pointer; font-size: .88rem; font-weight: 900; }
 .is-checked .check-button { border-color: var(--deep-sage); background: var(--deep-sage); }
+.check-button-static { cursor: default; }
+.is-checked .check-button-static { border-color: var(--deep-sage); background: var(--deep-sage); }
 .item-copy { display: grid; grid-template-columns: auto 1fr; flex: 1; min-width: 0; gap: 2px 7px; align-items: baseline; }
 .item-copy strong { grid-column: 2; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
 .item-qty { grid-column: 1; grid-row: 1; color: var(--muted); font-weight: 700; white-space: nowrap; }
@@ -218,6 +229,8 @@ textarea:focus { border-color: var(--deep-sage); box-shadow: 0 0 0 4px rgba(85,
 .edit-form { margin-bottom: 12px; }
 .edit-form input { min-height: 38px; padding: 7px 10px; font-size: .85rem; }
 .danger-link { padding: 0; border: 0; color: var(--coral); background: none; cursor: pointer; font-size: .8rem; font-weight: 800; }
+.bordered-delete { padding: 7px 14px; border: 1px solid var(--coral); border-radius: 10px; background: none; }
+.bordered-delete:hover { background: #fbeae4; }
 .button-danger { width: 100%; color: var(--coral); background: #fbeae4; }
 .button-danger:hover { background: #f7ddd4; }
 .empty-items { padding: 34px 10px 18px; color: var(--muted); text-align: center; }
@@ -243,6 +256,15 @@ textarea:focus { border-color: var(--deep-sage); box-shadow: 0 0 0 4px rgba(85,
 .presence-list { display: grid; gap: 12px; }
 .presence-person { display: flex; align-items: center; gap: 10px; font-size: .9rem; font-weight: 700; }
 .avatar { display: grid; place-items: center; width: 32px; height: 32px; border-radius: 11px; color: var(--deep-sage); background: #e6f0df; font-size: .7rem; font-weight: 900; }
+.list-meals { display: grid; gap: 8px; }
+.list-meal-row { display: flex; align-items: center; gap: 10px; padding: 6px 4px; border-bottom: 1px solid #edf0e6; }
+.list-meal-row:last-child { border-bottom: 0; }
+.list-meal-icon { display: grid; place-items: center; flex: 0 0 auto; width: 30px; height: 30px; border-radius: 10px; color: var(--deep-sage); background: #eef4e9; font-size: .95rem; }
+.list-meal-name { flex: 1; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; font-size: .9rem; font-weight: 700; }
+.list-meal-remove { margin: 0; flex: 0 0 auto; }
+.list-meal-remove-button { padding: 2px 7px; border: 0; border-radius: 7px; color: var(--muted); background: transparent; cursor: pointer; font-size: .8rem; line-height: 1; }
+.list-meal-remove-button:hover { color: var(--coral); background: #fbeae4; }
+.list-meals-panel .add-meal-button { margin-top: 12px; width: 100%; }
 .sharing-panel p, .tip-panel p { color: var(--muted); font-size: .86rem; }
 .invite-result { margin-top: 15px; }
 .invite-link-result { padding: 11px; border-radius: 12px; background: #f1f5ec; }