@gusnips/react 0.1.0

package/dist/auth-store.js

@@ -0,0 +1,27 @@
+import { create } from "zustand";
+/**
+ * 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 function createAuthStore() {
+    return create((set) => ({
+        user: null,
+        isAuthenticated: false,
+        isLoading: typeof window !== "undefined",
+        setUser: (user) => set({ user, isAuthenticated: Boolean(user), isLoading: false }),
+        setLoading: (isLoading) => set({ isLoading }),
+        clear: () => set({ user: null, isAuthenticated: false, isLoading: false }),
+    }));
+}
+//# sourceMappingURL=auth-store.js.map

package/dist/auth-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-store.js","sourceRoot":"","sources":["../src/auth-store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAqC,MAAM,SAAS,CAAC;AAkCpE;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,eAAe;IAC7B,OAAO,MAAM,CAAmB,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;QACxC,IAAI,EAAE,IAAI;QACV,eAAe,EAAE,KAAK;QACtB,SAAS,EAAE,OAAO,MAAM,KAAK,WAAW;QACxC,OAAO,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,eAAe,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC;QAClF,UAAU,EAAE,CAAC,SAAS,EAAE,EAAE,CAAC,GAAG,CAAC,EAAE,SAAS,EAAE,CAAC;QAC7C,KAAK,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC;KAC3E,CAAC,CAAC,CAAC;AACN,CAAC"}

package/dist/chunk-reload.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Surviving a deploy that lands while a tab is open.
+ *
+ * Every app on this stack is a Vite SPA with `lazy()` routes, deployed on push. When a build
+ * replaces the one a tab is running, the next navigation asks for a chunk whose hashed name no
+ * longer exists — and a static host answers a missing asset with the SPA fallback, so the
+ * import gets HTML where it expected a module. React's lazy boundary throws, and the person
+ * gets a white screen on a click that worked a minute ago.
+ *
+ * One repo in the fleet had all of this. The others had none of it, and none of them knew.
+ */
+/**
+ * A lazy-chunk fetch failure — recoverable by reloading.
+ *
+ * Matched by message because no browser gives it a shared type. Every phrasing in the wild is
+ * here: Chrome/Edge "Failed to fetch dynamically imported module", Firefox "error loading
+ * dynamically imported module", Safari "Importing a module script failed", webpack's
+ * ChunkLoadError and "Loading chunk N failed", and the SPA-fallback "MIME type" refusal —
+ * which is the one that actually fires on a static host, because the missing `.js` is answered
+ * with `index.html`.
+ *
+ * A standalone predicate rather than a method on the boundary, so a global `unhandledrejection`
+ * handler can classify the same failure without importing a component.
+ */
+export declare function isChunkLoadError(error: unknown): boolean;
+/**
+ * Hard-reload once to pick up the fresh deploy. Returns false when the guard suppressed it.
+ *
+ * The guard is the part that matters. Reloading on a chunk error is obvious; reloading on a
+ * chunk error that the reload does not fix is an infinite loop with the user inside it. At most
+ * one reload per minute, so a genuinely missing chunk degrades to the error UI — which can at
+ * least say something — instead of flickering forever.
+ *
+ * `sessionStorage` and not `localStorage`: the guard is about this tab's current predicament,
+ * and a stale flag in another tab must not suppress a reload this one needs. Wrapped because
+ * storage throws outright when site data is blocked, and a privacy setting must not be the
+ * reason somebody cannot recover.
+ */
+export declare function reloadOnceForChunkError(): boolean;
+/**
+ * Vite's *hint* failure, which is not the same thing and must not be treated as one.
+ *
+ * Vite injects a speculative `<link rel="stylesheet">` for a chunk's CSS before importing it.
+ * When that link fails, the import itself still runs right after and usually succeeds — so this
+ * one is worth swallowing, where a failure of the import is the real thing
+ * {@link isChunkLoadError} matches. Vite builds this message in exactly one place and only ever
+ * for a stylesheet link; script hints never reject.
+ */
+export declare function isPreloadHintFailure(error: unknown): boolean;
+/**
+ * Install the `vite:preloadError` listener. Call once, from the browser entry.
+ *
+ * Vite offers `preventDefault()` here so an app can own a failed asset itself — but taking that
+ * deal unconditionally resolves the dynamic import with `undefined` (Vite's helper ends in
+ * `baseModule().catch(handlePreloadError)`), and `React.lazy` then reads `.default` off nothing.
+ * The user gets the crash screen and the developer gets a TypeError with only React frames in
+ * it, naming no chunk. So it is taken ONLY for a failed preload hint, where the import still
+ * runs. A real module failure is left to throw, where the error boundary can recognise it.
+ */
+export declare function installPreloadErrorHandler(): void;
+//# sourceMappingURL=chunk-reload.d.ts.map

package/dist/chunk-reload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk-reload.d.ts","sourceRoot":"","sources":["../src/chunk-reload.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAKH;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CASxD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,IAAI,OAAO,CAWjD;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAE5D;AAED;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,IAAI,IAAI,CAKjD"}

