@remit/web-client 0.0.325 → 0.0.326

package/src/lib/error-classifier.test.ts

@@ -1,434 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { ApiError } from "./api";
-import {
-	getErrorStatus,
-	hasHttpStatus,
-	isAbortError,
-	isClientBug,
-	isNetworkError,
-	isNotFound,
-	isServerError,
-	restartExpectedMeta,
-	shouldEscalate,
-	softErrorStatuses,
-} from "./error-classifier";
-import { NetworkError, taggedFetch } from "./network-error";
-
-const timeoutError = (): Error => {
-	const error = new Error("The operation timed out.");
-	error.name = "TimeoutError";
-	return error;
-};
-
-const abortError = (): Error => {
-	const error = new Error("aborted");
-	error.name = "AbortError";
-	return error;
-};
-
-describe("getErrorStatus", () => {
-	it("reads status off an ApiError", () => {
-		assert.equal(getErrorStatus(new ApiError("boom", 503)), 503);
-	});
-
-	it("reads a numeric status off a plain object", () => {
-		assert.equal(getErrorStatus({ status: 500 }), 500);
-		assert.equal(getErrorStatus({ statusCode: 404 }), 404);
-	});
-
-	it("returns undefined when no status is present", () => {
-		assert.equal(getErrorStatus(new Error("network")), undefined);
-		assert.equal(getErrorStatus("nope"), undefined);
-		assert.equal(getErrorStatus(null), undefined);
-	});
-});
-
-describe("isServerError", () => {
-	it("is true for any 5xx", () => {
-		assert.equal(isServerError(new ApiError("boom", 500)), true);
-		assert.equal(isServerError(new ApiError("boom", 502)), true);
-		assert.equal(isServerError({ status: 599 }), true);
-	});
-
-	it("is false for a 4xx", () => {
-		assert.equal(isServerError(new ApiError("not found", 404)), false);
-		assert.equal(isServerError(new ApiError("forbidden", 403)), false);
-	});
-
-	it("is false for a statusless error", () => {
-		assert.equal(isServerError(new TypeError("Failed to fetch")), false);
-		assert.equal(isServerError(undefined), false);
-	});
-});
-
-describe("hasHttpStatus", () => {
-	it("is true when the error carries a status", () => {
-		assert.equal(hasHttpStatus(new ApiError("boom", 500)), true);
-		assert.equal(hasHttpStatus({ statusCode: 404 }), true);
-	});
-
-	it("is false for a statusless error", () => {
-		assert.equal(hasHttpStatus(new TypeError("Failed to fetch")), false);
-		assert.equal(hasHttpStatus(null), false);
-	});
-});
-
-describe("isAbortError", () => {
-	it("is true for an AbortError", () => {
-		assert.equal(isAbortError(abortError()), true);
-	});
-
-	it("is false for anything else", () => {
-		assert.equal(isAbortError(new ApiError("boom", 500)), false);
-		assert.equal(isAbortError(new TypeError("Failed to fetch")), false);
-	});
-});
-
-describe("isNetworkError", () => {
-	// The boundary tags the failure, so the browser's wording never matters.
-	// These are the real rejections `fetch` produces, across engines — every one
-	// of them has to stay soft, whatever it happens to say.
-	const transportFailures = [
-		new TypeError("Failed to fetch"), // Chrome, Edge
-		new TypeError("NetworkError when attempting to fetch resource."), // Firefox
-		new TypeError("Load failed"), // WebKit
-		new TypeError("The network connection was lost."), // WebKit, wifi dropped
-		new TypeError("The request timed out."), // WebKit
-		new TypeError("fetch failed"), // undici
-		new Error("something no engine has said yet"),
-	];
-
-	it("is true for anything the fetch boundary tagged, whatever it says", () => {
-		for (const failure of transportFailures) {
-			assert.equal(
-				isNetworkError(new NetworkError(failure)),
-				true,
-				`"${failure.message}" must stay soft`,
-			);
-		}
-	});
-
-	it("is true for a timeout — a timeout is a transport failure", () => {
-		assert.equal(isNetworkError(new NetworkError(timeoutError())), true);
-	});
-
-	it("is false for an aborted request (its own category)", () => {
-		assert.equal(isNetworkError(abortError()), false);
-	});
-
-	it("is false when the error carries a status", () => {
-		assert.equal(isNetworkError(new ApiError("boom", 500)), false);
-		assert.equal(isNetworkError(new ApiError("not found", 404)), false);
-	});
-
-	it("is false for an exception thrown by our own code", () => {
-		assert.equal(
-			isNetworkError(
-				new TypeError('can\'t access property "map", x is undefined'),
-			),
-			false,
-		);
-	});
-
-	it("does not mistake an untagged error for transport just because it reads like one", () => {
-		// A bug whose message happens to contain a fetch-failure phrase is still a
-		// bug. Only the boundary gets to say otherwise.
-		assert.equal(isNetworkError(new TypeError("Failed to fetch")), false);
-	});
-});
-
-describe("taggedFetch — where the decision is actually made", () => {
-	const withFetch = async (
-		impl: typeof fetch,
-		run: () => Promise<void>,
-	): Promise<void> => {
-		const original = globalThis.fetch;
-		globalThis.fetch = impl;
-		try {
-			await run();
-		} finally {
-			globalThis.fetch = original;
-		}
-	};
-
-	it("tags every transport rejection, regardless of its message", async () => {
-		for (const message of [
-			"Failed to fetch",
-			"The network connection was lost.",
-			"fetch failed",
-			"anything at all",
-		]) {
-			await withFetch(
-				() => Promise.reject(new TypeError(message)),
-				async () => {
-					const error = await taggedFetch("/x").catch((e: unknown) => e);
-					assert.ok(error instanceof NetworkError);
-					assert.equal(isNetworkError(error), true);
-					assert.equal(shouldEscalate(error), false);
-				},
-			);
-		}
-	});
-
-	it("tags a timeout, because a timeout never reached a server", async () => {
-		await withFetch(
-			() => Promise.reject(timeoutError()),
-			async () => {
-				const error = await taggedFetch("/x").catch((e: unknown) => e);
-				assert.ok(error instanceof NetworkError);
-				assert.equal(shouldEscalate(error), false);
-			},
-		);
-	});
-
-	it("leaves a deliberate abort untagged — it is not a failure", async () => {
-		await withFetch(
-			() => Promise.reject(abortError()),
-			async () => {
-				const error = await taggedFetch("/x").catch((e: unknown) => e);
-				assert.ok(!(error instanceof NetworkError));
-				assert.equal(isAbortError(error), true);
-			},
-		);
-	});
-
-	it("passes a response through untouched, including an error status", async () => {
-		const response = new Response("nope", { status: 500 });
-		await withFetch(
-			() => Promise.resolve(response),
-			async () => {
-				assert.equal(await taggedFetch("/x"), response);
-			},
-		);
-	});
-});
-
-describe("isClientBug", () => {
-	it("is true for an exception raised inside our own code", () => {
-		assert.equal(
-			isClientBug(
-				new TypeError('can\'t access property "map", x is undefined'),
-			),
-			true,
-		);
-	});
-
-	it("is false for a request that reached, or failed to reach, a server", () => {
-		assert.equal(isClientBug(new ApiError("boom", 500)), false);
-		assert.equal(isClientBug(new ApiError("not found", 404)), false);
-		assert.equal(
-			isClientBug(new NetworkError(new TypeError("Failed to fetch"))),
-			false,
-		);
-		assert.equal(isClientBug(abortError()), false);
-	});
-});
-
-describe("shouldEscalate (the fail-fast decision table — #1059)", () => {
-	it("escalates a 5xx by default", () => {
-		assert.equal(shouldEscalate(new ApiError("boom", 500)), true);
-		assert.equal(shouldEscalate(new ApiError("boom", 503)), true);
-	});
-
-	it("escalates a 5xx EVEN when the call site marked it soft (rule 2 wins)", () => {
-		assert.equal(
-			shouldEscalate(new ApiError("boom", 500), { softError: true }),
-			true,
-		);
-	});
-
-	it("escalates a 4xx by DEFAULT (no opt-out)", () => {
-		assert.equal(shouldEscalate(new ApiError("not found", 404)), true);
-		assert.equal(shouldEscalate(new ApiError("forbidden", 403)), true);
-	});
-
-	it("does NOT escalate a 4xx the call site opted out of via meta.softError", () => {
-		assert.equal(
-			shouldEscalate(new ApiError("not found", 404), { softError: true }),
-			false,
-		);
-	});
-
-	it("does NOT escalate an aborted/cancelled request", () => {
-		assert.equal(shouldEscalate(abortError()), false);
-	});
-
-	it("does NOT escalate a network/offline blip", () => {
-		assert.equal(
-			shouldEscalate(new NetworkError(new TypeError("Failed to fetch"))),
-			false,
-		);
-		assert.equal(
-			shouldEscalate(
-				new NetworkError(new TypeError("The network connection was lost.")),
-			),
-			false,
-		);
-	});
-
-	it("a network error is soft regardless of meta", () => {
-		assert.equal(
-			shouldEscalate(new NetworkError(new TypeError("Failed to fetch")), {
-				softError: false,
-			}),
-			false,
-		);
-	});
-
-	it("escalates an exception thrown by our own code, softError or not", () => {
-		const bug = new TypeError('can\'t access property "map", x is undefined');
-		assert.equal(shouldEscalate(bug), true);
-		assert.equal(shouldEscalate(bug, { softError: true }), true);
-	});
-
-	it("escalates a 401 on a write EVEN when the call site marked it soft (rule 4 wins)", () => {
-		assert.equal(
-			shouldEscalate(
-				new ApiError("signed out", 401),
-				{ softError: true },
-				"user",
-			),
-			true,
-			"a dismissible banner leaves the user signed out with no way back in",
-		);
-	});
-
-	it("leaves a soft 401 soft when nobody is waiting on the answer", () => {
-		assert.equal(
-			shouldEscalate(
-				new ApiError("signed out", 401),
-				{ softError: true },
-				"nobody",
-			),
-			false,
-			"a background poll's 401 must not put the fatal page over the whole app",
-		);
-	});
-
-	it("defaults to nobody waiting, so an unstated call site keeps a soft 401 soft", () => {
-		assert.equal(
-			shouldEscalate(new ApiError("signed out", 401), { softError: true }),
-			false,
-		);
-	});
-
-	it("escalates a 401 on a read that never opted out", () => {
-		assert.equal(
-			shouldEscalate(new ApiError("signed out", 401), undefined, "nobody"),
-			true,
-			"a read with no softError escalates on the default, waiting or not",
-		);
-	});
-
-	it("leaves a soft 403 soft — the call site can state that refusal in place", () => {
-		assert.equal(
-			shouldEscalate(new ApiError("not yours", 403), { softError: true }),
-			false,
-		);
-	});
-});
-
-/**
- * The send watch reads a row the server deletes on success, so the 404 is the
- * outcome it is there to see. Everything else that endpoint can answer is still
- * news — a lapsed session most of all, because a background read that renders it
- * as nothing leaves the user on a screen that has quietly stopped working.
- */
-describe("meta.softErrorStatuses (one outcome owned, the rest not)", () => {
-	const ownsNotFound = softErrorStatuses(404);
-
-	it("does NOT escalate the status the call site named", () => {
-		assert.equal(
-			shouldEscalate(new ApiError("gone", 404), ownsNotFound, "nobody"),
-			false,
-		);
-	});
-
-	it("escalates every other 4xx, the lapsed session included", () => {
-		assert.equal(
-			shouldEscalate(new ApiError("signed out", 401), ownsNotFound, "nobody"),
-			true,
-		);
-		assert.equal(
-			shouldEscalate(new ApiError("not yours", 403), ownsNotFound, "nobody"),
-			true,
-		);
-	});
-
-	it("escalates a 5xx and a client bug, as every opt-out does", () => {
-		assert.equal(
-			shouldEscalate(new ApiError("boom", 500), ownsNotFound, "nobody"),
-			true,
-		);
-		assert.equal(
-			shouldEscalate(new TypeError("x is undefined"), ownsNotFound, "nobody"),
-			true,
-		);
-	});
-
-	it("does not open the restart gap for a call site that never claimed one", () => {
-		assert.equal(
-			shouldEscalate(new ApiError("bad gateway", 502), ownsNotFound, "nobody"),
-			true,
-		);
-	});
-
-	it("names the record's absence, whichever client raised it", () => {
-		assert.equal(isNotFound(new ApiError("gone", 404)), true);
-		assert.equal(isNotFound({ status: 404 }), true);
-		assert.equal(isNotFound(new ApiError("gone", 410)), false);
-		assert.equal(isNotFound(new TypeError("x is undefined")), false);
-	});
-});
-
-/**
- * A self-update stops and starts the backend, so for those seconds the proxy in
- * front of it has nothing to dial. That gap belongs to the surface that asked
- * for the restart; every other 5xx, on that call site and on any other, is still
- * the API reporting itself broken (#468).
- */
-describe("meta.restartExpected (the gap in a restart this call site asked for)", () => {
-	it("does NOT escalate the gateway statuses answered while the backend is down", () => {
-		for (const status of [502, 503, 504]) {
-			assert.equal(
-				shouldEscalate(
-					new ApiError("gateway", status),
-					restartExpectedMeta,
-					"nobody",
-				),
-				false,
-				`a ${status} inside the restart window belongs to the update surface`,
-			);
-		}
-	});
-
-	it("escalates a 500 — a server that answered is up, and up and broken is not designed", () => {
-		assert.equal(
-			shouldEscalate(new ApiError("boom", 500), restartExpectedMeta, "nobody"),
-			true,
-		);
-	});
-
-	it("escalates the same 502 without the claim, however soft the call site is", () => {
-		assert.equal(
-			shouldEscalate(new ApiError("gateway", 502), undefined, "nobody"),
-			true,
-		);
-		assert.equal(
-			shouldEscalate(new ApiError("gateway", 502), { softError: true }, "user"),
-			true,
-		);
-	});
-
-	it("escalates a client bug raised inside the window", () => {
-		assert.equal(
-			shouldEscalate(
-				new TypeError("x is undefined"),
-				restartExpectedMeta,
-				"nobody",
-			),
-			true,
-		);
-	});
-});

