feat: implement remaining TODO.md feature ideas + fix mobile headers

Implements the six previously-unscoped feature ideas plus a mobile
layout fix reported via screenshot:

- Mobile: Recipes/Collections/Pantry/Meal Plan/Shopping Lists headers
  now stack and wrap instead of clipping buttons on narrow viewports.
- Recipe diff/compare view: word/list diff against any past version,
  next to Restore in version history.
- Shared meal plans & shopping lists: new shoppingListMembers/
  mealPlanMembers tables (viewer/editor roles, mirrors
  collectionMembers), share dialogs, membership-checked routes.
- PDF cookbook export: /print/collection/[id] renders a whole
  collection with page breaks, using the existing print-CSS pattern
  instead of adding a PDF rendering dependency.
- Grocery delivery handoff: shopping lists can copy-as-text (works
  today) or send to Instacart once INSTACART_API_KEY is configured
  (stub adapter — real API needs a partner agreement).
- Personalized "For You" feed tab: ranks public recipes by tag/
  dietary overlap with the user's favorited/highly-rated history.
- PWA: added manifest.json + icons on top of the existing service
  worker so the app is installable; cook-mode pages were already
  cached for offline use.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

.env.example

@@ -66,3 +66,7 @@ OPENROUTER_DEFAULT_MODEL=google/gemini-flash-1.5
 OPENAI_API_KEY=
 ANTHROPIC_API_KEY=
 OLLAMA_BASE_URL=http://localhost:11434
+
+# Grocery delivery handoff (optional — without these, shopping lists only offer "copy as text")
+NEXT_PUBLIC_GROCERY_PROVIDER=
+INSTACART_API_KEY=

apps/web/app/(app)/collections/[id]/page.tsx

@@ -1,11 +1,15 @@
 import type { Metadata } from "next";
 import { notFound } from "next/navigation";
 import { headers } from "next/headers";
+import Link from "next/link";
+import { Printer } from "lucide-react";
 import { auth } from "@/lib/auth/server";
 import { db, collections, eq, and, or } from "@epicure/db";
 import { RecipeCard } from "@/components/recipe/recipe-card";
 import { ForkCollectionButton } from "@/components/collections/fork-collection-button";
 import { ShareCollectionButton } from "@/components/collections/share-collection-button";
+import { buttonVariants } from "@/components/ui/button";
+import { cn } from "@/lib/utils";
 
 type Params = { params: Promise<{ id: string }> };
 