package/dist/chunk-reload.js

@@ -0,0 +1,92 @@
+/**
+ * Surviving a deploy that lands while a tab is open.
+ *
+ * Every app on this stack is a Vite SPA with `lazy()` routes, deployed on push. When a build
+ * replaces the one a tab is running, the next navigation asks for a chunk whose hashed name no
+ * longer exists — and a static host answers a missing asset with the SPA fallback, so the
+ * import gets HTML where it expected a module. React's lazy boundary throws, and the person
+ * gets a white screen on a click that worked a minute ago.
+ *
+ * One repo in the fleet had all of this. The others had none of it, and none of them knew.
+ */
+const RELOAD_FLAG_KEY = "frontkit:chunk-reload-at";
+const RELOAD_WINDOW_MS = 60_000;
+/**
+ * A lazy-chunk fetch failure — recoverable by reloading.
+ *
+ * Matched by message because no browser gives it a shared type. Every phrasing in the wild is
+ * here: Chrome/Edge "Failed to fetch dynamically imported module", Firefox "error loading
+ * dynamically imported module", Safari "Importing a module script failed", webpack's
+ * ChunkLoadError and "Loading chunk N failed", and the SPA-fallback "MIME type" refusal —
+ * which is the one that actually fires on a static host, because the missing `.js` is answered
+ * with `index.html`.
+ *
+ * A standalone predicate rather than a method on the boundary, so a global `unhandledrejection`
+ * handler can classify the same failure without importing a component.
+ */
+export function isChunkLoadError(error) {
+    if (error instanceof Error && error.name === "ChunkLoadError")
+        return true;
+    const message = (error instanceof Error ? error.message : String(error) || "").toLowerCase();
+    return (message.includes("dynamically imported module") ||
+        message.includes("importing a module script failed") ||
+        message.includes("mime type") ||
+        message.includes("loading chunk"));
+}
+/**
+ * Hard-reload once to pick up the fresh deploy. Returns false when the guard suppressed it.
+ *
+ * The guard is the part that matters. Reloading on a chunk error is obvious; reloading on a
+ * chunk error that the reload does not fix is an infinite loop with the user inside it. At most
+ * one reload per minute, so a genuinely missing chunk degrades to the error UI — which can at
+ * least say something — instead of flickering forever.
+ *
+ * `sessionStorage` and not `localStorage`: the guard is about this tab's current predicament,
+ * and a stale flag in another tab must not suppress a reload this one needs. Wrapped because
+ * storage throws outright when site data is blocked, and a privacy setting must not be the
+ * reason somebody cannot recover.
+ */
+export function reloadOnceForChunkError() {
+    const now = Date.now();
+    try {
+        const last = Number(sessionStorage.getItem(RELOAD_FLAG_KEY) ?? 0);
+        if (now - last < RELOAD_WINDOW_MS)
+            return false;
+        sessionStorage.setItem(RELOAD_FLAG_KEY, String(now));
+    }
+    catch {
+        // Storage blocked — proceed with the reload rather than refusing to recover.
+    }
+    window.location.reload();
+    return true;
+}
+/**
+ * Vite's *hint* failure, which is not the same thing and must not be treated as one.
+ *
+ * Vite injects a speculative `<link rel="stylesheet">` for a chunk's CSS before importing it.
+ * When that link fails, the import itself still runs right after and usually succeeds — so this
+ * one is worth swallowing, where a failure of the import is the real thing
+ * {@link isChunkLoadError} matches. Vite builds this message in exactly one place and only ever
+ * for a stylesheet link; script hints never reject.
+ */
+export function isPreloadHintFailure(error) {
+    return error instanceof Error && error.message.startsWith("Unable to preload CSS for");
+}
+/**
+ * Install the `vite:preloadError` listener. Call once, from the browser entry.
+ *
+ * Vite offers `preventDefault()` here so an app can own a failed asset itself — but taking that
+ * deal unconditionally resolves the dynamic import with `undefined` (Vite's helper ends in
+ * `baseModule().catch(handlePreloadError)`), and `React.lazy` then reads `.default` off nothing.
+ * The user gets the crash screen and the developer gets a TypeError with only React frames in
+ * it, naming no chunk. So it is taken ONLY for a failed preload hint, where the import still
+ * runs. A real module failure is left to throw, where the error boundary can recognise it.
+ */
+export function installPreloadErrorHandler() {
+    window.addEventListener("vite:preloadError", (event) => {
+        const payload = event.payload;
+        if (isPreloadHintFailure(payload))
+            event.preventDefault();
+    });
+}
+//# sourceMappingURL=chunk-reload.js.map

