basalt-ui 1.29.1 → 1.29.2

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [1.29.2](https://github.com/jkrumm/basalt-ui/compare/v1.29.1...v1.29.2) (2026-09-03)
+
+
+### Bug Fixes
+
+* distribute unwrap's NonNullable over Eden's union response shape ([d46bc00](https://github.com/jkrumm/basalt-ui/commit/d46bc00ae46fcbe76e0b89516140735b1f3295fb))
+
 ## [1.29.1](https://github.com/jkrumm/basalt-ui/compare/v1.29.0...v1.29.1) (2026-09-03)
 
 

package/MIGRATING.md

@@ -58,6 +58,13 @@ What is new, one line each — nothing here renames or removes anything:
   type of the reference rather than applying an overload, and TS cannot propagate generic inference
   across an overload set the way it can for a single signature. `.then(unwrap)` now infers `TData`
   again, alongside `unwrap(await p)` and `unwrap(p)` — nothing about the runtime behaviour changed.
+- **`unwrap` strips `null`/`undefined` from a union-typed Eden response again** — the single
+  conditional signature above still inferred `TData` off `Envelope<infer TData>`, and an Eden
+  Treaty response is a UNION of envelopes (`{ data: T; error: null } | { data: null; error:
+EdenFetchError }`), not one envelope with a nullable `data`; inferring through the wrapper type
+  read `T | null` at every Eden call site. `UnwrapResult` now infers the raw `data` field and wraps
+  it in `NonNullable`, which distributes over a union `R` — `unwrap(await api.x.get())` resolves to
+  `T` again, with no `| null`. Runtime unchanged.
 - **`scrollParentOf` / `SCROLLPORT_ATTRIBUTE`** (`basalt-ui`) — resolve which box actually scrolls an
   element (`null` = the document). The seam behind the shell scrollport change below.
 - **`PageAside`** (`basalt-ui`) — the right-hand aside REGION a route claims, with the panel filter

package/dist/query-client.d.ts

@@ -42,6 +42,16 @@ export declare function createBasaltQueryClient(config?: QueryClientConfig): Que
  * `unwrap` reference — so `api.threads.get().then(unwrap)` silently widened. A single generic
  * signature has exactly one type to read regardless of how the reference is used.
  *
+ * **The conditional infers the raw `data` type and strips `null`/`undefined` from it**, rather
+ * than inferring the already-narrowed `Envelope<TData>`'s `TData` directly — Eden Treaty's
+ * response type is a UNION of envelope shapes (`{ data: T; error: null } | { data: null; error:
+ * EdenFetchError }`), and inferring through `Envelope<infer TData>` reads `TData` off whichever
+ * union member the conditional happens to match, landing on `T | null` at every Eden call site. A
+ * conditional type distributes over a union input when the checked type is a bare type parameter,
+ * so inferring `D` from `{ data: infer D; error: unknown }` and wrapping the result in
+ * `NonNullable` runs the check per union member and unions the results back together —
+ * `NonNullable<T> | NonNullable<null>` collapses to `T`.
+ *
  * @example
  * import { unwrap } from 'basalt-ui'
  *
@@ -61,7 +71,15 @@ type Envelope<TData = unknown> = {
     error: unknown;
 };
 /** `unwrap`'s conditional return: a `Promise<TData>` when `R` is a promised envelope, `TData` when
- * it is an already-resolved one — inferred off the SAME `R` the overload used to split on. */
-type UnwrapResult<R> = R extends Promise<Envelope<infer TData>> ? Promise<TData> : R extends Envelope<infer TData> ? TData : never;
+ * it is an already-resolved one — inferred off the SAME `R` the overload used to split on, and
+ * distributing over a union `R` (see the JSDoc above) so an Eden Treaty response's null branch
+ * never leaks into the resolved type. */
+type UnwrapResult<R> = R extends Promise<{
+    data: infer TData;
+    error: unknown;
+}> ? Promise<NonNullable<TData>> : R extends {
+    data: infer TData;
+    error: unknown;
+} ? NonNullable<TData> : never;
 export {};
 //# sourceMappingURL=query-client.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"query-client.d.ts","sourceRoot":"","sources":["../src/query-client.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACnD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AAW9D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,CAAC,EAAE,iBAAiB,GAAG,WAAW,CAQ/E;AAID;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAK3F;AAED,iGAAiG;AACjG,KAAK,QAAQ,CAAC,KAAK,GAAG,OAAO,IAAI;IAAE,IAAI,EAAE,KAAK,GAAG,IAAI,GAAG,SAAS,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAA;AAEnF;8FAC8F;AAC9F,KAAK,YAAY,CAAC,CAAC,IACjB,CAAC,SAAS,OAAO,CAAC,QAAQ,CAAC,MAAM,KAAK,CAAC,CAAC,GACpC,OAAO,CAAC,KAAK,CAAC,GACd,CAAC,SAAS,QAAQ,CAAC,MAAM,KAAK,CAAC,GAC7B,KAAK,GACL,KAAK,CAAA"}
+{"version":3,"file":"query-client.d.ts","sourceRoot":"","sources":["../src/query-client.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACnD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AAW9D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,CAAC,EAAE,iBAAiB,GAAG,WAAW,CAQ/E;AAID;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAK3F;AAED,iGAAiG;AACjG,KAAK,QAAQ,CAAC,KAAK,GAAG,OAAO,IAAI;IAAE,IAAI,EAAE,KAAK,GAAG,IAAI,GAAG,SAAS,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAA;AAEnF;;;yCAGyC;AACzC,KAAK,YAAY,CAAC,CAAC,IACjB,CAAC,SAAS,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,KAAK,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC,GACpD,OAAO,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,GAC3B,CAAC,SAAS;IAAE,IAAI,EAAE,MAAM,KAAK,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GAC7C,WAAW,CAAC,KAAK,CAAC,GAClB,KAAK,CAAA"}

package/llms.txt

@@ -1,4 +1,4 @@
-# basalt-ui v1.29.1
+# basalt-ui v1.29.2
 # Opinionated framework for Mantine-based React apps — theme, app shell, visx charts, toolchain presets
 #
 # basalt-ui is an opinionated framework for Mantine-based React apps.
@@ -19,7 +19,7 @@
 # ./tokens.css subpath. Guide: docs/FRAMEWORK-FREE.md in the repo.
 
 Package: basalt-ui
-Version: 1.29.1
+Version: 1.29.2
 
 ## basalt-ui
 Import: import { ... } from 'basalt-ui'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "basalt-ui",
-  "version": "1.29.1",
+  "version": "1.29.2",
   "description": "Opinionated framework for Mantine-based React apps — theme, app shell, visx charts, toolchain presets",
   "keywords": [
     "charts",

package/src/query-client.ts

@@ -63,6 +63,16 @@ export function createBasaltQueryClient(config?: QueryClientConfig): QueryClient
  * `unwrap` reference — so `api.threads.get().then(unwrap)` silently widened. A single generic
  * signature has exactly one type to read regardless of how the reference is used.
  *
+ * **The conditional infers the raw `data` type and strips `null`/`undefined` from it**, rather
+ * than inferring the already-narrowed `Envelope<TData>`'s `TData` directly — Eden Treaty's
+ * response type is a UNION of envelope shapes (`{ data: T; error: null } | { data: null; error:
+ * EdenFetchError }`), and inferring through `Envelope<infer TData>` reads `TData` off whichever
+ * union member the conditional happens to match, landing on `T | null` at every Eden call site. A
+ * conditional type distributes over a union input when the checked type is a bare type parameter,
+ * so inferring `D` from `{ data: infer D; error: unknown }` and wrapping the result in
+ * `NonNullable` runs the check per union member and unions the results back together —
+ * `NonNullable<T> | NonNullable<null>` collapses to `T`.
+ *
  * @example
  * import { unwrap } from 'basalt-ui'
  *
@@ -86,12 +96,14 @@ export function unwrap<R extends Envelope | Promise<Envelope>>(response: R): Unw
 type Envelope<TData = unknown> = { data: TData | null | undefined; error: unknown }
 
 /** `unwrap`'s conditional return: a `Promise<TData>` when `R` is a promised envelope, `TData` when
- * it is an already-resolved one — inferred off the SAME `R` the overload used to split on. */
+ * it is an already-resolved one — inferred off the SAME `R` the overload used to split on, and
+ * distributing over a union `R` (see the JSDoc above) so an Eden Treaty response's null branch
+ * never leaks into the resolved type. */
 type UnwrapResult<R> =
-  R extends Promise<Envelope<infer TData>>
-    ? Promise<TData>
-    : R extends Envelope<infer TData>
-      ? TData
+  R extends Promise<{ data: infer TData; error: unknown }>
+    ? Promise<NonNullable<TData>>
+    : R extends { data: infer TData; error: unknown }
+      ? NonNullable<TData>
       : never
 
 function unwrapEnvelope<TData>(envelope: Envelope<TData>): TData {