@gusnips/react 0.1.0

package/dist/hydrate.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The browser half of prerendering: deciding whether to hydrate or to mount fresh.
+ *
+ * Three separate repos invented all of this independently — same constant name, same string
+ * value, same decision, and near-identical explaining comments. That is not a coincidence worth
+ * deduping; it is one lesson learned three times, and it belongs somewhere it can be learned
+ * once.
+ *
+ * The constants themselves live in `prerender-contract.ts`, which imports nothing, because the
+ * BUILD needs them too and must not pull `react-dom/client` into a Node process to get a string.
+ */
+import type { ReactNode } from "react";
+export { PRERENDERED_ROUTE_ATTR, SHELL_ROUTE } from "./prerender-contract.ts";
+/**
+ * Hydrate the render this file IS, and mount fresh over anything else.
+ *
+ * "Does the root have children" is the wrong question, and getting it wrong is silent. A static
+ * host answers every address it does not publish with the nearest `404.html` — and that file has
+ * the not-found page rendered INTO it — so an address served from a shell arrives at a full root
+ * holding somebody else's markup. Hydrating that is React reconciling two different pages: it
+ * recovers by throwing the whole tree away and says so in the console, which is a page that
+ * works and a bug nobody sees. The file names the route it is a render of, so we can simply ask.
+ *
+ * `route` is passed in rather than read from `window.location` on purpose. A localized app
+ * serves `/pt/pricing` from a file rendered for `/pricing`, with the locale carried in the
+ * router's `basename` — so the address and the route are different strings, and only the caller
+ * knows which one the build wrote.
+ */
+export declare function hydrateOrMount(rootEl: Element, tree: ReactNode, route: string): void;
+//# sourceMappingURL=hydrate.d.ts.map

package/dist/hydrate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hydrate.d.ts","sourceRoot":"","sources":["../src/hydrate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAIvC,OAAO,EAAE,sBAAsB,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAE9E;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAGpF"}

package/dist/hydrate.js

@@ -0,0 +1,25 @@
+import { createRoot, hydrateRoot } from "react-dom/client";
+import { PRERENDERED_ROUTE_ATTR } from "./prerender-contract.js";
+export { PRERENDERED_ROUTE_ATTR, SHELL_ROUTE } from "./prerender-contract.js";
+/**
+ * Hydrate the render this file IS, and mount fresh over anything else.
+ *
+ * "Does the root have children" is the wrong question, and getting it wrong is silent. A static
+ * host answers every address it does not publish with the nearest `404.html` — and that file has
+ * the not-found page rendered INTO it — so an address served from a shell arrives at a full root
+ * holding somebody else's markup. Hydrating that is React reconciling two different pages: it
+ * recovers by throwing the whole tree away and says so in the console, which is a page that
+ * works and a bug nobody sees. The file names the route it is a render of, so we can simply ask.
+ *
+ * `route` is passed in rather than read from `window.location` on purpose. A localized app
+ * serves `/pt/pricing` from a file rendered for `/pricing`, with the locale carried in the
+ * router's `basename` — so the address and the route are different strings, and only the caller
+ * knows which one the build wrote.
+ */
+export function hydrateOrMount(rootEl, tree, route) {
+    if (rootEl.getAttribute(PRERENDERED_ROUTE_ATTR) === route)
+        hydrateRoot(rootEl, tree);
+    else
+        createRoot(rootEl).render(tree);
+}
+//# sourceMappingURL=hydrate.js.map

package/dist/hydrate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hydrate.js","sourceRoot":"","sources":["../src/hydrate.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC3D,OAAO,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AAEjE,OAAO,EAAE,sBAAsB,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAE9E;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,cAAc,CAAC,MAAe,EAAE,IAAe,EAAE,KAAa;IAC5E,IAAI,MAAM,CAAC,YAAY,CAAC,sBAAsB,CAAC,KAAK,KAAK;QAAE,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;;QAChF,UAAU,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;AACvC,CAAC"}

package/dist/i18n.d.ts

