Spec #164: A sixth outcome word: not_found splits out of errors

backend/internal/latest/poller.go

@@ -273,7 +273,8 @@ const (
 // (issue #141). The classification the read already makes is counted, never a
 // second taxonomy: refused is the Site holding a challenge, unreachable the
 // browser interrupting, noChapter a 200 with real HTML but no chapter links,
-// unfetchable the host pin or a missing fetcher, and errors everything else.
+// unfetchable the host pin or a missing fetcher, notFound a 4xx other than
+// the 403 refusal — the page is gone — and errors everything else.
 type readOutcome int
 
 const (
@@ -283,14 +284,15 @@ const (
 	outcomeNoChapter
 	outcomeUnfetchable
 	outcomeError
+	outcomeNotFound
 )
 
-// outcomeCounts are the five named outcome counts of one pass. A success
-// count is derived, never stored: checked minus the four, with unreachable
-// excluded because the sidecar-loss path returns before the checked counter
-// increments (issue #141).
+// outcomeCounts are the six named outcome counts of one pass. A success
+// count is derived, never stored: checked minus the five named failures,
+// with unreachable excluded because the sidecar-loss path returns before the
+// checked counter increments (issue #141).
 type outcomeCounts struct {
-	refused, unreachable, noChapter, unfetchable, errors int
+	refused, unreachable, noChapter, unfetchable, errors, notFound int
 }
 
 func (c *outcomeCounts) add(o readOutcome) {
@@ -303,6 +305,8 @@ func (c *outcomeCounts) add(o readOutcome) {
 		c.noChapter++
 	case outcomeUnfetchable:
 		c.unfetchable++
+	case outcomeNotFound:
+		c.notFound++
 	case outcomeError:
 		c.errors++
 	}
@@ -517,6 +521,7 @@ func (p *Poller) recordPass(rec passRecord, fig passFigures) {
 		Unreachable: rec.counts.unreachable,
 		NoChapter:   rec.counts.noChapter,
 		Unfetchable: rec.counts.unfetchable,
+		NotFound:    rec.counts.notFound,
 		Errors:      rec.counts.errors,
 	}
 	if row.GapMS == 0 {
@@ -612,8 +617,8 @@ func maxSeriesWait(due []store.Series, now time.Time, rest time.Duration) time.D
 // the poller is a best-effort enhancement, and no single bad series may stall a
 // Lane or take down the process. The returned outcome classifies the read for
 // the pass row (issue #141), so the Lane can count a refusal, a lost browser,
-// a chapter-less page, an unfetchable address or a transport error without
-// re-deriving the taxonomy.
+// a chapter-less page, an unfetchable address, a missing page or a transport
+// error without re-deriving the taxonomy.
 func (p *Poller) checkOne(ctx context.Context, sr store.Series) (outcome readOutcome) {
 	defer func() {
 		if r := recover(); r != nil {
@@ -657,6 +662,10 @@ func (p *Poller) checkOne(ctx context.Context, sr store.Series) (outcome readOut
 		if errors.Is(err, errBrowserInterrupted) {
 			return outcomeUnreachable
 		}
+		if errors.Is(err, errNotFound) {
+			log.Printf("latest poll %q: page not found: %v", sr.Key(), err)
+			return outcomeNotFound
+		}
 		return outcomeError
 	}
 	// A legacy cover source is healed independently of the page read.

backend/internal/latest/poller_test.go

@@ -1947,9 +1947,9 @@ func TestRunLanePassCarryForwardOnlyWhenGapZero(t *testing.T) {
 	})
 }
 
-// The pass row's five outcome counts are the classification the Series read
+// The pass row's six outcome counts are the classification the Series read
 // already makes — never a second taxonomy (issue #141). Success is derived,
-// never stored: checked minus the four named counts, unreachable excluded
+// never stored: checked minus the five named failures, unreachable excluded
 // because its exit returns before the checked counter increments.
 func TestRunLanePassCountsOutcomes(t *testing.T) {
 	s, _ := newTestStore(t)
@@ -1986,7 +1986,7 @@ func TestRunLanePassCountsOutcomes(t *testing.T) {
 		t.Fatalf("outcome counts = refused %d unreachable %d no_chapter %d unfetchable %d errors %d, want 1 0 1 1 1",
 			pass.Refused, pass.Unreachable, pass.NoChapter, pass.Unfetchable, pass.Errors)
 	}
-	if success := pass.Checked - (pass.Refused + pass.NoChapter + pass.Unfetchable + pass.Errors); success != 1 {
+	if success := pass.Checked - (pass.Refused + pass.NoChapter + pass.Unfetchable + pass.NotFound + pass.Errors); success != 1 {
 		t.Fatalf("derived success = %d, want 1", success)
 	}
 	// The one genuine read went through: the success Series carries the
@@ -2009,6 +2009,36 @@ func TestRunLanePassCountsOutcomes(t *testing.T) {
 	}
 }
 
+// A 4xx other than the 403 refusal means the page is gone — a sixth outcome
+// word (issue #164) — while a 5xx stays errors. Both land in the durable row,
+// so the owner can tell "correct the address" from "the Site is unwell"
+// without opening a log.
+func TestRunLanePassSplitsNotFoundFromErrors(t *testing.T) {
+	s, _ := newTestStore(t)
+	now := time.UnixMilli(5_000_000)
+	seeds := map[string]string{
+		"asura:gone":   "https://asurascans.com/series/gone",
+		"asura:unwell": "https://asurascans.com/series/unwell",
+	}
+	for key, url := range seeds {
+		seedForCheck(t, s, key, url, 0)
+	}
+
+	f := &fakeFetcher{perURL: map[string]fakeResponse{
+		seeds["asura:gone"]:   {status: 404},
+		seeds["asura:unwell"]: {status: 503},
+	}}
+	newTestPoller(t, s, f, now).runLanePass(context.Background(), "asura", false)
+
+	pass := latestPassFor(t, s, "asura")
+	if pass.NotFound != 1 || pass.Errors != 1 {
+		t.Fatalf("not_found=%d errors=%d, want 1 1", pass.NotFound, pass.Errors)
+	}
+	if success := pass.Checked - (pass.Refused + pass.NoChapter + pass.Unfetchable + pass.NotFound + pass.Errors); success != 0 {
+		t.Fatalf("derived success = %d, want 0 (both reads failed)", success)
+	}
+}
+
 // A refusal is the Site's mood and outlives our process: the durable stamp a
 // pass writes is honoured by a freshly constructed poller, which must not
 // re-probe the Site inside its backoff (issue #141).

backend/internal/latest/read.go

@@ -25,9 +25,12 @@ type seriesRead struct {
 // errChallengeHeld (browser.go) is the outcome of a Site that answered with
 // its interstitial — status 403 (cf-mitigated) or a challenge page body — and
 // is how a Lane tells a refusal from an ordinary failure (issue #100).
+// errNotFound marks any other 4xx: the page is gone — a fact the owner can act
+// on — as distinct from a Site or database that is merely unwell (issue #164).
 var (
 	errNotFetchable = errors.New("series url not fetchable")
 	errNoFetcher    = errors.New("no fetcher for site")
+	errNotFound     = errors.New("series page not found")
 )
 
 // readSeriesPage performs the series-page read the poll and the acquirer have
@@ -59,6 +62,9 @@ func readSeriesPage(ctx context.Context, site, seriesURL string, browser, tls Fe
 		return seriesRead{}, fmt.Errorf("%w: fetch %s: status %d", errChallengeHeld, seriesURL, status)
 	}
 	if status != 200 {
+		if status >= 400 && status < 500 {
+			return seriesRead{}, fmt.Errorf("%w: fetch %s: status %d", errNotFound, seriesURL, status)
+		}
 		return seriesRead{}, fmt.Errorf("fetch %s: status %d", seriesURL, status)
 	}
 	if isInterstitial(body) {