package/dist/chunk-reload.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk-reload.js","sourceRoot":"","sources":["../src/chunk-reload.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,MAAM,eAAe,GAAG,0BAA0B,CAAC;AACnD,MAAM,gBAAgB,GAAG,MAAM,CAAC;AAEhC;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAc;IAC7C,IAAI,KAAK,YAAY,KAAK,IAAI,KAAK,CAAC,IAAI,KAAK,gBAAgB;QAAE,OAAO,IAAI,CAAC;IAC3E,MAAM,OAAO,GAAG,CAAC,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC;IAC7F,OAAO,CACL,OAAO,CAAC,QAAQ,CAAC,6BAA6B,CAAC;QAC/C,OAAO,CAAC,QAAQ,CAAC,kCAAkC,CAAC;QACpD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC;QAC7B,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAC,CAClC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,uBAAuB;IACrC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IACvB,IAAI,CAAC;QACH,MAAM,IAAI,GAAG,MAAM,CAAC,cAAc,CAAC,OAAO,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC;QAClE,IAAI,GAAG,GAAG,IAAI,GAAG,gBAAgB;YAAE,OAAO,KAAK,CAAC;QAChD,cAAc,CAAC,OAAO,CAAC,eAAe,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;IACvD,CAAC;IAAC,MAAM,CAAC;QACP,6EAA6E;IAC/E,CAAC;IACD,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;IACzB,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,oBAAoB,CAAC,KAAc;IACjD,OAAO,KAAK,YAAY,KAAK,IAAI,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,2BAA2B,CAAC,CAAC;AACzF,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,0BAA0B;IACxC,MAAM,CAAC,gBAAgB,CAAC,mBAAmB,EAAE,CAAC,KAAK,EAAE,EAAE;QACrD,MAAM,OAAO,GAAI,KAAuC,CAAC,OAAO,CAAC;QACjE,IAAI,oBAAoB,CAAC,OAAO,CAAC;YAAE,KAAK,CAAC,cAAc,EAAE,CAAC;IAC5D,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/cn.d.ts

@@ -0,0 +1,13 @@
+import { type ClassValue } from "clsx";
+/**
+ * Compose class names, letting later Tailwind utilities win over earlier ones
+ * (`p-2 p-4` → `p-4`).
+ *
+ * That precedence is the whole point, and it is why this is not `clsx` alone: a caller's
+ * `className` has to be able to OVERRIDE a component's defaults rather than fight them at
+ * equal specificity, where the winner would be whichever rule Tailwind happened to emit last.
+ *
+ * Ten repos wrote this function. All ten wrote it identically.
+ */
+export declare function cn(...inputs: ClassValue[]): string;
+//# sourceMappingURL=cn.d.ts.map

package/dist/cn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cn.d.ts","sourceRoot":"","sources":["../src/cn.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,UAAU,EAAE,MAAM,MAAM,CAAC;AAG7C;;;;;;;;;GASG;AACH,wBAAgB,EAAE,CAAC,GAAG,MAAM,EAAE,UAAU,EAAE,GAAG,MAAM,CAElD"}

package/dist/cn.js

@@ -0,0 +1,16 @@
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+/**
+ * Compose class names, letting later Tailwind utilities win over earlier ones
+ * (`p-2 p-4` → `p-4`).
+ *
+ * That precedence is the whole point, and it is why this is not `clsx` alone: a caller's
+ * `className` has to be able to OVERRIDE a component's defaults rather than fight them at
+ * equal specificity, where the winner would be whichever rule Tailwind happened to emit last.
+ *
+ * Ten repos wrote this function. All ten wrote it identically.
+ */
+export function cn(...inputs) {
+    return twMerge(clsx(inputs));
+}
+//# sourceMappingURL=cn.js.map

package/dist/cn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cn.js","sourceRoot":"","sources":["../src/cn.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAmB,MAAM,MAAM,CAAC;AAC7C,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAEzC;;;;;;;;;GASG;AACH,MAAM,UAAU,EAAE,CAAC,GAAG,MAAoB;IACxC,OAAO,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;AAC/B,CAAC"}

package/dist/describe-error.d.ts