@@ -0,0 +1,70 @@
+/**
+ * The i18next bootstrap two donors wrote nearly comment-for-comment.
+ *
+ * Each browser surface spreads these into its own init with its own bundled resources:
+ *
+ * ```ts
+ * i18n.use(LanguageDetector).use(initReactI18next).init({ resources, ...i18nInitOptions({…}) })
+ * ```
+ *
+ * Keeping the options here is what stops a console, a storefront and a docs site in the same
+ * product from drifting apart on the details below — each of which is a bug somebody already
+ * shipped.
+ */
+export interface I18nInitOptions {
+    /** The language everything falls back to. */
+    fallbackLng: string;
+    /** Every language this app ships, as the exact tags used in the catalogs. */
+    supportedLngs: readonly string[];
+    /**
+     * Where the reader's choice is remembered.
+     *
+     * One key everywhere is a convention, not a mechanism: `localStorage` is scoped to an ORIGIN,
+     * so a console on `app.example.com` shares nothing with a storefront on `example.com` no
+     * matter what the key is called. Which is why {@link queryKey} exists.
+     */
+    storageKey: string;
+    /**
+     * The query parameter that hands a language ACROSS an origin, e.g. `"lang"`.
+     *
+     * When set it is detected FIRST, ahead of storage and the browser — it is the only one of the
+     * three that somebody chose on purpose and just now. A reader who picked Português on the
+     * storefront and followed a link into the app means it more than their laptop's locale does.
+     * It is cached on arrival, so it decides once and no URL inside the app has to carry it.
+     *
+     * Only one donor had this. The other has the same split-origin layout and the same problem.
+     */
+    queryKey?: string;
+}
+export declare function i18nInitOptions({ fallbackLng, supportedLngs, storageKey, queryKey, }: I18nInitOptions): {
+    fallbackLng: string;
+    supportedLngs: string[];
+    load: "currentOnly";
+    interpolation: {
+        escapeValue: boolean;
+    };
+    detection: {
+        lookupLocalStorage: string;
+        lookupQuerystring?: string | undefined;
+        order: string[];
+        caches: string[];
+    };
+    react: {
+        useSuspense: boolean;
+    };
+};
+/**
+ * Substitute `{{brand}}`-style placeholders through a bundled resource tree, once, before
+ * i18next ever sees it.
+ *
+ * Done here rather than through interpolation because i18next v26 has no global interpolation
+ * defaults, and these strings are often resolved by dynamic key — so a wrapping `t()` would not
+ * reach them. The point is that a rename or a domain move is ONE edit in the brand constants
+ * instead of a sweep across every locale file.
+ *
+ * Returns a fresh tree; the input is untouched. The placeholder names come from `vars`, so
+ * adding one needs no change here — two donors hardcoded their own list in the regex and both
+ * had to remember to update it.
+ */
+export declare function applyBrandVars<T>(resources: T, vars: Record<string, string>): T;
+//# sourceMappingURL=i18n.d.ts.map

package/dist/i18n.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n.d.ts","sourceRoot":"","sources":["../src/i18n.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,MAAM,WAAW,eAAe;IAC9B,6CAA6C;IAC7C,WAAW,EAAE,MAAM,CAAC;IACpB,6EAA6E;IAC7E,aAAa,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC;;;;;;OAMG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB;;;;;;;;;OASG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,wBAAgB,eAAe,CAAC,EAC9B,WAAW,EACX,aAAa,EACb,UAAU,EACV,QAAQ,GACT,EAAE,eAAe;;;;;;;;;;;;;;;;EAqBjB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,CAmB/E"}

package/dist/i18n.js

@@ -0,0 +1,66 @@
+/**
+ * The i18next bootstrap two donors wrote nearly comment-for-comment.
+ *
+ * Each browser surface spreads these into its own init with its own bundled resources:
+ *
+ * ```ts
+ * i18n.use(LanguageDetector).use(initReactI18next).init({ resources, ...i18nInitOptions({…}) })
+ * ```
+ *
+ * Keeping the options here is what stops a console, a storefront and a docs site in the same
+ * product from drifting apart on the details below — each of which is a bug somebody already
+ * shipped.
+ */
+export function i18nInitOptions({ fallbackLng, supportedLngs, storageKey, queryKey, }) {
+    return {
+        fallbackLng,
+        supportedLngs: [...supportedLngs],
+        load: "currentOnly",
+        interpolation: { escapeValue: false }, // React already escapes.
+        detection: {
+            order: queryKey
+                ? ["querystring", "localStorage", "navigator"]
+                : ["localStorage", "navigator"],
+            caches: ["localStorage"],
+            ...(queryKey ? { lookupQuerystring: queryKey } : {}),
+            lookupLocalStorage: storageKey,
+        },
+        react: { useSuspense: false },
+        // `nonExplicitSupportedLngs` is omitted deliberately, and both donors say so in the same
+        // words. Enabling it validates the BASE subtag against `supportedLngs`, which rejects a
+        // region-coded "pt-BR" (its base "pt" is not in the list) and silently falls the whole app
+        // back to English. Detected sub-locales like "en-US" already resolve to their base through
+        // i18next's ordinary fallback hierarchy, so the flag buys nothing and breaks pt-BR.
+    };
+}
+/**
+ * Substitute `{{brand}}`-style placeholders through a bundled resource tree, once, before
+ * i18next ever sees it.
+ *
+ * Done here rather than through interpolation because i18next v26 has no global interpolation
+ * defaults, and these strings are often resolved by dynamic key — so a wrapping `t()` would not
+ * reach them. The point is that a rename or a domain move is ONE edit in the brand constants
+ * instead of a sweep across every locale file.
+ *
+ * Returns a fresh tree; the input is untouched. The placeholder names come from `vars`, so
+ * adding one needs no change here — two donors hardcoded their own list in the regex and both
+ * had to remember to update it.
+ */
+export function applyBrandVars(resources, vars) {
+    const names = Object.keys(vars);
+    if (names.length === 0)
+        return resources;
+    const pattern = new RegExp(`\\{\\{(${names.map((n) => n.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|")})\\}\\}`, "g");
+    const fill = (s) => s.replace(pattern, (_, name) => vars[name] ?? "");
+    const walk = (value) => {
+        if (typeof value === "string")
+            return fill(value);
+        if (Array.isArray(value))
+            return value.map(walk);
+        if (value && typeof value === "object")
+            return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, walk(v)]));
+        return value;
+    };
+    return walk(resources);
+}
+//# sourceMappingURL=i18n.js.map