package/src/lib/error-classifier.ts

@@ -1,260 +0,0 @@
-import { ApiError } from "./api";
-import { NetworkError } from "./network-error";
-
-/**
- * Extract an HTTP status code from a thrown error, regardless of which client
- * raised it.
- *
- * Two client shapes coexist in the web client:
- *  - the hand-written `api` wrapper throws `ApiError` (carries `.status`);
- *  - the generated `@remit/api-http-client` (hey-api) throws the parsed JSON error
- *    body. A response interceptor (see `lib/client.ts`) re-wraps those as
- *    `ApiError` too, so in practice both paths carry `.status`. As a belt-and-
- *    braces fallback we also read a numeric `status`/`statusCode` off a plain
- *    object.
- */
-export const getErrorStatus = (error: unknown): number | undefined => {
-	if (error instanceof ApiError) return error.status;
-	if (error && typeof error === "object") {
-		const candidate = error as { status?: unknown; statusCode?: unknown };
-		if (typeof candidate.status === "number") return candidate.status;
-		if (typeof candidate.statusCode === "number") return candidate.statusCode;
-	}
-	return undefined;
-};
-
-/** The error carries a real HTTP status — our API answered. */
-export const hasHttpStatus = (error: unknown): boolean =>
-	getErrorStatus(error) !== undefined;
-
-/** A genuine first-party server failure: an HTTP 5xx. */
-export const isServerError = (error: unknown): boolean => {
-	const status = getErrorStatus(error);
-	return status !== undefined && status >= 500 && status <= 599;
-};
-
-/**
- * A deliberately cancelled request (route change, React Query cancellation).
- * Never a failure.
- */
-export const isAbortError = (error: unknown): boolean => {
-	if (
-		typeof DOMException !== "undefined" &&
-		error instanceof DOMException &&
-		error.name === "AbortError"
-	) {
-		return true;
-	}
-	if (
-		error &&
-		typeof error === "object" &&
-		"name" in error &&
-		(error as { name?: unknown }).name === "AbortError"
-	) {
-		return true;
-	}
-	return false;
-};
-
-const isOffline = (): boolean =>
-	typeof navigator !== "undefined" && navigator.onLine === false;
-
-/**
- * A transport failure from a wifi drop, tab wake, captive portal, or a timeout:
- * the request never reached a server, so it is environmental, not a proven
- * first-party failure.
- *
- * This is decided at the fetch boundary, not inferred here. Every app-owned
- * request goes through `taggedFetch`, which knows a `fetch()` rejection is
- * transport-level because `fetch` rejects for no other reason, and tags it a
- * `NetworkError`. Reading that tag is exact; matching browser failure strings
- * was not — the list is open-ended (WebKit alone has four, undici another) and
- * anything missed would put a full-screen fatal page in front of someone who
- * had merely walked out of wifi range.
- *
- * `navigator.onLine === false` is kept as a second signal for an error that
- * reached us from outside that boundary while the browser reports no
- * connectivity at all.
- */
-export const isNetworkError = (error: unknown): boolean => {
-	if (isAbortError(error)) return false;
-	if (hasHttpStatus(error)) return false;
-	if (error instanceof NetworkError) return true;
-	return isOffline();
-};
-
-/**
- * An exception raised by our own client code rather than by a request: it
- * carries no HTTP status, is not an abort, and was not tagged as transport.
- * That leaves a programming error — the one class the user can do nothing
- * about and must never be asked to shrug off.
- */
-export const isClientBug = (error: unknown): boolean =>
-	!hasHttpStatus(error) && !isAbortError(error) && !isNetworkError(error);
-
-/**
- * Fatal with no opt-out: our API answered "I'm broken", or our own code threw.
- * Neither is something a call site can reclassify as soft, and neither may be
- * reduced to a dismissible banner — both belong on the full-screen page, which
- * offers a way forward and a bug report (issue #55).
- */
-export const isAlwaysFatal = (error: unknown): boolean =>
-	isServerError(error) || isClientBug(error);
-
-/**
- * The session is gone. Not 403: a handler answers 403 for a resource belonging
- * to another account config, which is a refusal a call site can state where it
- * stands. A 401 is the user signed out from under whatever they were doing.
- */
-export const isUnauthenticated = (error: unknown): boolean =>
-	getErrorStatus(error) === 401;
-
-/**
- * Who is waiting on this request's answer. One decision turns on it, and only
- * one: whether a 401 overrides the call site's own `meta.softError`.
- *
- * "user" — the user did something and the app owes them the outcome. Every
- * mutation is this, the debounced autosave included: it carries text that is on
- * screen, and if it is refused for want of a session then so is the send behind
- * it. No banner a call site can render signs anyone back in, so this is the one
- * 4xx a call site may not keep to itself.
- *
- * "nobody" — a poll, a prefetch, a best-effort background trigger, an inline
- * sub-resource with an error surface of its own. A 401 there is not news the
- * app may take the whole screen for, and `meta.softError` decides as usual.
- *
- * Reads are "nobody" as a class, which is not the same as saying no read
- * matters: a read the screen is actually waiting on has no `meta.softError` on
- * it, so rule 1 escalates it anyway. The only reads this spares are the ones
- * that already declared they own their failures — the update poll mounted at
- * the app root, the message body with its own inline banner. Escalating those
- * put the full-screen page over every screen in the app.
- */
-export type Awaiting = "user" | "nobody";
-
-const isSoftErrorMeta = (
-	error: unknown,
-	meta: Record<string, unknown> | undefined,
-): boolean => {
-	if (meta?.softError === true) return true;
-	const owned = meta?.softErrorStatuses;
-	if (!Array.isArray(owned)) return false;
-	const status = getErrorStatus(error);
-	return status !== undefined && owned.includes(status);
-};
-
-/**
- * The statuses answered for the seconds a service is not there. Every `/api/*`
- * request is proxied to apisix, which stays up while the backend behind it
- * restarts and refuses in milliseconds — the 29ms 502 in #468, not a dial Caddy
- * waited out. 503 and 504 are the same gap through a hop that answers
- * differently.
- */
-const RESTART_GAP_STATUSES = [502, 503, 504];
-
-/**
- * The gap in a restart this call site asked for. A self-update stops and starts
- * the backend on purpose, so the poll watching that run meets a proxy with
- * nothing behind it — the designed shape of the operation the user pressed, not
- * our API answering "I'm broken".
- *
- * A 500 is not in it: a server that answered is a server that is up, and up and
- * broken is never designed.
- */
-const isDesignedRestartGap = (
-	error: unknown,
-	meta: Record<string, unknown> | undefined,
-): boolean => {
-	if (meta?.restartExpected !== true) return false;
-	const status = getErrorStatus(error);
-	return status !== undefined && RESTART_GAP_STATUSES.includes(status);
-};
-
-/**
- * The single fail-fast decision: should this error escalate to the full-screen
- * fatal overlay? Default is YES — a non-2xx must never silently vanish.
- *
- * The contract (issue #1059):
- *  1. DEFAULT = escalate.
- *  2. A 5xx (500–599) ALWAYS escalates — no opt-out, even on a background
- *     refetch, even when the call site marked `meta.softError`. Our API
- *     answered "I'm broken"; that is never benign. The single exception is a
- *     502/503/504 on a call site that declared it is polling across a restart it
- *     asked for (`meta.restartExpected`, #468): there the backend being gone is
- *     the operation working, and that call site renders the wait itself.
- *  3. A client-side exception ALWAYS escalates, on the same terms. It is our
- *     bug; there is nothing for the user to retry and nothing to dismiss.
- *  4. A 401 on a request the user is waiting on ALWAYS escalates, on the same
- *     terms. Dismissing it leaves them signed out with no way back in, and a
- *     send that keeps failing becomes a loop with no exit — `BetterAuthShell`
- *     re-gates only when `useSession()` revalidates, which a banner never makes
- *     happen. See `Awaiting` for what nobody waiting on it means.
- *  5. The ONLY soft (do-NOT-escalate) exemptions:
- *     a. aborts / cancellations — never a failure;
- *     b. network/offline errors — environmental, recovered by React Query's
- *        reconnect/retry;
- *     c. a non-5xx error on a query/mutation that opted out via
- *        `meta.softError === true` — the call site owns that error's UX
- *        (e.g. a 404 empty state, a 4xx "Reconnect" banner) — or, where it owns
- *        one status and not the rest, `meta.softErrorStatuses`.
- */
-export const shouldEscalate = (
-	error: unknown,
-	meta?: Record<string, unknown>,
-	awaiting: Awaiting = "nobody",
-): boolean => {
-	if (isServerError(error)) return !isDesignedRestartGap(error, meta);
-	if (isAbortError(error)) return false;
-	if (isNetworkError(error)) return false;
-	if (awaiting === "user" && isUnauthenticated(error)) return true;
-	if (isAlwaysFatal(error)) return true;
-	if (isSoftErrorMeta(error, meta)) return false;
-	return true;
-};
-
-/**
- * The meta a call site sets to keep its own non-5xx failures off the
- * full-screen fatal page, because it renders them itself — a banner, a retry,
- * an empty state. Rules 2, 3 and 4 above still win: a 5xx, a client-side
- * exception, and a 401 on something the user is waiting on, escalate regardless.
- *
- * Two classes of call site must always carry it. One is a request the user
- * never asked for and is not waiting on — a debounced autosave, a
- * dwell-triggered mark-as-read: a refusal there is not news worth stopping the
- * app for. The other is any surface holding text the user has not finished
- * writing. The fatal page unmounts the app, so escalating from a composer
- * throws the message away and leaves nothing to retry, which is a worse outcome
- * than the failure it reports.
- */
-export const softErrorMeta: { softError: true } = { softError: true };
-
-/**
- * The narrow form, for a call site that owns one outcome and none of the others.
- * A read whose record may legitimately be gone owns the 404 and nothing else: a
- * blanket `softErrorMeta` there would also swallow the 401 and the 403, and a
- * background read that answers a lapsed session with nothing leaves the user
- * looking at a screen that has quietly stopped working.
- */
-export const softErrorStatuses = (
-	...statuses: number[]
-): { softErrorStatuses: number[] } => ({ softErrorStatuses: statuses });
-
-/**
- * The one opt-out from rule 2, for a request watching a restart the run it is
- * following performs. Set it only while a run is known to be in flight — the
- * update poll carries it while it holds a run it started or the server's last
- * answer reported one going — because a 502 outside that window is the API being
- * broken, which is exactly what rule 2 is for.
- *
- * A call site that sets this owns the whole wait, so the window outlives the
- * budget: the give-up screen keeps polling a server it has stopped expecting,
- * and a fatal page thrown over that verdict would replace the one screen that
- * names the run and the log to read. A 500 from that same poll still escalates.
- */
-export const restartExpectedMeta: { restartExpected: true } = {
-	restartExpected: true,
-};
-
-/** The record is not there. */
-export const isNotFound = (error: unknown): boolean =>
-	getErrorStatus(error) === 404;