Move legacy job repair to migration 0011 and keep archived dinners pending

R1-A: Migration 0010 is back to its round-2 content, the ALTER TABLE only,
since a database that already applied 0010 never runs it again. The
repair that writes revision 0 into ground_dinner job payloads without one
is now migration 0011, applied by the same boot Migrate call, so before
the job runner starts and before FailInterruptedGroundings.
TestUpgradeKeepsLegacyQueuedGrounding now upgrades from 0009 and from a
database with 0010 already recorded, each with a pending Regular and a
queued legacy job; both keep the dinner pending through the boot cleanup
and then ground it.

R2-A: The boot cleanup no longer fails archived dinners. Archiving stops a
running job and leaves the dinner pending, which the cleanup relabelled
failed with interrupted. TestRestartKeepsArchivedPendingDinner archives a
pending Regular while its job runs and checks the cleanup leaves it
pending with no error.

Maestro task 5037ff86-181d-448e-927b-c2fd2258a25d.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

docs/ARCHITECTURE.md

@@ -96,7 +96,7 @@ Columns ending in `_ct` hold AES-256-GCM ciphertext (via `secretbox`).
 | `recipe_ingredients` | recipe_id, position, raw_text, name, qty, unit, note. |
 | `recipe_steps` | recipe_id, position, text. |
 | `photos` | source_url, local_path, width, height, sha256, fetched_at. |
-| `dinners` | The meal record and its lifecycle: name, normalized_name, status (`suggested` / `quest_log` / `tried` / `regular` / `archived`), origin, method, minutes_total, difficulty, cuisine, is_favorite, recipe_id, recipe_url (a pasted recipe link awaiting grounding), photo_id, grounding_status (`pending` / `grounded` / `failed` / `manual`), grounding_error (why grounding failed), grounding_revision (raised whenever a dinner is renamed, so only the latest `ground_dinner` job may write it and no candidate offered before the rename grounds it), updated_by. |
+| `dinners` | The meal record and its lifecycle: name, normalized_name, status (`suggested` / `quest_log` / `tried` / `regular` / `archived`), origin, method, minutes_total, difficulty, cuisine, is_favorite, recipe_id, recipe_url (a pasted recipe link awaiting grounding), photo_id, grounding_status (`pending` / `grounded` / `failed` / `manual`), grounding_error (why grounding failed), grounding_revision (raised when a pending dinner is renamed, so only the latest `ground_dinner` job may write it), updated_by. |
 | `suggestion_batches` | trigger, status, ai_run_id. |
 | `suggestions` | dinner_id, batch_id, reason, cited_regular_ids (JSON), status, decided_at. |
 | `week_plans` | week_start (unique), status (`draft` / `synced` / `changed`), ai_note, ai_run_id, calendar_synced_at. |
@@ -179,12 +179,12 @@ automatic** (D-021).
   response holds the key. `Service.HarnessConfig` reads the settings for
   each skill run, so a saved change applies to the next run.
 - Dinners (`dinners.Service`). `POST /api/v1/dinners` adds a Regular from
-  `{name}` or `{name, recipe_url}` (an https:// link, kept in
-  `recipe_url` for grounding and never returned in a dinner response, as
-  it may carry a personal token) with status and origin `regular` and
-  grounding_status `pending`, answering 201 with the dinner. The name is
-  always the household's: no part of a link is ever used as a dinner's
-  name, and a link without a name is 400. A name
+  exactly one of `{name}` or `{recipe_url}` (an https:// link, kept in
+  `recipe_url` for grounding) with status and origin `regular` and
+  grounding_status `pending`, answering 201 with the dinner. A link's
+  dinner is named from its last path segment (separators become spaces,
+  an extension and all-digit words are dropped: `…/12345/beef-stew/` is
+  "Beef stew"); a link that names nothing is 400 — add it by name. A name
   is trimmed, at most 120 characters and must keep a word after
   `harness.Normalize`, which sets `normalized_name`. A name
   `harness.Similar` to an unarchived dinner's, or a link one already has
@@ -209,15 +209,13 @@ automatic** (D-021).
   and `grounding_job_id` null. The job grounds the dinner's
   `recipe_url` directly with `GroundURL`, else its name with `Ground`
   (see Recipe grounding), and sets grounding_status `grounded` with the
-  recipe's recipe_id, photo_id, method, minutes_total and difficulty,
-  clearing the pasted `recipe_url` (the recipe replaces it), or
+  recipe's recipe_id, photo_id, method, minutes_total and difficulty, or
   `failed` with `grounding_error` — also the job's failure code — one of
   `no_recipe_found`, `recipe_unusable` (the pasted link), `search_not_configured`,
   `search_failed`, `ai_failed`, `interrupted` (the server stopped) or
   `grounding_error`. Each job carries the dinner's `grounding_revision`
-  from when it was enqueued; renaming a dinner raises the revision, and
-  renaming a `pending` one enqueues a job for the new name, clearing its
-  `recipe_url` when the normalized name changes.
+  from when it was enqueued; renaming a `pending` dinner clears its
+  `recipe_url`, raises the revision and enqueues a job for the new name.
   A job for a dinner archived, no longer `pending` or at another revision
   does no work, and a job only writes a dinner still unarchived, `pending`
   and at its revision, so a fix-up made meanwhile wins and an earlier job