package/dist/i18n.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n.js","sourceRoot":"","sources":["../src/i18n.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AA4BH,MAAM,UAAU,eAAe,CAAC,EAC9B,WAAW,EACX,aAAa,EACb,UAAU,EACV,QAAQ,GACQ;IAChB,OAAO;QACL,WAAW;QACX,aAAa,EAAE,CAAC,GAAG,aAAa,CAAC;QACjC,IAAI,EAAE,aAAsB;QAC5B,aAAa,EAAE,EAAE,WAAW,EAAE,KAAK,EAAE,EAAE,yBAAyB;QAChE,SAAS,EAAE;YACT,KAAK,EAAE,QAAQ;gBACb,CAAC,CAAC,CAAC,aAAa,EAAE,cAAc,EAAE,WAAW,CAAC;gBAC9C,CAAC,CAAC,CAAC,cAAc,EAAE,WAAW,CAAC;YACjC,MAAM,EAAE,CAAC,cAAc,CAAC;YACxB,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,iBAAiB,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YACpD,kBAAkB,EAAE,UAAU;SAC/B;QACD,KAAK,EAAE,EAAE,WAAW,EAAE,KAAK,EAAE;QAC7B,yFAAyF;QACzF,wFAAwF;QACxF,2FAA2F;QAC3F,2FAA2F;QAC3F,oFAAoF;KACrF,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,cAAc,CAAI,SAAY,EAAE,IAA4B;IAC1E,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAChC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IACzC,MAAM,OAAO,GAAG,IAAI,MAAM,CACxB,UAAU,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,EACvF,GAAG,CACJ,CAAC;IAEF,MAAM,IAAI,GAAG,CAAC,CAAS,EAAU,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,IAAY,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;IAE9F,MAAM,IAAI,GAAG,CAAC,KAAc,EAAW,EAAE;QACvC,IAAI,OAAO,KAAK,KAAK,QAAQ;YAAE,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC;QAClD,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;YAAE,OAAO,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACjD,IAAI,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ;YACpC,OAAO,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACjF,OAAO,KAAK,CAAC;IACf,CAAC,CAAC;IAEF,OAAO,IAAI,CAAC,SAAS,CAAM,CAAC;AAC9B,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export { cn } from "./cn.ts";
+export { ApiError, isAbortError } from "./api-error.ts";
+export { createApiClient, type ApiClient, type ApiClientOptions, type RefreshResult, type RequestOptions, type SessionAdapter, } from "./api-client.ts";
+export { createSseParser, readSseStream, type SseFrame } from "./sse.ts";
+export { queryDefaults, shouldRetry, type QueryDefaultsOptions } from "./query.ts";
+export { ErrorBoundary, type ErrorBoundaryFallbackProps, type ErrorBoundaryProps, } from "./error-boundary.tsx";
+export { createErrorDescriber, humanizeWait, retryAfterSecs, type DescribedError, type ErrorContext, type ErrorDescriberOptions, type Translate, } from "./describe-error.ts";
+export { installPreloadErrorHandler, isChunkLoadError, isPreloadHintFailure, reloadOnceForChunkError, } from "./chunk-reload.ts";
+export { hydrateOrMount, PRERENDERED_ROUTE_ATTR, SHELL_ROUTE } from "./hydrate.ts";
+export { applyBrandVars, i18nInitOptions, type I18nInitOptions } from "./i18n.ts";
+export type { EmptyStateProps, ErrorStateProps } from "./states.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAqBA,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAE7B,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EACL,eAAe,EACf,KAAK,SAAS,EACd,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,cAAc,GACpB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,KAAK,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEzE,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,KAAK,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEnF,OAAO,EACL,aAAa,EACb,KAAK,0BAA0B,EAC/B,KAAK,kBAAkB,GACxB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,oBAAoB,EACpB,YAAY,EACZ,cAAc,EACd,KAAK,cAAc,EACnB,KAAK,YAAY,EACjB,KAAK,qBAAqB,EAC1B,KAAK,SAAS,GACf,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,0BAA0B,EAC1B,gBAAgB,EAChB,oBAAoB,EACpB,uBAAuB,GACxB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,cAAc,EAAE,sBAAsB,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEnF,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,KAAK,eAAe,EAAE,MAAM,WAAW,CAAC;AAElF,YAAY,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,31 @@
+// @gusnips/react — the headless runtime under a Vite + React SPA.
+//
+// No styling, no brand, no Node built-ins.
+//
+// Three things live behind their own subpath, and the rule picking them is invariant 15 stated
+// as a test rather than a judgement: **a peer marked `optional` must not be reachable from this
+// barrel.** An optional peer the barrel imports anyway is not optional — it is a required peer
+// with the error moved from install time to the adopter's first build, which is the worse of the
+// two places to find out.
+//
+//   @gusnips/react/ui       the Base UI wrappers   → @base-ui/react
+//   @gusnips/react/store    createAuthStore        → zustand
+//   @gusnips/react/guards   the route guards       → react-router-dom
+//
+// So what is left here imports `react`, `react-dom` and `@gusnips/http` and nothing else, and an
+// app on TanStack Router or on Redux takes the fetch client without installing a router or a
+// store it will never call. `@tanstack/react-query`, `i18next` and `react-i18next` stay optional
+// AND stay here, because `query.ts`, `i18n.ts` and `states.ts` import only their TYPES — which
+// erase, so the built barrel does not reference them at runtime. Check that claim against
+// `dist/`, never against this file: a type-only re-export looks identical in source.
+export { cn } from "./cn.js";
+export { ApiError, isAbortError } from "./api-error.js";
+export { createApiClient, } from "./api-client.js";
+export { createSseParser, readSseStream } from "./sse.js";
+export { queryDefaults, shouldRetry } from "./query.js";
+export { ErrorBoundary, } from "./error-boundary.js";
+export { createErrorDescriber, humanizeWait, retryAfterSecs, } from "./describe-error.js";
+export { installPreloadErrorHandler, isChunkLoadError, isPreloadHintFailure, reloadOnceForChunkError, } from "./chunk-reload.js";
+export { hydrateOrMount, PRERENDERED_ROUTE_ATTR, SHELL_ROUTE } from "./hydrate.js";
+export { applyBrandVars, i18nInitOptions } from "./i18n.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,kEAAkE;AAClE,EAAE;AACF,2CAA2C;AAC3C,EAAE;AACF,+FAA+F;AAC/F,gGAAgG;AAChG,+FAA+F;AAC/F,iGAAiG;AACjG,0BAA0B;AAC1B,EAAE;AACF,oEAAoE;AACpE,6DAA6D;AAC7D,sEAAsE;AACtE,EAAE;AACF,iGAAiG;AACjG,6FAA6F;AAC7F,iGAAiG;AACjG,+FAA+F;AAC/F,0FAA0F;AAC1F,qFAAqF;AAErF,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAE7B,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EACL,eAAe,GAMhB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,eAAe,EAAE,aAAa,EAAiB,MAAM,UAAU,CAAC;AAEzE,OAAO,EAAE,aAAa,EAAE,WAAW,EAA6B,MAAM,YAAY,CAAC;AAEnF,OAAO,EACL,aAAa,GAGd,MAAM,qBAAsB,CAAC;AAC9B,OAAO,EACL,oBAAoB,EACpB,YAAY,EACZ,cAAc,GAKf,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,0BAA0B,EAC1B,gBAAgB,EAChB,oBAAoB,EACpB,uBAAuB,GACxB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,cAAc,EAAE,sBAAsB,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEnF,OAAO,EAAE,cAAc,EAAE,eAAe,EAAwB,MAAM,WAAW,CAAC"}