@@ -0,0 +1,74 @@
+import { ApiError } from "./api-error.ts";
+/**
+ * Turning anything thrown into copy a person can act on.
+ *
+ * The API already answers with a message written for a developer, a stable `messageKey` for the
+ * domain refusals, and `details` carrying the parts that make a refusal actionable. This is the
+ * one place that decides what the SCREEN says — which is not always the same sentence.
+ * "Monthly quota spent, upgrade or buy a pack" is right in a JSON body and wrong under a button
+ * that could just say what to do next.
+ *
+ * `cause` is what happened. `hint` is what to do about it. **A surface that shows only the first
+ * half is the dead end this exists to prevent** — which is why the type has two fields and not
+ * one, and why `hint` being absent should be a deliberate choice at each call site rather than
+ * the default nobody noticed.
+ *
+ * The per-code switch stays in the product: two donors' switches shared their SHAPE and almost
+ * no arms, because the arms are that API's vocabulary. What ships is the scaffolding around it,
+ * which is the part that was written twice and got subtly different both times.
+ */
+export interface DescribedError {
+    /** What happened, in the reader's words. */
+    cause: string;
+    /** What to do about it. Its absence should be a decision, not an oversight. */
+    hint?: string;
+}
+/** The subset of i18next's `t` this module needs — typed here so `i18next` stays optional. */
+export type Translate = (key: string, params?: Record<string, unknown>) => string;
+/** Seconds until a refusal clears, when the envelope carries them. */
+export declare function retryAfterSecs(error: ApiError): number | null;
+/**
+ * "in 4 minutes" / "in 2 hours" — a wait nobody has to convert from seconds.
+ *
+ * The thresholds are deliberately not round: 90 seconds rather than 60, so "in 75 seconds" does
+ * not become the less precise "in 1 minute", and 90 minutes rather than 60 for the same reason
+ * one rung up. Needs `waitSeconds` / `waitMinutes` / `waitHours` in the catalog, each with a
+ * `count` plural.
+ */
+export declare function humanizeWait(t: Translate, secs: number, prefix?: string): string;
+export interface ErrorDescriberOptions<Code extends string> {
+    t: Translate;
+    /**
+     * The server's own catalog namespace, e.g. `"serverErrors."`. A `messageKey` outside it is
+     * ignored — the server names a sentence, it does not get to name any key in the app.
+     */
+    messageKeyPrefix?: string;
+    /**
+     * The keys this build actually carries, usually `Object.keys(en.serverErrors)`.
+     *
+     * Membership is checked with `hasOwnProperty` and not `in`, which would accept `"toString"`.
+     * A key that is absent falls back to the server's English `message`, because a deploy can land
+     * ahead of the bundle a tab is still running and a missing translation must degrade to
+     * readable rather than render the key itself at somebody.
+     */
+    knownMessageKeys?: readonly string[] | Record<string, unknown>;
+    /** Catalog namespace for this module's own copy. Defaults to `"errors."`. */
+    copyPrefix?: string;
+    /** Per-code copy. Everything not listed falls through to the default arm below. */
+    codes?: Partial<Record<Code, (ctx: ErrorContext) => DescribedError>>;
+}
+export interface ErrorContext {
+    error: ApiError;
+    /** The server's own localized sentence, when `messageKey` named one this build carries. */
+    says: string | null;
+    /** Seconds until it clears, already humanized. Null when the envelope did not say. */
+    wait: string | null;
+    waitSecs: number | null;
+    t: Translate;
+}
+/**
+ * Build the describer. Needs `network`, `networkHint`, `unexpected`, `retrySoon`,
+ * `waitSeconds`, `waitMinutes` and `waitHours` under `copyPrefix` in every locale.
+ */
+export declare function createErrorDescriber<Code extends string>({ t, messageKeyPrefix, knownMessageKeys, copyPrefix, codes, }: ErrorDescriberOptions<Code>): (error: unknown) => DescribedError;
+//# sourceMappingURL=describe-error.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"describe-error.d.ts","sourceRoot":"","sources":["../src/describe-error.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C;;;;;;;;;;;;;;;;;GAiBG;AAEH,MAAM,WAAW,cAAc;IAC7B,4CAA4C;IAC5C,KAAK,EAAE,MAAM,CAAC;IACd,+EAA+E;IAC/E,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,8FAA8F;AAC9F,MAAM,MAAM,SAAS,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,MAAM,CAAC;AAElF,sEAAsE;AACtE,wBAAgB,cAAc,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,GAAG,IAAI,CAK7D;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,SAAK,GAAG,MAAM,CAK5E;AAED,MAAM,WAAW,qBAAqB,CAAC,IAAI,SAAS,MAAM;IACxD,CAAC,EAAE,SAAS,CAAC;IACb;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;;;;OAOG;IACH,gBAAgB,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/D,6EAA6E;IAC7E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,mFAAmF;IACnF,KAAK,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,GAAG,EAAE,YAAY,KAAK,cAAc,CAAC,CAAC,CAAC;CACtE;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,QAAQ,CAAC;IAChB,2FAA2F;IAC3F,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,sFAAsF;IACtF,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,CAAC,EAAE,SAAS,CAAC;CACd;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,SAAS,MAAM,EAAE,EACxD,CAAC,EACD,gBAAkC,EAClC,gBAAgB,EAChB,UAAsB,EACtB,KAAU,GACX,EAAE,qBAAqB,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,OAAO,KAAK,cAAc,CA2ClE"}

package/dist/describe-error.js