@@ -30,7 +34,7 @@ export default async function CollectionPage({ params }: Params) {
 
   return (
     <div className="space-y-6">
-      <div className="flex items-start justify-between gap-4">
+      <div className="flex flex-col gap-3 sm:flex-row sm:items-start sm:justify-between">
         <div>
           <h1 className="text-3xl font-bold tracking-tight">{col.name}</h1>
           {col.description && <p className="text-muted-foreground mt-1">{col.description}</p>}
@@ -38,7 +42,13 @@ export default async function CollectionPage({ params }: Params) {
             {col.recipes.length} recipe{col.recipes.length !== 1 ? "s" : ""} · {col.isPublic ? "Public" : "Private"}
           </p>
         </div>
-        <div className="flex items-center gap-2">
+        <div className="flex flex-wrap items-center gap-2">
+          {col.recipes.length > 0 && (
+            <Link href={`/print/collection/${id}`} target="_blank" className={cn(buttonVariants({ variant: "outline", size: "sm" }))}>
+              <Printer className="h-4 w-4" />
+              Export as PDF
+            </Link>
+          )}
           {isOwner && <ShareCollectionButton collectionId={id} />}
           {!isOwner && col.isPublic && (
             <ForkCollectionButton collectionId={id} />

apps/web/app/(app)/meal-plan/page.tsx

@@ -3,9 +3,10 @@ import { headers } from "next/headers";
 import Link from "next/link";
 import { ChevronLeft, ChevronRight, ShoppingCart, Printer } from "lucide-react";
 import { auth } from "@/lib/auth/server";
-import { db, mealPlans, recipes, eq, and, desc } from "@epicure/db";
+import { db, mealPlans, mealPlanMembers, recipes, eq, and, desc } from "@epicure/db";
 import { buttonVariants } from "@/components/ui/button";
 import { MealPlanner } from "@/components/meal-plan/meal-planner";
+import { ShareMealPlanButton } from "@/components/meal-plan/share-meal-plan-button";
 import { WeeklyNutritionBar } from "@/components/nutrition/weekly-nutrition-bar";
 import { cn } from "@/lib/utils";
 
@@ -47,7 +48,7 @@ export default async function MealPlanPage({
   const sunday = addWeeks(monday, 1);
   sunday.setDate(sunday.getDate() - 1);
 
-  const [plan, userRecipes] = await Promise.all([
+  const [plan, userRecipes, sharedMemberships] = await Promise.all([
     db.query.mealPlans.findFirst({
       where: and(eq(mealPlans.userId, session.user.id), eq(mealPlans.weekStart, weekStart)),
       with: {
@@ -61,6 +62,10 @@ export default async function MealPlanPage({
       orderBy: desc(recipes.updatedAt),
       columns: { id: true, title: true },
     }),
+    db.query.mealPlanMembers.findMany({
+      where: eq(mealPlanMembers.userId, session.user.id),
+      with: { mealPlan: { with: { user: true } } },
+    }),
   ]);
 
   const entries = (plan?.entries ?? []).map((e) => ({
@@ -76,12 +81,13 @@ export default async function MealPlanPage({
 
   return (
     <div className="space-y-6">
-      <div className="flex items-center justify-between">
+      <div className="flex flex-col gap-3 sm:flex-row sm:items-center sm:justify-between">
         <div>
           <h1 className="text-3xl font-bold tracking-tight">Meal Plan</h1>
           <p className="text-muted-foreground mt-1">{label}</p>
         </div>
-        <div className="flex items-center gap-2">
+        <div className="flex flex-wrap items-center gap-2">
+          <ShareMealPlanButton weekStart={weekStart} />
           <Link href="/shopping-lists" className={cn(buttonVariants({ variant: "outline", size: "sm" }))}>
             <ShoppingCart className="h-4 w-4" />
             Shopping lists
@@ -101,6 +107,26 @@ export default async function MealPlanPage({
 
       <WeeklyNutritionBar weekStart={weekStart} />
       <MealPlanner weekStart={weekStart} initialEntries={entries} userRecipes={userRecipes} />
+
+      {sharedMemberships.length > 0 && (
+        <div className="space-y-3">
+          <h2 className="text-sm font-semibold text-muted-foreground">Shared with you</h2>
+          <div className="space-y-2 max-w-lg">
+            {sharedMemberships.map((m) => (
+              <Link
+                key={m.id}
+                href={`/meal-plan/shared/${m.mealPlan.id}`}
+                className="flex items-center justify-between rounded-xl border p-4 hover:shadow-sm transition-shadow"
+              >
+                <div>
+                  <p className="font-medium">{`${m.mealPlan.user?.name ?? "Unknown"}'s plan`}</p>
+                  <p className="text-sm text-muted-foreground">Week of {m.mealPlan.weekStart} · {m.role}</p>
+                </div>
+              </Link>
+            ))}
+          </div>
+        </div>
+      )}
     </div>
   );
 }

apps/web/app/(app)/meal-plan/shared/[mealPlanId]/page.tsx

@@ -0,0 +1,55 @@
+import type { Metadata } from "next";
+import { notFound } from "next/navigation";
+import { headers } from "next/headers";
+import { auth } from "@/lib/auth/server";
+import { db, mealPlans, recipes, eq, desc } from "@epicure/db";
+import { getMealPlanAccessById, canWriteMealPlan } from "@/lib/meal-plan-access";
+import { SharedMealPlanView } from "@/components/meal-plan/shared-meal-plan-view";
+
+type Params = { params: Promise<{ mealPlanId: string }> };
+
+export const metadata: Metadata = { title: "Shared Meal Plan" };
+
+export default async function SharedMealPlanPage({ params }: Params) {
+  const { mealPlanId } = await params;
+  const session = await auth.api.getSession({ headers: await headers() });
+  if (!session) return null;
+
+  const access = await getMealPlanAccessById(mealPlanId, session.user.id);
+  if (!access) notFound();
+
+  const plan = await db.query.mealPlans.findFirst({
+    where: eq(mealPlans.id, mealPlanId),
+    with: { entries: { with: { recipe: true } }, user: true },
+  });
+  if (!plan) notFound();
+
+  const userRecipes = await db.query.recipes.findMany({
+    where: eq(recipes.authorId, session.user.id),
+    orderBy: desc(recipes.updatedAt),
+    columns: { id: true, title: true },
+  });
+
+  const canEdit = canWriteMealPlan(access.role);
+
+  return (
+    <div className="space-y-6">
+      <div>
+        <h1 className="text-3xl font-bold tracking-tight">{`${plan.user?.name ?? "Shared"}'s Meal Plan`}</h1>
+        <p className="text-muted-foreground mt-1">Week of {plan.weekStart} · {access.role}</p>
+      </div>
+      <SharedMealPlanView
+        mealPlanId={mealPlanId}
+        canEdit={canEdit}
+        userRecipes={userRecipes}
+        initialEntries={plan.entries.map((e) => ({
+          id: e.id,
+          day: e.day,
+          mealType: e.mealType,
+          servings: e.servings,
+          recipe: e.recipe ? { id: e.recipe.id, title: e.recipe.title } : null,
+        }))}
+      />
+    </div>
+  );
+}

apps/web/app/(app)/recipes/[id]/page.tsx

@@ -149,7 +149,23 @@ export default async function RecipePage({ params }: Params) {
               }))}
             />
             <PrintButton recipeId={id} />
-            <VersionHistoryButton recipeId={id} />
+            <VersionHistoryButton
+              recipeId={id}
+              currentSnapshot={{
+                title: recipe.title,
+                description: recipe.description,
+                ingredients: recipe.ingredients.map((ing) => ({
+                  rawName: ing.rawName,
+                  quantity: ing.quantity,
+                  unit: ing.unit,
+                  note: ing.note,
+                })),
+                steps: recipe.steps.map((s) => ({
+                  instruction: s.instruction,
+                  timerSeconds: s.timerSeconds,
+                })),
+              }}
+            />
             <Tooltip>
               <TooltipTrigger render={
                 <Link href={`/recipes/${id}/edit`} className={cn(buttonVariants({ variant: "ghost", size: "icon" }))}>

apps/web/app/(app)/recipes/can-cook/page.tsx

@@ -8,6 +8,14 @@ import { CanCookContent } from "@/components/recipe/can-cook-content";
 
 export const metadata: Metadata = { title: "What can I cook?" };
 
+const EXPIRING_WITHIN_DAYS = 3;
+
+function isExpiringSoon(expiresAt: Date | null): boolean {
+  if (!expiresAt) return false;
+  const days = Math.ceil((expiresAt.getTime() - Date.now()) / (1000 * 60 * 60 * 24));
+  return days >= 0 && days <= EXPIRING_WITHIN_DAYS;
+}
+
 export default async function CanCookPage() {
   const session = await auth.api.getSession({ headers: await headers() });
   if (!session) return null;
@@ -27,6 +35,12 @@ export default async function CanCookPage() {
 
   const pantryKeys = new Set(pantry.map((p) => p.rawName.toLowerCase()));
 
+  const expiringSoonKeys = new Set(
+    pantry
+      .filter((p) => isExpiringSoon(p.expiresAt))
+      .map((p) => p.rawName.toLowerCase())
+  );
+
   const scored = userRecipes
     .filter((r) => r.ingredients.length > 0)
     .map((recipe) => {
@@ -37,6 +51,9 @@ export default async function CanCookPage() {
         .filter((ing) => !pantryKeys.has(ing.rawName.toLowerCase()))
         .map((ing) => ing.rawName)
         .slice(0, 5);
+      const usesExpiring = recipe.ingredients
+        .filter((ing) => expiringSoonKeys.has(ing.rawName.toLowerCase()))
+        .map((ing) => ing.rawName);
       const total = recipe.ingredients.length;
       const cover = recipe.photos?.find((p) => p.isCover) ?? recipe.photos?.[0];
       return {
@@ -50,9 +67,15 @@ export default async function CanCookPage() {
         total,
         pct: Math.round((matched / total) * 100),
         missing,
+        usesExpiring,
       };
     })
-    .sort((a, b) => b.pct - a.pct);
+    .sort((a, b) => {
+      if (a.usesExpiring.length > 0 !== b.usesExpiring.length > 0) {
+        return a.usesExpiring.length > 0 ? -1 : 1;
+      }
+      return b.pct - a.pct;
+    });
 
   return <CanCookContent pantryCount={pantry.length} scored={scored} />;
 }

apps/web/app/(app)/shopping-lists/[id]/page.tsx

@@ -4,10 +4,13 @@ import { headers } from "next/headers";
 import Link from "next/link";
 import { Printer } from "lucide-react";
 import { auth } from "@/lib/auth/server";
-import { db, shoppingLists, eq, and } from "@epicure/db";
+import { db, shoppingLists, eq } from "@epicure/db";
 import { ShoppingListView } from "@/components/meal-plan/shopping-list-view";
+import { ShareShoppingListButton } from "@/components/shopping-lists/share-shopping-list-button";
+import { GroceryExportButton } from "@/components/shopping-lists/grocery-export-button";
 import { buttonVariants } from "@/components/ui/button";
 import { cn } from "@/lib/utils";
+import { getShoppingListAccess, canWriteShoppingList } from "@/lib/shopping-list-access";
 
 type Params = { params: Promise<{ id: string }> };
 
@@ -18,29 +21,39 @@ export default async function ShoppingListPage({ params }: Params) {
   const session = await auth.api.getSession({ headers: await headers() });
   if (!session) return null;
 
+  const access = await getShoppingListAccess(id, session.user.id);
+  if (!access) notFound();
+
   const list = await db.query.shoppingLists.findFirst({
-    where: and(eq(shoppingLists.id, id), eq(shoppingLists.userId, session.user.id)),
+    where: eq(shoppingLists.id, id),
     with: { items: { orderBy: (t, { asc }) => [asc(t.aisle), asc(t.rawName)] } },
   });
-
   if (!list) notFound();
 
+  const canEdit = canWriteShoppingList(access.role);
+  const instacartEnabled = process.env["NEXT_PUBLIC_GROCERY_PROVIDER"] === "instacart";
+
   return (
     <div className="space-y-6 max-w-lg">
-      <div className="flex items-start justify-between">
+      <div className="flex flex-col gap-3 sm:flex-row sm:items-start sm:justify-between">
         <div>
           <h1 className="text-3xl font-bold tracking-tight">{list.name}</h1>
           <p className="text-muted-foreground mt-1">
             {list.items.length} items{list.generatedAt ? " · Generated from meal plan" : ""}
           </p>
         </div>
-        <Link href={`/print/shopping-list/${id}`} target="_blank" className={cn(buttonVariants({ variant: "outline", size: "sm" }))}>
-          <Printer className="h-4 w-4" />
-          Print
-        </Link>
+        <div className="flex flex-wrap items-center gap-2">
+          <GroceryExportButton listId={id} instacartEnabled={instacartEnabled} />
+          {access.role === "owner" && <ShareShoppingListButton listId={id} />}
+          <Link href={`/print/shopping-list/${id}`} target="_blank" className={cn(buttonVariants({ variant: "outline", size: "sm" }))}>
+            <Printer className="h-4 w-4" />
+            Print
+          </Link>
+        </div>
       </div>
       <ShoppingListView
         listId={id}
+        readOnly={!canEdit}
         initialItems={list.items.map((i) => ({
           id: i.id,
           rawName: i.rawName,

apps/web/app/(app)/shopping-lists/page.tsx

@@ -1,7 +1,7 @@
 import type { Metadata } from "next";
 import { headers } from "next/headers";
 import { auth } from "@/lib/auth/server";
-import { db, shoppingLists, eq, desc } from "@epicure/db";
+import { db, shoppingLists, shoppingListMembers, eq, desc } from "@epicure/db";
 import { ShoppingListsPageContent } from "@/components/shopping-lists/shopping-lists-page-content";
 
 export const metadata: Metadata = { title: "Shopping Lists" };
@@ -10,11 +10,17 @@ export default async function ShoppingListsPage() {
   const session = await auth.api.getSession({ headers: await headers() });
   if (!session) return null;
 
-  const lists = await db.query.shoppingLists.findMany({
-    where: eq(shoppingLists.userId, session.user.id),
-    orderBy: desc(shoppingLists.createdAt),
-    with: { items: { columns: { id: true, checked: true } } },
-  });
+  const [lists, memberships] = await Promise.all([
+    db.query.shoppingLists.findMany({
+      where: eq(shoppingLists.userId, session.user.id),
+      orderBy: desc(shoppingLists.createdAt),
+      with: { items: { columns: { id: true, checked: true } } },
+    }),
+    db.query.shoppingListMembers.findMany({
+      where: eq(shoppingListMembers.userId, session.user.id),
+      with: { list: { with: { user: true } } },
+    }),
+  ]);
 
   return (
     <ShoppingListsPageContent
@@ -25,6 +31,12 @@ export default async function ShoppingListsPage() {
         totalItems: list.items.length,
         checkedItems: list.items.filter((i) => i.checked).length,
       }))}
+      sharedLists={memberships.map((m) => ({
+        id: m.list.id,
+        name: m.list.name,
+        ownerName: m.list.user?.name ?? "Unknown",
+        role: m.role,
+      }))}
     />
   );
 }

apps/web/app/api/v1/feed/for-you/route.ts

@@ -0,0 +1,69 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db, recipes, users, favorites, ratings, eq, and, ne, gte, notInArray, inArray, desc } from "@epicure/db";
+import { requireSession } from "@/lib/api-auth";
+import { buildPreferenceMap, rankForYou } from "@/lib/for-you-ranking";
+
+export async function GET(req: NextRequest) {
+  const { session, response } = await requireSession();
+  if (response) return response;
+  const userId = session!.user.id;
+
+  const { searchParams } = new URL(req.url);
+  const limit = Math.min(parseInt(searchParams.get("limit") ?? "20"), 50);
+
+  // Recipes the user has favorited, or rated 4+, define their taste profile.
+  const [favoritedRows, highRatedRows] = await Promise.all([
+    db.select({ recipeId: favorites.recipeId }).from(favorites).where(eq(favorites.userId, userId)),
+    db.select({ recipeId: ratings.recipeId }).from(ratings).where(and(eq(ratings.userId, userId), gte(ratings.score, 4))),
+  ]);
+
+  const likedIds = [...new Set([...favoritedRows.map((r) => r.recipeId), ...highRatedRows.map((r) => r.recipeId)])];
+
+  const likedRecipes = likedIds.length > 0
+    ? await db.select({ tags: recipes.tags, dietaryTags: recipes.dietaryTags }).from(recipes).where(inArray(recipes.id, likedIds))
+    : [];
+
+  const preferences = buildPreferenceMap(likedRecipes);
+
+  const excludeIds = likedIds.length > 0 ? likedIds : ["__none__"];
+
+  const candidates = await db
+    .select({
+      id: recipes.id,
+      title: recipes.title,
+      description: recipes.description,
+      baseServings: recipes.baseServings,
+      prepMins: recipes.prepMins,
+      cookMins: recipes.cookMins,
+      difficulty: recipes.difficulty,
+      visibility: recipes.visibility,
+      aiGenerated: recipes.aiGenerated,
+      createdAt: recipes.createdAt,
+      authorId: recipes.authorId,
+      authorName: users.name,
+      authorUsername: users.username,
+      authorAvatarUrl: users.avatarUrl,
+      tags: recipes.tags,
+      dietaryTags: recipes.dietaryTags,
+    })
+    .from(recipes)
+    .innerJoin(users, eq(recipes.authorId, users.id))
+    .where(and(
+      eq(recipes.visibility, "public"),
+      ne(recipes.authorId, userId),
+      notInArray(recipes.id, excludeIds)
+    ))
+    .orderBy(desc(recipes.createdAt))
+    .limit(200); // score a bounded recent window rather than the whole table
+
+  const ranked = preferences.size > 0
+    ? rankForYou(candidates, preferences)
+    : [...candidates].sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+
+  const data = ranked.slice(0, limit).map(({ tags: _tags, dietaryTags: _dietaryTags, ...r }) => ({
+    ...r,
+    createdAt: r.createdAt.toISOString(),
+  }));
+
+  return NextResponse.json({ data });
+}

apps/web/app/api/v1/meal-plans/[weekStart]/members/__tests__/route.test.ts

@@ -0,0 +1,137 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { NextRequest } from "next/server";
+
+const mockSession = { user: { id: "user-1" } };
+
+vi.mock("@/lib/api-auth", () => ({
+  requireSession: vi.fn(),
+}));
+
+const { mockPlanFindFirst, mockMemberFindFirst, mockMemberFindMany, mockUserFindFirst, mockInsertValues, mockInsertPlanValues, mockDeleteWhere } = vi.hoisted(() => ({
+  mockPlanFindFirst: vi.fn(),
+  mockMemberFindFirst: vi.fn(),
+  mockMemberFindMany: vi.fn(),
+  mockUserFindFirst: vi.fn(),
+  mockInsertValues: vi.fn().mockResolvedValue(undefined),
+  mockInsertPlanValues: vi.fn().mockResolvedValue(undefined),
+  mockDeleteWhere: vi.fn().mockResolvedValue(undefined),
+}));
+
+vi.mock("@epicure/db", () => ({
+  db: {
+    query: {
+      mealPlans: { findFirst: mockPlanFindFirst },
+      mealPlanMembers: { findFirst: mockMemberFindFirst, findMany: mockMemberFindMany },
+      users: { findFirst: mockUserFindFirst },
+    },
+    insert: vi.fn(() => ({ values: mockInsertValues })),
+    delete: vi.fn(() => ({ where: mockDeleteWhere })),
+  },
+  mealPlans: { id: "id", userId: "user_id", weekStart: "week_start" },
+  mealPlanMembers: { id: "id", mealPlanId: "meal_plan_id", userId: "user_id" },
+  users: { id: "id", email: "email" },
+  eq: vi.fn((a, b) => ({ a, b, op: "eq" })),
+  and: vi.fn((...args) => ({ args, op: "and" })),
+}));
+
+const { requireSession } = await import("@/lib/api-auth");
+import { GET, POST, DELETE } from "../route";
+
+const ctx = { params: Promise.resolve({ weekStart: "2026-06-01" }) };
+
+function makeRequest(method: string, body?: unknown, search = "") {
+  return new NextRequest(`http://localhost/api/v1/meal-plans/2026-06-01/members${search}`, {
+    method,
+    headers: { "Content-Type": "application/json" },
+    body: body ? JSON.stringify(body) : undefined,
+  });
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  vi.mocked(requireSession).mockResolvedValue({ session: mockSession as never, response: null });
+});
+
+describe("GET /api/v1/meal-plans/[weekStart]/members", () => {
+  it("returns an empty list when the owner has no plan for this week yet", async () => {
+    mockPlanFindFirst.mockResolvedValue(undefined);
+    const res = await GET(makeRequest("GET"), ctx);
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual([]);
+  });
+
+  it("returns members for an existing plan", async () => {
+    mockPlanFindFirst.mockResolvedValue({ id: "plan-1", userId: "user-1" });
+    mockMemberFindMany.mockResolvedValue([
+      { id: "m1", userId: "user-2", role: "editor", createdAt: new Date(), user: { name: "Bob", username: null, avatarUrl: null } },
+    ]);
+    const res = await GET(makeRequest("GET"), ctx);
+    const body = await res.json() as unknown[];
+    expect(body).toHaveLength(1);
+  });
+});
+
+describe("POST /api/v1/meal-plans/[weekStart]/members", () => {
+  it("returns 400 on invalid body", async () => {
+    const res = await POST(makeRequest("POST", { role: "viewer" }), ctx);
+    expect(res.status).toBe(400);
+  });
+
+  it("returns 404 when the target user doesn't exist", async () => {
+    mockUserFindFirst.mockResolvedValue(undefined);
+    const res = await POST(makeRequest("POST", { email: "b@test.com", role: "viewer" }), ctx);
+    expect(res.status).toBe(404);
+  });
+
+  it("returns 400 when inviting yourself", async () => {
+    mockUserFindFirst.mockResolvedValue({ id: "user-1" });
+    const res = await POST(makeRequest("POST", { email: "a@test.com", role: "viewer" }), ctx);
+    expect(res.status).toBe(400);
+  });
+
+  it("auto-creates the plan for the week and invites the member", async () => {
+    mockUserFindFirst.mockResolvedValue({ id: "user-2" });
+    mockPlanFindFirst.mockResolvedValue(undefined); // no plan yet for this week
+    mockMemberFindFirst.mockResolvedValue(undefined);
+    const res = await POST(makeRequest("POST", { email: "b@test.com", role: "editor" }), ctx);
+    expect(res.status).toBe(201);
+    expect(mockInsertValues).toHaveBeenCalledWith(expect.objectContaining({ userId: "user-1", weekStart: "2026-06-01" }));
+    expect(mockInsertValues).toHaveBeenCalledWith(expect.objectContaining({ userId: "user-2", role: "editor" }));
+  });
+
+  it("returns 409 when already a member", async () => {
+    mockUserFindFirst.mockResolvedValue({ id: "user-2" });
+    mockPlanFindFirst.mockResolvedValue({ id: "plan-1", userId: "user-1", weekStart: "2026-06-01" });
+    mockMemberFindFirst.mockResolvedValue({ id: "existing" });
+    const res = await POST(makeRequest("POST", { email: "b@test.com", role: "viewer" }), ctx);
+    expect(res.status).toBe(409);
+  });
+});
+
+describe("DELETE /api/v1/meal-plans/[weekStart]/members", () => {
+  it("returns 400 when memberId is missing", async () => {
+    const res = await DELETE(makeRequest("DELETE"), ctx);
+    expect(res.status).toBe(400);
+  });
+
+  it("returns 404 when the owner has no plan for this week", async () => {
+    mockPlanFindFirst.mockResolvedValue(undefined);
+    const res = await DELETE(makeRequest("DELETE", undefined, "?memberId=m1"), ctx);
+    expect(res.status).toBe(404);
+  });
+
+  it("returns 403 when caller is neither owner nor the member themselves", async () => {
+    mockPlanFindFirst.mockResolvedValue({ id: "plan-1", userId: "user-1" });
+    mockMemberFindFirst.mockResolvedValue({ id: "m1", userId: "user-2" });
+    vi.mocked(requireSession).mockResolvedValue({ session: { user: { id: "user-3" } } as never, response: null });
+    const res = await DELETE(makeRequest("DELETE", undefined, "?memberId=m1"), ctx);
+    expect(res.status).toBe(403);
+  });
+
+  it("allows the owner to remove a member", async () => {
+    mockPlanFindFirst.mockResolvedValue({ id: "plan-1", userId: "user-1" });
+    mockMemberFindFirst.mockResolvedValue({ id: "m1", userId: "user-2" });
+    const res = await DELETE(makeRequest("DELETE", undefined, "?memberId=m1"), ctx);
+    expect(res.status).toBe(204);
+  });
+});

apps/web/app/api/v1/meal-plans/[weekStart]/members/route.ts

@@ -0,0 +1,122 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import { db, mealPlans, mealPlanMembers, users, eq, and } from "@epicure/db";
+import { requireSession } from "@/lib/api-auth";
+
+type Params = { params: Promise<{ weekStart: string }> };
+
+async function getOrCreatePlan(userId: string, weekStart: string) {
+  const existing = await db.query.mealPlans.findFirst({
+    where: and(eq(mealPlans.userId, userId), eq(mealPlans.weekStart, weekStart)),
+  });
+  if (existing) return existing;
+
+  const id = crypto.randomUUID();
+  await db.insert(mealPlans).values({ id, userId, weekStart });
+  return { id, userId, weekStart, createdAt: new Date() };
+}
+
+// ─── GET /api/v1/meal-plans/[weekStart]/members ──────────────────────────────
+// Owner only — returns members joined with basic user info.
+export async function GET(_req: NextRequest, { params }: Params) {
+  const { session, response } = await requireSession();
+  if (response) return response;
+  const { weekStart } = await params;
+
+  const plan = await db.query.mealPlans.findFirst({
+    where: and(eq(mealPlans.userId, session!.user.id), eq(mealPlans.weekStart, weekStart)),
+  });
+  if (!plan) return NextResponse.json([]);
+
+  const members = await db.query.mealPlanMembers.findMany({
+    where: eq(mealPlanMembers.mealPlanId, plan.id),
+    with: { user: true },
+  });
+
+  return NextResponse.json(
+    members.map((m) => ({
+      id: m.id,
+      userId: m.userId,
+      role: m.role,
+      createdAt: m.createdAt,
+      user: { name: m.user.name, username: m.user.username, avatarUrl: m.user.avatarUrl },
+    }))
+  );
+}
+
+// ─── POST /api/v1/meal-plans/[weekStart]/members ─────────────────────────────
+// Owner only — invite by email or userId. Auto-creates the plan for this week if missing.
+const InviteSchema = z
+  .object({
+    email: z.string().email().optional(),
+    userId: z.string().optional(),
+    role: z.enum(["viewer", "editor"]),
+  })
+  .refine((d) => d.email !== undefined || d.userId !== undefined, {
+    message: "Provide either email or userId",
+  });
+
+export async function POST(req: NextRequest, { params }: Params) {
+  const { session, response } = await requireSession();
+  if (response) return response;
+  const { weekStart } = await params;
+
+  const body = await req.json() as unknown;
+  const parsed = InviteSchema.safeParse(body);
+  if (!parsed.success) return NextResponse.json({ error: "Validation error" }, { status: 400 });
+
+  const { email, userId, role } = parsed.data;
+
+  const targetUser = await db.query.users.findFirst({
+    where: email ? eq(users.email, email) : eq(users.id, userId!),
+  });
+  if (!targetUser) return NextResponse.json({ error: "User not found" }, { status: 404 });
+
+  if (targetUser.id === session!.user.id) {
+    return NextResponse.json({ error: "Cannot invite yourself" }, { status: 400 });
+  }
+
+  const plan = await getOrCreatePlan(session!.user.id, weekStart);
+
+  const existing = await db.query.mealPlanMembers.findFirst({
+    where: and(eq(mealPlanMembers.mealPlanId, plan.id), eq(mealPlanMembers.userId, targetUser.id)),
+  });
+  if (existing) return NextResponse.json({ error: "Already a member" }, { status: 409 });
+
+  const memberId = crypto.randomUUID();
+  await db.insert(mealPlanMembers).values({
+    id: memberId,
+    mealPlanId: plan.id,
+    userId: targetUser.id,
+    role,
+  });
+
+  return NextResponse.json({ id: memberId, mealPlanId: plan.id }, { status: 201 });
+}
+
+// ─── DELETE /api/v1/meal-plans/[weekStart]/members?memberId=… ────────────────
+// Owner OR the member themselves can remove.
+export async function DELETE(req: NextRequest, { params }: Params) {
+  const { session, response } = await requireSession();
+  if (response) return response;
+  const { weekStart } = await params;
+  const memberId = req.nextUrl.searchParams.get("memberId");
+  if (!memberId) return NextResponse.json({ error: "memberId required" }, { status: 400 });
+
+  const plan = await db.query.mealPlans.findFirst({
+    where: and(eq(mealPlans.userId, session!.user.id), eq(mealPlans.weekStart, weekStart)),
+  });
+  if (!plan) return NextResponse.json({ error: "Not found" }, { status: 404 });
+
+  const member = await db.query.mealPlanMembers.findFirst({
+    where: and(eq(mealPlanMembers.id, memberId), eq(mealPlanMembers.mealPlanId, plan.id)),
+  });
+  if (!member) return NextResponse.json({ error: "Not found" }, { status: 404 });
+
+  const isOwner = plan.userId === session!.user.id;
+  const isSelf = member.userId === session!.user.id;
+  if (!isOwner && !isSelf) return NextResponse.json({ error: "Forbidden" }, { status: 403 });
+
+  await db.delete(mealPlanMembers).where(eq(mealPlanMembers.id, memberId));
+  return new NextResponse(null, { status: 204 });
+}

apps/web/app/api/v1/meal-plans/shared/[mealPlanId]/entries/__tests__/route.test.ts

@@ -0,0 +1,104 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { NextRequest } from "next/server";
+
+const mockSession = { user: { id: "user-2" } };
+
+vi.mock("@/lib/api-auth", () => ({
+  requireSession: vi.fn(),
+}));
+
+vi.mock("@/lib/webhooks", () => ({
+  dispatchWebhook: vi.fn(),
+}));
+
+const { mockPlanFindFirst, mockMemberFindFirst, mockRecipeFindFirst, mockInsertValues, mockDeleteWhere } = vi.hoisted(() => ({
+  mockPlanFindFirst: vi.fn(),
+  mockMemberFindFirst: vi.fn(),
+  mockRecipeFindFirst: vi.fn(),
+  mockInsertValues: vi.fn().mockResolvedValue(undefined),
+  mockDeleteWhere: vi.fn().mockResolvedValue(undefined),
+}));
+
+vi.mock("@epicure/db", () => ({
+  db: {
+    query: {
+      mealPlans: { findFirst: mockPlanFindFirst },
+      mealPlanMembers: { findFirst: mockMemberFindFirst },
+      recipes: { findFirst: mockRecipeFindFirst },
+    },
+    insert: vi.fn(() => ({ values: mockInsertValues })),
+    delete: vi.fn(() => ({ where: mockDeleteWhere })),
+  },
+  mealPlans: { id: "id", userId: "user_id" },
+  mealPlanMembers: { mealPlanId: "meal_plan_id", userId: "user_id" },
+  mealPlanEntries: { id: "id", mealPlanId: "meal_plan_id", day: "day", mealType: "meal_type" },
+  recipes: { id: "id", authorId: "author_id", visibility: "visibility" },
+  eq: vi.fn((a, b) => ({ a, b, op: "eq" })),
+  and: vi.fn((...args) => ({ args, op: "and" })),
+  or: vi.fn((...args) => ({ args, op: "or" })),
+  ne: vi.fn((a, b) => ({ a, b, op: "ne" })),
+}));
+
+const { requireSession } = await import("@/lib/api-auth");
+import { POST, DELETE } from "../route";
+
+const ctx = { params: Promise.resolve({ mealPlanId: "plan-1" }) };
+
+function makeRequest(method: string, body?: unknown, search = "") {
+  return new NextRequest(`http://localhost/api/v1/meal-plans/shared/plan-1/entries${search}`, {
+    method,
+    headers: { "Content-Type": "application/json" },
+    body: body ? JSON.stringify(body) : undefined,
+  });
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  vi.mocked(requireSession).mockResolvedValue({ session: mockSession as never, response: null });
+  mockPlanFindFirst.mockResolvedValue({ id: "plan-1", userId: "user-1" });
+});
+
+const validBody = { day: "mon", mealType: "dinner", recipeId: "r-1", servings: 2 };
+
+describe("POST /api/v1/meal-plans/shared/[mealPlanId]/entries", () => {
+  it("returns 404 when the caller has no access to the plan", async () => {
+    mockMemberFindFirst.mockResolvedValue(undefined);
+    const res = await POST(makeRequest("POST", validBody), ctx);
+    expect(res.status).toBe(404);
+  });
+
+  it("returns 403 for a viewer trying to add an entry", async () => {
+    mockMemberFindFirst.mockResolvedValue({ role: "viewer" });
+    const res = await POST(makeRequest("POST", validBody), ctx);
+    expect(res.status).toBe(403);
+  });
+
+  it("allows an editor to add an entry", async () => {
+    mockMemberFindFirst.mockResolvedValue({ role: "editor" });
+    mockRecipeFindFirst.mockResolvedValue({ id: "r-1" });
+    const res = await POST(makeRequest("POST", validBody), ctx);
+    expect(res.status).toBe(201);
+    expect(mockInsertValues).toHaveBeenCalledWith(expect.objectContaining({ mealPlanId: "plan-1", day: "mon" }));
+  });
+
+  it("returns 404 when the recipe isn't accessible to the editor", async () => {
+    mockMemberFindFirst.mockResolvedValue({ role: "editor" });
+    mockRecipeFindFirst.mockResolvedValue(undefined);
+    const res = await POST(makeRequest("POST", validBody), ctx);
+    expect(res.status).toBe(404);
+  });
+});
+
+describe("DELETE /api/v1/meal-plans/shared/[mealPlanId]/entries", () => {
+  it("returns 403 for a viewer trying to remove an entry", async () => {
+    mockMemberFindFirst.mockResolvedValue({ role: "viewer" });
+    const res = await DELETE(makeRequest("DELETE", undefined, "?entryId=e1"), ctx);
+    expect(res.status).toBe(403);
+  });
+
+  it("allows an editor to remove an entry", async () => {
+    mockMemberFindFirst.mockResolvedValue({ role: "editor" });
+    const res = await DELETE(makeRequest("DELETE", undefined, "?entryId=e1"), ctx);
+    expect(res.status).toBe(204);
+  });
+});

apps/web/app/api/v1/meal-plans/shared/[mealPlanId]/entries/route.ts

@@ -0,0 +1,81 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import { db, mealPlanEntries, recipes, eq, and, or, ne } from "@epicure/db";
+import { requireSession } from "@/lib/api-auth";
+import { getMealPlanAccessById, canWriteMealPlan } from "@/lib/meal-plan-access";
+import { dispatchWebhook } from "@/lib/webhooks";
+
+type Params = { params: Promise<{ mealPlanId: string }> };
+
+const Schema = z.object({
+  day: z.enum(["mon", "tue", "wed", "thu", "fri", "sat", "sun"]),
+  mealType: z.enum(["breakfast", "lunch", "dinner", "snack"]),
+  recipeId: z.string().optional(),
+  servings: z.number().int().min(1).max(100).default(2),
+  note: z.string().max(500).optional(),
+});
+
+export async function POST(req: NextRequest, { params }: Params) {
+  const { session, response } = await requireSession();
+  if (response) return response;
+  const { mealPlanId } = await params;
+
+  const access = await getMealPlanAccessById(mealPlanId, session!.user.id);
+  if (!access) return NextResponse.json({ error: "Not found" }, { status: 404 });
+  if (!canWriteMealPlan(access.role)) return NextResponse.json({ error: "Forbidden" }, { status: 403 });
+
+  const body = await req.json() as unknown;
+  const parsed = Schema.safeParse(body);
+  if (!parsed.success) return NextResponse.json({ error: "Validation error" }, { status: 400 });
+
+  if (parsed.data.recipeId) {
+    const recipe = await db.query.recipes.findFirst({
+      where: and(
+        eq(recipes.id, parsed.data.recipeId),
+        or(eq(recipes.authorId, session!.user.id), ne(recipes.visibility, "private"))
+      ),
+    });
+    if (!recipe) return NextResponse.json({ error: "Recipe not found" }, { status: 404 });
+  }
+
+  await db.delete(mealPlanEntries).where(
+    and(
+      eq(mealPlanEntries.mealPlanId, mealPlanId),
+      eq(mealPlanEntries.day, parsed.data.day),
+      eq(mealPlanEntries.mealType, parsed.data.mealType)
+    )
+  );
+
+  const entryId = crypto.randomUUID();
+  await db.insert(mealPlanEntries).values({
+    id: entryId,
+    mealPlanId,
+    day: parsed.data.day,
+    mealType: parsed.data.mealType,
+    recipeId: parsed.data.recipeId,
+    servings: parsed.data.servings,
+    note: parsed.data.note,
+  });
+
+  void dispatchWebhook(access.plan.userId, "meal_plan.updated", { mealPlanId, day: parsed.data.day, mealType: parsed.data.mealType });
+  return NextResponse.json({ id: entryId }, { status: 201 });
+}
+
+export async function DELETE(req: NextRequest, { params }: Params) {
+  const { session, response } = await requireSession();
+  if (response) return response;
+  const { mealPlanId } = await params;
+
+  const access = await getMealPlanAccessById(mealPlanId, session!.user.id);
+  if (!access) return NextResponse.json({ error: "Not found" }, { status: 404 });
+  if (!canWriteMealPlan(access.role)) return NextResponse.json({ error: "Forbidden" }, { status: 403 });
+
+  const entryId = req.nextUrl.searchParams.get("entryId");
+  if (!entryId) return NextResponse.json({ error: "entryId required" }, { status: 400 });
+
+  await db.delete(mealPlanEntries).where(
+    and(eq(mealPlanEntries.id, entryId), eq(mealPlanEntries.mealPlanId, mealPlanId))
+  );
+
+  return new NextResponse(null, { status: 204 });
+}

apps/web/app/api/v1/meal-plans/shared/[mealPlanId]/route.ts

@@ -0,0 +1,27 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db, mealPlans, users, eq } from "@epicure/db";
+import { requireSession } from "@/lib/api-auth";
+import { getMealPlanAccessById } from "@/lib/meal-plan-access";
+
+type Params = { params: Promise<{ mealPlanId: string }> };
+
+export async function GET(_req: NextRequest, { params }: Params) {
+  const { session, response } = await requireSession();
+  if (response) return response;
+  const { mealPlanId } = await params;
+
+  const access = await getMealPlanAccessById(mealPlanId, session!.user.id);
+  if (!access) return NextResponse.json({ error: "Not found" }, { status: 404 });
+
+  const plan = await db.query.mealPlans.findFirst({
+    where: eq(mealPlans.id, mealPlanId),
+    with: {
+      entries: { with: { recipe: { with: { photos: true } } } },
+    },
+  });
+  if (!plan) return NextResponse.json({ error: "Not found" }, { status: 404 });
+
+  const owner = await db.query.users.findFirst({ where: eq(users.id, plan.userId) });
+
+  return NextResponse.json({ ...plan, role: access.role, owner: owner ? { name: owner.name } : null });
+}

apps/web/app/api/v1/shopping-lists/[id]/export/instacart/route.ts

@@ -0,0 +1,33 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db, shoppingLists, eq } from "@epicure/db";
+import { requireSession } from "@/lib/api-auth";
+import { getShoppingListAccess } from "@/lib/shopping-list-access";
+import { buildGroceryExportPayload } from "@/lib/grocery-export";
+import { createInstacartShoppingListLink } from "@/lib/grocery-providers/instacart";
+
+type Params = { params: Promise<{ id: string }> };
+
+export async function POST(_req: NextRequest, { params }: Params) {
+  const { session, response } = await requireSession();
+  if (response) return response;
+  const { id } = await params;
+
+  const access = await getShoppingListAccess(id, session!.user.id);
+  if (!access) return NextResponse.json({ error: "Not found" }, { status: 404 });
+
+  const list = await db.query.shoppingLists.findFirst({
+    where: eq(shoppingLists.id, id),
+    with: { items: true },
+  });
+  if (!list) return NextResponse.json({ error: "Not found" }, { status: 404 });
+
+  const payload = buildGroceryExportPayload(list);
+
+  try {
+    const result = await createInstacartShoppingListLink(payload);
+    if (!result) return NextResponse.json({ error: "Instacart is not configured" }, { status: 501 });
+    return NextResponse.json(result);
+  } catch (err) {
+    return NextResponse.json({ error: String(err instanceof Error ? err.message : err) }, { status: 501 });
+  }
+}

apps/web/app/api/v1/shopping-lists/[id]/export/route.ts

@@ -0,0 +1,25 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db, shoppingLists, eq } from "@epicure/db";
+import { requireSession } from "@/lib/api-auth";
+import { getShoppingListAccess } from "@/lib/shopping-list-access";
+import { buildGroceryExportPayload } from "@/lib/grocery-export";
+
+type Params = { params: Promise<{ id: string }> };
+
+export async function GET(_req: NextRequest, { params }: Params) {
+  const { session, response } = await requireSession();
+  if (response) return response;
+  const { id } = await params;
+
+  const access = await getShoppingListAccess(id, session!.user.id);
+  if (!access) return NextResponse.json({ error: "Not found" }, { status: 404 });
+
+  const list = await db.query.shoppingLists.findFirst({
+    where: eq(shoppingLists.id, id),
+    with: { items: true },
+  });
+  if (!list) return NextResponse.json({ error: "Not found" }, { status: 404 });
+
+  const payload = buildGroceryExportPayload(list);
+  return NextResponse.json(payload);
+}

apps/web/app/api/v1/shopping-lists/[id]/items/[itemId]/route.ts

@@ -1,6 +1,7 @@
 import { NextRequest, NextResponse } from "next/server";
-import { db, shoppingLists, shoppingListItems, eq, and } from "@epicure/db";
+import { db, shoppingListItems, eq, and } from "@epicure/db";
 import { requireSession } from "@/lib/api-auth";
+import { getShoppingListAccess, canWriteShoppingList } from "@/lib/shopping-list-access";
 
 type Params = { params: Promise<{ id: string; itemId: string }> };
 
@@ -9,10 +10,9 @@ export async function PUT(req: NextRequest, { params }: Params) {
   if (response) return response;
   const { id, itemId } = await params;
 
-  const list = await db.query.shoppingLists.findFirst({
-    where: and(eq(shoppingLists.id, id), eq(shoppingLists.userId, session!.user.id)),
-  });
-  if (!list) return NextResponse.json({ error: "Not found" }, { status: 404 });
+  const access = await getShoppingListAccess(id, session!.user.id);
+  if (!access) return NextResponse.json({ error: "Not found" }, { status: 404 });
+  if (!canWriteShoppingList(access.role)) return NextResponse.json({ error: "Forbidden" }, { status: 403 });
 
   const body = await req.json() as { checked?: boolean };
   await db.update(shoppingListItems)

apps/web/app/api/v1/shopping-lists/[id]/items/route.ts

@@ -1,7 +1,8 @@
 import { NextRequest, NextResponse } from "next/server";
 import { z } from "zod";
-import { db, shoppingLists, shoppingListItems, eq, and } from "@epicure/db";
+import { db, shoppingListItems } from "@epicure/db";
 import { requireSession } from "@/lib/api-auth";
+import { getShoppingListAccess, canWriteShoppingList } from "@/lib/shopping-list-access";
 
 const AddItemsSchema = z.object({
   items: z.array(z.object({
@@ -19,10 +20,9 @@ export async function POST(req: NextRequest, { params }: Params) {
   if (response) return response;
   const { id } = await params;
 
-  const list = await db.query.shoppingLists.findFirst({
-    where: and(eq(shoppingLists.id, id), eq(shoppingLists.userId, session!.user.id)),
-  });
-  if (!list) return NextResponse.json({ error: "Not found" }, { status: 404 });
+  const access = await getShoppingListAccess(id, session!.user.id);
+  if (!access) return NextResponse.json({ error: "Not found" }, { status: 404 });
+  if (!canWriteShoppingList(access.role)) return NextResponse.json({ error: "Forbidden" }, { status: 403 });
 
   const body = await req.json() as unknown;
   const parsed = AddItemsSchema.safeParse(body);

apps/web/app/api/v1/shopping-lists/[id]/members/__tests__/route.test.ts

@@ -0,0 +1,149 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { NextRequest } from "next/server";
+
+const mockSession = { user: { id: "user-1" } };
+
+vi.mock("@/lib/api-auth", () => ({
+  requireSession: vi.fn(),
+}));
+
+const { mockListFindFirst, mockMemberFindFirst, mockMemberFindMany, mockUserFindFirst, mockInsertValues, mockDeleteWhere } = vi.hoisted(() => ({
+  mockListFindFirst: vi.fn(),
+  mockMemberFindFirst: vi.fn(),
+  mockMemberFindMany: vi.fn(),
+  mockUserFindFirst: vi.fn(),
+  mockInsertValues: vi.fn().mockResolvedValue(undefined),
+  mockDeleteWhere: vi.fn().mockResolvedValue(undefined),
+}));
+
+vi.mock("@epicure/db", () => ({
+  db: {
+    query: {
+      shoppingLists: { findFirst: mockListFindFirst },
+      shoppingListMembers: { findFirst: mockMemberFindFirst, findMany: mockMemberFindMany },
+      users: { findFirst: mockUserFindFirst },
+    },
+    insert: vi.fn(() => ({ values: mockInsertValues })),
+    delete: vi.fn(() => ({ where: mockDeleteWhere })),
+  },
+  shoppingLists: { id: "id", userId: "user_id" },
+  shoppingListMembers: { id: "id", listId: "list_id", userId: "user_id" },
+  users: { id: "id", email: "email" },
+  eq: vi.fn((a, b) => ({ a, b, op: "eq" })),
+  and: vi.fn((...args) => ({ args, op: "and" })),
+}));
+
+const { requireSession } = await import("@/lib/api-auth");
+import { GET, POST, DELETE } from "../route";
+
+const ctx = { params: Promise.resolve({ id: "list-1" }) };
+
+function makeRequest(method: string, body?: unknown, search = "") {
+  return new NextRequest(`http://localhost/api/v1/shopping-lists/list-1/members${search}`, {
+    method,
+    headers: { "Content-Type": "application/json" },
+    body: body ? JSON.stringify(body) : undefined,
+  });
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  vi.mocked(requireSession).mockResolvedValue({ session: mockSession as never, response: null });
+});
+
+describe("GET /api/v1/shopping-lists/[id]/members", () => {
+  it("returns 404 when the caller is not the owner", async () => {
+    mockListFindFirst.mockResolvedValue(undefined);
+    const res = await GET(makeRequest("GET"), ctx);
+    expect(res.status).toBe(404);
+  });
+
+  it("returns the member list for the owner", async () => {
+    mockListFindFirst.mockResolvedValue({ id: "list-1", userId: "user-1" });
+    mockMemberFindMany.mockResolvedValue([
+      { id: "m1", userId: "user-2", role: "viewer", createdAt: new Date(), user: { name: "Bob", username: "bob", avatarUrl: null } },
+    ]);
+    const res = await GET(makeRequest("GET"), ctx);
+    expect(res.status).toBe(200);
+    const body = await res.json() as unknown[];
+    expect(body).toHaveLength(1);
+  });
+});
+
+describe("POST /api/v1/shopping-lists/[id]/members", () => {
+  beforeEach(() => {
+    mockListFindFirst.mockResolvedValue({ id: "list-1", userId: "user-1" });
+  });
+
+  it("returns 404 when the caller is not the owner", async () => {
+    mockListFindFirst.mockResolvedValue(undefined);
+    const res = await POST(makeRequest("POST", { email: "b@test.com", role: "viewer" }), ctx);
+    expect(res.status).toBe(404);
+  });
+
+  it("returns 400 on invalid body", async () => {
+    const res = await POST(makeRequest("POST", { role: "viewer" }), ctx);
+    expect(res.status).toBe(400);
+  });
+
+  it("returns 404 when the target user doesn't exist", async () => {
+    mockUserFindFirst.mockResolvedValue(undefined);
+    const res = await POST(makeRequest("POST", { email: "b@test.com", role: "viewer" }), ctx);
+    expect(res.status).toBe(404);
+  });
+
+  it("returns 400 when inviting yourself", async () => {
+    mockUserFindFirst.mockResolvedValue({ id: "user-1", email: "a@test.com" });
+    const res = await POST(makeRequest("POST", { email: "a@test.com", role: "viewer" }), ctx);
+    expect(res.status).toBe(400);
+  });
+
+  it("returns 409 when already a member", async () => {
+    mockUserFindFirst.mockResolvedValue({ id: "user-2", email: "b@test.com" });
+    mockMemberFindFirst.mockResolvedValue({ id: "existing" });
+    const res = await POST(makeRequest("POST", { email: "b@test.com", role: "viewer" }), ctx);
+    expect(res.status).toBe(409);
+  });
+
+  it("creates the membership on success", async () => {
+    mockUserFindFirst.mockResolvedValue({ id: "user-2", email: "b@test.com" });
+    mockMemberFindFirst.mockResolvedValue(undefined);
+    const res = await POST(makeRequest("POST", { email: "b@test.com", role: "editor" }), ctx);
+    expect(res.status).toBe(201);
+    expect(mockInsertValues).toHaveBeenCalledWith(expect.objectContaining({ listId: "list-1", userId: "user-2", role: "editor" }));
+  });
+});
+
+describe("DELETE /api/v1/shopping-lists/[id]/members", () => {
+  it("returns 400 when memberId is missing", async () => {
+    const res = await DELETE(makeRequest("DELETE"), ctx);
+    expect(res.status).toBe(400);
+  });
+
+  it("returns 404 when the member doesn't exist", async () => {
+    mockMemberFindFirst.mockResolvedValue(undefined);
+    const res = await DELETE(makeRequest("DELETE", undefined, "?memberId=m1"), ctx);
+    expect(res.status).toBe(404);
+  });
+
+  it("returns 403 when caller is neither owner nor the member themselves", async () => {
+    mockMemberFindFirst.mockResolvedValue({ id: "m1", userId: "user-2" });
+    mockListFindFirst.mockResolvedValue({ id: "list-1", userId: "user-3" });
+    const res = await DELETE(makeRequest("DELETE", undefined, "?memberId=m1"), ctx);
+    expect(res.status).toBe(403);
+  });
+
+  it("allows the owner to remove a member", async () => {
+    mockMemberFindFirst.mockResolvedValue({ id: "m1", userId: "user-2" });
+    mockListFindFirst.mockResolvedValue({ id: "list-1", userId: "user-1" });
+    const res = await DELETE(makeRequest("DELETE", undefined, "?memberId=m1"), ctx);
+    expect(res.status).toBe(204);
+  });
+
+  it("allows a member to remove themselves", async () => {
+    mockMemberFindFirst.mockResolvedValue({ id: "m1", userId: "user-1" });
+    mockListFindFirst.mockResolvedValue({ id: "list-1", userId: "user-3" });
+    const res = await DELETE(makeRequest("DELETE", undefined, "?memberId=m1"), ctx);
+    expect(res.status).toBe(204);
+  });
+});

apps/web/app/api/v1/shopping-lists/[id]/members/route.ts

@@ -0,0 +1,127 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import { db, shoppingLists, shoppingListMembers, users, eq, and } from "@epicure/db";
+import { requireSession } from "@/lib/api-auth";
+
+type Params = { params: Promise<{ id: string }> };
+
+// ─── GET /api/v1/shopping-lists/[id]/members ─────────────────────────────────
+// Owner only — returns members joined with basic user info.
+export async function GET(_req: NextRequest, { params }: Params) {
+  const { session, response } = await requireSession();
+  if (response) return response;
+
+  const { id } = await params;
+
+  const list = await db.query.shoppingLists.findFirst({
+    where: and(eq(shoppingLists.id, id), eq(shoppingLists.userId, session!.user.id)),
+  });
+  if (!list) return NextResponse.json({ error: "Not found" }, { status: 404 });
+
+  const members = await db.query.shoppingListMembers.findMany({
+    where: eq(shoppingListMembers.listId, id),
+    with: { user: true },
+  });
+
+  const result = members.map((m) => ({
+    id: m.id,
+    userId: m.userId,
+    role: m.role,
+    createdAt: m.createdAt,
+    user: {
+      name: m.user.name,
+      username: m.user.username,
+      avatarUrl: m.user.avatarUrl,
+    },
+  }));
+
+  return NextResponse.json(result);
+}
+
+// ─── POST /api/v1/shopping-lists/[id]/members ────────────────────────────────
+// Owner only — invite by email or userId.
+const InviteSchema = z
+  .object({
+    email: z.string().email().optional(),
+    userId: z.string().optional(),
+    role: z.enum(["viewer", "editor"]),
+  })
+  .refine((d) => d.email !== undefined || d.userId !== undefined, {
+    message: "Provide either email or userId",
+  });
+
+export async function POST(req: NextRequest, { params }: Params) {
+  const { session, response } = await requireSession();
+  if (response) return response;
+
+  const { id } = await params;
+
+  const list = await db.query.shoppingLists.findFirst({
+    where: and(eq(shoppingLists.id, id), eq(shoppingLists.userId, session!.user.id)),
+  });
+  if (!list) return NextResponse.json({ error: "Not found" }, { status: 404 });
+
+  const body = await req.json() as unknown;
+  const parsed = InviteSchema.safeParse(body);
+  if (!parsed.success) return NextResponse.json({ error: "Validation error" }, { status: 400 });
+
+  const { email, userId, role } = parsed.data;
+
+  const targetUser = await db.query.users.findFirst({
+    where: email ? eq(users.email, email) : eq(users.id, userId!),
+  });
+  if (!targetUser) return NextResponse.json({ error: "User not found" }, { status: 404 });
+
+  if (targetUser.id === session!.user.id) {
+    return NextResponse.json({ error: "Cannot invite yourself" }, { status: 400 });
+  }
+
+  const existing = await db.query.shoppingListMembers.findFirst({
+    where: and(
+      eq(shoppingListMembers.listId, id),
+      eq(shoppingListMembers.userId, targetUser.id),
+    ),
+  });
+  if (existing) return NextResponse.json({ error: "Already a member" }, { status: 409 });
+
+  const memberId = crypto.randomUUID();
+  await db.insert(shoppingListMembers).values({
+    id: memberId,
+    listId: id,
+    userId: targetUser.id,
+    role,
+  });
+
+  return NextResponse.json({ id: memberId }, { status: 201 });
+}
+
+// ─── DELETE /api/v1/shopping-lists/[id]/members?memberId=… ───────────────────
+// Owner OR the member themselves can remove.
+export async function DELETE(req: NextRequest, { params }: Params) {
+  const { session, response } = await requireSession();
+  if (response) return response;
+
+  const { id } = await params;
+  const memberId = req.nextUrl.searchParams.get("memberId");
+  if (!memberId) return NextResponse.json({ error: "memberId required" }, { status: 400 });
+
+  const member = await db.query.shoppingListMembers.findFirst({
+    where: and(eq(shoppingListMembers.id, memberId), eq(shoppingListMembers.listId, id)),
+  });
+  if (!member) return NextResponse.json({ error: "Not found" }, { status: 404 });
+
+  const list = await db.query.shoppingLists.findFirst({
+    where: eq(shoppingLists.id, id),
+  });
+
+  const isOwner = list?.userId === session!.user.id;
+  const isSelf = member.userId === session!.user.id;
+
+  if (!isOwner && !isSelf) {
+    return NextResponse.json({ error: "Forbidden" }, { status: 403 });
+  }
+
+  await db.delete(shoppingListMembers).where(eq(shoppingListMembers.id, memberId));
+
+  return new NextResponse(null, { status: 204 });
+}

apps/web/app/api/v1/shopping-lists/[id]/route.ts

@@ -1,8 +1,9 @@
 import { NextRequest, NextResponse } from "next/server";
 import { z } from "zod";
-import { db, shoppingLists, shoppingListItems, eq, and } from "@epicure/db";
+import { db, shoppingLists, shoppingListItems, eq } from "@epicure/db";
 import { requireSession } from "@/lib/api-auth";
 import { dispatchWebhook } from "@/lib/webhooks";
+import { getShoppingListAccess, canWriteShoppingList } from "@/lib/shopping-list-access";
 
 type Params = { params: Promise<{ id: string }> };
 
@@ -11,12 +12,14 @@ export async function GET(_req: NextRequest, { params }: Params) {
   if (response) return response;
   const { id } = await params;
 
+  const access = await getShoppingListAccess(id, session!.user.id);
+  if (!access) return NextResponse.json({ error: "Not found" }, { status: 404 });
+
   const list = await db.query.shoppingLists.findFirst({
-    where: and(eq(shoppingLists.id, id), eq(shoppingLists.userId, session!.user.id)),
+    where: eq(shoppingLists.id, id),
     with: { items: { orderBy: (t, { asc }) => [asc(t.aisle), asc(t.rawName)] } },
   });
 
-  if (!list) return NextResponse.json({ error: "Not found" }, { status: 404 });
   return NextResponse.json(list);
 }
 
@@ -27,10 +30,9 @@ export async function PATCH(req: NextRequest, { params }: Params) {
   if (response) return response;
   const { id } = await params;
 
-  const list = await db.query.shoppingLists.findFirst({
-    where: and(eq(shoppingLists.id, id), eq(shoppingLists.userId, session!.user.id)),
-  });
-  if (!list) return NextResponse.json({ error: "Not found" }, { status: 404 });
+  const access = await getShoppingListAccess(id, session!.user.id);
+  if (!access) return NextResponse.json({ error: "Not found" }, { status: 404 });
+  if (!canWriteShoppingList(access.role)) return NextResponse.json({ error: "Forbidden" }, { status: 403 });
 
   const body = PatchSchema.safeParse(await req.json());
   if (!body.success) return NextResponse.json({ error: "Validation error" }, { status: 400 });
@@ -38,7 +40,7 @@ export async function PATCH(req: NextRequest, { params }: Params) {
   if (body.data.completed) {
     // Mark all items as checked
     await db.update(shoppingListItems).set({ checked: true }).where(eq(shoppingListItems.listId, id));
-    void dispatchWebhook(session!.user.id, "shopping_list.completed", { id, name: list.name });
+    void dispatchWebhook(session!.user.id, "shopping_list.completed", { id, name: access.list.name });
   }
 
   return NextResponse.json({ updated: true });
@@ -49,6 +51,10 @@ export async function DELETE(_req: NextRequest, { params }: Params) {
   if (response) return response;
   const { id } = await params;
 
-  await db.delete(shoppingLists).where(and(eq(shoppingLists.id, id), eq(shoppingLists.userId, session!.user.id)));
+  const access = await getShoppingListAccess(id, session!.user.id);
+  if (!access) return NextResponse.json({ error: "Not found" }, { status: 404 });
+  if (access.role !== "owner") return NextResponse.json({ error: "Forbidden" }, { status: 403 });
+
+  await db.delete(shoppingLists).where(eq(shoppingLists.id, id));
   return new NextResponse(null, { status: 204 });
 }

apps/web/app/layout.tsx

@@ -1,4 +1,4 @@
-import type { Metadata } from "next";
+import type { Metadata, Viewport } from "next";
 import { Lora, Geist_Mono } from "next/font/google";
 import { headers } from "next/headers";
 import { Providers } from "@/components/providers";
@@ -21,6 +21,11 @@ const geistMono = Geist_Mono({
 export const metadata: Metadata = {
   title: { default: "Epicure", template: "%s | Epicure" },
   description: "Your personal AI-powered recipe book.",
+  manifest: "/manifest.json",
+};
+
+export const viewport: Viewport = {
+  themeColor: "#18181b",
 };
 
 export default async function RootLayout({

apps/web/app/print/collection/[id]/page.tsx

@@ -0,0 +1,148 @@
+import { notFound } from "next/navigation";
+import { headers } from "next/headers";
+import { auth } from "@/lib/auth/server";
+import { db, collections, eq, and, or } from "@epicure/db";
+import { PrintTrigger } from "@/components/recipe/print-trigger";
+import { hasQuantity } from "@/lib/fractions";
+import { getMessages, formatMessage } from "@/lib/i18n/server";
+
+type Params = { params: Promise<{ id: string }> };
+
+export default async function CollectionPrintPage({ params }: Params) {
+  const { id } = await params;
+  const session = await auth.api.getSession({ headers: await headers() });
+  if (!session) return null;
+
+  const m = getMessages((session.user as { locale?: string }).locale);
+
+  const col = await db.query.collections.findFirst({
+    where: and(
+      eq(collections.id, id),
+      or(eq(collections.userId, session.user.id), eq(collections.isPublic, true))
+    ),
+    with: {
+      recipes: {
+        with: {
+          recipe: {
+            with: {
+              ingredients: { orderBy: (t, { asc }) => asc(t.order) },
+              steps: { orderBy: (t, { asc }) => asc(t.order) },
+            },
+          },
+        },
+      },
+    },
+  });
+
+  if (!col) notFound();
+
+  const recipeEntries = col.recipes.filter((r) => r.recipe !== null);
+
+  return (
+    <>
+      <style>{`
+        @media print {
+          body { margin: 0; }
+          .no-print { display: none !important; }
+          article { page-break-after: always; }
+          article:last-child { page-break-after: auto; }
+        }
+        body {
+          font-family: Georgia, 'Times New Roman', serif;
+          color: #1a1a1a;
+          max-width: 680px;
+          margin: 40px auto;
+          padding: 0 24px;
+          font-size: 14px;
+          line-height: 1.6;
+        }
+        h1 { font-size: 2em; margin: 0 0 8px; line-height: 1.2; }
+        h2 { font-size: 1.1em; text-transform: uppercase; letter-spacing: 0.08em; border-bottom: 1px solid #ccc; padding-bottom: 4px; margin: 24px 0 12px; }
+        .meta { display: flex; gap: 24px; font-size: 0.85em; color: #555; margin: 12px 0 16px; flex-wrap: wrap; }
+        .meta span { display: flex; align-items: center; gap: 4px; }
+        .description { color: #444; font-style: italic; margin-bottom: 16px; }
+        ul.ingredients { list-style: none; padding: 0; margin: 0; display: grid; grid-template-columns: 1fr 1fr; gap: 4px 24px; }
+        ul.ingredients li { padding: 4px 0; border-bottom: 1px dotted #e0e0e0; font-family: system-ui, sans-serif; font-size: 0.9em; }
+        ul.ingredients li .qty { color: #666; min-width: 60px; display: inline-block; }
+        ol.steps { padding-left: 20px; margin: 0; }
+        ol.steps li { padding: 6px 0 6px 4px; border-bottom: 1px dotted #e0e0e0; font-size: 0.95em; }
+        ol.steps li:last-child { border-bottom: none; }
+        .timer { font-size: 0.85em; color: #666; font-family: system-ui, sans-serif; margin-left: 8px; }
+        .cookbook-cover { text-align: center; margin-bottom: 40px; }
+        .cookbook-cover h1 { font-size: 2.6em; }
+        footer { margin-top: 40px; font-size: 0.75em; color: #aaa; text-align: center; font-family: system-ui, sans-serif; }
+        .print-btn {
+          position: fixed; top: 16px; right: 16px; padding: 8px 16px;
+          background: #18181b; color: white; border: none; border-radius: 6px;
+          cursor: pointer; font-size: 13px; font-family: system-ui, sans-serif;
+        }
+        .print-btn:hover { background: #3f3f46; }
+      `}</style>
+
+      <PrintTrigger />
+
+      <div className="cookbook-cover">
+        <h1>{col.name}</h1>
+        {col.description && <p className="description">{col.description}</p>}
+        <p style={{ fontFamily: "system-ui, sans-serif", fontSize: "0.85em", color: "#888" }}>
+          {recipeEntries.length} recipe{recipeEntries.length !== 1 ? "s" : ""}
+        </p>
+      </div>
+
+      {recipeEntries.map(({ recipe }) => {
+        if (!recipe) return null;
+        const totalMins = (recipe.prepMins ?? 0) + (recipe.cookMins ?? 0);
+        return (
+          <article key={recipe.id}>
+            <h1>{recipe.title}</h1>
+
+            {recipe.description && <p className="description">{recipe.description}</p>}
+
+            <div className="meta">
+              {recipe.baseServings && <span>{formatMessage(m.recipe.servings, { count: recipe.baseServings })}</span>}
+              {recipe.prepMins && <span>{formatMessage(m.recipe.prep, { mins: recipe.prepMins })}</span>}
+              {recipe.cookMins && <span>{formatMessage(m.recipe.cook, { mins: recipe.cookMins })}</span>}
+              {totalMins > 0 && <span>{formatMessage(m.recipe.total, { mins: totalMins })}</span>}
+              {recipe.difficulty && <span>{recipe.difficulty.charAt(0).toUpperCase() + recipe.difficulty.slice(1)}</span>}
+            </div>
+
+            {recipe.ingredients.length > 0 && (
+              <>
+                <h2>{m.recipe.ingredients}</h2>
+                <ul className="ingredients">
+                  {recipe.ingredients.map((ing) => (
+                    <li key={ing.id}>
+                      <span className="qty">
+                        {[hasQuantity(ing.quantity) ? ing.quantity : null, ing.unit].filter(Boolean).join(" ")}
+                      </span>
+                      {ing.rawName}
+                      {ing.note && <span style={{ color: "#888" }}> ({ing.note})</span>}
+                    </li>
+                  ))}
+                </ul>
+              </>
+            )}
+
+            {recipe.steps.length > 0 && (
+              <>
+                <h2>{m.recipe.instructions}</h2>
+                <ol className="steps">
+                  {recipe.steps.map((step) => (
+                    <li key={step.id}>
+                      {step.instruction}
+                      {step.timerSeconds && (
+                        <span className="timer">⏱ {Math.floor(step.timerSeconds / 60)} min</span>
+                      )}
+                    </li>
+                  ))}
+                </ol>
+              </>
+            )}
+          </article>
+        );
+      })}
+
+      <footer>{m.print.footer}</footer>
+    </>
+  );
+}

apps/web/components/collections/collections-page-content.tsx

@@ -22,7 +22,7 @@ export function CollectionsPageContent({ collections }: Props) {
 
   return (
     <div className="space-y-6">
-      <div className="flex items-center justify-between">
+      <div className="flex flex-col gap-3 sm:flex-row sm:items-center sm:justify-between">
         <div>
           <h1 className="text-3xl font-bold tracking-tight">{t("title")}</h1>
           <p className="text-muted-foreground mt-1">{t("subtitle")}</p>

apps/web/components/feed/feed-page-content.tsx

@@ -2,7 +2,7 @@
 import { useState, useEffect } from "react";
 import { useTranslations } from "next-intl";
 import Link from "next/link";
-import { Clock, Users, ChefHat, Flame, Heart } from "lucide-react";
+import { Clock, Users, ChefHat, Flame, Heart, Sparkles } from "lucide-react";
 import { Avatar, AvatarFallback, AvatarImage } from "@/components/ui/avatar";
 import { Badge } from "@/components/ui/badge";
 import { useLocale } from "@/lib/i18n/provider";
@@ -99,10 +99,36 @@ function TrendingTab() {
   );
 }
 
+function ForYouTab() {
+  const { locale } = useLocale();
+  const t = useTranslations("feed");
+  const [recipes, setRecipes] = useState<FeedRecipe[]>([]);
+  const [loading, setLoading] = useState(true);
+
+  useEffect(() => {
+    fetch("/api/v1/feed/for-you")
+      .then((r) => r.json() as Promise<{ data: FeedRecipe[] }>)
+      .then(({ data }) => setRecipes(data))
+      .catch(() => {})
+      .finally(() => setLoading(false));
+  }, []);
+
+  if (loading) return <p className="text-sm text-muted-foreground">{t("loading")}</p>;
+  if (recipes.length === 0) return <p className="text-sm text-muted-foreground">{t("forYouEmpty")}</p>;
+
+  return (
+    <div className="space-y-4">
+      {recipes.map((recipe) => (
+        <RecipeCard key={recipe.id} recipe={recipe} locale={locale} />
+      ))}
+    </div>
+  );
+}
+
 export function FeedPageContent({ followedCount, feedRecipes }: Props) {
   const t = useTranslations("feed");
   const { locale } = useLocale();
-  const [tab, setTab] = useState<"following" | "trending">("following");
+  const [tab, setTab] = useState<"following" | "trending" | "forYou">("following");
 
   return (
     <div className="space-y-6 max-w-2xl">
@@ -131,6 +157,17 @@ export function FeedPageContent({ followedCount, feedRecipes }: Props) {
           <Flame className="h-3.5 w-3.5" />
           {t("trending")}
         </button>
+        <button
+          onClick={() => setTab("forYou")}
+          className={`pb-2 px-1 text-sm font-medium border-b-2 transition-colors flex items-center gap-1.5 ${
+            tab === "forYou"
+              ? "border-primary text-foreground"
+              : "border-transparent text-muted-foreground hover:text-foreground"
+          }`}
+        >
+          <Sparkles className="h-3.5 w-3.5" />
+          {t("forYou")}
+        </button>
       </div>
 
       {tab === "following" ? (
@@ -147,8 +184,10 @@ export function FeedPageContent({ followedCount, feedRecipes }: Props) {
             ))}
           </div>
         )
-      ) : (
+      ) : tab === "trending" ? (
         <TrendingTab />
+      ) : (
+        <ForYouTab />
       )}
     </div>
   );

apps/web/components/meal-plan/share-meal-plan-button.tsx

@@ -0,0 +1,191 @@
+"use client";
+
+import { useState } from "react";
+import { UserPlus, X } from "lucide-react";
+import { toast } from "sonner";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogHeader,
+  DialogTitle,
+} from "@/components/ui/dialog";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
+import { Badge } from "@/components/ui/badge";
+
+type Role = "viewer" | "editor";
+
+interface Member {
+  id: string;
+  userId: string;
+  role: Role;
+  createdAt: string;
+  user: {
+    name: string;
+    username: string | null;
+    avatarUrl: string | null;
+  };
+}
+
+interface Props {
+  weekStart: string;
+}
+
+export function ShareMealPlanButton({ weekStart }: Props) {
+  const [open, setOpen] = useState(false);
+  const [email, setEmail] = useState("");
+  const [role, setRole] = useState<Role>("viewer");
+  const [members, setMembers] = useState<Member[]>([]);
+  const [loading, setLoading] = useState(false);
+  const [inviting, setInviting] = useState(false);
+
+  async function fetchMembers() {
+    setLoading(true);
+    try {
+      const res = await fetch(`/api/v1/meal-plans/${weekStart}/members`);
+      if (!res.ok) throw new Error("Failed to load members");
+      const data = await res.json() as Member[];
+      setMembers(data);
+    } catch {
+      toast.error("Could not load members");
+    } finally {
+      setLoading(false);
+    }
+  }
+
+  function handleOpenChange(next: boolean) {
+    setOpen(next);
+    if (next) {
+      void fetchMembers();
+    } else {
+      setEmail("");
+      setRole("viewer");
+    }
+  }
+
+  async function handleInvite() {
+    if (!email.trim()) {
+      toast.error("Enter an email address");
+      return;
+    }
+    setInviting(true);
+    try {
+      const res = await fetch(`/api/v1/meal-plans/${weekStart}/members`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ email: email.trim(), role }),
+      });
+      if (res.status === 409) { toast.error("Already a member"); return; }
+      if (res.status === 404) { toast.error("User not found"); return; }
+      if (!res.ok) { toast.error("Could not invite user"); return; }
+      toast.success("Invitation sent");
+      setEmail("");
+      await fetchMembers();
+    } catch {
+      toast.error("Could not invite user");
+    } finally {
+      setInviting(false);
+    }
+  }
+
+  async function handleRemove(memberId: string) {
+    try {
+      const res = await fetch(
+        `/api/v1/meal-plans/${weekStart}/members?memberId=${memberId}`,
+        { method: "DELETE" },
+      );
+      if (!res.ok) { toast.error("Could not remove member"); return; }
+      setMembers((prev) => prev.filter((m) => m.id !== memberId));
+      toast.success("Member removed");
+    } catch {
+      toast.error("Could not remove member");
+    }
+  }
+
+  return (
+    <>
+      <Button variant="outline" size="sm" onClick={() => handleOpenChange(true)}>
+        <UserPlus className="h-4 w-4" />
+        Share
+      </Button>
+
+      <Dialog open={open} onOpenChange={handleOpenChange}>
+        <DialogContent className="sm:max-w-md">
+          <DialogHeader>
+            <DialogTitle>Share this week&apos;s plan</DialogTitle>
+            <DialogDescription>
+              Invite household members to view or edit this week&apos;s meal plan.
+            </DialogDescription>
+          </DialogHeader>
+
+          <div className="flex gap-2 mt-2">
+            <Input
+              type="email"
+              placeholder="Email address"
+              value={email}
+              onChange={(e) => setEmail(e.target.value)}
+              onKeyDown={(e) => { if (e.key === "Enter") void handleInvite(); }}
+              className="flex-1"
+            />
+            <Select value={role} onValueChange={(v) => setRole(v as Role)}>
+              <SelectTrigger className="w-28">
+                <SelectValue />
+              </SelectTrigger>
+              <SelectContent>
+                <SelectItem value="viewer">Viewer</SelectItem>
+                <SelectItem value="editor">Editor</SelectItem>
+              </SelectContent>
+            </Select>
+            <Button onClick={() => void handleInvite()} disabled={inviting}>
+              Invite
+            </Button>
+          </div>
+
+          <div className="mt-4 space-y-2">
+            {loading && (
+              <p className="text-sm text-muted-foreground">Loading members…</p>
+            )}
+            {!loading && members.length === 0 && (
+              <p className="text-sm text-muted-foreground">No members yet.</p>
+            )}
+            {members.map((m) => (
+              <div
+                key={m.id}
+                className="flex items-center justify-between gap-2 rounded-md border px-3 py-2 text-sm"
+              >
+                <div className="flex-1 min-w-0">
+                  <span className="font-medium truncate">{m.user.name}</span>
+                  {m.user.username && (
+                    <span className="text-muted-foreground ml-1">
+                      @{m.user.username}
+                    </span>
+                  )}
+                </div>
+                <Badge variant={m.role === "editor" ? "default" : "secondary"}>
+                  {m.role}
+                </Badge>
+                <Button
+                  variant="ghost"
+                  size="icon"
+                  className="h-7 w-7 shrink-0"
+                  onClick={() => void handleRemove(m.id)}
+                  aria-label="Remove member"
+                >
+                  <X className="h-3.5 w-3.5" />
+                </Button>
+              </div>
+            ))}
+          </div>
+        </DialogContent>
+      </Dialog>
+    </>
+  );
+}

apps/web/components/meal-plan/shared-meal-plan-view.tsx

@@ -0,0 +1,128 @@
+"use client";
+
+import { useState } from "react";
+import { toast } from "sonner";
+import { Trash2 } from "lucide-react";
+import { Button } from "@/components/ui/button";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+
+type Day = "mon" | "tue" | "wed" | "thu" | "fri" | "sat" | "sun";
+type MealType = "breakfast" | "lunch" | "dinner" | "snack";
+
+const DAYS: Day[] = ["mon", "tue", "wed", "thu", "fri", "sat", "sun"];
+const MEAL_TYPES: MealType[] = ["breakfast", "lunch", "dinner", "snack"];
+
+type Entry = {
+  id: string;
+  day: Day;
+  mealType: MealType;
+  servings: number;
+  recipe: { id: string; title: string } | null;
+};
+
+type UserRecipe = { id: string; title: string };
+
+export function SharedMealPlanView({
+  mealPlanId,
+  initialEntries,
+  userRecipes,
+  canEdit,
+}: {
+  mealPlanId: string;
+  initialEntries: Entry[];
+  userRecipes: UserRecipe[];
+  canEdit: boolean;
+}) {
+  const [entries, setEntries] = useState<Entry[]>(initialEntries);
+  const [addingCell, setAddingCell] = useState<string | null>(null);
+
+  function cellKey(day: Day, mealType: MealType) {
+    return `${day}-${mealType}`;
+  }
+
+  async function addEntry(day: Day, mealType: MealType, recipeId: string) {
+    const res = await fetch(`/api/v1/meal-plans/shared/${mealPlanId}/entries`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ day, mealType, recipeId, servings: 2 }),
+    });
+    if (!res.ok) { toast.error("Could not add recipe"); return; }
+    const { id } = await res.json() as { id: string };
+    const recipe = userRecipes.find((r) => r.id === recipeId) ?? null;
+    setEntries((prev) => [
+      ...prev.filter((e) => !(e.day === day && e.mealType === mealType)),
+      { id, day, mealType, servings: 2, recipe },
+    ]);
+    setAddingCell(null);
+  }
+
+  async function removeEntry(entry: Entry) {
+    const res = await fetch(`/api/v1/meal-plans/shared/${mealPlanId}/entries?entryId=${entry.id}`, {
+      method: "DELETE",
+    });
+    if (!res.ok) { toast.error("Could not remove entry"); return; }
+    setEntries((prev) => prev.filter((e) => e.id !== entry.id));
+  }
+
+  return (
+    <div className="overflow-x-auto">
+      <table className="w-full border-collapse text-sm min-w-[640px]">
+        <thead>
+          <tr>
+            <th className="text-left p-2 text-muted-foreground font-medium"></th>
+            {DAYS.map((day) => (
+              <th key={day} className="text-left p-2 text-muted-foreground font-medium capitalize">{day}</th>
+            ))}
+          </tr>
+        </thead>
+        <tbody>
+          {MEAL_TYPES.map((mealType) => (
+            <tr key={mealType} className="border-t">
+              <td className="p-2 text-muted-foreground font-medium capitalize align-top">{mealType}</td>
+              {DAYS.map((day) => {
+                const entry = entries.find((e) => e.day === day && e.mealType === mealType);
+                const key = cellKey(day, mealType);
+                return (
+                  <td key={key} className="p-2 align-top min-w-[120px]">
+                    {entry ? (
+                      <div className="flex items-start justify-between gap-1 rounded-lg border p-2">
+                        <span className="text-xs">{entry.recipe?.title ?? "—"}</span>
+                        {canEdit && (
+                          <Button variant="ghost" size="icon" className="h-5 w-5 shrink-0" onClick={() => void removeEntry(entry)}>
+                            <Trash2 className="h-3 w-3" />
+                          </Button>
+                        )}
+                      </div>
+                    ) : canEdit ? (
+                      addingCell === key ? (
+                        <Select onValueChange={(v) => void addEntry(day, mealType, v as string)}>
+                          <SelectTrigger className="h-8 text-xs">
+                            <SelectValue placeholder="Pick recipe" />
+                          </SelectTrigger>
+                          <SelectContent>
+                            {userRecipes.map((r) => (
+                              <SelectItem key={r.id} value={r.id}>{r.title}</SelectItem>
+                            ))}
+                          </SelectContent>
+                        </Select>
+                      ) : (
+                        <button
+                          className="w-full h-8 rounded-lg border border-dashed text-xs text-muted-foreground hover:bg-muted/30"
+                          onClick={() => setAddingCell(key)}
+                        >
+                          + Add
+                        </button>
+                      )
+                    ) : (
+                      <span className="text-xs text-muted-foreground">—</span>
+                    )}
+                  </td>
+                );
+              })}
+            </tr>
+          ))}
+        </tbody>
+      </table>
+    </div>
+  );
+}

apps/web/components/meal-plan/shopping-list-view.tsx

@@ -20,9 +20,11 @@ type Item = {
 export function ShoppingListView({
   listId,
   initialItems,
+  readOnly = false,
 }: {
   listId: string;
   initialItems: Item[];
+  readOnly?: boolean;
 }) {
   const t = useTranslations("mealPlan");
   const tShopping = useTranslations("shoppingLists");
@@ -54,6 +56,7 @@ export function ShoppingListView({
   }
 
   async function toggleItem(item: Item) {
+    if (readOnly) return;
     const next = !item.checked;
     setItems((prev) => prev.map((i) => i.id === item.id ? { ...i, checked: next } : i));
     await fetch(`/api/v1/shopping-lists/${listId}/items/${item.id}`, {
@@ -97,7 +100,8 @@ export function ShoppingListView({
               <button
                 key={item.id}
                 onClick={() => toggleItem(item)}
-                className="w-full flex items-center gap-3 px-4 py-3 hover:bg-muted/30 text-left transition-colors"
+                disabled={readOnly}
+                className="w-full flex items-center gap-3 px-4 py-3 hover:bg-muted/30 text-left transition-colors disabled:cursor-default disabled:hover:bg-transparent"
               >
                 <div className={cn(
                   "h-5 w-5 rounded border-2 flex items-center justify-center shrink-0 transition-colors",

apps/web/components/pantry/pantry-page-header.tsx

@@ -8,12 +8,12 @@ import { cn } from "@/lib/utils";
 export function PantryPageHeader() {
   const t = useTranslations("pantry");
   return (
-    <div className="flex items-start justify-between">
+    <div className="flex flex-col gap-3 sm:flex-row sm:items-start sm:justify-between">
       <div>
         <h1 className="text-3xl font-bold tracking-tight">{t("title")}</h1>
         <p className="text-muted-foreground mt-1">{t("subtitle")}</p>
       </div>
-      <div className="flex items-center gap-2">
+      <div className="flex flex-wrap items-center gap-2">
         <Link href="/recipes/can-cook" className={cn(buttonVariants({ variant: "outline", size: "sm" }))}>
           <ChefHat className="h-4 w-4" />
           {t("canCook")}

apps/web/components/recipe/can-cook-content.tsx

@@ -2,7 +2,7 @@
 
 import Link from "next/link";
 import { useTranslations } from "next-intl";
-import { Package } from "lucide-react";
+import { Package, Clock } from "lucide-react";
 import { Badge } from "@/components/ui/badge";
 import { Progress } from "@/components/ui/progress";
 import { buttonVariants } from "@/components/ui/button";
@@ -19,6 +19,7 @@ type ScoredItem = {
   total: number;
   pct: number;
   missing: string[];
+  usesExpiring: string[];
 };
 
 type Props = {
@@ -40,7 +41,15 @@ function RecipeRow({ s }: { s: ScoredItem }) {
         <div className="h-14 w-14 rounded-lg bg-muted shrink-0" />
       )}
       <div className="flex-1 min-w-0 space-y-1">
-        <p className="font-medium truncate">{s.recipe.title}</p>
+        <div className="flex items-center gap-2">
+          <p className="font-medium truncate">{s.recipe.title}</p>
+          {s.usesExpiring.length > 0 && (
+            <Badge variant="outline" className="shrink-0 text-orange-500 border-orange-500 gap-1">
+              <Clock className="h-3 w-3" />
+              {t("useItUp")}
+            </Badge>
+          )}
+        </div>
         <div className="flex items-center gap-2">
           <Progress value={s.pct} className="h-1.5 flex-1 max-w-[120px]" />
           <span className="text-xs text-muted-foreground">

apps/web/components/recipe/recipes-header.tsx

@@ -111,7 +111,7 @@ export function RecipesHeader({
   return (
     <>
       <div className="space-y-4">
-        <div className="flex items-center justify-between">
+        <div className="flex flex-col gap-3 sm:flex-row sm:items-center sm:justify-between">
           <div>
             <h1 className="text-3xl font-bold tracking-tight">{t("title")}</h1>
             <p className="text-muted-foreground mt-1">
@@ -120,7 +120,7 @@ export function RecipesHeader({
                 : t(count !== 1 ? "resultPlural" : "resultSingular", { count })}
             </p>
           </div>
-          <div className="flex items-center gap-2">
+          <div className="flex flex-wrap items-center gap-2">
             <Button variant="ghost" size="sm" onClick={() => setUrlOpen(true)}>
               <Link2 className="h-4 w-4" />
               {t("importUrl")}

apps/web/components/recipe/version-diff-view.tsx

@@ -0,0 +1,103 @@
+"use client";
+
+import { diffWords } from "diff";
+
+export type DiffSnapshot = {
+  title: string;
+  description?: string | null;
+  ingredients: Array<{ rawName: string; quantity?: string | number | null; unit?: string | null; note?: string | null }>;
+  steps: Array<{ instruction: string; timerSeconds?: number | null }>;
+};
+
+function ingredientLine(i: DiffSnapshot["ingredients"][number]): string {
+  return [i.quantity, i.unit, i.rawName, i.note && `(${i.note})`].filter(Boolean).join(" ");
+}
+
+function stepLine(s: DiffSnapshot["steps"][number]): string {
+  return s.instruction;
+}
+
+function TextDiff({ before, after }: { before: string; after: string }) {
+  const parts = diffWords(before, after);
+  return (
+    <p className="text-sm leading-relaxed">
+      {parts.map((part, i) => (
+        <span
+          key={i}
+          className={
+            part.added
+              ? "bg-green-500/20 text-green-700 dark:text-green-400"
+              : part.removed
+                ? "bg-red-500/20 text-red-700 dark:text-red-400 line-through"
+                : undefined
+          }
+        >
+          {part.value}
+        </span>
+      ))}
+    </p>
+  );
+}
+
+function ListDiff({ before, after }: { before: string[]; after: string[] }) {
+  const max = Math.max(before.length, after.length);
+  const rows = [];
+  for (let i = 0; i < max; i++) {
+    const b = before[i];
+    const a = after[i];
+    if (b === undefined) {
+      rows.push(
+        <div key={i} className="bg-green-500/10 rounded px-2 py-1 text-sm text-green-700 dark:text-green-400">
+          + {a}
+        </div>
+      );
+    } else if (a === undefined) {
+      rows.push(
+        <div key={i} className="bg-red-500/10 rounded px-2 py-1 text-sm text-red-700 dark:text-red-400 line-through">
+          − {b}
+        </div>
+      );
+    } else if (b === a) {
+      rows.push(
+        <div key={i} className="px-2 py-1 text-sm text-muted-foreground">
+          {b}
+        </div>
+      );
+    } else {
+      rows.push(
+        <div key={i} className="rounded px-2 py-1">
+          <TextDiff before={b} after={a} />
+        </div>
+      );
+    }
+  }
+  return <div className="space-y-1">{rows}</div>;
+}
+
+export function VersionDiffView({ before, after }: { before: DiffSnapshot; after: DiffSnapshot }) {
+  return (
+    <div className="space-y-6">
+      <section className="space-y-2">
+        <h3 className="text-sm font-semibold text-muted-foreground">Title</h3>
+        <TextDiff before={before.title} after={after.title} />
+      </section>
+
+      {(before.description || after.description) && (
+        <section className="space-y-2">
+          <h3 className="text-sm font-semibold text-muted-foreground">Description</h3>
+          <TextDiff before={before.description ?? ""} after={after.description ?? ""} />
+        </section>
+      )}
+
+      <section className="space-y-2">
+        <h3 className="text-sm font-semibold text-muted-foreground">Ingredients</h3>
+        <ListDiff before={before.ingredients.map(ingredientLine)} after={after.ingredients.map(ingredientLine)} />
+      </section>
+
+      <section className="space-y-2">
+        <h3 className="text-sm font-semibold text-muted-foreground">Steps</h3>
+        <ListDiff before={before.steps.map(stepLine)} after={after.steps.map(stepLine)} />
+      </section>
+    </div>
+  );
+}

apps/web/components/recipe/version-history-button.tsx

@@ -3,7 +3,7 @@
 import { useState } from "react";
 import { useTranslations } from "next-intl";
 import { useRouter } from "next/navigation";
-import { History, RotateCcw, ChevronDown } from "lucide-react";
+import { History, RotateCcw, ChevronDown, GitCompare } from "lucide-react";
 import { toast } from "sonner";
 import { Button } from "@/components/ui/button";
 import {
@@ -12,7 +12,14 @@ import {
   SheetHeader,
   SheetTitle,
 } from "@/components/ui/sheet";
+import {
+  Dialog,
+  DialogContent,
+  DialogHeader,
+  DialogTitle,
+} from "@/components/ui/dialog";
 import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "@/components/ui/tooltip";
+import { VersionDiffView, type DiffSnapshot } from "@/components/recipe/version-diff-view";
 
 type VersionSummary = {
   id: string;
@@ -21,9 +28,13 @@ type VersionSummary = {
   createdAt: string;
 };
 
-type SnapshotData = {
-  ingredients: unknown[];
-  steps: unknown[];
+type SnapshotData = DiffSnapshot & {
+  description?: string | null;
+  baseServings?: number;
+  difficulty?: string | null;
+  prepMins?: number | null;
+  cookMins?: number | null;
+  dietaryTags?: Record<string, boolean>;
 };
 
 type VersionDetail = {
@@ -39,7 +50,13 @@ function formatDate(dateStr: string): string {
   return date.toLocaleDateString("en-US", { month: "short", day: "numeric", year: "numeric" });
 }
 
-export function VersionHistoryButton({ recipeId }: { recipeId: string }) {
+export function VersionHistoryButton({
+  recipeId,
+  currentSnapshot,
+}: {
+  recipeId: string;
+  currentSnapshot: DiffSnapshot;
+}) {
   const t = useTranslations("recipe");
   const tForm = useTranslations("recipeForm");
   const router = useRouter();
@@ -49,6 +66,7 @@ export function VersionHistoryButton({ recipeId }: { recipeId: string }) {
   const [expandedId, setExpandedId] = useState<string | null>(null);
   const [expandedData, setExpandedData] = useState<Record<string, VersionDetail>>({});
   const [restoringId, setRestoringId] = useState<string | null>(null);
+  const [comparingId, setComparingId] = useState<string | null>(null);
 
   async function handleOpen(isOpen: boolean) {
     setOpen(isOpen);
@@ -66,19 +84,27 @@ export function VersionHistoryButton({ recipeId }: { recipeId: string }) {
     }
   }
 
+  async function ensureDetail(versionId: string): Promise<VersionDetail | null> {
+    if (expandedData[versionId]) return expandedData[versionId]!;
+    const res = await fetch(`/api/v1/recipes/${recipeId}/versions/${versionId}`);
+    if (!res.ok) return null;
+    const data = await res.json() as VersionDetail;
+    setExpandedData((prev) => ({ ...prev, [versionId]: data }));
+    return data;
+  }
+
   async function handleExpand(version: VersionSummary) {
     if (expandedId === version.id) {
       setExpandedId(null);
       return;
     }
     setExpandedId(version.id);
-    if (!expandedData[version.id]) {
-      const res = await fetch(`/api/v1/recipes/${recipeId}/versions/${version.id}`);
-      if (res.ok) {
-        const data = await res.json() as VersionDetail;
-        setExpandedData((prev) => ({ ...prev, [version.id]: data }));
-      }
-    }
+    await ensureDetail(version.id);
+  }
+
+  async function handleCompare(version: VersionSummary) {
+    await ensureDetail(version.id);
+    setComparingId(version.id);
   }
 
   async function handleRestore(version: VersionSummary) {
@@ -151,6 +177,15 @@ export function VersionHistoryButton({ recipeId }: { recipeId: string }) {
                   >
                     <ChevronDown className={`h-4 w-4 transition-transform ${isExpanded ? "rotate-180" : ""}`} />
                   </Button>
+                  <Button
+                    variant="outline"
+                    size="sm"
+                    className="shrink-0"
+                    onClick={() => void handleCompare(v)}
+                  >
+                    <GitCompare className="h-3 w-3" />
+                    Compare
+                  </Button>
                   <Button
                     variant="outline"
                     size="sm"
@@ -169,8 +204,8 @@ export function VersionHistoryButton({ recipeId }: { recipeId: string }) {
                       <p>Loading...</p>
                     ) : (
                       <p>
-                        {(detail.snapshotData.ingredients as unknown[]).length} ingredient{(detail.snapshotData.ingredients as unknown[]).length !== 1 ? "s" : ""},{" "}
-                        {(detail.snapshotData.steps as unknown[]).length} step{(detail.snapshotData.steps as unknown[]).length !== 1 ? "s" : ""}
+                        {detail.snapshotData.ingredients.length} ingredient{detail.snapshotData.ingredients.length !== 1 ? "s" : ""},{" "}
+                        {detail.snapshotData.steps.length} step{detail.snapshotData.steps.length !== 1 ? "s" : ""}
                       </p>
                     )}
                   </div>
@@ -181,6 +216,19 @@ export function VersionHistoryButton({ recipeId }: { recipeId: string }) {
         </div>
       </SheetContent>
     </Sheet>
+
+    <Dialog open={comparingId !== null} onOpenChange={(isOpen) => !isOpen && setComparingId(null)}>
+      <DialogContent className="max-w-2xl max-h-[85vh] overflow-y-auto">
+        <DialogHeader>
+          <DialogTitle>
+            {comparingId ? `Compare v${expandedData[comparingId]?.version} with current` : "Compare"}
+          </DialogTitle>
+        </DialogHeader>
+        {comparingId && expandedData[comparingId] && (
+          <VersionDiffView before={expandedData[comparingId]!.snapshotData} after={currentSnapshot} />
+        )}
+      </DialogContent>
+    </Dialog>
     </>
   );
 }

apps/web/components/shopping-lists/grocery-export-button.tsx

@@ -0,0 +1,83 @@
+"use client";
+
+import { useState } from "react";
+import { ShoppingBag, Copy, ExternalLink } from "lucide-react";
+import { toast } from "sonner";
+import {
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuTrigger,
+} from "@/components/ui/dropdown-menu";
+import { Button } from "@/components/ui/button";
+import type { GroceryExportPayload } from "@/lib/grocery-export";
+import { groceryExportToText } from "@/lib/grocery-export";
+
+interface Props {
+  listId: string;
+  /** Set when NEXT_PUBLIC_GROCERY_PROVIDER=instacart — otherwise only "copy as text" is offered. */
+  instacartEnabled: boolean;
+}
+
+export function GroceryExportButton({ listId, instacartEnabled }: Props) {
+  const [loading, setLoading] = useState(false);
+
+  async function fetchPayload(): Promise<GroceryExportPayload | null> {
+    const res = await fetch(`/api/v1/shopping-lists/${listId}/export`);
+    if (!res.ok) {
+      toast.error("Could not build export");
+      return null;
+    }
+    return res.json() as Promise<GroceryExportPayload>;
+  }
+
+  async function handleCopy() {
+    setLoading(true);
+    try {
+      const payload = await fetchPayload();
+      if (!payload) return;
+      await navigator.clipboard.writeText(groceryExportToText(payload));
+      toast.success("List copied to clipboard");
+    } finally {
+      setLoading(false);
+    }
+  }
+
+  async function handleInstacart() {
+    setLoading(true);
+    try {
+      const res = await fetch(`/api/v1/shopping-lists/${listId}/export/instacart`, { method: "POST" });
+      if (!res.ok) {
+        toast.error("Instacart isn't configured yet");
+        return;
+      }
+      const { url } = await res.json() as { url: string };
+      window.open(url, "_blank");
+    } finally {
+      setLoading(false);
+    }
+  }
+
+  return (
+    <DropdownMenu>
+      <DropdownMenuTrigger render={
+        <Button variant="outline" size="sm" disabled={loading}>
+          <ShoppingBag className="h-4 w-4" />
+          Send to grocery delivery
+        </Button>
+      } />
+      <DropdownMenuContent align="end">
+        <DropdownMenuItem onClick={() => void handleCopy()}>
+          <Copy className="h-4 w-4" />
+          Copy list as text
+        </DropdownMenuItem>
+        {instacartEnabled && (
+          <DropdownMenuItem onClick={() => void handleInstacart()}>
+            <ExternalLink className="h-4 w-4" />
+            Send to Instacart
+          </DropdownMenuItem>
+        )}
+      </DropdownMenuContent>
+    </DropdownMenu>
+  );
+}

apps/web/components/shopping-lists/share-shopping-list-button.tsx

@@ -0,0 +1,191 @@
+"use client";
+
+import { useState } from "react";
+import { UserPlus, X } from "lucide-react";
+import { toast } from "sonner";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogHeader,
+  DialogTitle,
+} from "@/components/ui/dialog";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
+import { Badge } from "@/components/ui/badge";
+
+type Role = "viewer" | "editor";
+
+interface Member {
+  id: string;
+  userId: string;
+  role: Role;
+  createdAt: string;
+  user: {
+    name: string;
+    username: string | null;
+    avatarUrl: string | null;
+  };
+}
+
+interface Props {
+  listId: string;
+}
+
+export function ShareShoppingListButton({ listId }: Props) {
+  const [open, setOpen] = useState(false);
+  const [email, setEmail] = useState("");
+  const [role, setRole] = useState<Role>("viewer");
+  const [members, setMembers] = useState<Member[]>([]);
+  const [loading, setLoading] = useState(false);
+  const [inviting, setInviting] = useState(false);
+
+  async function fetchMembers() {
+    setLoading(true);
+    try {
+      const res = await fetch(`/api/v1/shopping-lists/${listId}/members`);
+      if (!res.ok) throw new Error("Failed to load members");
+      const data = await res.json() as Member[];
+      setMembers(data);
+    } catch {
+      toast.error("Could not load members");
+    } finally {
+      setLoading(false);
+    }
+  }
+
+  function handleOpenChange(next: boolean) {
+    setOpen(next);
+    if (next) {
+      void fetchMembers();
+    } else {
+      setEmail("");
+      setRole("viewer");
+    }
+  }
+
+  async function handleInvite() {
+    if (!email.trim()) {
+      toast.error("Enter an email address");
+      return;
+    }
+    setInviting(true);
+    try {
+      const res = await fetch(`/api/v1/shopping-lists/${listId}/members`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ email: email.trim(), role }),
+      });
+      if (res.status === 409) { toast.error("Already a member"); return; }
+      if (res.status === 404) { toast.error("User not found"); return; }
+      if (!res.ok) { toast.error("Could not invite user"); return; }
+      toast.success("Invitation sent");
+      setEmail("");
+      await fetchMembers();
+    } catch {
+      toast.error("Could not invite user");
+    } finally {
+      setInviting(false);
+    }
+  }
+
+  async function handleRemove(memberId: string) {
+    try {
+      const res = await fetch(
+        `/api/v1/shopping-lists/${listId}/members?memberId=${memberId}`,
+        { method: "DELETE" },
+      );
+      if (!res.ok) { toast.error("Could not remove member"); return; }
+      setMembers((prev) => prev.filter((m) => m.id !== memberId));
+      toast.success("Member removed");
+    } catch {
+      toast.error("Could not remove member");
+    }
+  }
+
+  return (
+    <>
+      <Button variant="outline" size="sm" onClick={() => handleOpenChange(true)}>
+        <UserPlus className="h-4 w-4" />
+        Share
+      </Button>
+
+      <Dialog open={open} onOpenChange={handleOpenChange}>
+        <DialogContent className="sm:max-w-md">
+          <DialogHeader>
+            <DialogTitle>Share shopping list</DialogTitle>
+            <DialogDescription>
+              Invite household members to view or edit this list.
+            </DialogDescription>
+          </DialogHeader>
+
+          <div className="flex gap-2 mt-2">
+            <Input
+              type="email"
+              placeholder="Email address"
+              value={email}
+              onChange={(e) => setEmail(e.target.value)}
+              onKeyDown={(e) => { if (e.key === "Enter") void handleInvite(); }}
+              className="flex-1"
+            />
+            <Select value={role} onValueChange={(v) => setRole(v as Role)}>
+              <SelectTrigger className="w-28">
+                <SelectValue />
+              </SelectTrigger>
+              <SelectContent>
+                <SelectItem value="viewer">Viewer</SelectItem>
+                <SelectItem value="editor">Editor</SelectItem>
+              </SelectContent>
+            </Select>
+            <Button onClick={() => void handleInvite()} disabled={inviting}>
+              Invite
+            </Button>
+          </div>
+
+          <div className="mt-4 space-y-2">
+            {loading && (
+              <p className="text-sm text-muted-foreground">Loading members…</p>
+            )}
+            {!loading && members.length === 0 && (
+              <p className="text-sm text-muted-foreground">No members yet.</p>
+            )}
+            {members.map((m) => (
+              <div
+                key={m.id}
+                className="flex items-center justify-between gap-2 rounded-md border px-3 py-2 text-sm"
+              >
+                <div className="flex-1 min-w-0">
+                  <span className="font-medium truncate">{m.user.name}</span>
+                  {m.user.username && (
+                    <span className="text-muted-foreground ml-1">
+                      @{m.user.username}
+                    </span>
+                  )}
+                </div>
+                <Badge variant={m.role === "editor" ? "default" : "secondary"}>
+                  {m.role}
+                </Badge>
+                <Button
+                  variant="ghost"
+                  size="icon"
+                  className="h-7 w-7 shrink-0"
+                  onClick={() => void handleRemove(m.id)}
+                  aria-label="Remove member"
+                >
+                  <X className="h-3.5 w-3.5" />
+                </Button>
+              </div>
+            ))}
+          </div>
+        </DialogContent>
+      </Dialog>
+    </>
+  );
+}

apps/web/components/shopping-lists/shopping-lists-page-content.tsx

@@ -12,16 +12,24 @@ type ShoppingListItem = {
   checkedItems: number;
 };
 
-type Props = {
-  lists: ShoppingListItem[];
+type SharedListItem = {
+  id: string;
+  name: string;
+  ownerName: string;
+  role: "viewer" | "editor";
 };
 
-export function ShoppingListsPageContent({ lists }: Props) {
+type Props = {
+  lists: ShoppingListItem[];
+  sharedLists?: SharedListItem[];
+};
+
+export function ShoppingListsPageContent({ lists, sharedLists = [] }: Props) {
   const t = useTranslations("shoppingLists");
 
   return (
     <div className="space-y-6">
-      <div className="flex items-center justify-between">
+      <div className="flex flex-col gap-3 sm:flex-row sm:items-center sm:justify-between">
         <div>
           <h1 className="text-3xl font-bold tracking-tight">{t("title")}</h1>
           <p className="text-muted-foreground mt-1">{t("subtitle")}</p>
@@ -58,6 +66,26 @@ export function ShoppingListsPageContent({ lists }: Props) {
           ))}
         </div>
       )}
+
+      {sharedLists.length > 0 && (
+        <div className="space-y-3 max-w-lg">
+          <h2 className="text-sm font-semibold text-muted-foreground">Shared with you</h2>
+          {sharedLists.map((list) => (
+            <Link
+              key={list.id}
+              href={`/shopping-lists/${list.id}`}
+              className="flex items-center justify-between rounded-xl border p-4 hover:shadow-sm transition-shadow"
+            >
+              <div className="space-y-1">
+                <h3 className="font-semibold">{list.name}</h3>
+                <p className="text-sm text-muted-foreground">
+                  {list.ownerName} · {list.role}
+                </p>
+              </div>
+            </Link>
+          ))}
+        </div>
+      )}
     </div>
   );
 }

apps/web/lib/__tests__/for-you-ranking.test.ts

@@ -0,0 +1,56 @@
+import { describe, it, expect } from "vitest";
+import { buildPreferenceMap, scoreCandidate, rankForYou } from "../for-you-ranking";
+
+describe("buildPreferenceMap", () => {
+  it("counts tags and true dietary-tag keys across liked recipes", () => {
+    const map = buildPreferenceMap([
+      { tags: ["spicy", "quick"], dietaryTags: { vegan: true, glutenFree: false } },
+      { tags: ["spicy"], dietaryTags: null },
+    ]);
+    expect(map.get("spicy")).toBe(2);
+    expect(map.get("quick")).toBe(1);
+    expect(map.get("vegan")).toBe(1);
+    expect(map.get("glutenFree")).toBeUndefined();
+  });
+
+  it("returns an empty map for no liked recipes", () => {
+    expect(buildPreferenceMap([]).size).toBe(0);
+  });
+});
+
+describe("scoreCandidate", () => {
+  it("sums preference weights for overlapping tags", () => {
+    const prefs = new Map([["spicy", 3], ["vegan", 1]]);
+    const score = scoreCandidate({ tags: ["spicy"], dietaryTags: { vegan: true } }, prefs);
+    expect(score).toBe(4);
+  });
+
+  it("scores 0 when nothing overlaps", () => {
+    const prefs = new Map([["spicy", 3]]);
+    expect(scoreCandidate({ tags: ["sweet"], dietaryTags: null }, prefs)).toBe(0);
+  });
+});
+
+describe("rankForYou", () => {
+  const base = { dietaryTags: null };
+
+  it("sorts by score descending", () => {
+    const prefs = new Map([["spicy", 5]]);
+    const candidates = [
+      { id: "a", tags: ["sweet"], createdAt: new Date("2024-01-01"), ...base },
+      { id: "b", tags: ["spicy"], createdAt: new Date("2024-01-01"), ...base },
+    ];
+    const ranked = rankForYou(candidates, prefs);
+    expect(ranked.map((r) => r.id)).toEqual(["b", "a"]);
+  });
+
+  it("breaks ties by recency", () => {
+    const prefs = new Map<string, number>();
+    const candidates = [
+      { id: "old", tags: [], createdAt: new Date("2024-01-01"), ...base },
+      { id: "new", tags: [], createdAt: new Date("2024-06-01"), ...base },
+    ];
+    const ranked = rankForYou(candidates, prefs);
+    expect(ranked.map((r) => r.id)).toEqual(["new", "old"]);
+  });
+});

apps/web/lib/__tests__/grocery-export.test.ts

@@ -0,0 +1,29 @@
+import { describe, it, expect } from "vitest";
+import { buildGroceryExportPayload, groceryExportToText } from "../grocery-export";
+
+describe("buildGroceryExportPayload", () => {
+  it("maps unchecked items and drops checked ones", () => {
+    const payload = buildGroceryExportPayload({
+      name: "Weekly groceries",
+      items: [
+        { rawName: "Milk", quantity: "1", unit: "L", checked: false },
+        { rawName: "Eggs", quantity: "12", unit: null, checked: true },
+      ],
+    });
+    expect(payload.listName).toBe("Weekly groceries");
+    expect(payload.items).toEqual([{ name: "Milk", quantity: "1", unit: "L" }]);
+  });
+});
+
+describe("groceryExportToText", () => {
+  it("renders a plain-text list with quantities", () => {
+    const text = groceryExportToText({
+      listName: "Weekly groceries",
+      items: [
+        { name: "Milk", quantity: "1", unit: "L" },
+        { name: "Bananas", quantity: null, unit: null },
+      ],
+    });
+    expect(text).toBe("Weekly groceries\n\n1 L Milk\nBananas");
+  });
+});

apps/web/lib/__tests__/meal-plan-access.test.ts

@@ -0,0 +1,59 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+const { mockPlanFindFirst, mockMemberFindFirst } = vi.hoisted(() => ({
+  mockPlanFindFirst: vi.fn(),
+  mockMemberFindFirst: vi.fn(),
+}));
+
+vi.mock("@epicure/db", () => ({
+  db: {
+    query: {
+      mealPlans: { findFirst: mockPlanFindFirst },
+      mealPlanMembers: { findFirst: mockMemberFindFirst },
+    },
+  },
+  mealPlans: { id: "id", userId: "user_id" },
+  mealPlanMembers: { mealPlanId: "meal_plan_id", userId: "user_id" },
+  eq: vi.fn((a, b) => ({ a, b, op: "eq" })),
+  and: vi.fn((...args) => ({ args, op: "and" })),
+}));
+
+const { getMealPlanAccessById, canWriteMealPlan } = await import("../meal-plan-access");
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+describe("getMealPlanAccessById", () => {
+  it("returns null when the plan doesn't exist", async () => {
+    mockPlanFindFirst.mockResolvedValue(undefined);
+    expect(await getMealPlanAccessById("plan-1", "user-1")).toBeNull();
+  });
+
+  it("grants owner role to the plan's userId", async () => {
+    mockPlanFindFirst.mockResolvedValue({ id: "plan-1", userId: "user-1" });
+    const access = await getMealPlanAccessById("plan-1", "user-1");
+    expect(access?.role).toBe("owner");
+  });
+
+  it("grants the member's assigned role", async () => {
+    mockPlanFindFirst.mockResolvedValue({ id: "plan-1", userId: "user-owner" });
+    mockMemberFindFirst.mockResolvedValue({ role: "viewer" });
+    const access = await getMealPlanAccessById("plan-1", "user-2");
+    expect(access?.role).toBe("viewer");
+  });
+
+  it("returns null when the user is neither owner nor a member", async () => {
+    mockPlanFindFirst.mockResolvedValue({ id: "plan-1", userId: "user-owner" });
+    mockMemberFindFirst.mockResolvedValue(undefined);
+    expect(await getMealPlanAccessById("plan-1", "user-2")).toBeNull();
+  });
+});
+
+describe("canWriteMealPlan", () => {
+  it("allows owner and editor, denies viewer", () => {
+    expect(canWriteMealPlan("owner")).toBe(true);
+    expect(canWriteMealPlan("editor")).toBe(true);
+    expect(canWriteMealPlan("viewer")).toBe(false);
+  });
+});

apps/web/lib/__tests__/shopping-list-access.test.ts

@@ -0,0 +1,59 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+const { mockListFindFirst, mockMemberFindFirst } = vi.hoisted(() => ({
+  mockListFindFirst: vi.fn(),
+  mockMemberFindFirst: vi.fn(),
+}));
+
+vi.mock("@epicure/db", () => ({
+  db: {
+    query: {
+      shoppingLists: { findFirst: mockListFindFirst },
+      shoppingListMembers: { findFirst: mockMemberFindFirst },
+    },
+  },
+  shoppingLists: { id: "id", userId: "user_id" },
+  shoppingListMembers: { listId: "list_id", userId: "user_id" },
+  eq: vi.fn((a, b) => ({ a, b, op: "eq" })),
+  and: vi.fn((...args) => ({ args, op: "and" })),
+}));
+
+const { getShoppingListAccess, canWriteShoppingList } = await import("../shopping-list-access");
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+describe("getShoppingListAccess", () => {
+  it("returns null when the list doesn't exist", async () => {
+    mockListFindFirst.mockResolvedValue(undefined);
+    expect(await getShoppingListAccess("list-1", "user-1")).toBeNull();
+  });
+
+  it("grants owner role to the list's userId", async () => {
+    mockListFindFirst.mockResolvedValue({ id: "list-1", userId: "user-1" });
+    const access = await getShoppingListAccess("list-1", "user-1");
+    expect(access?.role).toBe("owner");
+  });
+
+  it("grants the member's assigned role", async () => {
+    mockListFindFirst.mockResolvedValue({ id: "list-1", userId: "user-owner" });
+    mockMemberFindFirst.mockResolvedValue({ role: "editor" });
+    const access = await getShoppingListAccess("list-1", "user-2");
+    expect(access?.role).toBe("editor");
+  });
+
+  it("returns null when the user is neither owner nor a member", async () => {
+    mockListFindFirst.mockResolvedValue({ id: "list-1", userId: "user-owner" });
+    mockMemberFindFirst.mockResolvedValue(undefined);
+    expect(await getShoppingListAccess("list-1", "user-2")).toBeNull();
+  });
+});
+
+describe("canWriteShoppingList", () => {
+  it("allows owner and editor, denies viewer", () => {
+    expect(canWriteShoppingList("owner")).toBe(true);
+    expect(canWriteShoppingList("editor")).toBe(true);
+    expect(canWriteShoppingList("viewer")).toBe(false);
+  });
+});

apps/web/lib/for-you-ranking.ts

@@ -0,0 +1,43 @@
+export type TaggedRecipe = {
+  id: string;
+  tags: string[];
+  dietaryTags: Record<string, boolean> | null;
+  createdAt: Date;
+};
+
+/** Collapses a recipe's tags + true dietary-tag keys into one flat tag list. */
+function tagSet(recipe: Pick<TaggedRecipe, "tags" | "dietaryTags">): string[] {
+  const dietary = Object.entries(recipe.dietaryTags ?? {})
+    .filter(([, v]) => v)
+    .map(([k]) => k);
+  return [...recipe.tags, ...dietary];
+}
+
+/** Builds a tag → frequency map from the recipes a user has favorited/highly rated. */
+export function buildPreferenceMap(likedRecipes: Array<Pick<TaggedRecipe, "tags" | "dietaryTags">>): Map<string, number> {
+  const map = new Map<string, number>();
+  for (const recipe of likedRecipes) {
+    for (const tag of tagSet(recipe)) {
+      map.set(tag, (map.get(tag) ?? 0) + 1);
+    }
+  }
+  return map;
+}
+
+/**
+ * Scores a candidate recipe by how many of its tags overlap with the user's
+ * preference map (weighted by how often that tag shows up in their history).
+ * Recency is used only as a tiebreaker (see rankForYou) — an empty preference
+ * map scores everything 0, which the caller should treat as "fall back to
+ * trending" rather than a meaningful ranking.
+ */
+export function scoreCandidate(candidate: Pick<TaggedRecipe, "tags" | "dietaryTags">, preferences: Map<string, number>): number {
+  return tagSet(candidate).reduce((sum, tag) => sum + (preferences.get(tag) ?? 0), 0);
+}
+
+export function rankForYou<T extends TaggedRecipe>(candidates: T[], preferences: Map<string, number>): T[] {
+  return [...candidates]
+    .map((c) => ({ c, score: scoreCandidate(c, preferences) }))
+    .sort((a, b) => b.score - a.score || b.c.createdAt.getTime() - a.c.createdAt.getTime())
+    .map(({ c }) => c);
+}

apps/web/lib/grocery-export.ts

@@ -0,0 +1,33 @@
+export type GroceryExportItem = {
+  name: string;
+  quantity: string | null;
+  unit: string | null;
+};
+
+export type GroceryExportPayload = {
+  listName: string;
+  items: GroceryExportItem[];
+};
+
+type ShoppingListForExport = {
+  name: string;
+  items: Array<{ rawName: string; quantity: string | null; unit: string | null; checked: boolean }>;
+};
+
+/** Maps a shopping list into a provider-agnostic export shape any grocery-delivery adapter can consume. */
+export function buildGroceryExportPayload(list: ShoppingListForExport): GroceryExportPayload {
+  return {
+    listName: list.name,
+    items: list.items
+      .filter((i) => !i.checked)
+      .map((i) => ({ name: i.rawName, quantity: i.quantity, unit: i.unit })),
+  };
+}
+
+export function groceryExportToText(payload: GroceryExportPayload): string {
+  const lines = payload.items.map((i) => {
+    const qty = [i.quantity, i.unit].filter(Boolean).join(" ");
+    return qty ? `${qty} ${i.name}` : i.name;
+  });
+  return [payload.listName, "", ...lines].join("\n");
+}

apps/web/lib/grocery-providers/instacart.ts

@@ -0,0 +1,27 @@
+import type { GroceryExportPayload } from "@/lib/grocery-export";
+
+/**
+ * Stub adapter for the Instacart "Recipe & Shopping List" partner API.
+ *
+ * Not wired to a live endpoint — Instacart requires a signed partnership
+ * agreement and a per-integration API key before any request can succeed.
+ * This documents the request shape so activation is a config change, not a
+ * rewrite, once `INSTACART_API_KEY` is issued.
+ *
+ * Real endpoint (per Instacart Developer Platform docs, subject to change):
+ *   POST https://connect.instacart.com/idp/v1/products/products_link
+ *   Authorization: Bearer <INSTACART_API_KEY>
+ *   Body: { title: string, link_type: "shopping_list", line_items: [{ name, quantity, unit }] }
+ * Response contains a `products_link_url` the user is redirected to.
+ */
+export async function createInstacartShoppingListLink(
+  payload: GroceryExportPayload
+): Promise<{ url: string } | null> {
+  const apiKey = process.env["INSTACART_API_KEY"];
+  if (!apiKey) return null;
+
+  throw new Error(
+    "Instacart integration is stubbed — INSTACART_API_KEY is set but no live API call is wired up yet. " +
+      `Would send list "${payload.listName}" with ${payload.items.length} item(s).`
+  );
+}

apps/web/lib/meal-plan-access.ts

@@ -0,0 +1,29 @@
+import { db, mealPlans, mealPlanMembers, eq, and } from "@epicure/db";
+
+export type MealPlanRole = "owner" | "editor" | "viewer";
+
+export type MealPlanAccess = {
+  plan: typeof mealPlans.$inferSelect;
+  role: MealPlanRole;
+};
+
+/** Resolves a user's access to a meal plan by its id — owner, or member with their assigned role. Null if no access. */
+export async function getMealPlanAccessById(
+  mealPlanId: string,
+  userId: string
+): Promise<MealPlanAccess | null> {
+  const plan = await db.query.mealPlans.findFirst({ where: eq(mealPlans.id, mealPlanId) });
+  if (!plan) return null;
+  if (plan.userId === userId) return { plan, role: "owner" };
+
+  const member = await db.query.mealPlanMembers.findFirst({
+    where: and(eq(mealPlanMembers.mealPlanId, mealPlanId), eq(mealPlanMembers.userId, userId)),
+  });
+  if (!member) return null;
+
+  return { plan, role: member.role };
+}
+
+export function canWriteMealPlan(role: MealPlanRole): boolean {
+  return role === "owner" || role === "editor";
+}

apps/web/lib/shopping-list-access.ts

@@ -0,0 +1,29 @@
+import { db, shoppingLists, shoppingListMembers, eq, and } from "@epicure/db";
+
+export type ShoppingListRole = "owner" | "editor" | "viewer";
+
+export type ShoppingListAccess = {
+  list: typeof shoppingLists.$inferSelect;
+  role: ShoppingListRole;
+};
+
+/** Resolves a user's access to a shopping list — owner, or member with their assigned role. Null if no access. */
+export async function getShoppingListAccess(
+  listId: string,
+  userId: string
+): Promise<ShoppingListAccess | null> {
+  const list = await db.query.shoppingLists.findFirst({ where: eq(shoppingLists.id, listId) });
+  if (!list) return null;
+  if (list.userId === userId) return { list, role: "owner" };
+
+  const member = await db.query.shoppingListMembers.findFirst({
+    where: and(eq(shoppingListMembers.listId, listId), eq(shoppingListMembers.userId, userId)),
+  });
+  if (!member) return null;
+
+  return { list, role: member.role };
+}
+
+export function canWriteShoppingList(role: ShoppingListRole): boolean {
+  return role === "owner" || role === "editor";
+}

apps/web/messages/en.json

@@ -327,7 +327,8 @@
     "partialMatches": "Partial matches",
     "noMatches": "No strong matches found",
     "missing": "Missing",
-    "ingredientProgress": "{matched}/{total} ingredients"
+    "ingredientProgress": "{matched}/{total} ingredients",
+    "useItUp": "Use it up"
   },
   "mealPlan": {
     "title": "Meal Plan",
@@ -386,6 +387,8 @@
     "following": "Following",
     "trending": "Trending",
     "trendingEmpty": "No trending recipes this week.",
+    "forYou": "For You",
+    "forYouEmpty": "Favorite or rate some recipes to get personalized picks here.",
     "loading": "Loading…"
   },
   "shoppingLists": {

apps/web/messages/fr.json

@@ -315,7 +315,8 @@
     "partialMatches": "Correspondances partielles",
     "noMatches": "Aucune correspondance trouvée",
     "missing": "Manquant",
-    "ingredientProgress": "{matched}/{total} ingrédients"
+    "ingredientProgress": "{matched}/{total} ingrédients",
+    "useItUp": "À utiliser vite"
   },
   "mealPlan": {
     "title": "Planning repas",
@@ -374,6 +375,8 @@
     "following": "Abonnements",
     "trending": "Tendances",
     "trendingEmpty": "Aucune recette tendance cette semaine.",
+    "forYou": "Pour vous",
+    "forYouEmpty": "Ajoutez des favoris ou notez des recettes pour des suggestions personnalisées.",
     "loading": "Chargement…"
   },
   "shoppingLists": {

apps/web/public/icon-192.svg

@@ -0,0 +1,8 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 192 192" width="192" height="192">
+  <rect width="192" height="192" rx="36" fill="#18181b"/>
+  <circle cx="96" cy="96" r="34" fill="none" stroke="#fafafa" stroke-width="8"/>
+  <g fill="#fafafa">
+    <rect x="46" y="44" width="8" height="104" rx="4"/>
+    <rect x="138" y="44" width="8" height="104" rx="4"/>
+  </g>
+</svg>

apps/web/public/icon-512.svg

@@ -0,0 +1,8 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" width="512" height="512">
+  <rect width="512" height="512" rx="96" fill="#18181b"/>
+  <circle cx="256" cy="256" r="90" fill="none" stroke="#fafafa" stroke-width="20"/>
+  <g fill="#fafafa">
+    <rect x="122" y="118" width="20" height="276" rx="10"/>
+    <rect x="370" y="118" width="20" height="276" rx="10"/>
+  </g>
+</svg>

apps/web/public/manifest.json

@@ -0,0 +1,15 @@
+{
+  "name": "Epicure",
+  "short_name": "Epicure",
+  "description": "Your personal AI-powered recipe book.",
+  "start_url": "/",
+  "display": "standalone",
+  "background_color": "#ffffff",
+  "theme_color": "#18181b",
+  "icons": [
+    { "src": "/icon-192.svg", "sizes": "192x192", "type": "image/svg+xml", "purpose": "any" },
+    { "src": "/icon-192.svg", "sizes": "192x192", "type": "image/svg+xml", "purpose": "maskable" },
+    { "src": "/icon-512.svg", "sizes": "512x512", "type": "image/svg+xml", "purpose": "any" },
+    { "src": "/icon-512.svg", "sizes": "512x512", "type": "image/svg+xml", "purpose": "maskable" }
+  ]
+}

packages/db/src/index.ts

@@ -2,4 +2,4 @@ export { db } from "./client";
 export type { Db } from "./client";
 export * from "./schema";
 // Re-export query helpers so all callers use the same drizzle-orm instance
-export { eq, and, or, desc, asc, gt, lt, gte, lte, ne, inArray, isNull, isNotNull, sql, count, avg, sum, min, max, ilike, like } from "drizzle-orm";
+export { eq, and, or, desc, asc, gt, lt, gte, lte, ne, inArray, notInArray, isNull, isNotNull, sql, count, avg, sum, min, max, ilike, like } from "drizzle-orm";

packages/db/src/migrations/0014_late_marvex.sql

@@ -0,0 +1,24 @@
+CREATE TABLE "meal_plan_members" (
+	"id" text PRIMARY KEY NOT NULL,
+	"meal_plan_id" text NOT NULL,
+	"user_id" text NOT NULL,
+	"role" "collection_member_role" DEFAULT 'viewer' NOT NULL,
+	"created_at" timestamp DEFAULT now() NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE "shopping_list_members" (
+	"id" text PRIMARY KEY NOT NULL,
+	"list_id" text NOT NULL,
+	"user_id" text NOT NULL,
+	"role" "collection_member_role" DEFAULT 'viewer' NOT NULL,
+	"created_at" timestamp DEFAULT now() NOT NULL
+);
+--> statement-breakpoint
+ALTER TABLE "meal_plan_members" ADD CONSTRAINT "meal_plan_members_meal_plan_id_meal_plans_id_fk" FOREIGN KEY ("meal_plan_id") REFERENCES "public"."meal_plans"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "meal_plan_members" ADD CONSTRAINT "meal_plan_members_user_id_users_id_fk" FOREIGN KEY ("user_id") REFERENCES "public"."users"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "shopping_list_members" ADD CONSTRAINT "shopping_list_members_list_id_shopping_lists_id_fk" FOREIGN KEY ("list_id") REFERENCES "public"."shopping_lists"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "shopping_list_members" ADD CONSTRAINT "shopping_list_members_user_id_users_id_fk" FOREIGN KEY ("user_id") REFERENCES "public"."users"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+CREATE INDEX "meal_plan_members_plan_idx" ON "meal_plan_members" USING btree ("meal_plan_id");--> statement-breakpoint
+CREATE INDEX "meal_plan_members_user_idx" ON "meal_plan_members" USING btree ("user_id");--> statement-breakpoint
+CREATE INDEX "shopping_list_members_list_idx" ON "shopping_list_members" USING btree ("list_id");--> statement-breakpoint
+CREATE INDEX "shopping_list_members_user_idx" ON "shopping_list_members" USING btree ("user_id");

packages/db/src/migrations/meta/_journal.json

@@ -85,6 +85,27 @@
       "when": 1782896400709,
       "tag": "0011_premium_agent_zero",
       "breakpoints": true
+    },
+    {
+      "idx": 12,
+      "version": "7",
+      "when": 1782977005184,
+      "tag": "0012_sloppy_tigra",
+      "breakpoints": true
+    },
+    {
+      "idx": 13,
+      "version": "7",
+      "when": 1782977520719,
+      "tag": "0013_damp_richard_fisk",
+      "breakpoints": true
+    },
+    {
+      "idx": 14,
+      "version": "7",
+      "when": 1782984288632,
+      "tag": "0014_late_marvex",
+      "breakpoints": true
     }
   ]
 }

packages/db/src/schema/meal-planning.ts

@@ -7,11 +7,13 @@ import {
   date,
   decimal,
   pgEnum,
+  index,
 } from "drizzle-orm/pg-core";
 import { relations } from "drizzle-orm";
 import { users } from "./users";
 import { recipes } from "./recipes";
 import { ingredients } from "./recipes";
+import { collectionMemberRoleEnum } from "./social";
 
 export const mealTypeEnum = pgEnum("meal_type", ["breakfast", "lunch", "dinner", "snack"]);
 export const weekdayEnum = pgEnum("weekday", ["mon", "tue", "wed", "thu", "fri", "sat", "sun"]);
@@ -63,9 +65,32 @@ export const shoppingListItems = pgTable("shopping_list_items", {
   checked: boolean("checked").notNull().default(false),
 });
 
+export const shoppingListMembers = pgTable("shopping_list_members", {
+  id: text("id").primaryKey(),
+  listId: text("list_id").notNull().references(() => shoppingLists.id, { onDelete: "cascade" }),
+  userId: text("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+  role: collectionMemberRoleEnum("role").notNull().default("viewer"),
+  createdAt: timestamp("created_at").notNull().defaultNow(),
+}, (t) => [
+  index("shopping_list_members_list_idx").on(t.listId),
+  index("shopping_list_members_user_idx").on(t.userId),
+]);
+
+export const mealPlanMembers = pgTable("meal_plan_members", {
+  id: text("id").primaryKey(),
+  mealPlanId: text("meal_plan_id").notNull().references(() => mealPlans.id, { onDelete: "cascade" }),
+  userId: text("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+  role: collectionMemberRoleEnum("role").notNull().default("viewer"),
+  createdAt: timestamp("created_at").notNull().defaultNow(),
+}, (t) => [
+  index("meal_plan_members_plan_idx").on(t.mealPlanId),
+  index("meal_plan_members_user_idx").on(t.userId),
+]);
+
 export const mealPlansRelations = relations(mealPlans, ({ one, many }) => ({
   user: one(users, { fields: [mealPlans.userId], references: [users.id] }),
   entries: many(mealPlanEntries),
+  members: many(mealPlanMembers),
 }));
 
 export const mealPlanEntriesRelations = relations(mealPlanEntries, ({ one }) => ({
@@ -73,11 +98,22 @@ export const mealPlanEntriesRelations = relations(mealPlanEntries, ({ one }) =>
   recipe: one(recipes, { fields: [mealPlanEntries.recipeId], references: [recipes.id] }),
 }));
 
+export const mealPlanMembersRelations = relations(mealPlanMembers, ({ one }) => ({
+  mealPlan: one(mealPlans, { fields: [mealPlanMembers.mealPlanId], references: [mealPlans.id] }),
+  user: one(users, { fields: [mealPlanMembers.userId], references: [users.id] }),
+}));
+
 export const shoppingListsRelations = relations(shoppingLists, ({ one, many }) => ({
   user: one(users, { fields: [shoppingLists.userId], references: [users.id] }),
   items: many(shoppingListItems),
+  members: many(shoppingListMembers),
 }));
 
 export const shoppingListItemsRelations = relations(shoppingListItems, ({ one }) => ({
   list: one(shoppingLists, { fields: [shoppingListItems.listId], references: [shoppingLists.id] }),
 }));
+
+export const shoppingListMembersRelations = relations(shoppingListMembers, ({ one }) => ({
+  list: one(shoppingLists, { fields: [shoppingListMembers.listId], references: [shoppingLists.id] }),
+  user: one(users, { fields: [shoppingListMembers.userId], references: [users.id] }),
+}));

pnpm-lock.yaml

@@ -56,6 +56,9 @@ importers:
       cmdk:
         specifier: ^1.1.1
         version: 1.1.1(@types/react-dom@19.2.3(@types/react@19.2.17))(@types/react@19.2.17)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      diff:
+        specifier: ^9.0.0
+        version: 9.0.0
       drizzle-orm:
         specifier: ^0.44.7
         version: 0.44.7(@opentelemetry/api@1.9.1)(kysely@0.29.2)(postgres@3.4.9)
@@ -176,6 +179,9 @@ importers:
         specifier: ^3.4.7
         version: 3.4.9
     devDependencies:
+      '@types/node':
+        specifier: ^20.19.43
+        version: 20.19.43
       drizzle-kit:
         specifier: ^0.31.1
         version: 0.31.10
@@ -2982,6 +2988,10 @@ packages:
     resolution: {integrity: sha512-DPi0FmjiSU5EvQV0++GFDOJ9ASQUVFh5kD+OzOnYdi7n3Wpm9hWWGfB/O2blfHcMVTL5WkQXSnRiK9makhrcnw==}
     engines: {node: '>=0.3.1'}
 
+  diff@9.0.0:
+    resolution: {integrity: sha512-svtcdpS8CgJyqAjEQIXdb3OjhFVVYjzGAPO8WGCmRbrml64SPw/jJD4GoE98aR7r25A0XcgrK3F02yw9R/vhQw==}
+    engines: {node: '>=0.3.1'}
+
   doctrine@2.1.0:
     resolution: {integrity: sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==}
     engines: {node: '>=0.10.0'}
@@ -7865,6 +7875,8 @@ snapshots:
 
   diff@8.0.4: {}
 
+  diff@9.0.0: {}
+
   doctrine@2.1.0:
     dependencies:
       esutils: 2.0.3