package/dist/prerender-contract.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The two constants the build and the browser both need — and **nothing else in this file**.
+ *
+ * It is separate from `hydrate.ts` for one reason: that module imports `react-dom/client`, and
+ * `@gusnips/vite` needs these constants to WRITE the attribute at build time. If the constants
+ * lived beside the hydration helper, a build script asking for a string would pull the browser
+ * renderer into a Node process, and every `entry-server.tsx` that touched this package would do
+ * the same. Zero imports here is the whole point; keep it that way.
+ *
+ * The contract itself was invented three times independently, with the same name and the same
+ * string value each time. See `hydrate.ts` for why it exists at all.
+ */
+/**
+ * The attribute a prerendered file names its own route in — written by the build, read by the
+ * browser entry.
+ *
+ * One constant because the writer and the reader are in different builds, and a typo between
+ * them would show up only as a silent full re-render: a page that works, and a bug nobody sees.
+ */
+export declare const PRERENDERED_ROUTE_ATTR = "data-prerendered-route";
+/**
+ * What a 404 shell writes instead of a route.
+ *
+ * It is the pattern that actually matched — the catch-all — and it can never equal an address,
+ * which is the property that matters: every route a static host answers from the shell mounts
+ * fresh rather than hydrating the not-found page over itself. A real 404 pays one redundant
+ * client render for that, and keeps the markup a crawler reads.
+ */
+export declare const SHELL_ROUTE = "*";
+//# sourceMappingURL=prerender-contract.d.ts.map