@@ -0,0 +1,70 @@
+import { ApiError } from "./api-error.js";
+/** Seconds until a refusal clears, when the envelope carries them. */
+export function retryAfterSecs(error) {
+    const details = error.details;
+    if (typeof details !== "object" || details === null)
+        return null;
+    const value = details.retryAfterSecs;
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+/**
+ * "in 4 minutes" / "in 2 hours" — a wait nobody has to convert from seconds.
+ *
+ * The thresholds are deliberately not round: 90 seconds rather than 60, so "in 75 seconds" does
+ * not become the less precise "in 1 minute", and 90 minutes rather than 60 for the same reason
+ * one rung up. Needs `waitSeconds` / `waitMinutes` / `waitHours` in the catalog, each with a
+ * `count` plural.
+ */
+export function humanizeWait(t, secs, prefix = "") {
+    const key = (name) => `${prefix}${name}`;
+    if (secs < 90)
+        return t(key("waitSeconds"), { count: Math.max(1, Math.round(secs)) });
+    if (secs < 90 * 60)
+        return t(key("waitMinutes"), { count: Math.round(secs / 60) });
+    return t(key("waitHours"), { count: Math.round(secs / 3600) });
+}
+/**
+ * Build the describer. Needs `network`, `networkHint`, `unexpected`, `retrySoon`,
+ * `waitSeconds`, `waitMinutes` and `waitHours` under `copyPrefix` in every locale.
+ */
+export function createErrorDescriber({ t, messageKeyPrefix = "serverErrors.", knownMessageKeys, copyPrefix = "errors.", codes = {}, }) {
+    const known = Array.isArray(knownMessageKeys)
+        ? new Set(knownMessageKeys)
+        : new Set(Object.keys(knownMessageKeys ?? {}));
+    const has = (name) => known.size === 0 || known.has(name);
+    const key = (name) => `${copyPrefix}${name}`;
+    function serverSentence(error) {
+        const messageKey = error.messageKey;
+        if (messageKey === undefined || !messageKey.startsWith(messageKeyPrefix))
+            return null;
+        const name = messageKey.slice(messageKeyPrefix.length);
+        return has(name) ? t(messageKey, error.params) : null;
+    }
+    return function describeError(error) {
+        if (!(error instanceof ApiError)) {
+            // Not a response at all — the request never landed. Almost always the network, and almost
+            // never worth showing a stack trace for.
+            return { cause: t(key("network")), hint: t(key("networkHint")) };
+        }
+        const waitSecs = retryAfterSecs(error);
+        const ctx = {
+            error,
+            says: serverSentence(error),
+            wait: waitSecs === null ? null : humanizeWait(t, waitSecs, copyPrefix),
+            waitSecs,
+            t,
+        };
+        const arm = error.code === undefined ? undefined : codes[error.code];
+        if (arm)
+            return arm(ctx);
+        // Anything unmapped: the server's own sentence is still the most specific thing we have,
+        // and support can act on it. A 5xx additionally gets "try again shortly", because that one
+        // genuinely does clear on its own — a 4xx does not, and saying so would be a lie that costs
+        // the reader another attempt.
+        return {
+            cause: ctx.says ?? (error.message || t(key("unexpected"))),
+            hint: error.status >= 500 ? t(key("retrySoon")) : undefined,
+        };
+    };
+}
+//# sourceMappingURL=describe-error.js.map

package/dist/describe-error.js.map

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

package/dist/error-boundary.d.ts

@@ -0,0 +1,61 @@
+import { Component, type ErrorInfo, type ReactNode } from "react";
+/**
+ * The last stop before a white screen.
+ *
+ * React unmounts the whole tree when a render throws, and an app with no boundary anywhere
+ * answers that with a blank page: no words, no navigation, no reload — the most complete dead
+ * end a product can produce, and the one the never-dead-end rule cannot reach, because by then
+ * there is no component left to render a state from.
+ *
+ * It is deliberately dumb. No retry loop, no error reporting, no reset on a timer: it catches,
+ * it hands the error to a `fallback` the app draws in its own words, and it offers `reset`.
+ * Every donor that baked its own UI in here had to keep a second copy for its second surface;
+ * a render prop has no such problem, and the brand stays in the product where it belongs.
+ *
+ * A class, because `getDerivedStateFromError` has no hook equivalent — this is the one thing in
+ * the kit React still has no other way to express.
+ */
+export interface ErrorBoundaryFallbackProps {
+    error: Error;
+    /** Put the children back. */
+    reset: () => void;
+    /**
+     * True when the throw was a failed lazy-chunk import — a deploy landed while this tab was
+     * open, so the fix is a reload and NOT a retry (a rejected dynamic import rethrows on
+     * re-render forever). Draw the "updating" screen, not the crash screen.
+     */
+    isChunkError: boolean;
+}
+export interface ErrorBoundaryProps {
+    /** Drawn instead of the children once something has thrown. */
+    fallback: (props: ErrorBoundaryFallbackProps) => ReactNode;
+    /**
+     * Changing this value clears the error and remounts the children — pass the route, so
+     * navigating away from a screen that broke actually leaves it rather than carrying its
+     * wreckage to every page after it.
+     */
+    resetKey?: string;
+    /** Called once per catch. Report to whatever the app reports to. */
+    onError?: (error: Error, info: ErrorInfo) => void;
+    /**
+     * Classify a chunk-load failure. Pass `isChunkLoadError` from this package; it is a
+     * parameter rather than a hard import so an app that does not lazy-load pays nothing.
+     */
+    isChunkError?: (error: unknown) => boolean;
+    children: ReactNode;
+}
+interface State {
+    error: Error | null;
+    /** Which `resetKey` the current error belongs to. */
+    key: string | undefined;
+}
+export declare class ErrorBoundary extends Component<ErrorBoundaryProps, State> {
+    state: State;
+    static getDerivedStateFromError(error: Error): Pick<State, "error">;
+    static getDerivedStateFromProps(props: ErrorBoundaryProps, state: State): State | null;
+    componentDidCatch(error: Error, info: ErrorInfo): void;
+    private readonly reset;
+    render(): ReactNode;
+}
+export {};
+//# sourceMappingURL=error-boundary.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"error-boundary.d.ts","sourceRoot":"","sources":["../src/error-boundary.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAElE;;;;;;;;;;;;;;;GAeG;AAEH,MAAM,WAAW,0BAA0B;IACzC,KAAK,EAAE,KAAK,CAAC;IACb,6BAA6B;IAC7B,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB;;;;OAIG;IACH,YAAY,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,kBAAkB;IACjC,+DAA+D;IAC/D,QAAQ,EAAE,CAAC,KAAK,EAAE,0BAA0B,KAAK,SAAS,CAAC;IAC3D;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oEAAoE;IACpE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,KAAK,IAAI,CAAC;IAClD;;;OAGG;IACH,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;IAC3C,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED,UAAU,KAAK;IACb,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,qDAAqD;IACrD,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;CACzB;AAED,qBAAa,aAAc,SAAQ,SAAS,CAAC,kBAAkB,EAAE,KAAK,CAAC;IAC5D,KAAK,EAAE,KAAK,CAAmC;IAExD,MAAM,CAAC,wBAAwB,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC,KAAK,EAAE,OAAO,CAAC;IAInE,MAAM,CAAC,wBAAwB,CAAC,KAAK,EAAE,kBAAkB,EAAE,KAAK,EAAE,KAAK,GAAG,KAAK,GAAG,IAAI;IAQ7E,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,GAAG,IAAI;IAK/D,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA8D;IAE3E,MAAM,IAAI,SAAS;CAS7B"}

package/dist/error-boundary.js

@@ -0,0 +1,32 @@
+import { Component } from "react";
+export class ErrorBoundary extends Component {
+    state = { error: null, key: undefined };
+    static getDerivedStateFromError(error) {
+        return { error };
+    }
+    static getDerivedStateFromProps(props, state) {
+        if (state.error === null)
+            return { error: null, key: props.resetKey };
+        // The error belongs to the screen it happened on. Somewhere else is a fresh start, and
+        // staying broken there would strand somebody who already did the sensible thing and
+        // navigated away.
+        return state.key === props.resetKey ? null : { error: null, key: props.resetKey };
+    }
+    componentDidCatch(error, info) {
+        this.props.onError?.(error, info);
+        if (!this.props.onError)
+            console.error("Unhandled render error", error, info.componentStack);
+    }
+    reset = () => this.setState({ error: null, key: undefined });
+    render() {
+        const { error } = this.state;
+        if (error === null)
+            return this.props.children;
+        return this.props.fallback({
+            error,
+            reset: this.reset,
+            isChunkError: this.props.isChunkError?.(error) ?? false,
+        });
+    }
+}
+//# sourceMappingURL=error-boundary.js.map

package/dist/error-boundary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-boundary.js","sourceRoot":"","sources":["../src/error-boundary.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAkC,MAAM,OAAO,CAAC;AAwDlE,MAAM,OAAO,aAAc,SAAQ,SAAoC;IAC5D,KAAK,GAAU,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,SAAS,EAAE,CAAC;IAExD,MAAM,CAAC,wBAAwB,CAAC,KAAY;QAC1C,OAAO,EAAE,KAAK,EAAE,CAAC;IACnB,CAAC;IAED,MAAM,CAAC,wBAAwB,CAAC,KAAyB,EAAE,KAAY;QACrE,IAAI,KAAK,CAAC,KAAK,KAAK,IAAI;YAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,QAAQ,EAAE,CAAC;QACtE,uFAAuF;QACvF,oFAAoF;QACpF,kBAAkB;QAClB,OAAO,KAAK,CAAC,GAAG,KAAK,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,QAAQ,EAAE,CAAC;IACpF,CAAC;IAEQ,iBAAiB,CAAC,KAAY,EAAE,IAAe;QACtD,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QAClC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO;YAAE,OAAO,CAAC,KAAK,CAAC,wBAAwB,EAAE,KAAK,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;IAC/F,CAAC;IAEgB,KAAK,GAAG,GAAS,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,SAAS,EAAE,CAAC,CAAC;IAE3E,MAAM;QACb,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC;QAC7B,IAAI,KAAK,KAAK,IAAI;YAAE,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC;QAC/C,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC;YACzB,KAAK;YACL,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,YAAY,EAAE,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK;SACxD,CAAC,CAAC;IACL,CAAC;CACF"}

package/dist/guards.d.ts

@@ -0,0 +1,65 @@
+import type { ReactNode } from "react";
+/**
+ * Route guards.
+ *
+ * Two donors wrote these four, gave two of them the same names, and explained them in nearly
+ * the same words. What differed was one line — and that line is invariant 4, so it is the
+ * reason this file exists rather than being copied a ninth time.
+ *
+ * These are factories because the destinations are the app's: `paths.signIn` is not something a
+ * package can know, and one donor hardcoded `/login` in four places for exactly that reason.
+ *
+ * A guard is a COURTESY, never the boundary. The API refuses what it refuses whatever any of
+ * these decide. What they buy is that somebody who types a URL lands on one screen that
+ * explains itself instead of four panels each failing separately.
+ */
+/** What the guard needs off the session store. */
+export interface SessionState {
+    isAuthenticated: boolean;
+    isLoading: boolean;
+}
+/**
+ * The answer to a "who is this?" query, in the three states it actually has.
+ *
+ * This shape is invariant 4. A guard reading `!me?.isStaff` collapses "loading", "failed" and
+ * "no" into one branch — so an operator arriving while `/auth/me` is 500ing is told the page
+ * does not exist. Wrong cause, no retry, and no request id to quote to support. One donor hit
+ * that and fixed it; the other still has the collapsed version.
+ */
+export type MeQuery<TMe> = {
+    status: "loading";
+} | {
+    status: "error";
+    error: unknown;
+} | {
+    status: "success";
+    data: TMe;
+};
+export interface GuardOptions {
+    /** Drawn while the session or the profile is still resolving. */
+    loading: ReactNode;
+}
+/**
+ * Signed in, or off to sign in — remembering where they were headed, so the redirect afterwards
+ * lands on the page they actually wanted rather than the home screen.
+ */
+export declare function createRequireAuth(useSession: () => SessionState, signInPath: string, { loading }: GuardOptions): ({ children }: {
+    children: ReactNode;
+}) => import("react").JSX.Element;
+/** The mirror: somebody already signed in has no business on the sign-in screen. */
+export declare function createRequireAnonymous(useSession: () => SessionState, homePath: string, { loading }: GuardOptions): ({ children }: {
+    children: ReactNode;
+}) => import("react").JSX.Element;
+/**
+ * A gate on something the profile says — suspended, staff, on a given plan.
+ *
+ * `allow` gets the profile and answers yes or no. `onDenied` draws the refusal; `onError` draws
+ * the failure, and they are SEPARATE arguments on purpose. That separation is the whole point
+ * of this file: "you may not see this" and "we could not find out" are different sentences, and
+ * showing the first when the second is true is how an outage becomes a support ticket about
+ * permissions.
+ */
+export declare function createRequireProfile<TMe>(useMe: () => MeQuery<TMe>, { loading }: GuardOptions): (allow: (me: TMe) => boolean, onDenied: ReactNode | (() => ReactNode), onError: (error: unknown) => ReactNode) => ({ children }: {
+    children: ReactNode;
+}) => import("react").JSX.Element;
+//# sourceMappingURL=guards.d.ts.map

package/dist/guards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guards.d.ts","sourceRoot":"","sources":["../src/guards.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAGvC;;;;;;;;;;;;;GAaG;AAEH,kDAAkD;AAClD,MAAM,WAAW,YAAY;IAC3B,eAAe,EAAE,OAAO,CAAC;IACzB,SAAS,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,OAAO,CAAC,GAAG,IACrB;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,GAAG,CAAA;CAAE,CAAC;AAEjG,MAAM,WAAW,YAAY;IAC3B,iEAAiE;IACjE,OAAO,EAAE,SAAS,CAAC;CACpB;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,MAAM,YAAY,EAC9B,UAAU,EAAE,MAAM,EAClB,EAAE,OAAO,EAAE,EAAE,YAAY,IAEG,cAAc;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,iCAUlE;AAED,oFAAoF;AACpF,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,MAAM,YAAY,EAC9B,QAAQ,EAAE,MAAM,EAChB,EAAE,OAAO,EAAE,EAAE,YAAY,IAEQ,cAAc;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,iCAMvE;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC,EAAE,EAAE,OAAO,EAAE,EAAE,YAAY,IAE1F,OAAO,CAAC,EAAE,EAAE,GAAG,KAAK,OAAO,EAC3B,UAAU,SAAS,GAAG,CAAC,MAAM,SAAS,CAAC,EACvC,SAAS,CAAC,KAAK,EAAE,OAAO,KAAK,SAAS,MAEP,cAAc;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,iCAQvE"}

package/dist/guards.js

@@ -0,0 +1,52 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { Navigate, useLocation } from "react-router-dom";
+/**
+ * Signed in, or off to sign in — remembering where they were headed, so the redirect afterwards
+ * lands on the page they actually wanted rather than the home screen.
+ */
+export function createRequireAuth(useSession, signInPath, { loading }) {
+    return function RequireAuth({ children }) {
+        const { isAuthenticated, isLoading } = useSession();
+        const location = useLocation();
+        if (isLoading)
+            return _jsx(_Fragment, { children: loading });
+        if (!isAuthenticated)
+            return (_jsx(Navigate, { to: signInPath, replace: true, state: { from: location.pathname + location.search } }));
+        return _jsx(_Fragment, { children: children });
+    };
+}
+/** The mirror: somebody already signed in has no business on the sign-in screen. */
+export function createRequireAnonymous(useSession, homePath, { loading }) {
+    return function RequireAnonymous({ children }) {
+        const { isAuthenticated, isLoading } = useSession();
+        if (isLoading)
+            return _jsx(_Fragment, { children: loading });
+        if (isAuthenticated)
+            return _jsx(Navigate, { to: homePath, replace: true });
+        return _jsx(_Fragment, { children: children });
+    };
+}
+/**
+ * A gate on something the profile says — suspended, staff, on a given plan.
+ *
+ * `allow` gets the profile and answers yes or no. `onDenied` draws the refusal; `onError` draws
+ * the failure, and they are SEPARATE arguments on purpose. That separation is the whole point
+ * of this file: "you may not see this" and "we could not find out" are different sentences, and
+ * showing the first when the second is true is how an outage becomes a support ticket about
+ * permissions.
+ */
+export function createRequireProfile(useMe, { loading }) {
+    return function requireProfile(allow, onDenied, onError) {
+        return function RequireProfile({ children }) {
+            const query = useMe();
+            if (query.status === "loading")
+                return _jsx(_Fragment, { children: loading });
+            if (query.status === "error")
+                return _jsx(_Fragment, { children: onError(query.error) });
+            if (!allow(query.data))
+                return _jsx(_Fragment, { children: typeof onDenied === "function" ? onDenied() : onDenied });
+            return _jsx(_Fragment, { children: children });
+        };
+    };
+}
+//# sourceMappingURL=guards.js.map

package/dist/guards.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"guards.js","sourceRoot":"","sources":["../src/guards.tsx"],"names":[],"mappings":";AACA,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAuCzD;;;GAGG;AACH,MAAM,UAAU,iBAAiB,CAC/B,UAA8B,EAC9B,UAAkB,EAClB,EAAE,OAAO,EAAgB;IAEzB,OAAO,SAAS,WAAW,CAAC,EAAE,QAAQ,EAA2B;QAC/D,MAAM,EAAE,eAAe,EAAE,SAAS,EAAE,GAAG,UAAU,EAAE,CAAC;QACpD,MAAM,QAAQ,GAAG,WAAW,EAAE,CAAC;QAC/B,IAAI,SAAS;YAAE,OAAO,4BAAG,OAAO,GAAI,CAAC;QACrC,IAAI,CAAC,eAAe;YAClB,OAAO,CACL,KAAC,QAAQ,IAAC,EAAE,EAAE,UAAU,EAAE,OAAO,QAAC,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,CAAC,QAAQ,GAAG,QAAQ,CAAC,MAAM,EAAE,GAAI,CAC3F,CAAC;QACJ,OAAO,4BAAG,QAAQ,GAAI,CAAC;IACzB,CAAC,CAAC;AACJ,CAAC;AAED,oFAAoF;AACpF,MAAM,UAAU,sBAAsB,CACpC,UAA8B,EAC9B,QAAgB,EAChB,EAAE,OAAO,EAAgB;IAEzB,OAAO,SAAS,gBAAgB,CAAC,EAAE,QAAQ,EAA2B;QACpE,MAAM,EAAE,eAAe,EAAE,SAAS,EAAE,GAAG,UAAU,EAAE,CAAC;QACpD,IAAI,SAAS;YAAE,OAAO,4BAAG,OAAO,GAAI,CAAC;QACrC,IAAI,eAAe;YAAE,OAAO,KAAC,QAAQ,IAAC,EAAE,EAAE,QAAQ,EAAE,OAAO,SAAG,CAAC;QAC/D,OAAO,4BAAG,QAAQ,GAAI,CAAC;IACzB,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,oBAAoB,CAAM,KAAyB,EAAE,EAAE,OAAO,EAAgB;IAC5F,OAAO,SAAS,cAAc,CAC5B,KAA2B,EAC3B,QAAuC,EACvC,OAAsC;QAEtC,OAAO,SAAS,cAAc,CAAC,EAAE,QAAQ,EAA2B;YAClE,MAAM,KAAK,GAAG,KAAK,EAAE,CAAC;YACtB,IAAI,KAAK,CAAC,MAAM,KAAK,SAAS;gBAAE,OAAO,4BAAG,OAAO,GAAI,CAAC;YACtD,IAAI,KAAK,CAAC,MAAM,KAAK,OAAO;gBAAE,OAAO,4BAAG,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,GAAI,CAAC;YACjE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC;gBAAE,OAAO,4BAAG,OAAO,QAAQ,KAAK,UAAU,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,QAAQ,GAAI,CAAC;YAC7F,OAAO,4BAAG,QAAQ,GAAI,CAAC;QACzB,CAAC,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC"}