@gusnips/react 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Gustavo Salomé
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,180 @@
+# @gusnips/react
+
+The layer under a Vite + React SPA: the fetch client, the auth store, the route guards, the error
+boundary, the query rules. No styling, no brand, nothing that decides how your app looks.
+
+```bash
+bun add @gusnips/react
+```
+
+```ts
+const user = await api.get<User>("/me");
+```
+
+That is the whole call. `user` is a `User` — not a `Response`, not `res.json()`, not a null
+check. The client attached the token, unwrapped the envelope, and threw a typed `ApiError`
+carrying the code and the request id if the server refused.
+
+You build `api` once, wherever you keep that sort of thing:
+
+```ts
+import { createApiClient } from "@gusnips/react";
+
+const api = createApiClient({
+  baseUrl: "https://api.example.com",
+  session: mySession,
+  onSessionDead: () => window.location.replace("/sign-in"),
+});
+```
+
+## The client knows three things people learn the hard way
+
+**Six queries firing at once send one refresh, not six.** The auth server rotates the refresh
+token when you use it, so the losers of that race each invalidate the winner — and the person is
+signed out in the middle of a load that was working. Three separate codebases arrived at
+single-flight refresh independently. This is that.
+
+**A refresh that never reached the server is not a "no".** Dropping a packet tells you nothing
+about whether a session is good. So `refresh()` answers `{ token, reachedAuth }`, and only a real
+refusal signs anyone out. Before that split, a Wi-Fi blip logged people out mid-load.
+
+**A sign-out has a fail-safe timer.** Awaiting `signOut()` before redirecting covers a rejection,
+not a hang — and a hang leaves someone signed out in name only: every request 401ing, nothing
+left that could redirect it.
+
+There is also a deadline on every request, which none of the codebases this came from had. A
+request with no timeout is a spinner with no end.
+
+## Never retry what waiting cannot fix
+
+```ts
+import { queryDefaults } from "@gusnips/react";
+
+new QueryClient({
+  defaultOptions: queryDefaults({ durableLimitCodes: ["QUOTA_EXCEEDED", "PAYMENT_REQUIRED"] }),
+});
+```
+
+Retries 408, a transient 429, 5xx, and no-response-at-all. Nothing else — every other 4xx is an
+answer, and a second attempt just says it again.
+
+`durableLimitCodes` is the part a status code cannot tell you. A spent monthly quota and a burst
+limit both arrive as 429, but one clears by waiting and the other clears by buying. Retrying the
+second burns another request against the limiter to hear the same thing three times, so you name
+those codes and they are never retried.
+
+## Survives your deploys
+
+An app with `lazy()` routes serves chunks by hashed filename. Deploy while someone has a tab
+open, and their next click asks for a file that no longer exists — a white screen on a button
+that worked a minute ago.
+
+Two halves. In your browser entry:
+
+```ts
+import { installPreloadErrorHandler } from "@gusnips/react";
+
+installPreloadErrorHandler();
+```
+
+And in your error boundary:
+
+```ts
+if (isChunkLoadError(error) && reloadOnceForChunkError()) return null;
+```
+
+`reloadOnceForChunkError` reloads at most once a minute, because reloading on a chunk error the
+reload does not fix is an infinite loop with a person inside it. Past that, a genuinely missing
+chunk degrades to your error screen, which can at least say something.
+
+The handler is the other half, and it is narrower than it looks: it swallows Vite's CSS _preload
+hint_ failure and nothing else. A hint that fails is harmless — the import runs straight after
+and usually works. Taking Vite's `preventDefault()` for every preload error instead resolves the
+dynamic import with `undefined`, `React.lazy` reads `.default` off nothing, and you get a crash
+screen plus a TypeError with only React frames in it, naming no chunk.
+
+## Guards that can tell "no" from "I don't know"
+
+```tsx
+import { createRequireProfile } from "@gusnips/react/guards";
+
+const requireProfile = createRequireProfile(useMe, { loading: <Spinner /> });
+
+const RequireStaff = requireProfile(
+  (me) => me.isStaff,
+  <NotFound />,
+  (error) => <ErrorScreen error={error} />,
+);
+```
+
+`onDenied` and `onError` are separate because `!me?.isStaff` reads a 500 as "not staff". An
+operator arriving while `/auth/me` is down gets told the page does not exist: the wrong cause, no
+retry, and no request id to quote. A guard has three answers — wait, fail, refuse — and only a
+real `false` reaches the refusal.
+
+## Never dead-end anyone
+
+```ts
+import type { ErrorStateProps } from "@gusnips/react";
+```
+
+No component ships — seven codebases have an `ErrorState.tsx` and they overlap 9–37%, because one
+draws a tinted icon, one an illustration, one a mascot. What they share is the prop shape, and
+the prop shape _is_ the rule: `problem`, `cause`, `fix`, and `action`. **`fix` and `action` are
+required.** A required prop is the only version of "always offer a way out" that a caller in a
+hurry cannot skip.
+
+`createErrorDescriber` turns a thrown `ApiError` into the `cause` and `fix` to put in it.
+
+## Also here
+
+`hydrateOrMount` for prerendered pages, `ErrorBoundary`, an SSE reader split into a platform-free
+parser and a stream wrapper, `i18nInitOptions`, and `cn`.
+
+`createAuthStore` is at `@gusnips/react/store` — a zustand store whose `isLoading` starts `false`
+where there is no window. A session bootstrap can only be in flight in a browser, and `true`
+during a build is a wait that never ends: it once shipped a spinner as the indexable body of a
+page whose whole job was to be found.
+
+## The Base UI wrappers
+
+```ts
+import { Dialog, Drawer, Select, Combobox, Menu, Tabs, Input } from "@gusnips/react/ui";
+```
+
+Seven, behind a subpath, so an app on Radix or on nothing never resolves `@base-ui/react`.
+
+They are seven because the audit that produced them started with 27 and the hypothesis was wrong:
+no wrapper added scroll lock, focus trap, ESC, outside-dismiss, focus return, roving focus or
+typeahead. Base UI already does all of that, and a wrapper "adding" them is a second
+implementation of something that works. Twenty were dropped.
+
+What the remaining seven buy is composition you cannot skip — no caller can ship a scrimless
+dialog — required a11y props expressed as types, and a handful of facts that each cost somebody
+an afternoon. z-index goes on the Viewport, not the Popup, because `position: fixed` makes a
+stacking context. A drawer _ties_ with dialog rather than beating it, or a modal opened from
+inside a drawer never paints. A wrapper earns its place by knowing something, not by styling
+something.
+
+## Subpaths, and what each one costs you
+
+`@gusnips/react` itself needs `react`, `react-dom` and nothing else. Anything that needs more
+lives behind a subpath, so you install a dependency only if you import the thing that uses it:
+
+| Import from               | What is in it       | What you must have |
+| ------------------------- | ------------------- | ------------------ |
+| `@gusnips/react`          | the client and rest | react, react-dom   |
+| `@gusnips/react/store`    | `createAuthStore`   | zustand            |
+| `@gusnips/react/guards`   | the route guards    | react-router-dom   |
+| `@gusnips/react/ui`       | the seven wrappers  | @base-ui/react     |
+| `@gusnips/react/contract` | two prerender names | nothing            |
+
+The rule behind that table: **a peer marked optional must not be reachable from the main entry
+point.** An optional peer the barrel imports anyway is not optional — it is a required one whose
+error moved from install time to your first build, which is the worse of the two places to learn
+about it.
+
+`@tanstack/react-query`, `i18next` and `react-i18next` are optional and stay in the main entry,
+because only their types are used and types erase.
+
+MIT · part of [frontkit](https://github.com/gusnips/frontkit)

package/dist/api-client.d.ts

@@ -0,0 +1,139 @@
+import { type ApiSuccess } from "@gusnips/http";
+import { ApiError } from "./api-error.ts";
+/**
+ * The app's one door to the API. Nothing else should call `fetch`.
+ *
+ * Every route answers the same envelope, so unwrapping and error-shaping belong here once
+ * rather than in every hook. Three donors built this independently and all three arrived at
+ * single-flight token refresh — see {@link SessionAdapter.refresh} for the reason, which is
+ * the sharpest thing in this file.
+ *
+ * Four things deliberately did NOT come across from the donors, because they belong to a
+ * product and not to a client:
+ *
+ * - **Toasts.** Whether a failure is spoken aloud is a design decision that differs per surface.
+ *   Throw, and let the caller decide.
+ * - **In-flight GET deduplication.** react-query already dedups by key, so the client's copy is
+ *   redundant — and one donor's version returned a `clone()` of a body already being consumed,
+ *   which is a race with no symptom until it has one.
+ * - **Service-status tracking and impersonation.** One donor's, and firmly its own.
+ * - **Analytics correlation headers.** Injected through {@link ApiClientOptions.headers}.
+ */
+/** What a refresh attempt actually learned. */
+export interface RefreshResult {
+    token: string | null;
+    /**
+     * False when the refresh never got an ANSWER out of the auth server — a dropped connection,
+     * a 5xx, a captive portal.
+     *
+     * This flag is invariant 3, and only one of three donors had it. Losing a packet says nothing
+     * about whether a session is still good, so a client that collapses "auth said no" into
+     * "auth did not answer" signs people out over a Wi-Fi blip and costs them their place for
+     * nothing. Auth libraries usually name this: Supabase throws `AuthRetryableFetchError`, so
+     * an adapter answers `reachedAuth: !(error instanceof AuthRetryableFetchError)`.
+     */
+    reachedAuth: boolean;
+}
+/**
+ * The seam onto whatever holds the session. Supabase in every donor so far, but nothing here
+ * knows that — an adapter is four lines and keeps the auth vendor out of this package.
+ */
+export interface SessionAdapter {
+    getToken(): Promise<string | null>;
+    refresh(): Promise<RefreshResult>;
+    signOut(): Promise<void>;
+}
+export interface ApiClientOptions {
+    /** Origin + prefix, e.g. `https://api.example.com/v1`. No trailing slash. */
+    baseUrl: string;
+    session: SessionAdapter;
+    /**
+     * Extra headers, computed per request.
+     *
+     * A function, not an object, and that matters: one donor read
+     * `document.documentElement.lang` inline in its request builder, which crashes a prerender
+     * outright. Anything that touches the DOM, the current locale or the clock goes in here,
+     * where it runs only when a request is actually being sent.
+     */
+    headers?: () => Record<string, string>;
+    /**
+     * The session is gone and cannot be renewed — send them to sign in.
+     *
+     * The client does not know the route, and it deliberately still THROWS after calling this:
+     * `location.replace()` does not stop the current frame, so a caller's own `onError` must
+     * still run or a half-finished screen keeps rendering against data that will never arrive.
+     * The error it throws carries `expected: true`.
+     */
+    onSessionDead: () => void;
+    /**
+     * Every failed response, seen once, just before it is thrown.
+     *
+     * For a reaction that belongs to the whole app rather than to one call site. The donor's case
+     * is the sharp one: a mid-session account suspension 403s every authed route except
+     * `GET /auth/me`, so the moment one arrives the app has to refresh `me` and route to the
+     * screen that explains it — otherwise every query on the page fails at once and the shell
+     * half-renders behind an error storm until `me` goes stale on its own.
+     *
+     * It cannot live at a call site, because the point is that it fires from whichever call
+     * happened to be first. It went in the donor's client directly, which made the client import
+     * its query cache and its query keys — a cycle that this hook removes.
+     *
+     * Observation only: the error is thrown either way, and throwing from here would replace a
+     * real API failure with whatever the listener hit.
+     */
+    onError?: (error: ApiError) => void;
+    /**
+     * Abort a request that has not answered. Default 30s.
+     *
+     * Neither donor bounded its authenticated requests at all — both bounded only their keyless
+     * clients — so a stalled connection was a spinner with no end. providerkit learned the same
+     * lesson about streams: a request with no deadline is a bug that only shows up on a bad
+     * network, which is exactly when nobody can reproduce it.
+     */
+    timeoutMs?: number;
+    /** How many times to refresh-and-retry a 401. Default 2. */
+    maxRefreshAttempts?: number;
+    /** Pause between refresh attempts. Default 500ms. */
+    refreshRetryDelayMs?: number;
+    /**
+     * How long to wait for `signOut()` before redirecting anyway. Default 3s.
+     *
+     * A fail-safe, and one donor added it after the failure it prevents: awaiting `signOut()`
+     * covers a rejection but not a HANG, and a hang leaves the tab signed out in name only —
+     * still on the page, every request 401ing, nothing left that could redirect it.
+     */
+    signOutTimeoutMs?: number;
+    /** Header carrying the server's request id, echoed onto {@link ApiError.requestId}. */
+    requestIdHeader?: string;
+}
+export interface RequestOptions extends Omit<RequestInit, "headers"> {
+    headers?: Record<string, string>;
+    /** Override the client's default timeout for this call. `null` disables it (streams). */
+    timeoutMs?: number | null;
+}
+export interface ApiClient {
+    /** The raw `Response`, past auth and error handling. For blobs, streams and downloads. */
+    request(path: string, options?: RequestOptions): Promise<Response>;
+    /** `data` out of the success envelope. */
+    get<T>(path: string, options?: RequestOptions): Promise<T>;
+    post<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    put<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    patch<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    /**
+     * DELETE, discarding whatever comes back. Returns `void` because 204 is the usual answer and
+     * a 204 has NO BODY — `res.json()` on one throws `Unexpected end of JSON input`, which reads
+     * like a malformed response and is really just a success nobody was allowed to parse.
+     *
+     * Split from {@link ApiClient.delJson} rather than guessing per response, because the guess is
+     * the part that hides a bug: a route that was supposed to answer with data and returned
+     * nothing should fail loudly here, not hand back a silent `undefined` that surfaces three
+     * layers away. The donor that hit this had written exactly these two functions.
+     */
+    del(path: string, options?: RequestOptions): Promise<void>;
+    /** The DELETE that answers with something worth reading — a queue entry it handed back. */
+    delJson<T>(path: string, options?: RequestOptions): Promise<T>;
+    /** The whole envelope, for a list route whose counts live in `meta`. */
+    page<T, M>(path: string, options?: RequestOptions): Promise<ApiSuccess<T, M>>;
+}
+export declare function createApiClient({ baseUrl, session, headers: extraHeaders, onSessionDead, onError, timeoutMs, maxRefreshAttempts, refreshRetryDelayMs, signOutTimeoutMs, requestIdHeader, }: ApiClientOptions): ApiClient;
+//# sourceMappingURL=api-client.d.ts.map

package/dist/api-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-client.d.ts","sourceRoot":"","sources":["../src/api-client.ts"],"names":[],"mappings":"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"}

package/dist/api-client.js

@@ -0,0 +1,133 @@
+import { isApiError } from "@gusnips/http";
+import { ApiError } from "./api-error.js";
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+export function createApiClient({ baseUrl, session, headers: extraHeaders, onSessionDead, onError, timeoutMs = 30_000, maxRefreshAttempts = 2, refreshRetryDelayMs = 500, signOutTimeoutMs = 3_000, requestIdHeader = "x-request-id", }) {
+    /**
+     * Single-flight refresh.
+     *
+     * A page that fires six queries at once must not send six refreshes. The auth server rotates
+     * the refresh token on use, so the losers of that race each invalidate the winner — and the
+     * person is signed out in the middle of a load that was working. All three donors found this
+     * the hard way and all three fixed it the same way.
+     */
+    let refreshing = null;
+    function refresh() {
+        refreshing ??= session
+            .refresh()
+            .catch(() => ({ token: null, reachedAuth: false }))
+            .finally(() => {
+            refreshing = null;
+        });
+        return refreshing;
+    }
+    /** Latches, so whichever request gets here first owns the sign-out and the rest are no-ops. */
+    let signingOut = false;
+    function sessionDead() {
+        if (!signingOut) {
+            signingOut = true;
+            let done = false;
+            const go = () => {
+                if (done)
+                    return;
+                done = true;
+                onSessionDead();
+            };
+            void session
+                .signOut()
+                .catch(() => { })
+                .finally(go);
+            setTimeout(go, signOutTimeoutMs);
+        }
+        // Thrown even though the redirect is under way: see `onSessionDead`.
+        throw new ApiError(401, { code: "UNAUTHORIZED", message: "Session expired" }, { expected: true });
+    }
+    function buildHeaders(token, extra) {
+        const headers = new Headers({ ...extraHeaders?.(), ...extra });
+        if (token)
+            headers.set("Authorization", `Bearer ${token}`);
+        return headers;
+    }
+    async function send(path, token, { headers, timeoutMs: perCall, signal, ...init }) {
+        const budget = perCall === undefined ? timeoutMs : perCall;
+        if (budget === null)
+            return fetch(`${baseUrl}${path}`, { ...init, signal, headers: buildHeaders(token, headers) });
+        // `AbortSignal.any` rather than a listener: it also catches the already-aborted race, where
+        // a caller's signal fired before we ever attached. It keeps the caller's abort and our
+        // timeout distinguishable at the source, which is what lets `isAbortError` stay honest.
+        const timeout = AbortSignal.timeout(budget);
+        return fetch(`${baseUrl}${path}`, {
+            ...init,
+            signal: signal ? AbortSignal.any([signal, timeout]) : timeout,
+            headers: buildHeaders(token, headers),
+        });
+    }
+    async function request(path, options = {}) {
+        let res = await send(path, await session.getToken(), options);
+        if (res.status === 401) {
+            // Only a refresh that actually REACHED auth proves the session is gone. Anything else is
+            // a network problem, and the 401 falls through as an ordinary error — the next request
+            // refreshes cleanly once the connection is back. Invariant 3.
+            let answered = false;
+            for (let attempt = 0; attempt < maxRefreshAttempts; attempt++) {
+                if (attempt > 0)
+                    await sleep(refreshRetryDelayMs);
+                const result = await refresh();
+                answered = result.reachedAuth;
+                if (!result.token)
+                    continue;
+                res = await send(path, result.token, options);
+                if (res.status !== 401)
+                    break;
+            }
+            if (res.status === 401 && answered)
+                sessionDead();
+        }
+        if (!res.ok) {
+            const body = await res.json().catch(() => null);
+            const error = new ApiError(res.status, isApiError(body) ? body.error : null, {
+                requestId: res.headers.get(requestIdHeader) ?? undefined,
+            });
+            // A listener that throws must not become the error the caller sees: the API failure is
+            // the real news, and swallowing it for a bug in a side effect would send everyone
+            // debugging the wrong thing.
+            try {
+                onError?.(error);
+            }
+            catch {
+                // ignored on purpose — see above
+            }
+            throw error;
+        }
+        return res;
+    }
+    /**
+     * The success envelope. `request` has already thrown on anything that is not one, so what is
+     * left is `{data, meta?}` by contract — this is the single place that assertion is made.
+     */
+    async function envelope(res) {
+        return (await res.json());
+    }
+    const json = (body, options = {}) => body === undefined
+        ? options
+        : {
+            ...options,
+            body: JSON.stringify(body),
+            headers: { "Content-Type": "application/json", ...options.headers },
+        };
+    async function data(path, options) {
+        return (await envelope(await request(path, options))).data;
+    }
+    return {
+        request,
+        get: (path, options = {}) => data(path, { ...options, method: "GET" }),
+        post: (path, body, options = {}) => data(path, json(body, { ...options, method: "POST" })),
+        put: (path, body, options = {}) => data(path, json(body, { ...options, method: "PUT" })),
+        patch: (path, body, options = {}) => data(path, json(body, { ...options, method: "PATCH" })),
+        del: async (path, options = {}) => {
+            await request(path, { ...options, method: "DELETE" });
+        },
+        delJson: (path, options = {}) => data(path, { ...options, method: "DELETE" }),
+        page: async (path, options = {}) => envelope(await request(path, { ...options, method: "GET" })),
+    };
+}
+//# sourceMappingURL=api-client.js.map

package/dist/api-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-client.js","sourceRoot":"","sources":["../src/api-client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAmB,MAAM,eAAe,CAAC;AAC5D,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AA+I1C,MAAM,KAAK,GAAG,CAAC,EAAU,EAAiB,EAAE,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,UAAU,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;AAEnF,MAAM,UAAU,eAAe,CAAC,EAC9B,OAAO,EACP,OAAO,EACP,OAAO,EAAE,YAAY,EACrB,aAAa,EACb,OAAO,EACP,SAAS,GAAG,MAAM,EAClB,kBAAkB,GAAG,CAAC,EACtB,mBAAmB,GAAG,GAAG,EACzB,gBAAgB,GAAG,KAAK,EACxB,eAAe,GAAG,cAAc,GACf;IACjB;;;;;;;OAOG;IACH,IAAI,UAAU,GAAkC,IAAI,CAAC;IACrD,SAAS,OAAO;QACd,UAAU,KAAK,OAAO;aACnB,OAAO,EAAE;aACT,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC,CAAC;aAClD,OAAO,CAAC,GAAG,EAAE;YACZ,UAAU,GAAG,IAAI,CAAC;QACpB,CAAC,CAAC,CAAC;QACL,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,+FAA+F;IAC/F,IAAI,UAAU,GAAG,KAAK,CAAC;IACvB,SAAS,WAAW;QAClB,IAAI,CAAC,UAAU,EAAE,CAAC;YAChB,UAAU,GAAG,IAAI,CAAC;YAClB,IAAI,IAAI,GAAG,KAAK,CAAC;YACjB,MAAM,EAAE,GAAG,GAAS,EAAE;gBACpB,IAAI,IAAI;oBAAE,OAAO;gBACjB,IAAI,GAAG,IAAI,CAAC;gBACZ,aAAa,EAAE,CAAC;YAClB,CAAC,CAAC;YACF,KAAK,OAAO;iBACT,OAAO,EAAE;iBACT,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC;iBACf,OAAO,CAAC,EAAE,CAAC,CAAC;YACf,UAAU,CAAC,EAAE,EAAE,gBAAgB,CAAC,CAAC;QACnC,CAAC;QACD,qEAAqE;QACrE,MAAM,IAAI,QAAQ,CAChB,GAAG,EACH,EAAE,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,iBAAiB,EAAE,EACpD,EAAE,QAAQ,EAAE,IAAI,EAAE,CACnB,CAAC;IACJ,CAAC;IAED,SAAS,YAAY,CAAC,KAAoB,EAAE,KAA8B;QACxE,MAAM,OAAO,GAAG,IAAI,OAAO,CAAC,EAAE,GAAG,YAAY,EAAE,EAAE,EAAE,GAAG,KAAK,EAAE,CAAC,CAAC;QAC/D,IAAI,KAAK;YAAE,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE,UAAU,KAAK,EAAE,CAAC,CAAC;QAC3D,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,KAAK,UAAU,IAAI,CACjB,IAAY,EACZ,KAAoB,EACpB,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAkB;QAEhE,MAAM,MAAM,GAAG,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC;QAC3D,IAAI,MAAM,KAAK,IAAI;YACjB,OAAO,KAAK,CAAC,GAAG,OAAO,GAAG,IAAI,EAAE,EAAE,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,CAAC,KAAK,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC;QAEhG,4FAA4F;QAC5F,uFAAuF;QACvF,wFAAwF;QACxF,MAAM,OAAO,GAAG,WAAW,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QAC5C,OAAO,KAAK,CAAC,GAAG,OAAO,GAAG,IAAI,EAAE,EAAE;YAChC,GAAG,IAAI;YACP,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO;YAC7D,OAAO,EAAE,YAAY,CAAC,KAAK,EAAE,OAAO,CAAC;SACtC,CAAC,CAAC;IACL,CAAC;IAED,KAAK,UAAU,OAAO,CAAC,IAAY,EAAE,UAA0B,EAAE;QAC/D,IAAI,GAAG,GAAG,MAAM,IAAI,CAAC,IAAI,EAAE,MAAM,OAAO,CAAC,QAAQ,EAAE,EAAE,OAAO,CAAC,CAAC;QAE9D,IAAI,GAAG,CAAC,MAAM,KAAK,GAAG,EAAE,CAAC;YACvB,yFAAyF;YACzF,uFAAuF;YACvF,8DAA8D;YAC9D,IAAI,QAAQ,GAAG,KAAK,CAAC;YACrB,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,GAAG,kBAAkB,EAAE,OAAO,EAAE,EAAE,CAAC;gBAC9D,IAAI,OAAO,GAAG,CAAC;oBAAE,MAAM,KAAK,CAAC,mBAAmB,CAAC,CAAC;gBAClD,MAAM,MAAM,GAAG,MAAM,OAAO,EAAE,CAAC;gBAC/B,QAAQ,GAAG,MAAM,CAAC,WAAW,CAAC;gBAC9B,IAAI,CAAC,MAAM,CAAC,KAAK;oBAAE,SAAS;gBAC5B,GAAG,GAAG,MAAM,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;gBAC9C,IAAI,GAAG,CAAC,MAAM,KAAK,GAAG;oBAAE,MAAM;YAChC,CAAC;YACD,IAAI,GAAG,CAAC,MAAM,KAAK,GAAG,IAAI,QAAQ;gBAAE,WAAW,EAAE,CAAC;QACpD,CAAC;QAED,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC;YACZ,MAAM,IAAI,GAAY,MAAM,GAAG,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC;YACzD,MAAM,KAAK,GAAG,IAAI,QAAQ,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE;gBAC3E,SAAS,EAAE,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,IAAI,SAAS;aACzD,CAAC,CAAC;YACH,uFAAuF;YACvF,kFAAkF;YAClF,6BAA6B;YAC7B,IAAI,CAAC;gBACH,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC;YACnB,CAAC;YAAC,MAAM,CAAC;gBACP,iCAAiC;YACnC,CAAC;YACD,MAAM,KAAK,CAAC;QACd,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC;IAED;;;OAGG;IACH,KAAK,UAAU,QAAQ,CAAO,GAAa;QACzC,OAAO,CAAC,MAAM,GAAG,CAAC,IAAI,EAAE,CAAqB,CAAC;IAChD,CAAC;IAED,MAAM,IAAI,GAAG,CAAC,IAAa,EAAE,UAA0B,EAAE,EAAkB,EAAE,CAC3E,IAAI,KAAK,SAAS;QAChB,CAAC,CAAC,OAAO;QACT,CAAC,CAAC;YACE,GAAG,OAAO;YACV,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC;YAC1B,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE,GAAG,OAAO,CAAC,OAAO,EAAE;SACpE,CAAC;IAER,KAAK,UAAU,IAAI,CAAI,IAAY,EAAE,OAAuB;QAC1D,OAAO,CAAC,MAAM,QAAQ,CAAW,MAAM,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IACvE,CAAC;IAED,OAAO;QACL,OAAO;QACP,GAAG,EAAE,CAAI,IAAY,EAAE,UAA0B,EAAE,EAAE,EAAE,CACrD,IAAI,CAAI,IAAI,EAAE,EAAE,GAAG,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC;QAC9C,IAAI,EAAE,CAAI,IAAY,EAAE,IAAc,EAAE,UAA0B,EAAE,EAAE,EAAE,CACtE,IAAI,CAAI,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,EAAE,GAAG,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;QAC3D,GAAG,EAAE,CAAI,IAAY,EAAE,IAAc,EAAE,UAA0B,EAAE,EAAE,EAAE,CACrE,IAAI,CAAI,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,EAAE,GAAG,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC;QAC1D,KAAK,EAAE,CAAI,IAAY,EAAE,IAAc,EAAE,UAA0B,EAAE,EAAE,EAAE,CACvE,IAAI,CAAI,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,EAAE,GAAG,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC;QAC5D,GAAG,EAAE,KAAK,EAAE,IAAY,EAAE,UAA0B,EAAE,EAAE,EAAE;YACxD,MAAM,OAAO,CAAC,IAAI,EAAE,EAAE,GAAG,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC;QACxD,CAAC;QACD,OAAO,EAAE,CAAI,IAAY,EAAE,UAA0B,EAAE,EAAE,EAAE,CACzD,IAAI,CAAI,IAAI,EAAE,EAAE,GAAG,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;QACjD,IAAI,EAAE,KAAK,EAAQ,IAAY,EAAE,UAA0B,EAAE,EAAE,EAAE,CAC/D,QAAQ,CAAO,MAAM,OAAO,CAAC,IAAI,EAAE,EAAE,GAAG,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC;KACrE,CAAC;AACJ,CAAC"}

package/dist/api-error.d.ts

@@ -0,0 +1,45 @@
+import type { ApiError as ApiErrorBody } from "@gusnips/http";
+/**
+ * A refusal, with the whole envelope intact.
+ *
+ * `code` is what the UI switches on, `messageKey` is what gets localized, and `details` carries
+ * the parts that make a refusal actionable — the `resetAt` on a 429, the plan that lifts a 402.
+ * Keeping all of it means a caller never has to re-parse a response body that has already been
+ * read once.
+ *
+ * A real `class` and not an interface with a factory: one donor used the interface shape, which
+ * works until something needs `instanceof` across a module boundary or wants a subclass.
+ */
+export declare class ApiError extends Error {
+    readonly status: number;
+    readonly code: string | undefined;
+    readonly messageKey: string | undefined;
+    readonly params: Record<string, string | number> | undefined;
+    readonly details: unknown;
+    readonly requestId: string | undefined;
+    /**
+     * The client raised this itself to stop a caller while it was already handling the
+     * situation — today, the 401 thrown after a dead session, where the person is already on
+     * their way to the sign-in page.
+     *
+     * It is control flow, not a fault. Exception reporting should skip it, and an error surface
+     * should not ask somebody to retry something that is not broken. One donor had this and it is
+     * the difference between a clean sign-out and a crash report every time a session expires.
+     */
+    readonly expected: boolean;
+    constructor(status: number, body: ApiErrorBody["error"] | null, opts?: {
+        requestId?: string;
+        expected?: boolean;
+        message?: string;
+    });
+}
+/**
+ * An aborted request — the caller's own `AbortController`, or a navigation that unmounted the
+ * component waiting on it.
+ *
+ * Worth its own predicate because it is the one failure that must NOT be reported, retried or
+ * shown: nobody is waiting for the answer. Distinguishing it from a real failure is what keeps
+ * a route change from filling the console with errors nobody caused.
+ */
+export declare function isAbortError(error: unknown): boolean;
+//# sourceMappingURL=api-error.d.ts.map

package/dist/api-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-error.d.ts","sourceRoot":"","sources":["../src/api-error.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,IAAI,YAAY,EAAE,MAAM,eAAe,CAAC;AAE9D;;;;;;;;;;GAUG;AACH,qBAAa,QAAS,SAAQ,KAAK;IACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IACxC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG,SAAS,CAAC;IAC7D,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAEvC;;;;;;;;OAQG;IACH,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;gBAGzB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,YAAY,CAAC,OAAO,CAAC,GAAG,IAAI,EAClC,IAAI,GAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAO;CAY1E;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAEpD"}

package/dist/api-error.js

@@ -0,0 +1,52 @@
+/**
+ * A refusal, with the whole envelope intact.
+ *
+ * `code` is what the UI switches on, `messageKey` is what gets localized, and `details` carries
+ * the parts that make a refusal actionable — the `resetAt` on a 429, the plan that lifts a 402.
+ * Keeping all of it means a caller never has to re-parse a response body that has already been
+ * read once.
+ *
+ * A real `class` and not an interface with a factory: one donor used the interface shape, which
+ * works until something needs `instanceof` across a module boundary or wants a subclass.
+ */
+export class ApiError extends Error {
+    status;
+    code;
+    messageKey;
+    params;
+    details;
+    requestId;
+    /**
+     * The client raised this itself to stop a caller while it was already handling the
+     * situation — today, the 401 thrown after a dead session, where the person is already on
+     * their way to the sign-in page.
+     *
+     * It is control flow, not a fault. Exception reporting should skip it, and an error surface
+     * should not ask somebody to retry something that is not broken. One donor had this and it is
+     * the difference between a clean sign-out and a crash report every time a session expires.
+     */
+    expected;
+    constructor(status, body, opts = {}) {
+        super(opts.message ?? body?.message ?? `Request failed (${status})`);
+        this.name = "ApiError";
+        this.status = status;
+        this.code = body?.code;
+        this.messageKey = body?.messageKey;
+        this.params = body?.params;
+        this.details = body?.details;
+        this.requestId = opts.requestId;
+        this.expected = opts.expected ?? false;
+    }
+}
+/**
+ * An aborted request — the caller's own `AbortController`, or a navigation that unmounted the
+ * component waiting on it.
+ *
+ * Worth its own predicate because it is the one failure that must NOT be reported, retried or
+ * shown: nobody is waiting for the answer. Distinguishing it from a real failure is what keeps
+ * a route change from filling the console with errors nobody caused.
+ */
+export function isAbortError(error) {
+    return error instanceof DOMException && error.name === "AbortError";
+}
+//# sourceMappingURL=api-error.js.map

package/dist/api-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-error.js","sourceRoot":"","sources":["../src/api-error.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,MAAM,OAAO,QAAS,SAAQ,KAAK;IACxB,MAAM,CAAS;IACf,IAAI,CAAqB;IACzB,UAAU,CAAqB;IAC/B,MAAM,CAA8C;IACpD,OAAO,CAAU;IACjB,SAAS,CAAqB;IAEvC;;;;;;;;OAQG;IACM,QAAQ,CAAU;IAE3B,YACE,MAAc,EACd,IAAkC,EAClC,OAAqE,EAAE;QAEvE,KAAK,CAAC,IAAI,CAAC,OAAO,IAAI,IAAI,EAAE,OAAO,IAAI,mBAAmB,MAAM,GAAG,CAAC,CAAC;QACrE,IAAI,CAAC,IAAI,GAAG,UAAU,CAAC;QACvB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,IAAI,GAAG,IAAI,EAAE,IAAI,CAAC;QACvB,IAAI,CAAC,UAAU,GAAG,IAAI,EAAE,UAAU,CAAC;QACnC,IAAI,CAAC,MAAM,GAAG,IAAI,EAAE,MAAM,CAAC;QAC3B,IAAI,CAAC,OAAO,GAAG,IAAI,EAAE,OAAO,CAAC;QAC7B,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;QAChC,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,IAAI,KAAK,CAAC;IACzC,CAAC;CACF;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,YAAY,CAAC,KAAc;IACzC,OAAO,KAAK,YAAY,YAAY,IAAI,KAAK,CAAC,IAAI,KAAK,YAAY,CAAC;AACtE,CAAC"}

package/dist/auth-store.d.ts

@@ -0,0 +1,49 @@
+import { type StoreApi, type UseBoundStore } from "zustand";
+/**
+ * Session FLAGS only.
+ *
+ * Who the person is — their plan, their staff bit, whether they are suspended — comes from
+ * `GET /auth/me` through react-query, never from here. Mirroring server state in a client store
+ * is how two sources of truth start disagreeing, and the one that is wrong is always the one on
+ * screen. Three repos wrote this same store; two of them wrote that same warning in a comment.
+ *
+ * `TUser` stays generic because it is the one part that differs: one product carries an
+ * anonymous-browsing flag, another does not. Keep it to what a GUARD needs — an id and an
+ * email is what all three donors had.
+ */
+export interface AuthState<TUser> {
+    user: TUser | null;
+    isAuthenticated: boolean;
+    /**
+     * True until the first session lookup resolves. The guards must not bounce somebody to
+     * /login while we are still finding out whether they are signed in.
+     */
+    isLoading: boolean;
+    /**
+     * Set (or clear) the signed-in user. This ENDS the loading state — knowing who they are is
+     * what the bootstrap was waiting for. Two of the three donors left `isLoading` alone here and
+     * relied on a separate `setLoading(false)`; forgetting that call leaves every guard spinning,
+     * so the safe default is to do it in one write.
+     */
+    setUser: (user: TUser | null) => void;
+    setLoading: (isLoading: boolean) => void;
+    /** Sign-out: clears the user and ends the loading state in one write. */
+    clear: () => void;
+}
+/**
+ * Create the store.
+ *
+ * The whole reason this is a factory and not a store: `isLoading` must start FALSE where there
+ * is no window, and only a factory can decide that at the call site rather than at import.
+ *
+ * A session bootstrap can only be in flight in a browser. The BUILD renders this app to files
+ * with no window at all, so `true` there is a wait that never ends — one donor shipped a route
+ * guard holding its loading screen forever, and prerendered a public page as 1,174 bytes of
+ * `role="status"`: a spinner as the indexable body of a page whose entire purpose was to be
+ * found. With no browser there is no session and never will be, which is exactly the state a
+ * first-time visitor arrives in, so that is what the page should render.
+ *
+ * Only one of the three donors knew this. It is invariant 7.
+ */
+export declare function createAuthStore<TUser>(): UseBoundStore<StoreApi<AuthState<TUser>>>;
+//# sourceMappingURL=auth-store.d.ts.map

package/dist/auth-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-store.d.ts","sourceRoot":"","sources":["../src/auth-store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,QAAQ,EAAE,KAAK,aAAa,EAAE,MAAM,SAAS,CAAC;AAEpE;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,SAAS,CAAC,KAAK;IAC9B,IAAI,EAAE,KAAK,GAAG,IAAI,CAAC;IACnB,eAAe,EAAE,OAAO,CAAC;IACzB;;;OAGG;IACH,SAAS,EAAE,OAAO,CAAC;IACnB;;;;;OAKG;IACH,OAAO,EAAE,CAAC,IAAI,EAAE,KAAK,GAAG,IAAI,KAAK,IAAI,CAAC;IACtC,UAAU,EAAE,CAAC,SAAS,EAAE,OAAO,KAAK,IAAI,CAAC;IACzC,yEAAyE;IACzE,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAAC,KAAK,KAAK,aAAa,CAAC,QAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CASlF"}