package/dist/prerender-contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prerender-contract.d.ts","sourceRoot":"","sources":["../src/prerender-contract.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,2BAA2B,CAAC;AAE/D;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,MAAM,CAAC"}

package/dist/prerender-contract.js

@@ -0,0 +1,30 @@
+/**
+ * The two constants the build and the browser both need — and **nothing else in this file**.
+ *
+ * It is separate from `hydrate.ts` for one reason: that module imports `react-dom/client`, and
+ * `@gusnips/vite` needs these constants to WRITE the attribute at build time. If the constants
+ * lived beside the hydration helper, a build script asking for a string would pull the browser
+ * renderer into a Node process, and every `entry-server.tsx` that touched this package would do
+ * the same. Zero imports here is the whole point; keep it that way.
+ *
+ * The contract itself was invented three times independently, with the same name and the same
+ * string value each time. See `hydrate.ts` for why it exists at all.
+ */
+/**
+ * The attribute a prerendered file names its own route in — written by the build, read by the
+ * browser entry.
+ *
+ * One constant because the writer and the reader are in different builds, and a typo between
+ * them would show up only as a silent full re-render: a page that works, and a bug nobody sees.
+ */
+export const PRERENDERED_ROUTE_ATTR = "data-prerendered-route";
+/**
+ * What a 404 shell writes instead of a route.
+ *
+ * It is the pattern that actually matched — the catch-all — and it can never equal an address,
+ * which is the property that matters: every route a static host answers from the shell mounts
+ * fresh rather than hydrating the not-found page over itself. A real 404 pays one redundant
+ * client render for that, and keeps the markup a crawler reads.
+ */
+export const SHELL_ROUTE = "*";
+//# sourceMappingURL=prerender-contract.js.map

package/dist/prerender-contract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prerender-contract.js","sourceRoot":"","sources":["../src/prerender-contract.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,wBAAwB,CAAC;AAE/D;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,GAAG,CAAC"}

package/dist/query.d.ts

@@ -0,0 +1,28 @@
+import type { DefaultOptions } from "@tanstack/react-query";
+export interface QueryDefaultsOptions {
+    /**
+     * Error codes that mean "this limit does not clear by waiting" — a spent monthly quota, a
+     * balance that needs topping up. They usually arrive as 402 or 429; the status alone cannot
+     * tell them apart from a burst limit, which is why the caller names them.
+     */
+    durableLimitCodes?: readonly string[];
+    /** How many times to retry a transient failure. Two donors used 2, one used 1. */
+    maxRetries?: number;
+    staleTime?: number;
+    gcTime?: number;
+    /**
+     * Left to the caller on purpose. A dashboard someone leaves open wants it on; a console
+     * whose data changes only when the operator changes it wants it off, and one donor turned it
+     * off deliberately. There is no right answer to inherit.
+     */
+    refetchOnWindowFocus?: boolean;
+}
+/**
+ * Should this failure be retried?
+ *
+ * Exported on its own because an app with its own QueryClient config still wants this rule, and
+ * because it is the part worth testing.
+ */
+export declare function shouldRetry(error: unknown, durableLimitCodes?: readonly string[]): boolean;
+export declare function queryDefaults({ durableLimitCodes, maxRetries, staleTime, gcTime, refetchOnWindowFocus, }?: QueryDefaultsOptions): DefaultOptions;
+//# sourceMappingURL=query.d.ts.map

