Log every unexpected recipe grounding failure by fixed reason

Wrap an initial dinner read failure on the candidate and link path, and
any manual-recipe read, store or write failure, in ErrGroundFailed so the
handler logs only reason=ground_failed and the dinner id, never database
text. Not-found, archived and conflict answers stay distinct.

Strengthen TestFixInFlightKeepsMemberEdits: start from populated method,
minutes and difficulty, edit each in flight in turn, and require the edit
kept and the untouched populated fields replaced by the recipe's values.

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,19 +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. An
-  unknown dinner is 404, recipe search not set up 409 `not_configured` and
-  a search failure 502 `search_failed`; any other failure, such as a
-  stored recipe that cannot be read, is 500, logged with a fixed reason
-  and the dinner id only — never a candidate's URL or dependency error
-  text.
-  `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
@@ -528,11 +517,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
@@ -541,10 +530,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

@@ -347,7 +347,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 +375,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

@@ -80,8 +80,7 @@ type Querier interface {
 	// 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"
@@ -85,11 +81,6 @@ var ErrGroundTimeout = errors.New("dinners: grounding the recipe took too long")
 // logged.
 var ErrGroundFailed = errors.New("dinners: grounding the recipe failed")
 
-// ErrCandidatesFailed wraps any unexpected failure finding a dinner's
-// candidates. Its text may quote a candidate's URL and dependency errors,
-// so it is never logged.
-var ErrCandidatesFailed = errors.New("dinners: finding recipe candidates failed")
-
 // ErrArchived is grounding an archived dinner by hand.
 var ErrArchived = errors.New("dinner archived")
 
@@ -291,9 +282,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"`
@@ -302,182 +291,29 @@ 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
-// missing dinner is ErrNotFound; any other failure wraps
-// ErrCandidatesFailed, and a search that fails also wraps
-// recipes.ErrSearchFailed.
+// 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 errors.Is(err, ErrNotFound) {
-		return nil, err
-	}
 	if err != nil {
-		return nil, fmt.Errorf("%w: dinner %s: %w", ErrCandidatesFailed, id, err)
+		return nil, err
 	}
 	offers, err := s.grounder.Candidates(ctx, row.Name, row.Name, MaxCandidates)
 	if err != nil {
-		return nil, fmt.Errorf("%w: dinner %s: %w", ErrCandidatesFailed, id, err)
+		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 {
@@ -531,11 +367,6 @@ func (s *Service) Ground(ctx context.Context, id string, f Fix, updatedBy string
 	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)
@@ -570,7 +401,6 @@ func (s *Service) Ground(ctx context.Context, id string, f Fix, updatedBy string
 	if err != nil {
 		return Dinner{}, fmt.Errorf("%w: dinner %s: record: %w", ErrGroundFailed, id, err)
 	}
-	s.clearOffers(cur.ID, math.MaxInt64)
 	return fromRow(row), nil
 }
 
@@ -592,10 +422,9 @@ func (s *Service) groundRejected(ctx context.Context, id string) error {
 }
 
 // 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. A missing
+// or archived dinner is ErrNotFound or ErrArchived; any other failure
+// wraps ErrGroundFailed.
 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 {
@@ -693,7 +522,6 @@ func (s *Service) groundManual(ctx context.Context, id string, m ManualRecipe, u
 	if err != nil {
 		return Dinner{}, fmt.Errorf("%w: dinner %s: %w", ErrGroundFailed, id, err)
 	}
-	s.clearOffers(row.ID, math.MaxInt64)
 	return fromRow(row), nil
 }
 
@@ -722,8 +550,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")}},

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"`
@@ -205,8 +204,7 @@ func actorOrFail(w http.ResponseWriter, r *http.Request, logger *slog.Logger) (a
 // 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, as is any other failure finding candidates, which
-// wraps dinners.ErrCandidatesFailed.
+// and dinner id only.
 func writeDinnerError(w http.ResponseWriter, r *http.Request, logger *slog.Logger, action string, err error) {
 	var invalid *dinners.ValidationError
 	var dup *dinners.DuplicateError
@@ -232,12 +230,6 @@ func writeDinnerError(w http.ResponseWriter, r *http.Request, logger *slog.Logge
 		// 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.ErrCandidatesFailed):
-		// The error may quote a candidate's URL, which can carry a
-		// personal token, and dependency errors, so only the reason and
-		// dinner are logged.
-		logger.ErrorContext(r.Context(), action, "reason", "candidates_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):

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,
@@ -204,65 +180,13 @@ func TestGetRecipeCandidatesSearchFails(t *testing.T) {
 	}
 }
 
-// TestGetRecipeCandidatesStoredLookupFailure: a candidate whose stored
-// recipe cannot be read, or is stored incomplete, is a 500 logged by reason
-// and dinner id, never with the candidate's URL, which can carry a personal
-// token, or the database error.
-func TestGetRecipeCandidatesStoredLookupFailure(t *testing.T) {
-	t.Parallel()
-	const (
-		token = "personal-token-abc123"
-		host  = "secret-candidate.example"
-		page  = "https://" + host + "/curry?access_token=" + token
-	)
-	for _, tc := range []struct {
-		name, sabotage string
-		leaks          []string
-	}{
-		// Renaming a column the lookup selects fails the read.
-		{"lookup", `ALTER TABLE recipes RENAME COLUMN yield TO yield_gone`, []string{"no such column", "yield"}},
-		// A recipe stored without its photo, method or difficulty is
-		// incomplete.
-		{"incomplete", `INSERT INTO recipes (id, source_url, title, raw_jsonld, fetched_at, created_at, updated_at)
-			VALUES ('r-incomplete', '` + page + `', 'Curry', '{}', 'now', 'now', 'now')`, []string{"r-incomplete", "no photo"}},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			t.Parallel()
-			e := newDinnersEnv(t)
-			e.search.Results["Chicken curry"] = []recipes.Candidate{{URL: page}}
-			id := createDinner(t, e.h, `{"name":"Chicken curry"}`) // runner not started: stays pending
-			if _, err := e.st.Writer.ExecContext(t.Context(), tc.sabotage); err != nil {
-				t.Fatal(err)
-			}
-
-			rec, body := callDinners(t, e.h, http.MethodGet, dinnersPath+"/"+id+"/recipe-candidates", "")
-			if rec.Code != http.StatusInternalServerError || errorCode(body) != "internal" {
-				t.Errorf("GET = %d %s, want 500 internal", rec.Code, rec.Body)
-			}
-			logs := e.logs.String()
-			for _, secret := range append([]string{page, host, token, "access_token"}, tc.leaks...) {
-				if strings.Contains(rec.Body.String(), secret) {
-					t.Errorf("response contains %q: %s", secret, rec.Body)
-				}
-				if strings.Contains(logs, secret) {
-					t.Errorf("logs contain %q: %s", secret, logs)
-				}
-			}
-			if !strings.Contains(logs, "reason=candidates_failed") || !strings.Contains(logs, "dinner_id="+id) {
-				t.Errorf("logs = %q, want reason=candidates_failed and the dinner id", logs)
-			}
-		})
-	}
-}
-
 func TestPostGroundViaCandidate(t *testing.T) {
 	t.Parallel()
 	e := newDinnersEnv(t).withRecipes(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)
 	}
@@ -274,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)
@@ -510,8 +365,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

@@ -118,11 +118,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": []
 }