@@ -235,14 +233,10 @@ automatic** (D-021).
   searches for the dinner's name and returns `{candidates: [{candidate_id,
   title, site_name, photo_url, minutes}]}`, at most 3, ranked as `Ground`
   ranks them; it fetches pages but downloads no photo and runs no model,
-  so `photo_url` is set only for a page already stored. `candidate_id` is
-  an opaque id the server resolves to the page it last offered that dinner
-  (kept in memory, so a restart means fetching the candidates again) at
-  the `grounding_revision` it was searched at, so a candidate offered
-  before any rename is refused even if the name is changed back; the
-  page's URL, which may carry a token, is never returned or cached.
-  `POST /api/v1/dinners/{id}/ground` takes exactly one of `{candidate_id}`,
-  `{recipe_url}` (both grounded with `GroundURL`, setting `grounded`) or `{manual: {ingredients[], steps[], minutes,
+  so `photo_url` is set only for a page already stored, and `candidate_id`
+  is the page's URL. `POST /api/v1/dinners/{id}/ground` takes exactly one
+  of `{candidate_id}`, `{recipe_url}` (both grounded with `GroundURL`,
+  setting `grounded`) or `{manual: {ingredients[], steps[], minutes,
   method}}` (1–100 ingredient lines, up to 100 steps, each non-blank and at
   most 500 characters; minutes 1–1440). A manual recipe is stored as typed
   — no model runs — as a `recipes` row whose source_url is
@@ -256,16 +250,7 @@ automatic** (D-021).
   `search_failed` / `ai_failed` (only the reason code is logged, never the
   provider's text), and grounding a candidate or link that runs past 90
   seconds (fetch, photo and `normalize_recipe`, all in the request) 504
-  `ground_timeout`, leaving the dinner unchanged. An archived dinner is 409
-  `dinner_archived`. A candidate or link is written only if the dinner is
-  still as it was before grounding began: one renamed or grounded some
-  other way meanwhile is 409 `ground_conflict`, and one archived meanwhile
-  409 `dinner_archived`, either leaving the dinner unchanged. A method,
-  minutes or difficulty a member edits meanwhile is kept over the recipe's.
-  Any other failure grounding a candidate or link, or recording it on the
-  dinner, is 500, logged with a fixed reason and the dinner id only —
-  never the link, which can carry a personal token, or dependency error
-  text.
+  `ground_timeout`, leaving the dinner unchanged.
 - `/health` — liveness.
 - Everything else serves the embedded PWA with SPA fallback.
 
@@ -523,11 +508,11 @@ Regular has a name `harness.Similar` to it — the PWA's copy of the name
 rules in `web/src/dinners/names.ts` folds letters with
 `web/src/dinners/letterFolds.json`, which `gen_folds.py` writes from the
 same table as the server's, and runs the same cases,
-`web/src/dinners/testdata/dedupe_cases.json`, as the server's) and
+`internal/ai/harness/testdata/dedupe_cases.json`, as the server's) and
 notifications (`/onboarding/notifications`: what MealQuest notifies about,
-the iOS install hint, "Turn on notifications" and "Maybe later"). "Maybe
-later", and "Turn on notifications" once notifications are enabled, send
-`PATCH /api/v1/settings/household` with `{"onboarding_completed": true}`; the server sets `onboarding_completed_at`
+the iOS install hint, "Turn on notifications" and "Maybe later"). Either
+button sends `PATCH /api/v1/settings/household` with
+`{"onboarding_completed": true}`; the server sets `onboarding_completed_at`
 to the time of that update (keeping the first time if it is already set;
 the field itself is read-only and `false` is refused) and the app goes Home.
 Completing needs at least three Regulars (`household.MinRegulars`); with
@@ -536,10 +521,8 @@ fewer the server answers 400 `invalid_settings` naming
 fewer — by its URL, or after another member removes a Regular — so it then
 shows the server's reason with an "Add Regulars" button back to step 2.
 Notification permission is never asked for on page load; until Feature 19
-wires Web Push, "Turn on notifications" asks for nothing and says plainly
-that notifications are not on yet, offering "Finish setting up" (which
-completes onboarding as above) instead of a silent success. Offline on the
-saved pages the settings cannot be read (the service worker never caches `/api/v1/settings`),
+wires Web Push, "Turn on notifications" asks for nothing. Offline on the saved pages the
+settings cannot be read (the service worker never caches `/api/v1/settings`),
 so the saved pages open as they are.
 
 Regular dinners (`/settings/regulars`) lists the Regulars from

internal/ai/harness/dedupe_test.go

@@ -8,11 +8,11 @@ import (
 	"unicode/utf8"
 )
 
-// TestSharedDedupeCases runs web/src/dinners/testdata/dedupe_cases.json,
-// which the PWA's copy of Normalize and Similar (web/src/dinners/names.ts)
-// runs too, so the two cannot drift apart on these names.
+// TestSharedDedupeCases runs testdata/dedupe_cases.json, which the PWA's
+// copy of Normalize and Similar (web/src/dinners/names.ts) runs too, so the
+// two cannot drift apart on these names.
 func TestSharedDedupeCases(t *testing.T) {
-	raw, err := os.ReadFile("../../../web/src/dinners/testdata/dedupe_cases.json")
+	raw, err := os.ReadFile("testdata/dedupe_cases.json")
 	if err != nil {
 		t.Fatal(err)
 	}

internal/db/dinners.sql.go

@@ -248,76 +248,46 @@ func (q *Queries) GetDinner(ctx context.Context, id string) (Dinner, error) {
 
 const groundDinner = `-- name: GroundDinner :one
 UPDATE dinners
-SET recipe_id = ?1,
+SET recipe_id = ?,
 	recipe_url = NULL,
-	photo_id = ?2,
-	method = CASE WHEN method IS ?3
-		THEN ?4 ELSE method END,
-	minutes_total = CASE WHEN minutes_total IS ?5
-		THEN ?6 ELSE minutes_total END,
-	difficulty = CASE WHEN difficulty IS ?7
-		THEN ?8 ELSE difficulty END,
-	grounding_status = ?9,
+	photo_id = ?,
+	method = ?,
+	minutes_total = ?,
+	difficulty = ?,
+	grounding_status = ?,
 	grounding_error = NULL,
-	updated_by = ?10,
-	updated_at = ?11
-WHERE id = ?12
-	AND status <> 'archived'
-	AND name = ?13
-	AND normalized_name = ?14
-	AND grounding_status = ?15
-	AND grounding_revision = ?16
-	AND recipe_id IS ?17
+	updated_by = ?,
+	updated_at = ?
+WHERE id = ?
 RETURNING id, name, normalized_name, status, origin, method, minutes_total, difficulty, cuisine, is_favorite, recipe_id, photo_id, grounding_status, updated_by, created_at, updated_at, recipe_url, grounding_error, grounding_revision
 `
 
 type GroundDinnerParams struct {
-	RecipeID                  sql.NullString
-	PhotoID                   sql.NullString
-	ObservedMethod            sql.NullString
-	Method                    sql.NullString
-	ObservedMinutesTotal      sql.NullInt64
-	MinutesTotal              sql.NullInt64
-	ObservedDifficulty        sql.NullString
-	Difficulty                sql.NullString
-	GroundingStatus           string
-	UpdatedBy                 sql.NullString
-	UpdatedAt                 string
-	ID                        string
-	ObservedName              string
-	ObservedNormalizedName    string
-	ObservedGroundingStatus   string
-	ObservedGroundingRevision int64
-	ObservedRecipeID          sql.NullString
+	RecipeID        sql.NullString
+	PhotoID         sql.NullString
+	Method          sql.NullString
+	MinutesTotal    sql.NullInt64
+	Difficulty      sql.NullString
+	GroundingStatus string
+	UpdatedBy       sql.NullString
+	UpdatedAt       string
+	ID              string
 }
 
 // Records a dinner's grounding by hand (grounded or manual) and clears any
 // grounding_error and pasted recipe_url: the recipe chosen replaces the
-// link. It writes only an unarchived dinner still as it was observed
-// before grounding (same name, normalized_name, grounding_status,
-// grounding_revision and recipe_id), so a dinner renamed, archived or
-// grounded some other way meanwhile is left as it is. That dinner, or an
-// unknown id, returns sql.ErrNoRows. A method, minutes_total or difficulty
-// no longer as observed is kept: a member edited it while it was grounding.
+// link. An unknown id returns sql.ErrNoRows.
 func (q *Queries) GroundDinner(ctx context.Context, arg GroundDinnerParams) (Dinner, error) {
 	row := q.db.QueryRowContext(ctx, groundDinner,
 		arg.RecipeID,
 		arg.PhotoID,
-		arg.ObservedMethod,
 		arg.Method,
-		arg.ObservedMinutesTotal,
 		arg.MinutesTotal,
-		arg.ObservedDifficulty,
 		arg.Difficulty,
 		arg.GroundingStatus,
 		arg.UpdatedBy,
 		arg.UpdatedAt,
 		arg.ID,
-		arg.ObservedName,
-		arg.ObservedNormalizedName,
-		arg.ObservedGroundingStatus,
-		arg.ObservedGroundingRevision,
-		arg.ObservedRecipeID,
 	)
 	var i Dinner
 	err := row.Scan(
@@ -347,7 +317,6 @@ func (q *Queries) GroundDinner(ctx context.Context, arg GroundDinnerParams) (Din
 const groundPendingDinner = `-- name: GroundPendingDinner :execrows
 UPDATE dinners
 SET recipe_id = ?1,
-	recipe_url = NULL,
 	photo_id = ?2,
 	method = COALESCE(method, ?3),
 	minutes_total = COALESCE(minutes_total, ?4),
@@ -376,8 +345,7 @@ type GroundPendingDinnerParams struct {
 // the grounding_revision it was grounded for; a dinner grounded some other
 // way, renamed or archived meanwhile is left as it is (0 rows). A method,
 // minutes_total or difficulty already set is kept: a pending dinner has
-// them only when a member edited them while it was grounding. Like
-// GroundDinner it clears the pasted recipe_url: the recipe replaces the link.
+// them only when a member edited them while it was grounding.
 func (q *Queries) GroundPendingDinner(ctx context.Context, arg GroundPendingDinnerParams) (int64, error) {
 	result, err := q.db.ExecContext(ctx, groundPendingDinner,
 		arg.RecipeID,

internal/db/querier.go

@@ -69,19 +69,13 @@ type Querier interface {
 	GetRecipeSearchSettings(ctx context.Context) (RecipeSearchSetting, error)
 	// Records a dinner's grounding by hand (grounded or manual) and clears any
 	// grounding_error and pasted recipe_url: the recipe chosen replaces the
-	// link. It writes only an unarchived dinner still as it was observed
-	// before grounding (same name, normalized_name, grounding_status,
-	// grounding_revision and recipe_id), so a dinner renamed, archived or
-	// grounded some other way meanwhile is left as it is. That dinner, or an
-	// unknown id, returns sql.ErrNoRows. A method, minutes_total or difficulty
-	// no longer as observed is kept: a member edited it while it was grounding.
+	// link. An unknown id returns sql.ErrNoRows.
 	GroundDinner(ctx context.Context, arg GroundDinnerParams) (Dinner, error)
 	// Records the background grounding of an unarchived dinner still pending at
 	// the grounding_revision it was grounded for; a dinner grounded some other
 	// way, renamed or archived meanwhile is left as it is (0 rows). A method,
 	// minutes_total or difficulty already set is kept: a pending dinner has
-	// them only when a member edited them while it was grounding. Like
-	// GroundDinner it clears the pasted recipe_url: the recipe replaces the link.
+	// them only when a member edited them while it was grounding.
 	GroundPendingDinner(ctx context.Context, arg GroundPendingDinnerParams) (int64, error)
 	ListDinnersByStatus(ctx context.Context, status string) ([]Dinner, error)
 	// The planned dinners dated from from_date up to but not including

internal/dinners/dinners.go

@@ -7,7 +7,6 @@ package dinners
 
 import (
 	"context"
-	"crypto/rand"
 	"database/sql"
 	"errors"
 	"fmt"
@@ -17,6 +16,7 @@ import (
 	"slices"
 	"strings"
 	"sync"
+	"unicode"
 	"unicode/utf8"
 
 	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/ai/harness"
@@ -55,9 +55,7 @@ var listable = []string{StatusRegular, StatusQuestLog}
 // ErrNotFound is returned for an unknown dinner id.
 var ErrNotFound = errors.New("dinner not found")
 
-// Dinner is a dinner as the API shows it. It has no recipe_url: a pasted
-// link may carry a personal token, so it stays in the database for
-// grounding and never leaves the server.
+// Dinner is a dinner as the API shows it.
 type Dinner struct {
 	ID              string  `json:"id"`
 	Name            string  `json:"name"`
@@ -69,6 +67,7 @@ type Dinner struct {
 	Cuisine         *string `json:"cuisine"`
 	IsFavorite      bool    `json:"is_favorite"`
 	RecipeID        *string `json:"recipe_id"`
+	RecipeURL       *string `json:"recipe_url"`
 	PhotoURL        *string `json:"photo_url"`
 	GroundingStatus string  `json:"grounding_status"`
 	// GroundingError is why grounding failed, one of the Reason codes;
@@ -79,10 +78,7 @@ type Dinner struct {
 	UpdatedAt      string  `json:"updated_at"`
 }
 
-// NewRegular is a Regular to add: its Name, which the household always
-// gives, and optionally the RecipeURL to ground it in. The name is never
-// taken from the link: a pasted link may carry a personal token anywhere in
-// it, and the name is shown in every dinner response.
+// NewRegular is a Regular to add: exactly one of Name and RecipeURL.
 type NewRegular struct {
 	Name      *string
 	RecipeURL *string
@@ -141,18 +137,6 @@ type Service struct {
 	// by dinner id, so archiving or renaming a dinner can stop them.
 	groundingsMu sync.Mutex
 	groundings   map[string]map[*runningGrounding]struct{}
-
-	// offerKey keys the candidate ids Candidates offers, so they are
-	// opaque and stable for this process.
-	offerKey []byte
-	// offersMu guards offers and offerSearches. offers holds, by dinner
-	// id, the candidates last offered by Candidates until they expire, so
-	// a candidate id is resolved here and its URL never leaves the server.
-	// offerSearches holds the Candidates searches running, by dinner id,
-	// so clearing a dinner's offers keeps them from storing stale ones.
-	offersMu      sync.Mutex
-	offers        map[string]*offerSet
-	offerSearches map[string]map[*offerSearch]struct{}
 }
 
 // NewService returns a service over st that grounds dinners with grounder
@@ -169,8 +153,7 @@ func NewService(st *store.Store, grounder *recipes.Grounder, runner *jobs.Runner
 	case logger == nil:
 		return nil, errors.New("dinners: nil logger")
 	}
-	s := &Service{st: st, grounder: grounder, logger: logger, groundings: make(map[string]map[*runningGrounding]struct{}), offerKey: make([]byte, 32), offers: make(map[string]*offerSet), offerSearches: make(map[string]map[*offerSearch]struct{})}
-	rand.Read(s.offerKey) // never fails: it crashes the program instead
+	s := &Service{st: st, grounder: grounder, logger: logger, groundings: make(map[string]map[*runningGrounding]struct{})}
 	kind, err := jobs.Register(runner, KindGroundDinner, s.runGroundJob, Reasons...)
 	if err != nil {
 		return nil, err
@@ -187,9 +170,10 @@ type Created struct {
 	GroundingJobID *string `json:"grounding_job_id"`
 }
 
-// CreateRegular adds a Regular named r.Name, keeping r.RecipeURL for
-// grounding when given, with status and origin regular and grounding_status
-// pending, recording updatedBy, and enqueues the KindGroundDinner job that grounds it. It returns without
+// CreateRegular adds a Regular named by r.Name, or by the last path segment
+// of r.RecipeURL (whose recipe grounding later replaces), with status and
+// origin regular and grounding_status pending, recording updatedBy, and
+// enqueues the KindGroundDinner job that grounds it. It returns without
 // waiting for the job. A name repeating an unarchived dinner is a
 // *DuplicateError. When the job cannot be enqueued, the stored dinner is
 // returned with grounding_status failed (ReasonGroundingError) and no job
@@ -239,24 +223,34 @@ func (s *Service) createRegular(ctx context.Context, r NewRegular, updatedBy str
 	if updatedBy == "" {
 		return db.Dinner{}, errors.New("dinners: create: no member to record as updated_by")
 	}
-	if r.Name == nil {
-		return db.Dinner{}, invalid("name", "give the dinner's name, with or without a recipe_url")
-	}
-	name, err := checkName(*r.Name)
-	if err != nil {
-		return db.Dinner{}, err
-	}
+	var name string
 	var recipeURL sql.NullString
-	if r.RecipeURL != nil {
+	switch {
+	case r.Name != nil && r.RecipeURL != nil:
+		return db.Dinner{}, invalid("name", "give a name or a recipe_url, not both")
+	case r.Name != nil:
+		n, err := checkName(*r.Name)
+		if err != nil {
+			return db.Dinner{}, err
+		}
+		name = n
+	case r.RecipeURL != nil:
 		u, err := checkRecipeURL(*r.RecipeURL)
 		if err != nil {
 			return db.Dinner{}, err
 		}
+		n, ok := nameFromURL(u)
+		if !ok {
+			return db.Dinner{}, invalid("recipe_url", "the link does not name a dinner; add it by name instead")
+		}
+		name = n
 		recipeURL = sql.NullString{String: u.String(), Valid: true}
+	default:
+		return db.Dinner{}, invalid("name", "give a name or a recipe_url")
 	}
 
 	var row db.Dinner
-	err = s.st.WithTx(ctx, func(tx *sql.Tx) error {
+	err := s.st.WithTx(ctx, func(tx *sql.Tx) error {
 		q := db.New(tx)
 		if err := checkUnique(ctx, q, "", name, recipeURL); err != nil {
 			return err
@@ -305,14 +299,11 @@ func (s *Service) List(ctx context.Context, status string) ([]Dinner, error) {
 
 // Update applies p to dinner id, recording updatedBy. An invalid patch is a
 // *ValidationError and a new name repeating another unarchived dinner a
-// *DuplicateError; either changes nothing. Renaming a dinner raises its
-// grounding_revision and drops the candidates offered for its old name:
-// each was offered at an earlier revision, so none of them grounds it.
-// Renaming a dinner still pending also enqueues a fresh KindGroundDinner
-// job that grounds the new name, and clears its recipe_url when the
-// normalized name changes: a job queued or running for the old name or
-// link carries the old revision, so it can no longer write the dinner, and
-// one running is stopped.
+// *DuplicateError; either changes nothing. Renaming a dinner still pending
+// clears its recipe_url, raises its grounding_revision and enqueues a fresh
+// KindGroundDinner job that grounds the new name: a job queued or running
+// for the old name or link carries the old revision, so it can no longer
+// write the dinner, and one running is stopped.
 func (s *Service) Update(ctx context.Context, id string, p Patch, updatedBy string) (Dinner, error) {
 	if updatedBy == "" {
 		return Dinner{}, errors.New("dinners: update: no member to record as updated_by")
@@ -323,7 +314,7 @@ func (s *Service) Update(ctx context.Context, id string, p Patch, updatedBy stri
 	}
 
 	var row db.Dinner
-	var renamed, regrounding bool
+	var regrounding bool
 	err = s.st.WithTx(ctx, func(tx *sql.Tx) error {
 		q := db.New(tx)
 		cur, err := q.GetDinner(ctx, id)
@@ -357,13 +348,11 @@ func (s *Service) Update(ctx context.Context, id string, p Patch, updatedBy stri
 			}
 			params.Name = name
 			params.NormalizedName = harness.Normalize(name)
-			if name != cur.Name {
-				params.GroundingRevision++
-			}
 			if cur.GroundingStatus == GroundingPending && params.NormalizedName != cur.NormalizedName {
 				// The link was the old dinner's recipe; the new name is
 				// grounded by name, and a link can be given by hand.
 				params.RecipeUrl = sql.NullString{}
+				params.GroundingRevision++
 			}
 		}
 		if p.Method != nil {
@@ -379,17 +368,12 @@ func (s *Service) Update(ctx context.Context, id string, p Patch, updatedBy stri
 		if err != nil {
 			return fmt.Errorf("dinners: update %s: %w", id, err)
 		}
-		renamed = row.GroundingRevision != cur.GroundingRevision
-		regrounding = renamed && cur.GroundingStatus == GroundingPending
+		regrounding = row.GroundingRevision != cur.GroundingRevision
 		return nil
 	})
 	if err != nil {
 		return Dinner{}, err
 	}
-	if renamed {
-		updateCommitted()
-		s.clearOffers(row.ID, row.GroundingRevision)
-	}
 	if regrounding {
 		s.stopGroundings(row.ID, row.GroundingRevision)
 		jobID, err := s.enqueueGrounding(ctx, row.ID, row.GroundingRevision)
@@ -408,8 +392,7 @@ func (s *Service) Update(ctx context.Context, id string, p Patch, updatedBy stri
 
 // Archive sets dinner id's status to archived, recording updatedBy. The row
 // is kept, so its name still counts for Side quest dedupe. A
-// KindGroundDinner job running for it is stopped, and its candidates no
-// longer ground it.
+// KindGroundDinner job running for it is stopped.
 func (s *Service) Archive(ctx context.Context, id, updatedBy string) (Dinner, error) {
 	if updatedBy == "" {
 		return Dinner{}, errors.New("dinners: archive: no member to record as updated_by")
@@ -426,7 +409,6 @@ func (s *Service) Archive(ctx context.Context, id, updatedBy string) (Dinner, er
 		return Dinner{}, fmt.Errorf("dinners: archive %s: %w", id, err)
 	}
 	s.stopGroundings(row.ID, math.MaxInt64)
-	s.clearOffers(row.ID, math.MaxInt64)
 	return fromRow(row), nil
 }
 
@@ -513,6 +495,36 @@ func checkRecipeURL(raw string) (*url.URL, error) {
 	return u, nil
 }
 
+// nameFromURL names a dinner from the last path segment of u: separators
+// become spaces, a file extension and words of only digits are dropped and
+// the first letter is capitalized, so
+// https://example.com/recipes/12345/chicken-tikka-masala/ is
+// "Chicken tikka masala". ok is false when no usable name is left.
+func nameFromURL(u *url.URL) (name string, ok bool) {
+	segments := strings.FieldsFunc(u.Path, func(r rune) bool { return r == '/' })
+	if len(segments) == 0 {
+		return "", false
+	}
+	slug := segments[len(segments)-1]
+	if i := strings.LastIndexByte(slug, '.'); i > 0 {
+		slug = slug[:i]
+	}
+	var words []string
+	for _, w := range strings.FieldsFunc(slug, func(r rune) bool { return r == '-' || r == '_' || r == '+' || unicode.IsSpace(r) }) {
+		if strings.IndexFunc(w, func(r rune) bool { return !unicode.IsDigit(r) }) >= 0 {
+			words = append(words, strings.ToLower(w))
+		}
+	}
+	name = strings.Join(words, " ")
+	if r, size := utf8.DecodeRuneInString(name); r != utf8.RuneError {
+		name = string(unicode.ToUpper(r)) + name[size:]
+	}
+	if _, err := checkName(name); err != nil {
+		return "", false
+	}
+	return name, true
+}
+
 // checkUnique returns a *DuplicateError when name is harness.Similar to an
 // unarchived dinner other than self, or recipeURL is one's recipe link: the
 // source_url of the recipe it is grounded in, else the recipe_url still
@@ -553,6 +565,7 @@ func fromRow(r db.Dinner) Dinner {
 		Cuisine:         nullString(r.Cuisine),
 		IsFavorite:      r.IsFavorite == 1,
 		RecipeID:        nullString(r.RecipeID),
+		RecipeURL:       nullString(r.RecipeUrl),
 		GroundingStatus: r.GroundingStatus,
 		GroundingError:  nullString(r.GroundingError),
 		UpdatedBy:       nullString(r.UpdatedBy),

internal/dinners/dinners_test.go

@@ -1,76 +1,33 @@
-package dinners_test
+package dinners
 
 import (
-	"encoding/json"
-	"errors"
-	"strings"
+	"net/url"
 	"testing"
-
-	"code.cubecraftlabs.com/Maniacs_Mansion/Meal-Quest/internal/dinners"
 )
 
-// TestCreateRegularNeverNamesFromLink: a Regular added with a recipe link
-// is named only by the household, so no part of the link — host, path,
-// query or fragment — is stored as its name or shown in a dinner or a
-// duplicate error, even a token of plain letters in the path.
-func TestCreateRegularNeverNamesFromLink(t *testing.T) {
+func TestNameFromURL(t *testing.T) {
 	t.Parallel()
-	e := newUnstartedEnv(t)
-	const link = "https://c.example/stew-key-abcdefghijklmno?sig=zyxwvut#lookup"
-	// Each leak holds a character no ULID has (Crockford base32 has no I, L,
-	// O, U, "-", "." or "/"), so a dinner's id never matches one.
-	leaks := []string{link, "c.example", "stew-key", "abcdefghijklmno", "sig", "zyxwvut", "lookup"}
-	check := func(what, text string) {
-		t.Helper()
-		lower := strings.ToLower(text)
-		for _, leak := range leaks {
-			if strings.Contains(lower, leak) {
-				t.Errorf("%s contains %q: %s", what, leak, text)
-			}
+	tests := []struct {
+		link string
+		want string // "" means no usable name
+	}{
+		{"https://example.com/recipes/12345/chicken-tikka-masala/", "Chicken tikka masala"},
+		{"https://example.com/recipe/beef_stew.html", "Beef stew"},
+		{"https://example.com/2024/05/best-ever-chili-123", "Best ever chili"},
+		{"https://example.com/crème-brûlée", "Crème brûlée"},
+		{"https://example.com/recipes/chili?utm=1#notes", "Chili"},
+		{"https://example.com/", ""},
+		{"https://example.com/recipe/98765", ""},
+		{"https://example.com/the-best-easy-recipe", ""},
+	}
+	for _, tt := range tests {
+		u, err := url.Parse(tt.link)
+		if err != nil {
+			t.Fatal(err)
+		}
+		got, ok := nameFromURL(u)
+		if got != tt.want || ok != (tt.want != "") {
+			t.Errorf("nameFromURL(%s) = %q, %v; want %q", tt.link, got, ok, tt.want)
 		}
 	}
-
-	_, err := e.svc.CreateRegular(t.Context(), dinners.NewRegular{RecipeURL: ptr(link)}, member)
-	var verr *dinners.ValidationError
-	if !errors.As(err, &verr) {
-		t.Fatalf("link without a name: err = %v, want a *ValidationError", err)
-	}
-	check("validation error", verr.Error())
-
-	c, err := e.svc.CreateRegular(t.Context(), dinners.NewRegular{Name: ptr(" Sunday stew "), RecipeURL: ptr(link)}, member)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if c.Name != "Sunday stew" {
-		t.Errorf("name = %q, want the household's %q", c.Name, "Sunday stew")
-	}
-	created, err := json.Marshal(c)
-	if err != nil {
-		t.Fatal(err)
-	}
-	check("create response", string(created))
-	row := e.dinner(t, c.ID)
-	check("stored name", row.Name+" "+row.NormalizedName)
-	if row.RecipeUrl.String != link {
-		t.Errorf("stored recipe_url = %q, want %q kept for grounding", row.RecipeUrl.String, link)
-	}
-
-	list, err := e.svc.List(t.Context(), dinners.StatusRegular)
-	if err != nil {
-		t.Fatal(err)
-	}
-	listed, err := json.Marshal(list)
-	if err != nil {
-		t.Fatal(err)
-	}
-	check("list response", string(listed))
-
-	// The same link under another name is still a duplicate, and its error
-	// names the existing dinner by the household's name.
-	_, err = e.svc.CreateRegular(t.Context(), dinners.NewRegular{Name: ptr("Weeknight chili"), RecipeURL: ptr(link)}, member)
-	var dup *dinners.DuplicateError
-	if !errors.As(err, &dup) || dup.Existing.ID != c.ID {
-		t.Fatalf("same link again: err = %v, want a duplicate of %s", err, c.ID)
-	}
-	check("duplicate error", dup.Error())
 }

internal/dinners/export_test.go

@@ -14,56 +14,6 @@ func SetGroundTimeout(t *testing.T, d time.Duration) {
 	t.Cleanup(func() { groundTimeout = old })
 }
 
-// SetOfferLifetime sets how long candidates ground a dinner until t ends.
-// A test calling it must not run in parallel.
-func SetOfferLifetime(t *testing.T, d time.Duration) {
-	old := offerLifetime
-	offerLifetime = d
-	t.Cleanup(func() { offerLifetime = old })
-}
-
-// SetUpdateCommitted runs f in Update once a rename is committed, before
-// the dinner's offers are cleared, until t ends. A test calling it must
-// not run in parallel.
-func SetUpdateCommitted(t *testing.T, f func()) {
-	old := updateCommitted
-	updateCommitted = f
-	t.Cleanup(func() { updateCommitted = old })
-}
-
-// AdvanceClock moves the service's clock d ahead of real time until t
-// ends, without firing any timer. A test calling it must not run in
-// parallel.
-func AdvanceClock(t *testing.T, d time.Duration) {
-	old := now
-	now = func() time.Time { return old().Add(d) }
-	t.Cleanup(func() { now = old })
-}
-
-// HasOffers reports whether the service holds candidates offered for
-// dinner id.
-func (s *Service) HasOffers(id string) bool {
-	s.offersMu.Lock()
-	defer s.offersMu.Unlock()
-	_, ok := s.offers[id]
-	return ok
-}
-
-// StoreOffers stores urls as dinner id's offers, as a Candidates search
-// that read the dinner at grounding_revision revision would on finishing.
-func (s *Service) StoreOffers(id string, urls map[string]string, revision int64) {
-	keep, done := s.trackOffers(id)
-	defer done()
-	keep(urls, revision)
-}
-
-// OfferCount is the number of dinners whose candidates the service holds.
-func (s *Service) OfferCount() int {
-	s.offersMu.Lock()
-	defer s.offersMu.Unlock()
-	return len(s.offers)
-}
-
 // RunGroundJob runs the KindGroundDinner handler for p in the caller's
 // goroutine, as the job runner would, and returns the grounding status it
 // reports.

internal/dinners/grounding.go

@@ -2,14 +2,10 @@ package dinners
 
 import (
 	"context"
-	"crypto/hmac"
-	"crypto/sha256"
 	"database/sql"
-	"encoding/base64"
 	"encoding/json"
 	"errors"
 	"fmt"
-	"math"
 	"slices"
 	"strings"
 	"time"
@@ -80,18 +76,6 @@ var groundTimeout = GroundTimeout
 // runs past GroundTimeout; the dinner is left as it was.
 var ErrGroundTimeout = errors.New("dinners: grounding the recipe took too long")
 
-// ErrGroundFailed wraps any unexpected failure grounding a dinner by hand.
-// Its text may quote the link and dependency errors, so it is never
-// logged.
-var ErrGroundFailed = errors.New("dinners: grounding the recipe failed")
-
-// ErrArchived is grounding an archived dinner by hand.
-var ErrArchived = errors.New("dinner archived")
-
-// ErrGroundConflict is a candidate or link grounded for a dinner that was
-// renamed or grounded some other way while it was grounding.
-var ErrGroundConflict = errors.New("dinner changed while its recipe was grounding")
-
 // GroundJob is the KindGroundDinner payload: the dinner to ground and its
 // grounding_revision when the job was enqueued.
 type GroundJob struct {
@@ -286,9 +270,7 @@ func reasonFor(err error, fromURL bool) string {
 
 // Candidate is a recipe page offered to ground a dinner in.
 type Candidate struct {
-	// CandidateID is an opaque id for the page, resolved by the server:
-	// Fix.CandidateID grounds it. The page's URL is never returned, as it
-	// may carry a token.
+	// CandidateID is the page's URL; Fix.CandidateID grounds it.
 	CandidateID string `json:"candidate_id"`
 	Title       string `json:"title"`
 	SiteName    string `json:"site_name"`
@@ -297,47 +279,10 @@ type Candidate struct {
 	Minutes  *int    `json:"minutes"`
 }
 
-// offerLifetime is how long the candidates Candidates offers a dinner
-// ground it; tests shorten it.
-var offerLifetime = 30 * time.Minute
-
-// now is the clock offer lifetimes are measured on; tests advance it.
-var now = time.Now
-
-// updateCommitted runs in Update once a rename is committed, before the
-// dinner's offers are cleared; tests use it to act in between.
-var updateCommitted = func() {}
-
-// offerSet is the candidates last offered for a dinner: the page URL of
-// each candidate id, found by searching the dinner's name at its
-// grounding_revision revision. They ground the dinner until deadline, and
-// only while it is still at that revision, which every rename raises;
-// expiry drops the set from offers once deadline has passed.
-type offerSet struct {
-	urls     map[string]string
-	revision int64
-	deadline time.Time
-	expiry   *time.Timer
-}
-
-// offerSearch is a Candidates search running for a dinner. It stores no
-// offers found at a grounding_revision below below, which clearing the
-// dinner's offers raises.
-type offerSearch struct {
-	below int64
-}
-
 // Candidates searches for dinner id's name and returns up to MaxCandidates
-// recipe pages to ground it in, best first; the list may be empty. They
-// replace the dinner's earlier candidates: one not offered again no longer
-// grounds it. They ground it for offerLifetime, and not at all once it is
-// grounded by hand, renamed or archived, even while this search runs. A
+// recipe pages to ground it in, best first; the list may be empty. A
 // search that fails wraps recipes.ErrSearchFailed.
 func (s *Service) Candidates(ctx context.Context, id string) ([]Candidate, error) {
-	// Tracked before the dinner is read: grounding, renaming or archiving
-	// it after the read keeps this search from storing what it found.
-	keep, done := s.trackOffers(id)
-	defer done()
 	row, err := s.get(ctx, id)
 	if err != nil {
 		return nil, err
@@ -347,127 +292,16 @@ func (s *Service) Candidates(ctx context.Context, id string) ([]Candidate, error
 		return nil, err
 	}
 	out := make([]Candidate, len(offers))
-	urls := make(map[string]string, len(offers))
 	for i, o := range offers {
-		cid := s.candidateID(row.ID, o.URL)
-		urls[cid] = o.URL
-		out[i] = Candidate{CandidateID: cid, Title: o.Title, SiteName: o.SiteName, Minutes: o.Minutes}
+		out[i] = Candidate{CandidateID: o.URL, Title: o.Title, SiteName: o.SiteName, Minutes: o.Minutes}
 		if o.PhotoID != "" {
 			u := PhotoURL(o.PhotoID)
 			out[i].PhotoURL = &u
 		}
 	}
-	if row.Status != StatusArchived {
-		keep(urls, row.GroundingRevision)
-	}
 	return out, nil
 }
 
-// trackOffers registers a Candidates search for dinner id. It returns keep,
-// which stores urls, found for the dinner at grounding_revision revision,
-// as its offers for offerLifetime unless clearOffers has run for it since
-// with a revision above that, or offers found at a later revision are
-// stored, and done, to call when the search ends.
-func (s *Service) trackOffers(id string) (keep func(urls map[string]string, revision int64), done func()) {
-	search := &offerSearch{}
-	s.offersMu.Lock()
-	if s.offerSearches[id] == nil {
-		s.offerSearches[id] = make(map[*offerSearch]struct{})
-	}
-	s.offerSearches[id][search] = struct{}{}
-	s.offersMu.Unlock()
-	keep = func(urls map[string]string, revision int64) {
-		s.offersMu.Lock()
-		defer s.offersMu.Unlock()
-		if revision < search.below {
-			return
-		}
-		if set := s.offers[id]; set != nil && set.revision > revision {
-			// Found at a later revision, so the earlier search's offers
-			// are already stale.
-			return
-		}
-		s.dropOffers(id)
-		set := &offerSet{urls: urls, revision: revision, deadline: now().Add(offerLifetime)}
-		// expiry waits for offersMu, so it finds set stored even when it
-		// fires at once, and drops set only, never offers stored later.
-		set.expiry = time.AfterFunc(offerLifetime, func() {
-			s.offersMu.Lock()
-			defer s.offersMu.Unlock()
-			if s.offers[id] == set {
-				delete(s.offers, id)
-			}
-		})
-		s.offers[id] = set
-	}
-	done = func() {
-		s.offersMu.Lock()
-		delete(s.offerSearches[id], search)
-		if len(s.offerSearches[id]) == 0 {
-			delete(s.offerSearches, id)
-		}
-		s.offersMu.Unlock()
-	}
-	return keep, done
-}
-
-// clearOffers drops dinner id's offers found at a grounding_revision below
-// below and keeps every Candidates search running for it from storing
-// such offers, so none of them grounds it. Offers found at below or above
-// are kept. Call it with math.MaxInt64 once the dinner is grounded by hand
-// or archived, and with its new revision once it is renamed: a search
-// that read the rename meanwhile keeps its offers.
-func (s *Service) clearOffers(id string, below int64) {
-	s.offersMu.Lock()
-	defer s.offersMu.Unlock()
-	if set := s.offers[id]; set != nil && set.revision < below {
-		s.dropOffers(id)
-	}
-	for search := range s.offerSearches[id] {
-		search.below = max(search.below, below)
-	}
-}
-
-// dropOffers drops dinner id's offers and stops their expiry. The caller
-// holds offersMu.
-func (s *Service) dropOffers(id string) {
-	if set := s.offers[id]; set != nil {
-		set.expiry.Stop()
-		delete(s.offers, id)
-	}
-}
-
-// candidateID is the opaque id of the page at rawURL as a candidate for
-// dinner id: the same page is offered under the same id until the service
-// restarts, and the id reveals nothing of the URL.
-func (s *Service) candidateID(id, rawURL string) string {
-	mac := hmac.New(sha256.New, s.offerKey)
-	mac.Write([]byte(id + "\x00" + rawURL))
-	return base64.RawURLEncoding.EncodeToString(mac.Sum(nil)[:16])
-}
-
-// candidateURL is the page URL of candidate cid last offered for dinner d.
-// A cid not among the dinner's live offers, or whose page is not a valid
-// recipe link, is a *ValidationError. Offers past their deadline, or found
-// at a grounding_revision other than d's, are not live, even before they
-// are dropped: d was renamed since they were found, if only to its name
-// then.
-func (s *Service) candidateURL(d db.Dinner, cid string) (string, error) {
-	var raw string
-	var ok bool
-	s.offersMu.Lock()
-	if set := s.offers[d.ID]; set != nil && set.revision == d.GroundingRevision && now().Before(set.deadline) {
-		raw, ok = set.urls[cid]
-	}
-	s.offersMu.Unlock()
-	if ok {
-		if u, err := checkRecipeURL(raw); err == nil {
-			return u.String(), nil
-		}
-	}
-	return "", invalid("candidate_id", "is not a candidate from recipe-candidates; reload the candidates")
-}
-
 // Fix grounds a dinner by hand: exactly one of a candidate from
 // Candidates, a pasted recipe link or a recipe typed in.
 type Fix struct {
@@ -489,17 +323,11 @@ type ManualRecipe struct {
 // Ground grounds dinner id as f says, recording updatedBy. A candidate or
 // link is grounded with recipes.Grounder.GroundURL and sets
 // grounding_status grounded, with the recipe's photo, method, minutes and
-// difficulty; one a member changed while it was grounding is kept. A
-// manual recipe is stored as typed — no model runs — and sets
-// grounding_status manual with its method and minutes; it has no photo,
-// and the dinner keeps its difficulty. An invalid f is a *ValidationError
-// and an archived dinner ErrArchived. A failure grounding a candidate or
-// link, or recording it on the dinner, wraps ErrGroundFailed; a page that
-// cannot ground the dinner is also a *recipes.ErrUngroundable. A dinner
-// renamed, archived or grounded some other way while a candidate or link
-// was grounding is ErrGroundConflict or ErrArchived. A missing dinner is
-// ErrNotFound; any other failure, by candidate, link or manual recipe,
-// wraps ErrGroundFailed. None of these changes the dinner.
+// difficulty. A manual recipe is stored as typed — no model runs — and
+// sets grounding_status manual with its method and minutes; it has no
+// photo, and the dinner keeps its difficulty. An invalid f is a
+// *ValidationError; a page that cannot ground the dinner is a
+// *recipes.ErrUngroundable and changes nothing.
 func (s *Service) Ground(ctx context.Context, id string, f Fix, updatedBy string) (Dinner, error) {
 	if updatedBy == "" {
 		return Dinner{}, errors.New("dinners: ground: no member to record as updated_by")
@@ -511,21 +339,9 @@ func (s *Service) Ground(ctx context.Context, id string, f Fix, updatedBy string
 	if manual != nil {
 		return s.groundManual(ctx, id, *manual, updatedBy)
 	}
-	cur, err := s.get(ctx, id)
-	if errors.Is(err, ErrNotFound) {
+	if _, err := s.get(ctx, id); err != nil {
 		return Dinner{}, err
 	}
-	if err != nil {
-		return Dinner{}, fmt.Errorf("%w: dinner %s: %w", ErrGroundFailed, id, err)
-	}
-	if cur.Status == StatusArchived {
-		return Dinner{}, ErrArchived
-	}
-	if f.CandidateID != nil {
-		if link, err = s.candidateURL(cur, *f.CandidateID); err != nil {
-			return Dinner{}, err
-		}
-	}
 	groundCtx, cancel := context.WithTimeout(ctx, groundTimeout)
 	defer cancel()
 	gr, err := s.grounder.GroundURL(groundCtx, link)
@@ -533,59 +349,30 @@ func (s *Service) Ground(ctx context.Context, id string, f Fix, updatedBy string
 		if ctx.Err() == nil && errors.Is(groundCtx.Err(), context.DeadlineExceeded) {
 			return Dinner{}, ErrGroundTimeout
 		}
-		return Dinner{}, fmt.Errorf("%w: dinner %s: %w", ErrGroundFailed, id, err)
+		return Dinner{}, fmt.Errorf("dinners: ground %s: %w", id, err)
 	}
 	row, err := db.New(s.st.Writer).GroundDinner(ctx, db.GroundDinnerParams{
-		RecipeID:                  sql.NullString{String: gr.RecipeID, Valid: true},
-		PhotoID:                   sql.NullString{String: gr.PhotoID, Valid: true},
-		Method:                    sql.NullString{String: gr.Method, Valid: true},
-		MinutesTotal:              nullInt(gr.MinutesTotal),
-		Difficulty:                sql.NullString{String: gr.Difficulty, Valid: true},
-		GroundingStatus:           GroundingGrounded,
-		UpdatedBy:                 sql.NullString{String: updatedBy, Valid: true},
-		UpdatedAt:                 store.Now().String(),
-		ID:                        cur.ID,
-		ObservedName:              cur.Name,
-		ObservedNormalizedName:    cur.NormalizedName,
-		ObservedGroundingStatus:   cur.GroundingStatus,
-		ObservedGroundingRevision: cur.GroundingRevision,
-		ObservedRecipeID:          cur.RecipeID,
-		ObservedMethod:            cur.Method,
-		ObservedMinutesTotal:      cur.MinutesTotal,
-		ObservedDifficulty:        cur.Difficulty,
+		RecipeID:        sql.NullString{String: gr.RecipeID, Valid: true},
+		PhotoID:         sql.NullString{String: gr.PhotoID, Valid: true},
+		Method:          sql.NullString{String: gr.Method, Valid: true},
+		MinutesTotal:    nullInt(gr.MinutesTotal),
+		Difficulty:      sql.NullString{String: gr.Difficulty, Valid: true},
+		GroundingStatus: GroundingGrounded,
+		UpdatedBy:       sql.NullString{String: updatedBy, Valid: true},
+		UpdatedAt:       store.Now().String(),
+		ID:              id,
 	})
 	if errors.Is(err, sql.ErrNoRows) {
-		return Dinner{}, s.groundRejected(ctx, id)
+		return Dinner{}, ErrNotFound
 	}
 	if err != nil {
-		return Dinner{}, fmt.Errorf("%w: dinner %s: record: %w", ErrGroundFailed, id, err)
+		return Dinner{}, fmt.Errorf("dinners: ground %s: %w", id, err)
 	}
-	s.clearOffers(cur.ID, math.MaxInt64)
 	return fromRow(row), nil
 }
 
-// groundRejected is the error for dinner id when it was not as observed
-// before grounding: ErrNotFound, ErrArchived or ErrGroundConflict. Failing
-// to read it wraps ErrGroundFailed.
-func (s *Service) groundRejected(ctx context.Context, id string) error {
-	cur, err := s.get(ctx, id)
-	if errors.Is(err, ErrNotFound) {
-		return err
-	}
-	if err != nil {
-		return fmt.Errorf("%w: dinner %s: %w", ErrGroundFailed, id, err)
-	}
-	if cur.Status == StatusArchived {
-		return ErrArchived
-	}
-	return ErrGroundConflict
-}
-
 // groundManual stores m as dinner id's recipe, with its ingredients and
-// steps, and records it on the dinner, all in one transaction; the
-// dinner's candidates then no longer ground it. A missing or archived
-// dinner is ErrNotFound or ErrArchived; any other failure wraps
-// ErrGroundFailed.
+// steps, and records it on the dinner, all in one transaction.
 func (s *Service) groundManual(ctx context.Context, id string, m ManualRecipe, updatedBy string) (Dinner, error) {
 	var row db.Dinner
 	err := s.st.WithTx(ctx, func(tx *sql.Tx) error {
@@ -597,9 +384,6 @@ func (s *Service) groundManual(ctx context.Context, id string, m ManualRecipe, u
 		if err != nil {
 			return fmt.Errorf("dinners: read %s: %w", id, err)
 		}
-		if cur.Status == StatusArchived {
-			return ErrArchived
-		}
 		ld, err := json.Marshal(manualJSONLD{
 			Context:      "https://schema.org",
 			Type:         "Recipe",
@@ -655,35 +439,23 @@ func (s *Service) groundManual(ctx context.Context, id string, m ManualRecipe, u
 			}
 		}
 		row, err = q.GroundDinner(ctx, db.GroundDinnerParams{
-			RecipeID:                  sql.NullString{String: rec.ID, Valid: true},
-			Method:                    method,
-			MinutesTotal:              minutes,
-			Difficulty:                cur.Difficulty,
-			GroundingStatus:           GroundingManual,
-			UpdatedBy:                 sql.NullString{String: updatedBy, Valid: true},
-			UpdatedAt:                 now,
-			ID:                        cur.ID,
-			ObservedName:              cur.Name,
-			ObservedNormalizedName:    cur.NormalizedName,
-			ObservedGroundingStatus:   cur.GroundingStatus,
-			ObservedGroundingRevision: cur.GroundingRevision,
-			ObservedRecipeID:          cur.RecipeID,
-			ObservedMethod:            cur.Method,
-			ObservedMinutesTotal:      cur.MinutesTotal,
-			ObservedDifficulty:        cur.Difficulty,
+			RecipeID:        sql.NullString{String: rec.ID, Valid: true},
+			Method:          method,
+			MinutesTotal:    minutes,
+			Difficulty:      cur.Difficulty,
+			GroundingStatus: GroundingManual,
+			UpdatedBy:       sql.NullString{String: updatedBy, Valid: true},
+			UpdatedAt:       now,
+			ID:              cur.ID,
 		})
 		if err != nil {
 			return fmt.Errorf("dinners: ground %s: %w", id, err)
 		}
 		return nil
 	})
-	if errors.Is(err, ErrNotFound) || errors.Is(err, ErrArchived) {
+	if err != nil {
 		return Dinner{}, err
 	}
-	if err != nil {
-		return Dinner{}, fmt.Errorf("%w: dinner %s: %w", ErrGroundFailed, id, err)
-	}
-	s.clearOffers(row.ID, math.MaxInt64)
 	return fromRow(row), nil
 }
 
@@ -712,8 +484,11 @@ func (f Fix) validate() (link string, manual *ManualRecipe, err error) {
 	}
 	switch {
 	case f.CandidateID != nil:
-		// Ground resolves the candidate to its page.
-		return "", nil, nil
+		u, err := checkRecipeURL(*f.CandidateID)
+		if err != nil {
+			return "", nil, invalid("candidate_id", "is not a candidate from recipe-candidates")
+		}
+		return u.String(), nil, nil
 	case f.RecipeURL != nil:
 		u, err := checkRecipeURL(*f.RecipeURL)
 		if err != nil {

internal/dinners/grounding_test.go

@@ -9,7 +9,6 @@ import (
 	"io/fs"
 	"log/slog"
 	"slices"
-	"strings"
 	"testing"
 	"testing/fstest"
 	"time"
@@ -195,7 +194,7 @@ func TestCreateByRecipeURLGroundsThatURL(t *testing.T) {
 	e := newEnv(t)
 	e.model.QueueGenerate(recipestest.NormalizedReply("oven", 150))
 
-	c, err := e.svc.CreateRegular(t.Context(), dinners.NewRegular{Name: ptr("Beef stew"), RecipeURL: ptr(stew)}, member)
+	c, err := e.svc.CreateRegular(t.Context(), dinners.NewRegular{RecipeURL: ptr(stew)}, member)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -215,39 +214,6 @@ func TestCreateByRecipeURLGroundsThatURL(t *testing.T) {
 	}
 }
 
-// TestCreateByRecipeURLClearsLink: once background grounding resolves a
-// pasted link, which may carry a personal token, the dinner no longer
-// stores it; the recipe it grounded in records the page.
-func TestCreateByRecipeURLClearsLink(t *testing.T) {
-	t.Parallel()
-	e := newEnv(t)
-	const link = "https://c.example/recipes/beef-stew?access_token=personal-token-abc123"
-	e.pages.Bodies[link] = recipestest.RecipePage("Beef Stew", "Stew Co", "https://c.example/stew.jpg", 150)
-	e.model.QueueGenerate(recipestest.NormalizedReply("oven", 150))
-
-	c, err := e.svc.CreateRegular(t.Context(), dinners.NewRegular{Name: ptr("Beef stew"), RecipeURL: ptr(link)}, member)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if job := e.waitJob(t, *c.GroundingJobID); job.Status != jobs.StatusSucceeded {
-		t.Fatalf("job = %+v", job)
-	}
-	row := e.dinner(t, c.ID)
-	if row.GroundingStatus != "grounded" || !row.RecipeID.Valid {
-		t.Fatalf("dinner = %+v, want grounded", row)
-	}
-	if row.RecipeUrl.Valid {
-		t.Errorf("recipe_url = %q after grounding, want cleared", row.RecipeUrl.String)
-	}
-	rec, err := db.New(e.st.Reader).GetRecipe(t.Context(), row.RecipeID.String)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if rec.SourceUrl != link {
-		t.Errorf("recipe source = %q, want %q", rec.SourceUrl, link)
-	}
-}
-
 func TestCreateGroundingFailureRecordsReason(t *testing.T) {
 	t.Parallel()
 	tests := []struct {
@@ -257,7 +223,7 @@ func TestCreateGroundingFailureRecordsReason(t *testing.T) {
 		reason string
 	}{
 		{"no candidates", dinners.NewRegular{Name: ptr("Unknown dish")}, nil, dinners.ReasonNoRecipe},
-		{"unusable link", dinners.NewRegular{Name: ptr("Lost soup"), RecipeURL: ptr("https://gone.example/recipes/lost-soup")}, nil, dinners.ReasonRecipeUnusable},
+		{"unusable link", dinners.NewRegular{RecipeURL: ptr("https://gone.example/recipes/lost-soup")}, nil, dinners.ReasonRecipeUnusable},
 		{"search fails", dinners.NewRegular{Name: ptr("Chicken curry")}, func(e *env) { e.search.Err = recipes.ErrSearchRateLimited }, dinners.ReasonSearchFailed},
 		{"model fails", dinners.NewRegular{Name: ptr("Chicken curry")}, func(e *env) {
 			// One provider failure per candidate tried.
@@ -409,7 +375,7 @@ func TestRenameLinkWhilePendingGroundsNewName(t *testing.T) {
 	e.search.Results["Beef stew"] = []recipes.Candidate{{URL: stew}}
 	e.model.QueueGenerate(recipestest.NormalizedReply("oven", 150))
 
-	c, err := e.svc.CreateRegular(t.Context(), dinners.NewRegular{Name: ptr("Chicken curry"), RecipeURL: ptr(curryA)}, member)
+	c, err := e.svc.CreateRegular(t.Context(), dinners.NewRegular{RecipeURL: ptr(curryA)}, member)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -417,11 +383,8 @@ func TestRenameLinkWhilePendingGroundsNewName(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	if d.GroundingStatus != dinners.GroundingPending {
-		t.Fatalf("renamed = %+v, want still pending", d)
-	}
-	if row, err := db.New(e.st.Reader).GetDinner(t.Context(), c.ID); err != nil || row.RecipeUrl.Valid {
-		t.Fatalf("renamed row = %+v (err %v), want no recipe_url", row, err)
+	if d.GroundingStatus != dinners.GroundingPending || d.RecipeURL != nil {
+		t.Fatalf("renamed = %+v, want still pending with no recipe_url", d)
 	}
 	e.start(t)
 
@@ -676,26 +639,6 @@ func failedDinner(t *testing.T, e *env, name string) string {
 	return c.ID
 }
 
-// candidateID returns the candidate_id Candidates offers dinner id for the
-// page titled title.
-func candidateID(t *testing.T, e *env, id, title string) string {
-	t.Helper()
-	got, err := e.svc.Candidates(t.Context(), id)
-	if err != nil {
-		t.Fatal(err)
-	}
-	for _, c := range got {
-		if c.Title == title {
-			if strings.Contains(c.CandidateID, "://") {
-				t.Fatalf("candidate_id = %q, want an opaque id, not the page URL", c.CandidateID)
-			}
-			return c.CandidateID
-		}
-	}
-	t.Fatalf("candidates = %+v, want one titled %q", got, title)
-	return ""
-}
-
 func TestCandidates(t *testing.T) {
 	t.Parallel()
 	e := newEnv(t)
@@ -718,25 +661,14 @@ func TestCandidates(t *testing.T) {
 	}
 	first, second := got[0], got[1]
 	wantPhoto := dinners.PhotoURL(e.dinner(t, c.ID).PhotoID.String)
-	if first.Title != "Chicken Curry" || first.SiteName != "Curry House" ||
+	if first.CandidateID != curryA || first.Title != "Chicken Curry" || first.SiteName != "Curry House" ||
 		first.PhotoURL == nil || *first.PhotoURL != wantPhoto || first.Minutes == nil || *first.Minutes != 40 {
 		t.Errorf("first = %+v, want the stored curryA with photo %s", first, wantPhoto)
 	}
-	if second.Title != "Easy Weeknight Curry" || second.SiteName != "B Kitchen" ||
+	if second.CandidateID != curryB || second.Title != "Easy Weeknight Curry" || second.SiteName != "B Kitchen" ||
 		second.PhotoURL != nil || second.Minutes == nil || *second.Minutes != 25 {
 		t.Errorf("second = %+v, want curryB without a photo", second)
 	}
-	if first.CandidateID == "" || first.CandidateID == second.CandidateID ||
-		first.CandidateID == curryA || second.CandidateID == curryB {
-		t.Errorf("candidate ids = %q, %q, want distinct opaque ids", first.CandidateID, second.CandidateID)
-	}
-	again, err := e.svc.Candidates(t.Context(), c.ID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(again) != 2 || again[0].CandidateID != first.CandidateID || again[1].CandidateID != second.CandidateID {
-		t.Errorf("candidates again = %+v, want the same ids", again)
-	}
 
 	if _, err := e.svc.Candidates(t.Context(), "nope"); !errors.Is(err, dinners.ErrNotFound) {
 		t.Errorf("unknown dinner: err = %v, want ErrNotFound", err)
@@ -767,11 +699,9 @@ func TestFixViaCandidate(t *testing.T) {
 	t.Parallel()
 	e := newEnv(t)
 	id := failedDinner(t, e, "Mystery curry")
-	e.search.Results["Mystery curry"] = []recipes.Candidate{{URL: curryA}, {URL: curryB}}
-	cid := candidateID(t, e, id, "Easy Weeknight Curry")
 	e.model.QueueGenerate(recipestest.NormalizedReply("stovetop", 25))
 
-	d, err := e.svc.Ground(t.Context(), id, dinners.Fix{CandidateID: ptr(cid)}, "member-2")
+	d, err := e.svc.Ground(t.Context(), id, dinners.Fix{CandidateID: ptr(curryB)}, "member-2")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -788,435 +718,6 @@ func TestFixViaCandidate(t *testing.T) {
 	}
 }
 
-// wantStaleCandidate checks that candidate cid no longer grounds dinner
-// id: Ground refuses it as invalid, and the dinner is unchanged.
-func wantStaleCandidate(t *testing.T, e *env, id, cid string) {
-	t.Helper()
-	before := e.dinner(t, id)
-	_, err := e.svc.Ground(t.Context(), id, dinners.Fix{CandidateID: ptr(cid)}, member)
-	var invalid *dinners.ValidationError
-	if !errors.As(err, &invalid) {
-		t.Fatalf("stale candidate: err = %v, want *ValidationError", err)
-	}
-	if after := e.dinner(t, id); after != before {
-		t.Errorf("dinner changed by a stale candidate: %+v, was %+v", after, before)
-	}
-}
-
-// TestGroundingOrArchivingClearsCandidates: once a dinner is grounded by
-// hand — by candidate, link or manual recipe — renamed or archived, the
-// service holds none of its candidates' URLs and none of them grounds it.
-func TestGroundingOrArchivingClearsCandidates(t *testing.T) {
-	t.Parallel()
-	tests := []struct {
-		name string
-		// clear grounds or archives dinner id, offered candidate cid.
-		clear func(t *testing.T, e *env, id, cid string)
-		// archived says the dinner ends archived, which Ground refuses
-		// before it reads a candidate.
-		archived bool
-	}{
-		{"candidate", func(t *testing.T, e *env, id, cid string) {
-			e.model.QueueGenerate(recipestest.NormalizedReply("stovetop", 40))
-			if _, err := e.svc.Ground(t.Context(), id, dinners.Fix{CandidateID: ptr(cid)}, member); err != nil {
-				t.Fatal(err)
-			}
-		}, false},
-		{"link", func(t *testing.T, e *env, id, _ string) {
-			e.model.QueueGenerate(recipestest.NormalizedReply("oven", 150))
-			if _, err := e.svc.Ground(t.Context(), id, dinners.Fix{RecipeURL: ptr(stew)}, member); err != nil {
-				t.Fatal(err)
-			}
-		}, false},
-		{"manual", func(t *testing.T, e *env, id, _ string) {
-			m := &dinners.ManualRecipe{Ingredients: []string{"1 chicken"}, Minutes: ptr(40), Method: ptr("stovetop")}
-			if _, err := e.svc.Ground(t.Context(), id, dinners.Fix{Manual: m}, member); err != nil {
-				t.Fatal(err)
-			}
-		}, false},
-		{"rename", func(t *testing.T, e *env, id, _ string) {
-			if _, err := e.svc.Update(t.Context(), id, dinners.Patch{Name: ptr("Beef stew")}, member); err != nil {
-				t.Fatal(err)
-			}
-		}, false},
-		{"archive", func(t *testing.T, e *env, id, _ string) {
-			if _, err := e.svc.Archive(t.Context(), id, member); err != nil {
-				t.Fatal(err)
-			}
-		}, true},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-			e := newEnv(t)
-			id := failedDinner(t, e, "Mystery curry")
-			e.search.Results["Mystery curry"] = []recipes.Candidate{{URL: curryA}, {URL: curryB}}
-			cidA := candidateID(t, e, id, "Chicken Curry")
-			cidB := candidateID(t, e, id, "Easy Weeknight Curry")
-
-			tt.clear(t, e, id, cidA)
-			if e.svc.HasOffers(id) {
-				t.Errorf("service still holds the candidates of dinner %s", id)
-			}
-			if !tt.archived {
-				wantStaleCandidate(t, e, id, cidB)
-			}
-		})
-	}
-}
-
-// TestRenamePendingRefusesOldCandidates: candidates offered for a pending
-// dinner's old name no longer ground it once it is renamed — Ground refuses
-// them and leaves the old recipe off it — while candidates for the new name
-// do.
-func TestRenamePendingRefusesOldCandidates(t *testing.T) {
-	t.Parallel()
-	// Unstarted, so the dinner stays pending with its jobs queued.
-	e := newUnstartedEnv(t)
-	e.search.Results["Beef stew"] = []recipes.Candidate{{URL: stew}}
-	c, err := e.svc.CreateRegular(t.Context(), dinners.NewRegular{Name: ptr("Chicken curry")}, member)
-	if err != nil {
-		t.Fatal(err)
-	}
-	old := candidateID(t, e, c.ID, "Chicken Curry")
-
-	d, err := e.svc.Update(t.Context(), c.ID, dinners.Patch{Name: ptr("Beef stew")}, member)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if d.GroundingStatus != dinners.GroundingPending {
-		t.Fatalf("renamed = %+v, want still pending", d)
-	}
-	if e.svc.HasOffers(c.ID) {
-		t.Errorf("service still holds the old name's candidates of dinner %s", c.ID)
-	}
-	wantStaleCandidate(t, e, c.ID, old)
-	if row := e.dinner(t, c.ID); row.RecipeID.Valid || row.GroundingStatus != dinners.GroundingPending {
-		t.Fatalf("dinner = %+v, want pending with no recipe", row)
-	}
-
-	e.model.QueueGenerate(recipestest.NormalizedReply("oven", 150))
-	g, err := e.svc.Ground(t.Context(), c.ID, dinners.Fix{CandidateID: ptr(candidateID(t, e, c.ID, "Beef Stew"))}, member)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if g.GroundingStatus != dinners.GroundingGrounded || g.RecipeID == nil {
-		t.Fatalf("dinner = %+v, want grounded for the new name", g)
-	}
-	rec, err := db.New(e.st.Reader).GetRecipe(t.Context(), *g.RecipeID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if rec.SourceUrl != stew {
-		t.Errorf("recipe source = %s, want %s", rec.SourceUrl, stew)
-	}
-}
-
-// TestRenameSameNormalizedNameRefusesOldCandidates: a rename that leaves
-// the normalized name as it was still drops the candidates offered before
-// it, and none of them grounds the dinner.
-func TestRenameSameNormalizedNameRefusesOldCandidates(t *testing.T) {
-	t.Parallel()
-	// Unstarted, so the dinner stays pending with its jobs queued.
-	e := newUnstartedEnv(t)
-	e.search.Results["Quick Chicken curry"] = e.search.Results["Chicken curry"]
-	c, err := e.svc.CreateRegular(t.Context(), dinners.NewRegular{Name: ptr("Chicken curry")}, member)
-	if err != nil {
-		t.Fatal(err)
-	}
-	old := candidateID(t, e, c.ID, "Chicken Curry")
-	before := e.dinner(t, c.ID)
-
-	d, err := e.svc.Update(t.Context(), c.ID, dinners.Patch{Name: ptr("Quick Chicken curry")}, member)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if e.svc.HasOffers(c.ID) {
-		t.Errorf("service still holds the candidates offered before dinner %s was renamed", c.ID)
-	}
-	// A reply is queued, so only refusing the candidate keeps its recipe off.
-	e.model.QueueGenerate(recipestest.NormalizedReply("stovetop", 40))
-	wantStaleCandidate(t, e, c.ID, old)
-	row := e.dinner(t, c.ID)
-	if row.RecipeID.Valid {
-		t.Fatalf("dinner = %+v, want no recipe", row)
-	}
-	if row.NormalizedName != before.NormalizedName {
-		t.Fatalf("normalized name = %q, want %q unchanged", row.NormalizedName, before.NormalizedName)
-	}
-	// Still pending, now at the rename's revision, with a job for it.
-	if d.GroundingStatus != dinners.GroundingPending || row.GroundingRevision != before.GroundingRevision+1 {
-		t.Fatalf("renamed = %+v, want pending at revision %d", row, before.GroundingRevision+1)
-	}
-	var queued int
-	if err := e.st.Reader.QueryRowContext(t.Context(),
-		`SELECT count(*) FROM jobs WHERE status = 'queued' AND json_extract(payload, '$.revision') = ?`,
-		row.GroundingRevision).Scan(&queued); err != nil {
-		t.Fatal(err)
-	}
-	if queued != 1 {
-		t.Fatalf("queued jobs at revision %d = %d, want 1", row.GroundingRevision, queued)
-	}
-}
-
-// TestCandidatesBetweenRenameAndClearKept: a candidate search that reads
-// a dinner after its rename commits, and stores its candidates before the
-// rename clears the dinner's offers, keeps them: they ground the renamed
-// dinner, while one offered before the rename does not, even when a search
-// that read the dinner before the rename finishes after them.
-func TestCandidatesBetweenRenameAndClearKept(t *testing.T) {
-	// Unstarted, so the dinner stays pending with its jobs queued.
-	e := newUnstartedEnv(t)
-	e.search.Results["Beef stew"] = []recipes.Candidate{{URL: stew}}
-	c, err := e.svc.CreateRegular(t.Context(), dinners.NewRegular{Name: ptr("Chicken curry")}, member)
-	if err != nil {
-		t.Fatal(err)
-	}
-	old := candidateID(t, e, c.ID, "Chicken Curry")
-	before := e.dinner(t, c.ID)
-
-	var fresh string
-	dinners.SetUpdateCommitted(t, func() {
-		fresh = candidateID(t, e, c.ID, "Beef Stew")
-		e.svc.StoreOffers(c.ID, map[string]string{old: curryA}, before.GroundingRevision)
-	})
-	if _, err := e.svc.Update(t.Context(), c.ID, dinners.Patch{Name: ptr("Beef stew")}, member); err != nil {
-		t.Fatal(err)
-	}
-	if fresh == "" {
-		t.Fatal("no candidate search ran between the rename and clearing offers")
-	}
-	if !e.svc.HasOffers(c.ID) {
-		t.Fatalf("clearing offers after the rename dropped the candidates found at its revision for dinner %s", c.ID)
-	}
-	wantStaleCandidate(t, e, c.ID, old)
-
-	e.model.QueueGenerate(recipestest.NormalizedReply("oven", 150))
-	g, err := e.svc.Ground(t.Context(), c.ID, dinners.Fix{CandidateID: ptr(fresh)}, member)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if g.GroundingStatus != dinners.GroundingGrounded || g.RecipeID == nil {
-		t.Fatalf("dinner = %+v, want grounded for the new name", g)
-	}
-	rec, err := db.New(e.st.Reader).GetRecipe(t.Context(), *g.RecipeID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if rec.SourceUrl != stew {
-		t.Errorf("recipe source = %s, want %s", rec.SourceUrl, stew)
-	}
-}
-
-// TestRenameBackDuringCandidatesRefusesThem: a candidate search that read
-// a dinner as A and finishes after renames A -> B -> A have committed, but
-// before either has cleared the dinner's offers, stores candidates that
-// do not ground it, though its name is A again.
-func TestRenameBackDuringCandidatesRefusesThem(t *testing.T) {
-	e := newEnv(t)
-	id := failedDinner(t, e, "Mystery curry")
-	e.search.Results["Mystery curry"] = []recipes.Candidate{{URL: curryA}}
-	asked := len(e.search.Queries())
-	gate := make(chan struct{})
-	e.search.Gate = gate
-
-	type result struct {
-		got []dinners.Candidate
-		err error
-	}
-	done := make(chan result, 1)
-	go func() {
-		got, err := e.svc.Candidates(t.Context(), id)
-		done <- result{got, err}
-	}()
-	deadline := time.Now().Add(10 * time.Second)
-	for len(e.search.Queries()) == asked {
-		if time.Now().After(deadline) {
-			t.Fatal("candidate search never started")
-		}
-		time.Sleep(5 * time.Millisecond)
-	}
-
-	// The first rename's hook makes the second; the second's lets the
-	// search finish and tries its candidate, before either clears offers.
-	var hooks int
-	var stale error
-	var groundedBy *dinners.Dinner
-	dinners.SetUpdateCommitted(t, func() {
-		hooks++
-		switch hooks {
-		case 1:
-			if _, err := e.svc.Update(t.Context(), id, dinners.Patch{Name: ptr("Mystery curry")}, member); err != nil {
-				t.Error(err)
-			}
-		case 2:
-			close(gate)
-			r := <-done
-			if r.err != nil || len(r.got) != 1 {
-				t.Errorf("candidates = %+v, %v; want curryA", r.got, r.err)
-				return
-			}
-			e.model.QueueGenerate(recipestest.NormalizedReply("stovetop", 40))
-			d, err := e.svc.Ground(t.Context(), id, dinners.Fix{CandidateID: ptr(r.got[0].CandidateID)}, member)
-			if err == nil {
-				groundedBy = &d
-			}
-			stale = err
-		}
-	})
-	if _, err := e.svc.Update(t.Context(), id, dinners.Patch{Name: ptr("Beef stew")}, member); err != nil {
-		t.Fatal(err)
-	}
-	if hooks != 2 {
-		t.Fatalf("renames committed = %d, want 2", hooks)
-	}
-	var invalid *dinners.ValidationError
-	if !errors.As(stale, &invalid) {
-		t.Fatalf("stale candidate: err = %v, grounded %+v; want *ValidationError", stale, groundedBy)
-	}
-	row := e.dinner(t, id)
-	if row.Name != "Mystery curry" || row.RecipeID.Valid || row.GroundingStatus != dinners.GroundingFailed {
-		t.Errorf("dinner = %+v, want Mystery curry still failed with no recipe", row)
-	}
-	if e.svc.HasOffers(id) {
-		t.Errorf("service still holds the stale candidates of dinner %s", id)
-	}
-}
-
-// TestCandidatesRunningWhenCleared: a candidate search still running when
-// its dinner is grounded by hand, renamed or archived stores none of the
-// candidates it returns, so none of them grounds the dinner.
-func TestCandidatesRunningWhenCleared(t *testing.T) {
-	t.Parallel()
-	tests := []struct {
-		name  string
-		clear func(t *testing.T, e *env, id string)
-		// archived says the dinner ends archived.
-		archived bool
-	}{
-		{"manual", func(t *testing.T, e *env, id string) {
-			m := &dinners.ManualRecipe{Ingredients: []string{"1 chicken"}, Minutes: ptr(40), Method: ptr("stovetop")}
-			if _, err := e.svc.Ground(t.Context(), id, dinners.Fix{Manual: m}, member); err != nil {
-				t.Fatal(err)
-			}
-		}, false},
-		{"rename", func(t *testing.T, e *env, id string) {
-			if _, err := e.svc.Update(t.Context(), id, dinners.Patch{Name: ptr("Beef stew")}, member); err != nil {
-				t.Fatal(err)
-			}
-		}, false},
-		{"archive", func(t *testing.T, e *env, id string) {
-			if _, err := e.svc.Archive(t.Context(), id, member); err != nil {
-				t.Fatal(err)
-			}
-		}, true},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-			e := newEnv(t)
-			id := failedDinner(t, e, "Mystery curry")
-			e.search.Results["Mystery curry"] = []recipes.Candidate{{URL: curryA}}
-			asked := len(e.search.Queries())
-			gate := make(chan struct{})
-			e.search.Gate = gate
-
-			type result struct {
-				got []dinners.Candidate
-				err error
-			}
-			done := make(chan result, 1)
-			go func() {
-				got, err := e.svc.Candidates(t.Context(), id)
-				done <- result{got, err}
-			}()
-			deadline := time.Now().Add(10 * time.Second)
-			for len(e.search.Queries()) == asked {
-				if time.Now().After(deadline) {
-					t.Fatal("candidate search never started")
-				}
-				time.Sleep(5 * time.Millisecond)
-			}
-			tt.clear(t, e, id)
-			close(gate)
-			r := <-done
-			if r.err != nil {
-				t.Fatal(r.err)
-			}
-			if len(r.got) != 1 {
-				t.Fatalf("candidates = %+v, want curryA", r.got)
-			}
-			if e.svc.HasOffers(id) {
-				t.Errorf("a search finishing after dinner %s was cleared stored its candidates", id)
-			}
-			if !tt.archived {
-				wantStaleCandidate(t, e, id, r.got[0].CandidateID)
-			}
-		})
-	}
-}
-
-// TestCandidatesExpire: once their lifetime passes, a dinner's candidates
-// are dropped and no longer ground it, with no other search running.
-func TestCandidatesExpire(t *testing.T) {
-	dinners.SetOfferLifetime(t, 0)
-	e := newEnv(t)
-	id := failedDinner(t, e, "Mystery curry")
-	e.search.Results["Mystery curry"] = []recipes.Candidate{{URL: curryA}}
-	cid := candidateID(t, e, id, "Chicken Curry")
-
-	waitNoOffers(t, e)
-	wantStaleCandidate(t, e, id, cid)
-}
-
-// TestCandidatesExpireBeforeEviction: once their lifetime passes, a
-// dinner's candidates no longer ground it, even while the service still
-// holds them because their eviction has not run yet.
-func TestCandidatesExpireBeforeEviction(t *testing.T) {
-	dinners.SetOfferLifetime(t, time.Hour)
-	e := newEnv(t)
-	id := failedDinner(t, e, "Mystery curry")
-	e.search.Results["Mystery curry"] = []recipes.Candidate{{URL: curryA}}
-	cid := candidateID(t, e, id, "Chicken Curry")
-
-	dinners.AdvanceClock(t, time.Hour)
-	if !e.svc.HasOffers(id) {
-		t.Fatal("candidates evicted already, want them held until their timer fires")
-	}
-	wantStaleCandidate(t, e, id, cid)
-}
-
-// TestExpiredCandidatesNotHeld: the service holds no dinner's candidates
-// past their lifetime, however many dinners were offered some.
-func TestExpiredCandidatesNotHeld(t *testing.T) {
-	dinners.SetOfferLifetime(t, 50*time.Millisecond)
-	e := newEnv(t)
-	names := map[string]string{"Mystery curry": curryA, "Other curry": curryB}
-	ids := make([]string, 0, len(names))
-	for name, u := range names {
-		ids = append(ids, failedDinner(t, e, name))
-		e.search.Results[name] = []recipes.Candidate{{URL: u}}
-	}
-	for _, id := range ids {
-		if _, err := e.svc.Candidates(t.Context(), id); err != nil {
-			t.Fatal(err)
-		}
-	}
-	waitNoOffers(t, e)
-}
-
-// waitNoOffers waits for the service to hold no dinner's candidates.
-func waitNoOffers(t *testing.T, e *env) {
-	t.Helper()
-	deadline := time.Now().Add(5 * time.Second)
-	for n := e.svc.OfferCount(); n > 0; n = e.svc.OfferCount() {
-		if time.Now().After(deadline) {
-			t.Fatalf("service still holds the expired candidates of %d dinners", n)
-		}
-		time.Sleep(5 * time.Millisecond)
-	}
-}
-
 // TestFixReplacesPendingLink: fixing a Regular added from a link that held
 // no recipe drops that link, so it no longer blocks adding the link again,
 // while the link of the recipe chosen does.
@@ -1225,24 +726,18 @@ func TestFixReplacesPendingLink(t *testing.T) {
 	const lost = "https://gone.example/recipes/lamb-tagine"
 	tests := []struct {
 		name string
-		// fix is the fix for dinner id.
-		fix func(t *testing.T, e *env, id string) dinners.Fix
+		fix  dinners.Fix
 		// linkTaken is the recipe link the fixed dinner now has, if any.
 		linkTaken string
 	}{
-		{"candidate", func(t *testing.T, e *env, id string) dinners.Fix {
-			e.search.Results["Weeknight dinner"] = []recipes.Candidate{{URL: curryB}}
-			return dinners.Fix{CandidateID: ptr(candidateID(t, e, id, "Easy Weeknight Curry"))}
-		}, curryB},
-		{"manual", func(*testing.T, *env, string) dinners.Fix {
-			return dinners.Fix{Manual: &dinners.ManualRecipe{Ingredients: []string{"1 lamb"}, Minutes: ptr(90), Method: ptr("oven")}}
-		}, ""},
+		{"candidate", dinners.Fix{CandidateID: ptr(curryB)}, curryB},
+		{"manual", dinners.Fix{Manual: &dinners.ManualRecipe{Ingredients: []string{"1 lamb"}, Minutes: ptr(90), Method: ptr("oven")}}, ""},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			e := newEnv(t)
-			c, err := e.svc.CreateRegular(t.Context(), dinners.NewRegular{Name: ptr("Lamb roast"), RecipeURL: ptr(lost)}, member)
+			c, err := e.svc.CreateRegular(t.Context(), dinners.NewRegular{RecipeURL: ptr(lost)}, member)
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -1254,22 +749,19 @@ func TestFixReplacesPendingLink(t *testing.T) {
 				t.Fatal(err)
 			}
 			e.model.QueueGenerate(recipestest.NormalizedReply("stovetop", 25))
-			if _, err := e.svc.Ground(t.Context(), c.ID, tt.fix(t, e, c.ID), member); err != nil {
-				t.Fatal(err)
-			}
-			row, err := db.New(e.st.Reader).GetDinner(t.Context(), c.ID)
+			d, err := e.svc.Ground(t.Context(), c.ID, tt.fix, member)
 			if err != nil {
 				t.Fatal(err)
 			}
-			if row.RecipeUrl.Valid {
-				t.Errorf("recipe_url = %q after the fix, want the unusable link dropped", row.RecipeUrl.String)
+			if d.RecipeURL != nil {
+				t.Errorf("recipe_url = %q after the fix, want the unusable link dropped", *d.RecipeURL)
 			}
 
-			if _, err := e.svc.CreateRegular(t.Context(), dinners.NewRegular{Name: ptr("Lentil soup"), RecipeURL: ptr(lost)}, member); err != nil {
+			if _, err := e.svc.CreateRegular(t.Context(), dinners.NewRegular{RecipeURL: ptr(lost)}, member); err != nil {
 				t.Errorf("adding the dropped link again: %v, want added", err)
 			}
 			if tt.linkTaken != "" {
-				_, err := e.svc.CreateRegular(t.Context(), dinners.NewRegular{Name: ptr("Curry night"), RecipeURL: ptr(tt.linkTaken)}, member)
+				_, err := e.svc.CreateRegular(t.Context(), dinners.NewRegular{RecipeURL: ptr(tt.linkTaken)}, member)
 				var dup *dinners.DuplicateError
 				if !errors.As(err, &dup) || dup.Existing.ID != c.ID {
 					t.Errorf("adding the fixed dinner's recipe link: err = %v, want a duplicate of %s", err, c.ID)
@@ -1357,8 +849,7 @@ func TestFixValidation(t *testing.T) {
 	tests := map[string]dinners.Fix{
 		"nothing":           {},
 		"two":               {CandidateID: ptr(curryA), RecipeURL: ptr(stew)},
-		"unknown candidate": {CandidateID: ptr("cand-1")},
-		"candidate a URL":   {CandidateID: ptr(curryA)},
+		"candidate not URL": {CandidateID: ptr("cand-1")},
 		"http link":         {RecipeURL: ptr("http://a.example/x")},
 		"no ingredients":    {Manual: &dinners.ManualRecipe{Minutes: ptr(20), Method: ptr("oven")}},
 		"blank ingredient":  {Manual: &dinners.ManualRecipe{Ingredients: []string{" "}, Minutes: ptr(20), Method: ptr("oven")}},
@@ -1615,204 +1106,3 @@ func TestGroundTimesOut(t *testing.T) {
 		t.Errorf("grounding_status = %s, want failed as before", row.GroundingStatus)
 	}
 }
-
-// TestFixInFlightWhenDinnerChanges: a link still grounding when its dinner
-// is renamed, archived or grounded some other way writes nothing; the
-// change made meanwhile is kept.
-func TestFixInFlightWhenDinnerChanges(t *testing.T) {
-	t.Parallel()
-	tests := []struct {
-		name   string
-		change func(t *testing.T, e *env, id string)
-		want   error
-		// kept checks the dinner shows the change, not the link's recipe.
-		kept func(row db.Dinner) bool
-	}{
-		{"renamed", func(t *testing.T, e *env, id string) {
-			if _, err := e.svc.Update(t.Context(), id, dinners.Patch{Name: ptr("Chicken curry")}, member); err != nil {
-				t.Fatal(err)
-			}
-		}, dinners.ErrGroundConflict, func(row db.Dinner) bool {
-			return row.Name == "Chicken curry" && row.GroundingStatus == dinners.GroundingFailed && !row.RecipeID.Valid
-		}},
-		{"renamed to the same normalized name", func(t *testing.T, e *env, id string) {
-			if _, err := e.svc.Update(t.Context(), id, dinners.Patch{Name: ptr("Easy Grandma's stew")}, member); err != nil {
-				t.Fatal(err)
-			}
-		}, dinners.ErrGroundConflict, func(row db.Dinner) bool {
-			return row.Name == "Easy Grandma's stew" && row.GroundingStatus == dinners.GroundingFailed && !row.RecipeID.Valid
-		}},
-		{"archived", func(t *testing.T, e *env, id string) {
-			if _, err := e.svc.Archive(t.Context(), id, member); err != nil {
-				t.Fatal(err)
-			}
-		}, dinners.ErrArchived, func(row db.Dinner) bool {
-			return row.Status == dinners.StatusArchived && row.GroundingStatus == dinners.GroundingFailed && !row.RecipeID.Valid
-		}},
-		{"grounded by hand", func(t *testing.T, e *env, id string) {
-			if _, err := e.svc.Ground(t.Context(), id, dinners.Fix{Manual: &dinners.ManualRecipe{
-				Ingredients: []string{"1 lb beef"}, Minutes: ptr(240), Method: ptr("crockpot"),
-			}}, member); err != nil {
-				t.Fatal(err)
-			}
-		}, dinners.ErrGroundConflict, func(row db.Dinner) bool {
-			return row.GroundingStatus == dinners.GroundingManual && row.Method.String == "crockpot"
-		}},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-			e := newEnv(t)
-			id := failedDinner(t, e, "Grandma's stew")
-			e.model.QueueGenerate(recipestest.NormalizedReply("oven", 150))
-			e.pages.Gate = make(chan struct{})
-
-			done := make(chan error, 1)
-			go func() {
-				_, err := e.svc.Ground(context.Background(), id, dinners.Fix{RecipeURL: ptr(stew)}, member)
-				done <- err
-			}()
-			e.waitFetched(t, stew)
-			tt.change(t, e, id)
-			close(e.pages.Gate)
-
-			if err := <-done; !errors.Is(err, tt.want) {
-				t.Fatalf("err = %v, want %v", err, tt.want)
-			}
-			if row := e.dinner(t, id); !tt.kept(row) {
-				t.Errorf("dinner = %+v, want the %s change kept and the link's recipe not written", row, tt.name)
-			}
-		})
-	}
-}
-
-// TestFixInFlightKeepsMemberEdits: a method, minutes or difficulty a
-// member sets while a link is grounding is kept; a field they left alone
-// takes the link's recipe, even one already set before grounding began.
-func TestFixInFlightKeepsMemberEdits(t *testing.T) {
-	t.Parallel()
-	// Every field is set before grounding, then one is changed in flight.
-	before := dinners.Patch{Method: ptr("stovetop"), MinutesTotal: ptr(45), Difficulty: ptr("easy")}
-	tests := []struct {
-		name  string
-		edit  dinners.Patch
-		field string
-	}{
-		{"method", dinners.Patch{Method: ptr("grill")}, "method"},
-		{"minutes", dinners.Patch{MinutesTotal: ptr(20)}, "minutes_total"},
-		{"difficulty", dinners.Patch{Difficulty: ptr("medium")}, "difficulty"},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-			e := newEnv(t)
-			id := failedDinner(t, e, "Grandma's stew")
-			if _, err := e.svc.Update(t.Context(), id, before, member); err != nil {
-				t.Fatal(err)
-			}
-			e.model.QueueGenerate(recipestest.NormalizedReply("oven", 150))
-			e.pages.Gate = make(chan struct{})
-
-			done := make(chan error, 1)
-			go func() {
-				_, err := e.svc.Ground(context.Background(), id, dinners.Fix{RecipeURL: ptr(stew)}, member)
-				done <- err
-			}()
-			e.waitFetched(t, stew)
-			if _, err := e.svc.Update(t.Context(), id, tt.edit, member); err != nil {
-				t.Fatal(err)
-			}
-			close(e.pages.Gate)
-
-			if err := <-done; err != nil {
-				t.Fatal(err)
-			}
-			row := e.dinner(t, id)
-			if row.GroundingStatus != dinners.GroundingGrounded || !row.RecipeID.Valid {
-				t.Fatalf("dinner = %+v, want grounded in the link's recipe", row)
-			}
-			var recipe fields
-			if err := e.st.Reader.QueryRowContext(t.Context(),
-				`SELECT method, minutes_total, difficulty FROM recipes WHERE id = ?`, row.RecipeID.String,
-			).Scan(&recipe.method, &recipe.minutes, &recipe.difficulty); err != nil {
-				t.Fatal(err)
-			}
-			old, edited := patchFields(before), patchFields(tt.edit)
-			want := recipe
-			switch tt.field {
-			case "method":
-				want.method = edited.method
-			case "minutes_total":
-				want.minutes = edited.minutes
-			case "difficulty":
-				want.difficulty = edited.difficulty
-			}
-			if recipe.method == old.method || recipe.minutes == old.minutes || recipe.difficulty == old.difficulty {
-				t.Fatalf("recipe %+v shares a value with the dinner before grounding %+v", recipe, old)
-			}
-			got := fields{row.Method.String, row.MinutesTotal.Int64, row.Difficulty.String}
-			if got != want {
-				t.Errorf("method, minutes, difficulty = %+v, want %+v: the %s edit kept, the rest from the recipe", got, want, tt.field)
-			}
-		})
-	}
-}
-
-// fields are a dinner's or recipe's method, minutes_total and difficulty.
-type fields struct {
-	method     string
-	minutes    int64
-	difficulty string
-}
-
-// patchFields returns the fields p sets, zero where it sets none.
-func patchFields(p dinners.Patch) fields {
-	var f fields
-	if p.Method != nil {
-		f.method = *p.Method
-	}
-	if p.MinutesTotal != nil {
-		f.minutes = int64(*p.MinutesTotal)
-	}
-	if p.Difficulty != nil {
-		f.difficulty = *p.Difficulty
-	}
-	return f
-}
-
-// TestFixArchivedDinner: an archived dinner cannot be grounded by hand.
-func TestFixArchivedDinner(t *testing.T) {
-	t.Parallel()
-	e := newEnv(t)
-	id := failedDinner(t, e, "Grandma's stew")
-	if _, err := e.svc.Archive(t.Context(), id, member); err != nil {
-		t.Fatal(err)
-	}
-	before := e.dinner(t, id)
-	for _, f := range []dinners.Fix{
-		{RecipeURL: ptr(stew)},
-		{Manual: &dinners.ManualRecipe{Ingredients: []string{"1 lb beef"}, Minutes: ptr(240), Method: ptr("crockpot")}},
-	} {
-		if _, err := e.svc.Ground(t.Context(), id, f, member); !errors.Is(err, dinners.ErrArchived) {
-			t.Errorf("fix %+v: err = %v, want ErrArchived", f, err)
-		}
-	}
-	if got := e.pages.Fetched(); len(got) != 0 {
-		t.Errorf("fetched %q for an archived dinner", got)
-	}
-	if after := e.dinner(t, id); after != before {
-		t.Errorf("archived dinner changed: %+v, was %+v", after, before)
-	}
-}
-
-// waitFetched waits until rawURL has been fetched.
-func (e *env) waitFetched(t *testing.T, rawURL string) {
-	t.Helper()
-	deadline := time.Now().Add(10 * time.Second)
-	for !slices.Contains(e.pages.Fetched(), rawURL) {
-		if time.Now().After(deadline) {
-			t.Fatalf("%s never fetched", rawURL)
-		}
-		time.Sleep(5 * time.Millisecond)
-	}
-}

internal/recipes/ground.go

@@ -266,7 +266,7 @@ func (g *Grounder) GroundURL(ctx context.Context, rawURL string) (Grounded, erro
 	}
 	gr, reason, err := g.ground(ctx, rawURL, r)
 	if err != nil {
-		return Grounded{}, fmt.Errorf("recipes: ground pasted link: %w", err)
+		return Grounded{}, fmt.Errorf("recipes: ground %s: %w", rawURL, err)
 	}
 	if reason != nil {
 		return ungroundable(reason)

internal/server/dinners.go

@@ -19,8 +19,7 @@ const maxDinnerBody = 16 << 10
 // manual recipe of dinners.MaxManualLines lines of each kind.
 const maxGroundBody = 512 << 10
 
-// dinnerCreate is the POST /dinners body: a name, with or without a
-// recipe_url.
+// dinnerCreate is the POST /dinners body: a name or a recipe_url.
 type dinnerCreate struct {
 	Name      *string `json:"name"`
 	RecipeURL *string `json:"recipe_url"`
@@ -201,11 +200,7 @@ func actorOrFail(w http.ResponseWriter, r *http.Request, logger *slog.Logger) (a
 // writeDinnerError maps a dinners.Service error to its API error. A page
 // that cannot ground the dinner is 422 ungroundable; recipe search not set
 // up is 409 not_configured; a search or model failure is 502; grounding by
-// hand that runs past dinners.GroundTimeout is 504 ground_timeout; grounding
-// an archived dinner is 409 dinner_archived and one changed while grounding
-// 409 ground_conflict. Any other grounding failure, by candidate, link or
-// manual recipe, wraps dinners.ErrGroundFailed and is 500, logged by reason
-// and dinner id only.
+// hand that runs past dinners.GroundTimeout is 504 ground_timeout.
 func writeDinnerError(w http.ResponseWriter, r *http.Request, logger *slog.Logger, action string, err error) {
 	var invalid *dinners.ValidationError
 	var dup *dinners.DuplicateError
@@ -225,16 +220,6 @@ func writeDinnerError(w http.ResponseWriter, r *http.Request, logger *slog.Logge
 	case errors.Is(err, recipes.ErrNormalizeFailed):
 		logger.WarnContext(r.Context(), action, "reason", "normalize_recipe failed")
 		writeError(w, r, logger, http.StatusBadGateway, "ai_failed", "the AI provider failed to read the recipe")
-	case errors.Is(err, dinners.ErrGroundFailed):
-		// The error may quote the pasted link, which can carry a personal
-		// token, and dependency errors, so only the reason and dinner are
-		// logged.
-		logger.ErrorContext(r.Context(), action, "reason", "ground_failed", "dinner_id", chi.URLParam(r, "id"))
-		writeError(w, r, logger, http.StatusInternalServerError, "internal", "internal error")
-	case errors.Is(err, dinners.ErrArchived):
-		writeError(w, r, logger, http.StatusConflict, "dinner_archived", "the dinner is archived")
-	case errors.Is(err, dinners.ErrGroundConflict):
-		writeError(w, r, logger, http.StatusConflict, "ground_conflict", "the dinner changed while its recipe was grounding; reload and try again")
 	case errors.Is(err, dinners.ErrGroundTimeout):
 		logger.WarnContext(r.Context(), action, "reason", "ground_timeout")
 		writeError(w, r, logger, http.StatusGatewayTimeout, "ground_timeout", "grounding the recipe took too long; try again")

internal/server/dinners_test.go

@@ -159,6 +159,7 @@ func TestCreateDinnerByName(t *testing.T) {
 		"origin":           "regular",
 		"grounding_status": "pending",
 		"is_favorite":      false,
+		"recipe_url":       nil,
 		"photo_url":        nil,
 		"method":           nil,
 		"minutes_total":    nil,
@@ -169,9 +170,6 @@ func TestCreateDinnerByName(t *testing.T) {
 			t.Errorf("%s = %#v (present %v), want %#v", k, got, ok, v)
 		}
 	}
-	if got, ok := body["recipe_url"]; ok {
-		t.Errorf("recipe_url = %#v, want no recipe_url in a dinner response", got)
-	}
 	var normalized, updatedBy string
 	if err := st.Reader.QueryRow(`SELECT normalized_name, updated_by FROM dinners WHERE id = ?`, body["id"]).Scan(&normalized, &updatedBy); err != nil {
 		t.Fatal(err)
@@ -186,12 +184,13 @@ func TestCreateDinnerByURL(t *testing.T) {
 	router, _ := newDinnersRouter(t)
 
 	link := "https://www.example.com/recipes/12345/beef-and-broccoli-stir-fry/"
-	rec, body := callDinners(t, router, http.MethodPost, dinnersPath, `{"name":"Stir fry night","recipe_url":"`+link+`"}`)
+	rec, body := callDinners(t, router, http.MethodPost, dinnersPath, `{"recipe_url":"`+link+`"}`)
 	if rec.Code != http.StatusCreated {
 		t.Fatalf("status = %d, want 201: %s", rec.Code, rec.Body)
 	}
 	for k, v := range map[string]any{
-		"name":             "Stir fry night",
+		"name":             "Beef and broccoli stir fry",
+		"recipe_url":       link,
 		"status":           "regular",
 		"origin":           "regular",
 		"grounding_status": "pending",
@@ -201,27 +200,24 @@ func TestCreateDinnerByURL(t *testing.T) {
 			t.Errorf("%s = %#v, want %#v", k, body[k], v)
 		}
 	}
-	// The link stays on the server for grounding; responses never carry it.
-	if got, ok := body["recipe_url"]; ok {
-		t.Errorf("recipe_url = %#v, want no recipe_url in a dinner response", got)
-	}
 
 	// The same link again is a duplicate even though its name would differ.
 	rec, body = callDinners(t, router, http.MethodPost, dinnersPath, `{"name":"Something else entirely"}`)
 	if rec.Code != http.StatusCreated {
 		t.Fatalf("unrelated name = %d: %s", rec.Code, rec.Body)
 	}
-	rec, body = callDinners(t, router, http.MethodPost, dinnersPath, `{"name":"Beef and broccoli","recipe_url":"`+link+`"}`)
+	rec, body = callDinners(t, router, http.MethodPost, dinnersPath, `{"recipe_url":"`+link+`"}`)
 	if rec.Code != http.StatusConflict || errorCode(body) != "duplicate_dinner" {
 		t.Errorf("same link again = %d %v, want 409 duplicate_dinner", rec.Code, body)
 	}
 
 	for _, tc := range []struct{ name, body string }{
-		{"plain http", `{"name":"Chili","recipe_url":"http://example.com/recipes/chili"}`},
-		{"not a URL", `{"name":"Chili","recipe_url":"chili"}`},
-		{"credentials", `{"name":"Chili","recipe_url":"https://me:pw@example.com/recipes/chili"}`},
-		{"link without a name", `{"recipe_url":"https://example.com/recipes/chili"}`},
-		{"filler name with a link", `{"name":"The Best Easy Recipe","recipe_url":"https://example.com/recipes/chili"}`},
+		{"plain http", `{"recipe_url":"http://example.com/recipes/chili"}`},
+		{"not a URL", `{"recipe_url":"chili"}`},
+		{"credentials", `{"recipe_url":"https://me:pw@example.com/recipes/chili"}`},
+		{"no name in path", `{"recipe_url":"https://example.com/"}`},
+		{"numeric slug", `{"recipe_url":"https://example.com/recipe/98765"}`},
+		{"both fields", `{"name":"Chili","recipe_url":"https://example.com/recipes/chili"}`},
 		{"neither field", `{}`},
 	} {
 		rec, body := callDinners(t, router, http.MethodPost, dinnersPath, tc.body)
@@ -231,79 +227,6 @@ func TestCreateDinnerByURL(t *testing.T) {
 	}
 }
 
-// TestDinnerResponsesHideRecipeURL: a pasted link may carry a personal
-// token, so neither the create response nor a later list read shows any
-// part of it, while the stored link still awaits grounding.
-func TestDinnerResponsesHideRecipeURL(t *testing.T) {
-	t.Parallel()
-	router, st := newDinnersRouter(t)
-
-	const link = "https://c.example/recipes/stew?access_token=personal-token-abc123"
-	rec, body := callDinners(t, router, http.MethodPost, dinnersPath, `{"name":"Stew","recipe_url":"`+link+`"}`)
-	if rec.Code != http.StatusCreated {
-		t.Fatalf("status = %d, want 201: %s", rec.Code, rec.Body)
-	}
-	created := rec.Body.String()
-	rec, _ = callDinners(t, router, http.MethodGet, dinnersPath+"?status=regular", "")
-	if rec.Code != http.StatusOK {
-		t.Fatalf("GET status=regular = %d: %s", rec.Code, rec.Body)
-	}
-	for _, resp := range []struct{ name, body string }{{"create", created}, {"list", rec.Body.String()}} {
-		for _, secret := range []string{link, "c.example", "access_token", "personal-token-abc123", "recipe_url"} {
-			if strings.Contains(resp.body, secret) {
-				t.Errorf("%s response contains %q: %s", resp.name, secret, resp.body)
-			}
-		}
-	}
-
-	var stored string
-	if err := st.Reader.QueryRow(`SELECT recipe_url FROM dinners WHERE id = ?`, body["id"]).Scan(&stored); err != nil {
-		t.Fatal(err)
-	}
-	if stored != link {
-		t.Errorf("stored recipe_url = %q, want %q kept for grounding", stored, link)
-	}
-}
-
-// TestDinnerResponsesHideTokenInLinkPath: a personal token can sit
-// anywhere in a link's path, even as plain letters, so a dinner added from
-// a link is named only by the household and neither the create response, a
-// later list read nor the duplicate error for the same link shows any of
-// the link.
-func TestDinnerResponsesHideTokenInLinkPath(t *testing.T) {
-	t.Parallel()
-	router, _ := newDinnersRouter(t)
-
-	const link = "https://c.example/recipes/stew-key-abcdefghijklmno"
-	rec, body := callDinners(t, router, http.MethodPost, dinnersPath, `{"name":"Sunday stew","recipe_url":"`+link+`"}`)
-	if rec.Code != http.StatusCreated {
-		t.Fatalf("status = %d, want 201: %s", rec.Code, rec.Body)
-	}
-	if body["name"] != "Sunday stew" {
-		t.Errorf("name = %v, want Sunday stew", body["name"])
-	}
-	created := rec.Body.String()
-	rec, _ = callDinners(t, router, http.MethodGet, dinnersPath+"?status=regular", "")
-	if rec.Code != http.StatusOK {
-		t.Fatalf("GET status=regular = %d: %s", rec.Code, rec.Body)
-	}
-	listed := rec.Body.String()
-	rec, _ = callDinners(t, router, http.MethodPost, dinnersPath, `{"name":"Beef stew","recipe_url":"`+link+`"}`)
-	if rec.Code != http.StatusConflict {
-		t.Fatalf("same link again = %d, want 409: %s", rec.Code, rec.Body)
-	}
-	// Each secret holds a character no ULID has (Crockford base32 has no I,
-	// L, O, U, "-", "." or "/"), so the dinner's id never matches one.
-	for _, resp := range []struct{ name, body string }{{"create", created}, {"list", listed}, {"duplicate", rec.Body.String()}} {
-		lower := strings.ToLower(resp.body)
-		for _, secret := range []string{link, "c.example", "recipes/stew", "stew-key", "abcdefghijklmno"} {
-			if strings.Contains(lower, secret) {
-				t.Errorf("%s response contains %q: %s", resp.name, secret, resp.body)
-			}
-		}
-	}
-}
-
 func TestCreateDinnerDuplicate(t *testing.T) {
 	t.Parallel()
 	router, st := newDinnersRouter(t)
@@ -319,10 +242,10 @@ func TestCreateDinnerDuplicate(t *testing.T) {
 			t.Errorf("%q: %d %v, want 409 duplicate_dinner", name, rec.Code, body)
 		}
 	}
-	// A name repeating the dish is a duplicate with a link too.
-	rec, body := callDinners(t, router, http.MethodPost, dinnersPath, `{"name":"Chicken tikka masala","recipe_url":"https://example.com/other-curry.html"}`)
+	// A slug naming the same dish is a duplicate too.
+	rec, body := callDinners(t, router, http.MethodPost, dinnersPath, `{"recipe_url":"https://example.com/easy-chicken-tikka-masala.html"}`)
 	if rec.Code != http.StatusConflict {
-		t.Errorf("named duplicate with a link = %d %v, want 409", rec.Code, body)
+		t.Errorf("URL slug duplicate = %d %v, want 409", rec.Code, body)
 	}
 
 	var n int

internal/server/grounding_test.go

@@ -68,27 +68,6 @@ func listedDinner(t *testing.T, h http.Handler, id string) map[string]any {
 	return nil
 }
 
-// candidateID returns the candidate_id GET recipe-candidates offers dinner
-// id for the page titled title.
-func candidateID(t *testing.T, h http.Handler, id, title string) string {
-	t.Helper()
-	rec, body := callDinners(t, h, http.MethodGet, dinnersPath+"/"+id+"/recipe-candidates", "")
-	if rec.Code != http.StatusOK {
-		t.Fatalf("GET candidates = %d: %s", rec.Code, rec.Body)
-	}
-	for _, c := range body["candidates"].([]any) {
-		if c := c.(map[string]any); c["title"] == title {
-			cid := c["candidate_id"].(string)
-			if strings.Contains(cid, "://") {
-				t.Fatalf("candidate_id = %q, want an opaque id, not the page URL", cid)
-			}
-			return cid
-		}
-	}
-	t.Fatalf("candidates = %v, want one titled %q", body, title)
-	return ""
-}
-
 func TestPostDinnerReturnsBeforeGroundingCompletes(t *testing.T) {
 	t.Parallel()
 	e := newDinnersEnv(t).withRecipes(t)
@@ -159,11 +138,8 @@ func TestGetRecipeCandidates(t *testing.T) {
 		t.Fatalf("candidates = %v, want 2", body)
 	}
 	first := list[0].(map[string]any)
-	if cid, _ := first["candidate_id"].(string); cid == "" || strings.Contains(cid, "a.example") {
-		t.Errorf("candidate_id = %#v, want an opaque id", first["candidate_id"])
-	}
 	want := map[string]any{
-		"candidate_id": first["candidate_id"],
+		"candidate_id": curryPage,
 		"title":        "Chicken Curry",
 		"site_name":    "Curry House",
 		"photo_url":    nil,
@@ -210,8 +186,7 @@ func TestPostGroundViaCandidate(t *testing.T) {
 	id := createDinner(t, e.h, `{"name":"Chicken curry"}`)
 	e.model.QueueGenerate(recipestest.NormalizedReply("stovetop", 25))
 
-	cid := candidateID(t, e.h, id, "Weeknight Curry")
-	rec, d := callDinners(t, e.h, http.MethodPost, dinnersPath+"/"+id+"/ground", `{"candidate_id":"`+cid+`"}`)
+	rec, d := callDinners(t, e.h, http.MethodPost, dinnersPath+"/"+id+"/ground", `{"candidate_id":"`+curry2Page+`"}`)
 	if rec.Code != http.StatusOK {
 		t.Fatalf("POST = %d: %s", rec.Code, rec.Body)
 	}
@@ -223,81 +198,12 @@ func TestPostGroundViaCandidate(t *testing.T) {
 	// The candidate is now stored, so it is offered with its photo.
 	_, body := callDinners(t, e.h, http.MethodGet, dinnersPath+"/"+id+"/recipe-candidates", "")
 	for _, c := range body["candidates"].([]any) {
-		if c := c.(map[string]any); c["candidate_id"] == cid && c["photo_url"] != photo {
+		if c := c.(map[string]any); c["candidate_id"] == curry2Page && c["photo_url"] != photo {
 			t.Errorf("grounded candidate photo_url = %v, want %s", c["photo_url"], photo)
 		}
 	}
 }
 
-// TestRecipeCandidatesHideTokenURLs: a candidate page whose URL carries a
-// token in its path or query is offered by an opaque id alone, which
-// grounds the dinner in that page.
-func TestRecipeCandidatesHideTokenURLs(t *testing.T) {
-	t.Parallel()
-	e := newDinnersEnv(t)
-	const (
-		pathToken  = "path-token-abc123"
-		queryToken = "query-token-def456"
-		pathPage   = "https://secret-path.example/u/" + pathToken + "/chicken-curry"
-		queryPage  = "https://secret-query.example/curry?access_token=" + queryToken
-	)
-	e.search.Results["Chicken curry"] = []recipes.Candidate{{URL: pathPage}, {URL: queryPage}}
-	e.pages.Bodies[pathPage] = recipestest.RecipePage("Chicken Curry", "Curry House", "https://a.example/curry.jpg", 40)
-	e.pages.Bodies[queryPage] = recipestest.RecipePage("Weeknight Curry", "B Kitchen", "https://b.example/curry.jpg", 25)
-	e.images.JPEGs["https://b.example/curry.jpg"] = recipestest.JPEG(t, 400, 320, 2)
-	id := createDinner(t, e.h, `{"name":"Chicken curry"}`) // runner not started: stays pending
-
-	rec, body := callDinners(t, e.h, http.MethodGet, dinnersPath+"/"+id+"/recipe-candidates", "")
-	if rec.Code != http.StatusOK {
-		t.Fatalf("GET = %d: %s", rec.Code, rec.Body)
-	}
-	if list, _ := body["candidates"].([]any); len(list) != 2 {
-		t.Fatalf("candidates = %v, want 2", body)
-	}
-	for _, secret := range []string{pathPage, queryPage, "secret-path.example", "secret-query.example", pathToken, queryToken, "access_token"} {
-		if strings.Contains(rec.Body.String(), secret) {
-			t.Errorf("candidates response contains %q: %s", secret, rec.Body)
-		}
-	}
-
-	e.model.QueueGenerate(recipestest.NormalizedReply("stovetop", 25))
-	cid := candidateID(t, e.h, id, "Weeknight Curry")
-	rec, d := callDinners(t, e.h, http.MethodPost, dinnersPath+"/"+id+"/ground", `{"candidate_id":"`+cid+`"}`)
-	if rec.Code != http.StatusOK {
-		t.Fatalf("POST = %d: %s", rec.Code, rec.Body)
-	}
-	if strings.Contains(rec.Body.String(), queryToken) {
-		t.Errorf("ground response contains the token: %s", rec.Body)
-	}
-	var source string
-	if err := e.st.Reader.QueryRow(`SELECT source_url FROM recipes WHERE id = ?`, d["recipe_id"]).Scan(&source); err != nil {
-		t.Fatal(err)
-	}
-	if d["grounding_status"] != "grounded" || source != queryPage {
-		t.Errorf("dinner = %v in recipe %s, want grounded in %s", d, source, queryPage)
-	}
-}
-
-// TestPostGroundRejectsCandidateNotOffered: a candidate_id is only one
-// offered for that dinner; a page URL, or another dinner's candidate, is
-// refused.
-func TestPostGroundRejectsCandidateNotOffered(t *testing.T) {
-	t.Parallel()
-	e := newDinnersEnv(t).withRecipes(t)
-	id := createDinner(t, e.h, `{"name":"Chicken curry"}`)
-	other := createDinner(t, e.h, `{"name":"Pad thai"}`)
-	cid := candidateID(t, e.h, id, "Weeknight Curry")
-	for _, tc := range []struct{ name, dinner, cid string }{
-		{"page URL", id, curry2Page},
-		{"another dinner's", other, cid},
-	} {
-		rec, body := callDinners(t, e.h, http.MethodPost, dinnersPath+"/"+tc.dinner+"/ground", `{"candidate_id":"`+tc.cid+`"}`)
-		if rec.Code != http.StatusBadRequest || errorCode(body) != "invalid_dinner" {
-			t.Errorf("%s: %d %v, want 400 invalid_dinner", tc.name, rec.Code, body)
-		}
-	}
-}
-
 func TestPostGroundViaRecipeURL(t *testing.T) {
 	t.Parallel()
 	e := newDinnersEnv(t).withRecipes(t)
@@ -318,115 +224,6 @@ func TestPostGroundViaRecipeURL(t *testing.T) {
 	}
 }
 
-// TestPostGroundViaRecipeURLStorageFailure: a pasted link that fails for a
-// reason other than its recipe is a 500 logged by reason and dinner id,
-// never with the link, which can carry a personal token, or the dependency
-// error.
-func TestPostGroundViaRecipeURLStorageFailure(t *testing.T) {
-	t.Parallel()
-	e := newDinnersEnv(t).withRecipes(t)
-	const token = "personal-token-abc123"
-	link := stewPage + "?access_token=" + token
-	e.pages.Bodies[link] = e.pages.Bodies[stewPage]
-	id := createDinner(t, e.h, `{"name":"Sunday stew"}`)
-	e.model.QueueGenerate(recipestest.NormalizedReply("oven", 150))
-	if _, err := e.st.Writer.ExecContext(t.Context(),
-		`CREATE TRIGGER refuse_recipes BEFORE INSERT ON recipes BEGIN SELECT RAISE(ABORT, 'disk full'); END`); err != nil {
-		t.Fatal(err)
-	}
-
-	rec, body := callDinners(t, e.h, http.MethodPost, dinnersPath+"/"+id+"/ground", `{"recipe_url":"`+link+`"}`)
-	if rec.Code != http.StatusInternalServerError || errorCode(body) != "internal" || strings.Contains(rec.Body.String(), token) {
-		t.Errorf("POST = %d %s, want 500 internal without the link", rec.Code, rec.Body)
-	}
-	logs := e.logs.String()
-	if strings.Contains(logs, token) || strings.Contains(logs, "c.example") || strings.Contains(logs, "disk full") ||
-		!strings.Contains(logs, "reason=ground_failed") || !strings.Contains(logs, "dinner_id="+id) {
-		t.Errorf("logs = %q, want reason=ground_failed and the dinner id, without the link or dependency error", logs)
-	}
-}
-
-// TestPostGroundViaRecipeURLDinnerWriteFailure: a pasted link whose recipe
-// is stored but whose dinner cannot be written is a 500 logged by reason
-// and dinner id, never with the dependency error.
-func TestPostGroundViaRecipeURLDinnerWriteFailure(t *testing.T) {
-	t.Parallel()
-	e := newDinnersEnv(t).withRecipes(t)
-	id := createDinner(t, e.h, `{"name":"Sunday stew"}`)
-	e.model.QueueGenerate(recipestest.NormalizedReply("oven", 150))
-	if _, err := e.st.Writer.ExecContext(t.Context(),
-		`CREATE TRIGGER refuse_grounding BEFORE UPDATE OF recipe_id ON dinners WHEN NEW.recipe_id IS NOT NULL BEGIN SELECT RAISE(ABORT, 'disk full'); END`); err != nil {
-		t.Fatal(err)
-	}
-
-	rec, body := callDinners(t, e.h, http.MethodPost, dinnersPath+"/"+id+"/ground", `{"recipe_url":"`+stewPage+`"}`)
-	if rec.Code != http.StatusInternalServerError || errorCode(body) != "internal" {
-		t.Errorf("POST = %d %s, want 500 internal", rec.Code, rec.Body)
-	}
-	var stored int
-	if err := e.st.Reader.QueryRowContext(t.Context(), `SELECT COUNT(*) FROM recipes WHERE source_url = ?`, stewPage).Scan(&stored); err != nil || stored != 1 {
-		t.Fatalf("recipes stored for the link = %d (%v), want 1: the failure must be the dinner write", stored, err)
-	}
-	logs := e.logs.String()
-	if strings.Contains(logs, "disk full") || !strings.Contains(logs, "reason=ground_failed") || !strings.Contains(logs, "dinner_id="+id) {
-		t.Errorf("logs = %q, want reason=ground_failed and the dinner id, without the dependency error", logs)
-	}
-}
-
-// TestPostGroundUnexpectedFailures: grounding by hand that fails reading
-// the dinner, or storing a manual recipe, is a 500 logged by reason and
-// dinner id, never with the database error.
-func TestPostGroundUnexpectedFailures(t *testing.T) {
-	t.Parallel()
-	const (
-		// Renaming a column every dinner read selects fails the read.
-		breakRead = `ALTER TABLE dinners RENAME COLUMN cuisine TO cuisine_gone`
-		// The trigger's message stands in for the database error.
-		breakStore = `CREATE TRIGGER refuse_recipes BEFORE INSERT ON recipes BEGIN SELECT RAISE(ABORT, 'disk full'); END`
-		manual     = `{"manual":{"ingredients":["1 lb beef"],"steps":["Brown."],"minutes":240,"method":"crockpot"}}`
-	)
-	for _, tc := range []struct {
-		name, sabotage, fix, leak string
-	}{
-		{"link read", breakRead, `{"recipe_url":"` + stewPage + `"}`, "cuisine"},
-		{"manual read", breakRead, manual, "cuisine"},
-		{"manual store", breakStore, manual, "disk full"},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			t.Parallel()
-			e := newDinnersEnv(t).withRecipes(t)
-			id := createDinner(t, e.h, `{"name":"Sunday stew"}`)
-			if _, err := e.st.Writer.ExecContext(t.Context(), tc.sabotage); err != nil {
-				t.Fatal(err)
-			}
-
-			rec, body := callDinners(t, e.h, http.MethodPost, dinnersPath+"/"+id+"/ground", tc.fix)
-			if rec.Code != http.StatusInternalServerError || errorCode(body) != "internal" {
-				t.Errorf("POST = %d %s, want 500 internal", rec.Code, rec.Body)
-			}
-			logs := e.logs.String()
-			if strings.Contains(logs, tc.leak) || !strings.Contains(logs, "reason=ground_failed") || !strings.Contains(logs, "dinner_id="+id) {
-				t.Errorf("logs = %q, want reason=ground_failed and the dinner id, without the database error", logs)
-			}
-		})
-	}
-}
-
-// TestPostGroundArchived: grounding an archived dinner by hand is a 409.
-func TestPostGroundArchived(t *testing.T) {
-	t.Parallel()
-	e := newDinnersEnv(t)
-	id := createDinner(t, e.h, `{"name":"Family chili"}`)
-	if rec, _ := callDinners(t, e.h, http.MethodDelete, dinnersPath+"/"+id, ""); rec.Code != http.StatusOK {
-		t.Fatalf("DELETE = %d: %s", rec.Code, rec.Body)
-	}
-	rec, body := callDinners(t, e.h, http.MethodPost, dinnersPath+"/"+id+"/ground",
-		`{"manual":{"ingredients":["1 lb beef"],"minutes":240,"method":"crockpot"}}`)
-	if rec.Code != http.StatusConflict || errorCode(body) != "dinner_archived" {
-		t.Errorf("POST = %d %v, want 409 dinner_archived", rec.Code, body)
-	}
-}
-
 func TestPostGroundViaManual(t *testing.T) {
 	t.Parallel()
 	e := newDinnersEnv(t)
@@ -459,8 +256,7 @@ func TestPostGroundRejects(t *testing.T) {
 	for _, tc := range []struct{ name, body, code string }{
 		{"empty", `{}`, "invalid_dinner"},
 		{"two kinds", `{"candidate_id":"https://a.example/x","recipe_url":"https://a.example/x"}`, "invalid_dinner"},
-		{"candidate not offered", `{"candidate_id":"c1"}`, "invalid_dinner"},
-		{"candidate a page URL", `{"candidate_id":"https://a.example/x"}`, "invalid_dinner"},
+		{"candidate not a link", `{"candidate_id":"c1"}`, "invalid_dinner"},
 		{"http link", `{"recipe_url":"http://a.example/x"}`, "invalid_dinner"},
 		{"null", `{"recipe_url":null}`, "invalid_request"},
 		{"unknown field", `{"url":"https://a.example/x"}`, "invalid_request"},

migrations/queries/dinners.sql

@@ -84,33 +84,19 @@ RETURNING *;
 -- name: GroundDinner :one
 -- Records a dinner's grounding by hand (grounded or manual) and clears any
 -- grounding_error and pasted recipe_url: the recipe chosen replaces the
--- link. It writes only an unarchived dinner still as it was observed
--- before grounding (same name, normalized_name, grounding_status,
--- grounding_revision and recipe_id), so a dinner renamed, archived or
--- grounded some other way meanwhile is left as it is. That dinner, or an
--- unknown id, returns sql.ErrNoRows. A method, minutes_total or difficulty
--- no longer as observed is kept: a member edited it while it was grounding.
+-- link. An unknown id returns sql.ErrNoRows.
 UPDATE dinners
-SET recipe_id = sqlc.arg(recipe_id),
+SET recipe_id = ?,
 	recipe_url = NULL,
-	photo_id = sqlc.arg(photo_id),
-	method = CASE WHEN method IS sqlc.narg(observed_method)
-		THEN sqlc.arg(method) ELSE method END,
-	minutes_total = CASE WHEN minutes_total IS sqlc.narg(observed_minutes_total)
-		THEN sqlc.arg(minutes_total) ELSE minutes_total END,
-	difficulty = CASE WHEN difficulty IS sqlc.narg(observed_difficulty)
-		THEN sqlc.arg(difficulty) ELSE difficulty END,
-	grounding_status = sqlc.arg(grounding_status),
+	photo_id = ?,
+	method = ?,
+	minutes_total = ?,
+	difficulty = ?,
+	grounding_status = ?,
 	grounding_error = NULL,
-	updated_by = sqlc.arg(updated_by),
-	updated_at = sqlc.arg(updated_at)
-WHERE id = sqlc.arg(id)
-	AND status <> 'archived'
-	AND name = sqlc.arg(observed_name)
-	AND normalized_name = sqlc.arg(observed_normalized_name)
-	AND grounding_status = sqlc.arg(observed_grounding_status)
-	AND grounding_revision = sqlc.arg(observed_grounding_revision)
-	AND recipe_id IS sqlc.narg(observed_recipe_id)
+	updated_by = ?,
+	updated_at = ?
+WHERE id = ?
 RETURNING *;
 
 -- name: GroundPendingDinner :execrows
@@ -118,11 +104,9 @@ RETURNING *;
 -- the grounding_revision it was grounded for; a dinner grounded some other
 -- way, renamed or archived meanwhile is left as it is (0 rows). A method,
 -- minutes_total or difficulty already set is kept: a pending dinner has
--- them only when a member edited them while it was grounding. Like
--- GroundDinner it clears the pasted recipe_url: the recipe replaces the link.
+-- them only when a member edited them while it was grounding.
 UPDATE dinners
 SET recipe_id = sqlc.arg(recipe_id),
-	recipe_url = NULL,
 	photo_id = sqlc.arg(photo_id),
 	method = COALESCE(method, sqlc.arg(method)),
 	minutes_total = COALESCE(minutes_total, sqlc.arg(minutes_total)),

web/src/App.test.tsx

@@ -1,4 +1,4 @@
-import { act, cleanup, render, screen } from '@testing-library/react'
+import { act, render, screen } from '@testing-library/react'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { createApiClient, createVerifiedSession } from './api/index.ts'
 import { createNetworkStatus } from './pwa/networkStatus.ts'
@@ -236,13 +236,6 @@ describe('App offline bootstrap', () => {
     vi.spyOn(navigator, 'onLine', 'get').mockImplementation(() => onLine)
   })
 
-  // A test that emits an offline event leaves TanStack Query's online
-  // manager, shared by every test, offline until an online event.
-  afterEach(() => {
-    cleanup()
-    window.dispatchEvent(new Event('online'))
-  })
-
   it.each([
     ['/plan', 'Plan'],
     ['/dinner/01J9ZK', 'Dinner'],
@@ -257,31 +250,6 @@ describe('App offline bootstrap', () => {
     expect(screen.queryByRole('alert')).not.toBeInTheDocument()
   })
 
-  it('opens the saved page when the browser has emitted an offline event', async () => {
-    await visitOnline()
-    // /me is still loading, with the app mounted, when the browser emits
-    // its offline event; only then does /me fail.
-    let failMe!: () => void
-    vi.stubGlobal(
-      'fetch',
-      vi.fn<typeof fetch>().mockImplementationOnce(
-        () => new Promise((_, reject) => (failMe = () => reject(new TypeError('Failed to fetch')))),
-      ).mockRejectedValue(new TypeError('Failed to fetch')),
-    )
-    renderAt('/plan')
-    await vi.waitFor(() => expect(failMe).toBeDefined())
-    onLine = false
-    act(() => {
-      window.dispatchEvent(new Event('offline'))
-    })
-    act(() => failMe())
-
-    expect(await screen.findByRole('heading', { level: 1, name: 'Plan' })).toBeInTheDocument()
-    expect(screen.queryByRole('main', { name: 'Loading MealQuest' })).not.toBeInTheDocument()
-    expect(screen.getByRole('status')).toHaveTextContent('Offline — showing saved data')
-    expect(screen.queryByRole('alert')).not.toBeInTheDocument()
-  })
-
   it('opens the saved pages when the server is unreachable but the browser reports online', async () => {
     await visitOnline()
     vi.stubGlobal('fetch', vi.fn<typeof fetch>().mockRejectedValue(new TypeError('Failed to fetch')))

web/src/dinners/api.ts

@@ -33,10 +33,8 @@ export type Regular = {
   pending?: true
 }
 
-// NewRegular is a POST /api/v1/dinners body: the household's name for the
-// dinner, with the recipe link to ground it in when one was pasted. A
-// dinner is never named from its link, which may carry private details.
-export type NewRegular = { name: string; recipe_url?: string }
+// NewRegular is a POST /api/v1/dinners body: a name or a recipe link.
+export type NewRegular = { name: string } | { recipe_url: string }
 
 // RegularPatch is a PATCH /api/v1/dinners/{id} body; every field is optional.
 export type RegularPatch = Partial<{ name: string; method: Method; minutes_total: number; difficulty: Difficulty }>
@@ -197,9 +195,10 @@ function settle(queryClient: QueryClient) {
 
 let pendingIds = 0
 
-// useAddRegular adds a Regular by name, with or without a recipe link (POST
-// /api/v1/dinners). It shows in the list at once under its name and is
-// taken out again if the server refuses it.
+// useAddRegular adds a Regular by name or recipe link (POST
+// /api/v1/dinners). It shows in the list at once — a link under the link
+// itself until the server names it — and is taken out again if the server
+// refuses it.
 export function useAddRegular() {
   const { apiFetch } = useApi()
   const queryClient = useQueryClient()
@@ -211,7 +210,7 @@ export function useAddRegular() {
       const id = `pending-${++pendingIds}`
       const optimistic: CachedRegular = {
         id,
-        name: add.name,
+        name: 'name' in add ? add.name : add.recipe_url,
         method: null,
         minutes_total: null,
         difficulty: null,

web/src/dinners/names.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest'
-import cases from './testdata/dedupe_cases.json'
+import cases from '../../../internal/ai/harness/testdata/dedupe_cases.json'
 import { normalizeName, similarNames } from './names.ts'
 
 // The cases internal/ai/harness's tests run against Normalize and Similar.

web/src/dinners/names.ts

@@ -1,7 +1,7 @@
 // The PWA's copy of the server's dinner-name rules (internal/ai/harness
 // Normalize and Similar), so a screen can tell beforehand that the dinners
 // API would refuse a name as a duplicate. The server still decides.
-// web/src/dinners/testdata/dedupe_cases.json is run against both.
+// internal/ai/harness/testdata/dedupe_cases.json is run against both.
 
 import folds from './letterFolds.json'
 

web/src/onboarding/NotificationsStep.test.tsx

@@ -180,22 +180,10 @@ describe('onboarding step 3', () => {
     expect(requestPermission).not.toHaveBeenCalled()
   })
 
-  it('"Turn on notifications" says plainly that nothing was turned on while notifications are unavailable', async () => {
+  it('"Turn on notifications" finishes onboarding and goes Home while notifications are unavailable', async () => {
     const server = await renderApp()
     fireEvent.click(turnOn())
 
-    expect(await screen.findByRole('status')).toHaveTextContent(
-      "Notifications aren't on yet: MealQuest can't send them until the notification feature ships, so nothing was turned on.",
-    )
-    // Not a silent success: onboarding is not finished behind the household's back.
-    expect(server.held).toHaveLength(0)
-    expect(screen.getByRole('heading', { level: 1, name: 'Stay in the loop' })).toBeInTheDocument()
-    expect(screen.queryByRole('button', { name: 'Turn on notifications' })).not.toBeInTheDocument()
-    expect(screen.queryByRole('button', { name: 'Maybe later' })).not.toBeInTheDocument()
-
-    const finish = screen.getByRole('button', { name: 'Finish setting up' })
-    expectMinHitArea(finish)
-    fireEvent.click(finish)
     await vi.waitFor(() => expect(server.held).toHaveLength(1))
     expect(server.held[0]!.body).toEqual({ onboarding_completed: true })
     completed(server.held[0]!)
@@ -205,19 +193,6 @@ describe('onboarding step 3', () => {
     expect(requestPermission).not.toHaveBeenCalled()
   })
 
-  it('"Turn on notifications" says the browser blocked them when denied, then finishes on request', async () => {
-    const server = await renderStep(() => Promise.resolve('denied'))
-    fireEvent.click(turnOn())
-
-    expect(await screen.findByRole('status')).toHaveTextContent("Notifications aren't on: this browser blocked them.")
-    expect(server.held).toHaveLength(0)
-
-    fireEvent.click(screen.getByRole('button', { name: 'Finish setting up' }))
-    await vi.waitFor(() => expect(server.held).toHaveLength(1))
-    completed(server.held[0]!)
-    expect(await screen.findByRole('heading', { level: 1, name: 'Home' })).toBeInTheDocument()
-  })
-
   it('"Turn on notifications" asks the injected enableNotifications first, then finishes', async () => {
     let answer: (result: 'enabled') => void = () => {}
     const enable = vi.fn<EnableNotifications>(

web/src/onboarding/NotificationsStep.tsx

@@ -14,21 +14,11 @@ export type NotificationsResult = 'enabled' | 'denied' | 'unavailable'
 export type EnableNotifications = () => Promise<NotificationsResult>
 
 // TODO(Feature 19): Web Push. Until it is wired, notifications cannot be
-// turned on, and nothing asks the browser for permission. This placeholder
-// is the interim state: "Turn on notifications" answers 'unavailable', and
-// the step tells the household plainly that nothing was turned on.
+// turned on, and nothing asks the browser for permission.
 export function notificationsUnavailable(): Promise<NotificationsResult> {
   return Promise.resolve('unavailable')
 }
 
-// notOnReasons says why notifications are not on after asking, for each
-// result other than 'enabled'.
-const notOnReasons: Record<Exclude<NotificationsResult, 'enabled'>, string> = {
-  unavailable:
-    "Notifications aren't on yet: MealQuest can't send them until the notification feature ships, so nothing was turned on. You can finish setting up now.",
-  denied: "Notifications aren't on: this browser blocked them. You can allow them in the browser's settings later.",
-}
-
 const topics: { icon: LucideIcon; name: string; meaning: string }[] = [
   {
     icon: CalendarDays,
@@ -59,19 +49,16 @@ export type NotificationsStepProps = {
 }
 
 // NotificationsStep is onboarding step 3: what MealQuest notifies about, the
-// iOS install hint, and finishing onboarding. "Maybe later", and "Turn on
-// notifications" once they are enabled, record that onboarding is finished
-// and go Home. When they are not enabled, the step says so and offers only
-// "Finish setting up". When the server refuses because the household has
-// fewer than three Regulars, the reason shows with a way back to step 2 to
-// add them.
+// iOS install hint, and finishing onboarding. Either button records that
+// onboarding is finished and goes Home. When the server refuses because the
+// household has fewer than three Regulars, the reason shows with a way back
+// to step 2 to add them.
 export function NotificationsStep({ enableNotifications = notificationsUnavailable }: NotificationsStepProps) {
   const navigate = useNavigate()
   const complete = useCompleteOnboarding()
   const [enabling, setEnabling] = useState(false)
   const [problem, setProblem] = useState<string | null>(null)
   const [fewRegulars, setFewRegulars] = useState(false)
-  const [notOn, setNotOn] = useState<string | null>(null)
   const busy = enabling || complete.isPending
 
   async function finish() {
@@ -93,19 +80,14 @@ export function NotificationsStep({ enableNotifications = notificationsUnavailab
   async function turnOn() {
     clearProblem()
     setEnabling(true)
-    let result: NotificationsResult
     try {
-      result = await enableNotifications()
+      await enableNotifications()
     } catch (error) {
       setProblem(`Could not turn on notifications: ${(error as Error).message}`)
       return
     } finally {
       setEnabling(false)
     }
-    if (result !== 'enabled') {
-      setNotOn(notOnReasons[result])
-      return
-    }
     await finish()
   }
 
@@ -119,22 +101,14 @@ export function NotificationsStep({ enableNotifications = notificationsUnavailab
       step={3}
       title="Stay in the loop"
       action={
-        notOn ? (
-          <div className={styles.actions}>
-            <Button className={styles.action} disabled={busy} onClick={later}>
-              Finish setting up
-            </Button>
-          </div>
-        ) : (
-          <div className={styles.actions}>
-            <Button className={styles.action} disabled={busy} onClick={() => void turnOn()}>
-              Turn on notifications
-            </Button>
-            <Button variant="outline" className={styles.action} disabled={busy} onClick={later}>
-              Maybe later
-            </Button>
-          </div>
-        )
+        <div className={styles.actions}>
+          <Button className={styles.action} disabled={busy} onClick={() => void turnOn()}>
+            Turn on notifications
+          </Button>
+          <Button variant="outline" className={styles.action} disabled={busy} onClick={later}>
+            Maybe later
+          </Button>
+        </div>
       }
     >
       <p className={styles.helper}>MealQuest can let the household know when there&apos;s something to look at:</p>
@@ -154,11 +128,6 @@ export function NotificationsStep({ enableNotifications = notificationsUnavailab
       <div className={styles.hint}>
         <InstallHint />
       </div>
-      {notOn && (
-        <p role="status" className={styles.notOn}>
-          {notOn}
-        </p>
-      )}
       {problem && (
         <p role="alert" className={styles.problem}>
           {problem}

web/src/onboarding/Onboarding.module.css

@@ -229,18 +229,6 @@
   color: var(--color-accent-700);
 }
 
-/* Step 3: why notifications are not on after asking for them. */
-.notOn {
-  margin: var(--space-4) 0 0;
-  padding: var(--space-4);
-  border-radius: var(--radius-lg);
-  background: var(--color-surface);
-  font-family: var(--font-body);
-  font-size: 15px;
-  line-height: 1.4;
-  color: var(--color-text);
-}
-
 /* Step 3: back to step 2 when the server wants more Regulars. */
 .recover {
   margin-top: var(--space-3);

web/src/onboarding/OnboardingGate.tsx

@@ -19,8 +19,7 @@ function inOnboarding(pathname: string): boolean {
 // The service worker never caches the settings, so offline on the saved
 // pages (see AuthBootstrap) they cannot be read: the saved pages open as they
 // are, since onboarding needs the server anyway, and the settings are read
-// again when the browser is back online. The read runs even while the
-// browser reports offline, so that case fails fast instead of waiting.
+// again when the browser is back online.
 export function OnboardingGate() {
   const api = useApi()
   const { pathname } = useLocation()

web/src/settings/RegularsSettingsPage.module.css

@@ -43,13 +43,6 @@
   font-weight: 700;
 }
 
-/* The add form: the add row, then the name field a pasted link needs. */
-.addForm {
-  display: flex;
-  flex-direction: column;
-  gap: 8px;
-}
-
 /* The add field: the input fills the row beside the grape + button. */
 .add {
   display: flex;

web/src/settings/RegularsSettingsPage.test.tsx

@@ -192,33 +192,21 @@ describe('RegularsSettingsPage', () => {
     expect(screen.getByRole('heading', { level: 2, name: 'On rotation · 2' })).toBeInTheDocument()
   })
 
-  it('adds a Regular from a pasted recipe link under the name the household gives it', async () => {
-    const link = 'https://example.com/recipes/stew-key-abcdefghijklmno'
+  it('adds a Regular from a pasted recipe link', async () => {
+    const link = 'https://example.com/recipes/12345/beef-stew/'
     const server = stubServer([], {
-      'POST /api/v1/dinners': (body) => {
-        const created = dinnerBody('d9', (body as { name: string }).name, { grounding_status: 'pending' })
+      'POST /api/v1/dinners': () => {
+        const created = dinnerBody('d9', 'Beef stew', { grounding_status: 'pending', recipe_url: link })
         server.regulars = [created]
         return jsonResponse(201, { ...created, grounding_job_id: 'job-1' })
       },
     })
     await renderPage()
 
-    fireEvent.change(addField(), { target: { value: ` ${link} ` } })
-    // A link alone cannot be added: it never names a dinner.
-    expect(screen.getByRole('button', { name: 'Add Regular' })).toBeDisabled()
-    const name = screen.getByRole('textbox', { name: 'Dinner name' })
-    expect(name).toHaveAccessibleDescription(/never names a dinner/)
-    fireEvent.change(name, { target: { value: ' Sunday stew ' } })
-    fireEvent.click(screen.getByRole('button', { name: 'Add Regular' }))
-
-    expect(addField()).toHaveValue('')
-    expect(screen.queryByRole('textbox', { name: 'Dinner name' })).not.toBeInTheDocument()
-    expect(await screen.findByText('Sunday stew')).toBeInTheDocument()
-    expect(sent(server.fetchMock)).toEqual([
-      { request: 'POST /api/v1/dinners', body: { name: 'Sunday stew', recipe_url: link } },
-    ])
-    expect(within(row('Sunday stew')).getByText('Finding recipe…')).toBeInTheDocument()
-    expect(document.body).not.toHaveTextContent(/example\.com|abcdefghijklmno|key/i)
+    add(link)
+    expect(await screen.findByText('Beef stew')).toBeInTheDocument()
+    expect(sent(server.fetchMock)).toEqual([{ request: 'POST /api/v1/dinners', body: { recipe_url: link } }])
+    expect(within(row('Beef stew')).getByText('Finding recipe…')).toBeInTheDocument()
   })
 
   it('takes back an add the server refuses and says why', async () => {

web/src/settings/RegularsSettingsPage.tsx

@@ -49,14 +49,12 @@ export const methodLabels: Record<Method, string> = {
 
 const difficultyLabels: Record<Difficulty, string> = { easy: 'Easy', medium: 'Medium', hard: 'Hard' }
 
-// A pasted link is added as a recipe link under a name the household gives;
-// anything else is a dinner name.
+// A pasted link is added as a recipe link; anything else is a dinner name.
 const LINK = /^https?:\/\//i
 
 // Settings · Regular dinners: the household's Regulars, each with its photo,
 // method and minutes, favorite heart and whether its recipe was found. The
-// field at the top adds one by name, or by pasted recipe link with a name
-// the household gives it; tapping one
+// field at the top adds one by name or pasted recipe link; tapping one
 // edits or removes it, or fixes its recipe when none was found.
 export function RegularsSettingsPage() {
   const navigate = useNavigate()
@@ -87,24 +85,19 @@ function RegularsManager() {
   const favorite = useToggleFavorite()
   const { refusals, track } = useRefusals()
   const [draft, setDraft] = useState('')
-  const [linkName, setLinkName] = useState('')
   const [open, setOpen] = useState<Open>(null)
   const headingId = useId()
-  const linkHintId = useId()
-  const isLink = LINK.test(draft.trim())
-  const ready = draft.trim() !== '' && (!isLink || linkName.trim() !== '')
   const list = regulars.data ?? []
   // A Regular removed meanwhile closes its sheet.
   const opened = open && list.find((regular) => regular.id === open.id && !regular.pending)
 
   function onSubmit(event: FormEvent<HTMLFormElement>) {
     event.preventDefault()
-    if (!ready) return
     const text = draft.trim()
-    const body: NewRegular = isLink ? { name: linkName.trim(), recipe_url: text } : { name: text }
-    track(`add:${body.name.toLowerCase()}`, `add ${body.name}`, add.mutateAsync(body))
+    if (text === '') return
+    const body: NewRegular = LINK.test(text) ? { recipe_url: text } : { name: text }
+    track(`add:${text.toLowerCase()}`, `add ${text}`, add.mutateAsync(body))
     setDraft('')
-    setLinkName('')
   }
 
   function onRemove(regular: Regular) {
@@ -118,38 +111,20 @@ function RegularsManager() {
 
   return (
     <>
-      <form className={styles.addForm} onSubmit={onSubmit}>
-        <div className={styles.add}>
-          <TextInput
-            label="Add a Regular"
-            labelHidden
-            className={styles.addInput}
-            placeholder="Dinner name or recipe link"
-            autoComplete="off"
-            enterKeyHint="done"
-            value={draft}
-            onChange={(event) => setDraft(event.target.value)}
-          />
-          <IconButton type="submit" label="Add Regular" tone="accent" disabled={!ready}>
-            <Icon icon={Plus} size="nav" />
-          </IconButton>
-        </div>
-        {isLink && (
-          <>
-            <TextInput
-              label="Dinner name"
-              placeholder="What do you call this dinner?"
-              autoComplete="off"
-              enterKeyHint="done"
-              aria-describedby={linkHintId}
-              value={linkName}
-              onChange={(event) => setLinkName(event.target.value)}
-            />
-            <p id={linkHintId} className={styles.hint}>
-              Name it yourself: a link can carry private details, so it never names a dinner.
-            </p>
-          </>
-        )}
+      <form className={styles.add} onSubmit={onSubmit}>
+        <TextInput
+          label="Add a Regular"
+          labelHidden
+          className={styles.addInput}
+          placeholder="Dinner name or recipe link"
+          autoComplete="off"
+          enterKeyHint="done"
+          value={draft}
+          onChange={(event) => setDraft(event.target.value)}
+        />
+        <IconButton type="submit" label="Add Regular" tone="accent" disabled={draft.trim() === ''}>
+          <Icon icon={Plus} size="nav" />
+        </IconButton>
       </form>
       {refusals.map((refusal) => (
         <p key={refusal.key} role="alert" className={styles.problem}>

web/src/settings/api.ts

@@ -367,16 +367,12 @@ function parseHouseholdSettings(where: string, body: unknown): HouseholdSettings
 
 export const HOUSEHOLD_SETTINGS_KEY = ['settings', 'household'] as const
 
-// useHouseholdSettings runs even while the browser reports offline, like
-// /me: OnboardingGate reads it before every page, so offline it must fail
-// into the saved pages instead of waiting for the network.
 export function useHouseholdSettings() {
   const { apiFetch } = useApi()
   return useQuery({
     queryKey: HOUSEHOLD_SETTINGS_KEY,
     queryFn: async () =>
       parseHouseholdSettings(`GET ${HOUSEHOLD_SETTINGS_PATH}`, await apiFetch<unknown>(HOUSEHOLD_SETTINGS_PATH)),
-    networkMode: 'always',
   })
 }
 

web/src/sw.test.ts

@@ -1,52 +0,0 @@
-// Runs the service worker's activate handler against mocked Cache Storage,
-// with the Workbox precache and router stubbed out. tsconfig.sw.json checks
-// this file with the worker's types, like src/sw.ts itself.
-import { afterEach, describe, expect, it, vi } from 'vitest'
-
-vi.mock('workbox-precaching', () => ({
-  PrecacheFallbackPlugin: class {},
-  matchPrecache: vi.fn(),
-  precacheAndRoute: vi.fn(),
-}))
-vi.mock('workbox-routing', () => ({ registerRoute: vi.fn() }))
-
-describe('service worker activation', () => {
-  afterEach(() => {
-    vi.unstubAllGlobals()
-  })
-
-  it('deletes the v1 and v2 API caches and keeps the current caches', async () => {
-    // A household that ran the v1 and v2 workers: the v1 API cache held
-    // dinners with the pasted recipe_url, the v2 one recipe candidates whose
-    // candidate_id was the full URL. Its photos and fonts are not in the
-    // precache, and the current API cache may already exist.
-    const names = [
-      'mealquest-precache-v1',
-      'mealquest-api-v1',
-      'mealquest-api-v2',
-      'mealquest-api-v3',
-      'mealquest-media-v1',
-      'mealquest-fonts-v1',
-      'other-app-cache',
-    ]
-    const cacheStorage = {
-      keys: vi.fn(async () => names),
-      delete: vi.fn(async () => true),
-    }
-    vi.stubGlobal('caches', cacheStorage)
-    vi.stubGlobal('__WB_MANIFEST', [])
-    await import('./sw')
-
-    const pending: Promise<unknown>[] = []
-    const activate = Object.assign(new Event('activate'), {
-      waitUntil: (promise: Promise<unknown>) => pending.push(promise),
-    })
-    self.dispatchEvent(activate)
-    await Promise.all(pending)
-
-    expect(pending).toHaveLength(1)
-    expect(cacheStorage.delete).toHaveBeenCalledWith('mealquest-api-v1')
-    expect(cacheStorage.delete).toHaveBeenCalledWith('mealquest-api-v2')
-    expect(cacheStorage.delete).toHaveBeenCalledTimes(2)
-  })
-})

web/src/sw.ts

@@ -18,7 +18,7 @@ import { CacheFirst, NetworkOnly, type Strategy } from 'workbox-strategies'
 import { createApiStrategy } from './sw/apiStrategy'
 import {
   cacheNames,
-  cacheVersions,
+  cacheVersion,
   routeFor,
   staleCaches,
   type Route,
@@ -29,7 +29,7 @@ declare const self: ServiceWorkerGlobalScope & {
 }
 
 // The precache becomes mealquest-precache-v1.
-setCacheNameDetails({ prefix: 'mealquest', precache: 'precache', suffix: cacheVersions.precache })
+setCacheNameDetails({ prefix: 'mealquest', precache: 'precache', suffix: cacheVersion })
 
 const day = 24 * 60 * 60
 

web/src/sw/routes.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest'
-import { cacheFallbackHeader, cacheNames, cacheVersions, markCacheFallback, routeFor, staleCaches, type Route } from './routes'
+import { cacheFallbackHeader, cacheNames, markCacheFallback, routeFor, staleCaches, type Route } from './routes'
 
 const origin = 'https://mealquest.test'
 
@@ -146,19 +146,6 @@ describe('cache names', () => {
   it('all start with mealquest-', () => {
     for (const name of Object.values(cacheNames)) expect(name).toMatch(/^mealquest-/)
   })
-
-  it('retire only the v1 and v2 API caches', () => {
-    // v1 API responses held dinners with the pasted recipe_url and v2 ones
-    // recipe candidates whose candidate_id was the full URL; either can carry
-    // a personal token, and offline the worker would still serve them.
-    // The precache, photos and fonts keep their v1 caches.
-    expect(cacheNames).toEqual({
-      api: 'mealquest-api-v3',
-      media: 'mealquest-media-v1',
-      fonts: 'mealquest-fonts-v1',
-    })
-    expect(cacheVersions.precache).toBe('v1')
-  })
 })
 
 describe('staleCaches', () => {

web/src/sw/routes.ts

@@ -24,24 +24,14 @@ export interface RouteRequest {
   mode: RequestMode
 }
 
-// Each cache carries its own version. Bumping one renames only that cache;
-// activate then deletes its old name and keeps every other cache, so saved
-// photos and fonts stay available offline.
-export const cacheVersions = {
-  precache: 'v1',
-  // v2 retired the v1 API cache, whose dinner responses still carried the
-  // pasted recipe_url; v3 retires the v2 API cache, whose recipe-candidate
-  // responses used the full URL as candidate_id.
-  api: 'v3',
-  media: 'v1',
-  fonts: 'v1',
-} as const
+// Bumping the version renames every cache; activate then deletes the old ones.
+export const cacheVersion = 'v1'
 export const cachePrefix = 'mealquest-'
 
 export const cacheNames = {
-  api: `${cachePrefix}api-${cacheVersions.api}`,
-  media: `${cachePrefix}media-${cacheVersions.media}`,
-  fonts: `${cachePrefix}fonts-${cacheVersions.fonts}`,
+  api: `${cachePrefix}api-${cacheVersion}`,
+  media: `${cachePrefix}media-${cacheVersion}`,
+  fonts: `${cachePrefix}fonts-${cacheVersion}`,
 } as const
 
 export const networkTimeoutSeconds = 3

web/src/sw/worker.test.ts

@@ -2,7 +2,6 @@
 // source: they pin the parts routes.ts cannot express — the API cache's
 // strategy, the font strategy's expiration, the font route's place ahead of
 // the precache route and network-only requests left to the browser.
-// src/sw.test.ts runs the worker's activation against mocked Cache Storage.
 import { describe, expect, it } from 'vitest'
 import source from '../sw.ts?raw'
 

web/src/test/dinners.ts

@@ -10,6 +10,7 @@ export type DinnerBody = {
   cuisine: string | null
   is_favorite: boolean
   recipe_id: string | null
+  recipe_url: string | null
   photo_url: string | null
   grounding_status: string
   grounding_error: string | null
@@ -32,6 +33,7 @@ export function dinnerBody(id: string, name: string, overrides: Partial<DinnerBo
     cuisine: null,
     is_favorite: false,
     recipe_id: null,
+    recipe_url: null,
     photo_url: null,
     grounding_status: 'grounded',
     grounding_error: null,

web/tsconfig.json

@@ -19,5 +19,5 @@
     "noEmit": true
   },
   "include": ["src", "vite.config.ts", "manifest.json"],
-  "exclude": ["src/sw.ts", "src/sw.test.ts"]
+  "exclude": ["src/sw.ts"]
 }

web/tsconfig.sw.json

@@ -4,6 +4,6 @@
     "lib": ["ES2022", "WebWorker"],
     "types": []
   },
-  "include": ["src/sw.ts", "src/sw.test.ts"],
+  "include": ["src/sw.ts"],
   "exclude": []
 }