package/dist/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../src/query.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAuB5D,MAAM,WAAW,oBAAoB;IACnC;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,kFAAkF;IAClF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,iBAAiB,GAAE,SAAS,MAAM,EAAO,GAAG,OAAO,CAQ9F;AAED,wBAAgB,aAAa,CAAC,EAC5B,iBAAsB,EACtB,UAAc,EACd,SAAyB,EACzB,MAAuB,EACvB,oBAA4B,GAC7B,GAAE,oBAAyB,GAAG,cAAc,CAc5C"}

package/dist/query.js

@@ -0,0 +1,51 @@
+import { ApiError } from "./api-error.js";
+/**
+ * react-query defaults — the merge of three repos that each got part of this right.
+ *
+ * The default is three blind retries, which is wrong for an API that answers refusals
+ * precisely: a 402, a 403 or a 451 says exactly the same thing three times, and a 429 we hammer
+ * is a 429 we deserve. All three donors knew that much. What each knew alone:
+ *
+ * - one allowed **408** through, the only 4xx that a second attempt genuinely fixes;
+ * - one refused to retry a 429 whose CODE says the limit is durable — a monthly quota or a
+ *   spent balance clears by buying, not by waiting, so retrying burns another request against
+ *   the limiter and cannot succeed;
+ * - one set **`refetchOnReconnect`**, which none of the others had, and which is the single
+ *   most useful refetch there is: coming back from a tunnel is exactly when the screen is stale.
+ *
+ * This is invariant 8.
+ */
+/** 4xx statuses a second attempt can fix. Everything else in the 4xx family is an answer. */
+const RETRYABLE_CLIENT_STATUS = new Set([408, 429]);
+/**
+ * Should this failure be retried?
+ *
+ * Exported on its own because an app with its own QueryClient config still wants this rule, and
+ * because it is the part worth testing.
+ */
+export function shouldRetry(error, durableLimitCodes = []) {
+    // No response at all — offline, DNS, a dropped connection. The request never landed, so
+    // nothing about it is an answer, and a second attempt is exactly right.
+    if (!(error instanceof ApiError))
+        return true;
+    if (error.code !== undefined && durableLimitCodes.includes(error.code))
+        return false;
+    if (error.status >= 500)
+        return true;
+    return RETRYABLE_CLIENT_STATUS.has(error.status);
+}
+export function queryDefaults({ durableLimitCodes = [], maxRetries = 2, staleTime = 2 * 60 * 1000, gcTime = 10 * 60 * 1000, refetchOnWindowFocus = false, } = {}) {
+    return {
+        queries: {
+            staleTime,
+            gcTime,
+            retry: (failureCount, error) => failureCount < maxRetries && shouldRetry(error, durableLimitCodes),
+            refetchOnWindowFocus,
+            refetchOnReconnect: true,
+        },
+        // A mutation is not idempotent by default. Retrying one that already reached the server is
+        // how a customer gets charged twice; all three donors agreed on this without discussion.
+        mutations: { retry: false },
+    };
+}
+//# sourceMappingURL=query.js.map

package/dist/query.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.js","sourceRoot":"","sources":["../src/query.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C;;;;;;;;;;;;;;;GAeG;AAEH,6FAA6F;AAC7F,MAAM,uBAAuB,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;AAqBpD;;;;;GAKG;AACH,MAAM,UAAU,WAAW,CAAC,KAAc,EAAE,oBAAuC,EAAE;IACnF,wFAAwF;IACxF,wEAAwE;IACxE,IAAI,CAAC,CAAC,KAAK,YAAY,QAAQ,CAAC;QAAE,OAAO,IAAI,CAAC;IAE9C,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,IAAI,iBAAiB,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC;QAAE,OAAO,KAAK,CAAC;IACrF,IAAI,KAAK,CAAC,MAAM,IAAI,GAAG;QAAE,OAAO,IAAI,CAAC;IACrC,OAAO,uBAAuB,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;AACnD,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,EAC5B,iBAAiB,GAAG,EAAE,EACtB,UAAU,GAAG,CAAC,EACd,SAAS,GAAG,CAAC,GAAG,EAAE,GAAG,IAAI,EACzB,MAAM,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,EACvB,oBAAoB,GAAG,KAAK,MACJ,EAAE;IAC1B,OAAO;QACL,OAAO,EAAE;YACP,SAAS;YACT,MAAM;YACN,KAAK,EAAE,CAAC,YAAY,EAAE,KAAK,EAAE,EAAE,CAC7B,YAAY,GAAG,UAAU,IAAI,WAAW,CAAC,KAAK,EAAE,iBAAiB,CAAC;YACpE,oBAAoB;YACpB,kBAAkB,EAAE,IAAI;SACzB;QACD,2FAA2F;QAC3F,yFAAyF;QACzF,SAAS,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE;KAC5B,CAAC;AACJ,CAAC"}

package/dist/sse.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Server-sent events: the framing and the transport, kept apart.
+ *
+ * Three donors had three readers and each had half the answer. One was spec-correct about the
+ * wire but welded to `TextDecoderStream`, so the React Native app — whose fetch has no body
+ * reader — could not use a line of it. One was a platform-free `feed(text)` that three
+ * transports shared, and it silently dropped data. One was a whole second transport with its
+ * own fetch and its own 401 handling, bypassing the app's only API client.
+ *
+ * So: {@link createSseParser} is the state machine and knows about no platform at all;
+ * {@link readSseStream} is fifteen lines of `ReadableStream` on top of it. A caller on a
+ * platform without body readers keeps its own fifteen lines and shares the machine underneath.
+ * (providerkit reached this exact split from the other direction and for the same reason.)
+ *
+ * And streams ride the ordinary API client — `client.request(path, {headers: {Accept:
+ * "text/event-stream"}, timeoutMs: null})`. Not `EventSource`, which cannot carry an
+ * Authorization header, and not a second fetch, which would need its own copy of the refresh
+ * logic and would drift from it.
+ */
+/** One frame off the wire. `data` is raw text; see {@link createSseParser} on why. */
+export interface SseFrame {
+    /** The `event:` field, or `"message"` — which is what the spec says an unnamed frame is. */
+    event: string;
+    /** Every `data:` line in the frame, joined with newlines. Never parsed here. */
+    data: string;
+    /** The `id:` field, if the server sent one. Feed it back as `Last-Event-ID` to resume. */
+    id: string | undefined;
+}
+/**
+ * An incremental parser. Feed it text in whatever sizes the transport delivers.
+ *
+ * Frames split across reads are held until they complete, so a payload cut mid-line is never
+ * lost or truncated — which is the failure this shape exists to prevent, and the one that only
+ * shows up under a slow network.
+ *
+ * Three rules that are easy to get wrong, and one donor got each of them wrong:
+ *
+ * - **`data:` repeats.** A frame may carry several `data:` lines and they are JOINED with
+ *   newlines. One donor assigned instead of appending, so a multi-line payload arrived as its
+ *   last line only — no error, no warning, just a truncated message.
+ * - **Strip ONE leading space after the colon**, not all whitespace. `.trim()` is the obvious
+ *   thing and it corrupts any payload whose own content begins or ends with a space.
+ * - **A frame with no `data:` is not dispatched.** That is what lets a server send bare
+ *   `event: heartbeat` keepalives, or `:` comment lines, without waking a consumer.
+ *
+ * `data` is handed back as a raw string and deliberately NOT JSON-parsed. One donor parsed here
+ * and its three consumers wanted three different things — one wraps non-JSON, one uses a
+ * tolerant parser, one parses directly. Parsing in the parser picks a policy for all of them.
+ */
+export declare function createSseParser(onFrame: (frame: SseFrame) => void): {
+    feed: (text: string) => void;
+};
+/**
+ * Read a `Response` body as SSE. Resolves when the server closes the stream.
+ *
+ * Pass the response from the ordinary API client, so the stream inherits the token, the
+ * single-flight refresh, and a 402 or a 404 arriving as an `ApiError` the page can explain
+ * rather than an `onerror` event with nothing in it.
+ *
+ * Cancels the reader on the way out however it leaves — a stream abandoned without cancelling
+ * holds the connection open until the server gives up on it.
+ */
+export declare function readSseStream(response: Response, onFrame: (frame: SseFrame) => void): Promise<void>;
+//# sourceMappingURL=sse.d.ts.map

package/dist/sse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse.d.ts","sourceRoot":"","sources":["../src/sse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,sFAAsF;AACtF,MAAM,WAAW,QAAQ;IACvB,4FAA4F;IAC5F,KAAK,EAAE,MAAM,CAAC;IACd,gFAAgF;IAChF,IAAI,EAAE,MAAM,CAAC;IACb,0FAA0F;IAC1F,EAAE,EAAE,MAAM,GAAG,SAAS,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,QAAQ,KAAK,IAAI,GAAG;IACnE,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAC9B,CAgBA;AAqBD;;;;;;;;;GASG;AACH,wBAAsB,aAAa,CACjC,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,CAAC,KAAK,EAAE,QAAQ,KAAK,IAAI,GACjC,OAAO,CAAC,IAAI,CAAC,CAaf"}

package/dist/sse.js

@@ -0,0 +1,105 @@
+/**
+ * Server-sent events: the framing and the transport, kept apart.
+ *
+ * Three donors had three readers and each had half the answer. One was spec-correct about the
+ * wire but welded to `TextDecoderStream`, so the React Native app — whose fetch has no body
+ * reader — could not use a line of it. One was a platform-free `feed(text)` that three
+ * transports shared, and it silently dropped data. One was a whole second transport with its
+ * own fetch and its own 401 handling, bypassing the app's only API client.
+ *
+ * So: {@link createSseParser} is the state machine and knows about no platform at all;
+ * {@link readSseStream} is fifteen lines of `ReadableStream` on top of it. A caller on a
+ * platform without body readers keeps its own fifteen lines and shares the machine underneath.
+ * (providerkit reached this exact split from the other direction and for the same reason.)
+ *
+ * And streams ride the ordinary API client — `client.request(path, {headers: {Accept:
+ * "text/event-stream"}, timeoutMs: null})`. Not `EventSource`, which cannot carry an
+ * Authorization header, and not a second fetch, which would need its own copy of the refresh
+ * logic and would drift from it.
+ */
+/**
+ * An incremental parser. Feed it text in whatever sizes the transport delivers.
+ *
+ * Frames split across reads are held until they complete, so a payload cut mid-line is never
+ * lost or truncated — which is the failure this shape exists to prevent, and the one that only
+ * shows up under a slow network.
+ *
+ * Three rules that are easy to get wrong, and one donor got each of them wrong:
+ *
+ * - **`data:` repeats.** A frame may carry several `data:` lines and they are JOINED with
+ *   newlines. One donor assigned instead of appending, so a multi-line payload arrived as its
+ *   last line only — no error, no warning, just a truncated message.
+ * - **Strip ONE leading space after the colon**, not all whitespace. `.trim()` is the obvious
+ *   thing and it corrupts any payload whose own content begins or ends with a space.
+ * - **A frame with no `data:` is not dispatched.** That is what lets a server send bare
+ *   `event: heartbeat` keepalives, or `:` comment lines, without waking a consumer.
+ *
+ * `data` is handed back as a raw string and deliberately NOT JSON-parsed. One donor parsed here
+ * and its three consumers wanted three different things — one wraps non-JSON, one uses a
+ * tolerant parser, one parses directly. Parsing in the parser picks a policy for all of them.
+ */
+export function createSseParser(onFrame) {
+    let buffer = "";
+    return {
+        feed(text) {
+            // A server may send CRLF; the frame boundary is a blank line either way.
+            buffer += text.replace(/\r\n/g, "\n");
+            let end = buffer.indexOf("\n\n");
+            while (end !== -1) {
+                const frame = parseFrame(buffer.slice(0, end));
+                buffer = buffer.slice(end + 2);
+                if (frame)
+                    onFrame(frame);
+                end = buffer.indexOf("\n\n");
+            }
+        },
+    };
+}
+/** The SSE wire format: `field: value` lines, `data` repeatable, a leading `:` is a comment. */
+function parseFrame(raw) {
+    let event = "message";
+    let id;
+    const data = [];
+    for (const line of raw.split("\n")) {
+        if (line === "" || line.startsWith(":"))
+            continue;
+        const colon = line.indexOf(":");
+        const field = colon === -1 ? line : line.slice(0, colon);
+        const value = colon === -1 ? "" : line.slice(colon + 1).replace(/^ /, "");
+        if (field === "event")
+            event = value;
+        else if (field === "id")
+            id = value;
+        else if (field === "data")
+            data.push(value);
+    }
+    return data.length === 0 ? null : { event, data: data.join("\n"), id };
+}
+/**
+ * Read a `Response` body as SSE. Resolves when the server closes the stream.
+ *
+ * Pass the response from the ordinary API client, so the stream inherits the token, the
+ * single-flight refresh, and a 402 or a 404 arriving as an `ApiError` the page can explain
+ * rather than an `onerror` event with nothing in it.
+ *
+ * Cancels the reader on the way out however it leaves — a stream abandoned without cancelling
+ * holds the connection open until the server gives up on it.
+ */
+export async function readSseStream(response, onFrame) {
+    if (!response.body)
+        return;
+    const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
+    const parser = createSseParser(onFrame);
+    try {
+        for (;;) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            parser.feed(value);
+        }
+    }
+    finally {
+        await reader.cancel().catch(() => { });
+    }
+}
+//# sourceMappingURL=sse.js.map

package/dist/sse.js.map

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