fix(types): boundary primitives return a typed Accessor<T | U> at every layer

createErrorBoundary/createLoadingBoundary previously returned () => unknown
(or leaked SourceAccessor<unknown>), so reading a boundary's value required
casts and surfaced as TS warnings in every rollup build. The external
signature is now identical across @solidjs/signals core, solid-js client
hydration, and the server runtime: pass content and fallback functions, get
back Accessor<T | U>. The SSR loading boundary's template plumbing moves to a
private ssrLoadingBoundary cast at a single point, since its accessor yields
resolved fragments rather than T/U.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: ryansolid

.changeset/boundary-accessor-return-types.md

@@ -0,0 +1,6 @@
+---
+"@solidjs/signals": patch
+"solid-js": patch
+---
+
+`createErrorBoundary` and `createLoadingBoundary` now return a properly typed `Accessor<T | U>` (content union fallback) instead of `() => unknown`, with the same external signature across the core, client hydration, and server layers.

packages/solid-signals/src/boundaries.ts

@@ -368,10 +368,10 @@ export class CollectionQueue extends Queue {
 
 function createCollectionBoundary<T>(
   type: number,
-  fn: () => any,
-  fallback: (queue: CollectionQueue) => any,
+  fn: () => T,
+  fallback: (queue: CollectionQueue) => T,
   onFn?: () => any
-) {
+): Accessor<T> {
   if (__DEV__ && !getOwner()) {
     const message =
       "[NO_OWNER_BOUNDARY] Boundaries created outside a reactive context will never be disposed.";
@@ -410,14 +410,17 @@ function createCollectionBoundary<T>(
     controller.register(queue);
     cleanup(() => controller.unregister(queue));
   }
-  return accessor(
+  return accessor<T>(
     computed(
-      () => {
+      (): T => {
         if (!read(queue._disabled)) {
           const resolved = read(tree);
           if (!untrack(() => read(queue._disabled))) return ((queue._initialized = true), resolved);
         }
-        if (_revealUsed && read(queue._collapsed)) return undefined;
+        // Collapsed reveal slots suppress their own output entirely; the
+        // renderer treats the hole as empty, so the cast never leaks to users
+        // outside a `createRevealOrder` scope.
+        if (_revealUsed && read(queue._collapsed)) return undefined as T;
         return fallback(queue);
       },
       // Boundary structure, not a user source: its value is fallback-or-content and
@@ -452,12 +455,12 @@ function createCollectionBoundary<T>(
  * }
  * ```
  */
-export function createLoadingBoundary(
-  fn: () => any,
-  fallback: () => any,
+export function createLoadingBoundary<T, U>(
+  fn: () => T,
+  fallback: () => U,
   options?: { on?: () => any }
-) {
-  return createCollectionBoundary(STATUS_PENDING, fn, () => fallback(), options?.on);
+): Accessor<T | U> {
+  return createCollectionBoundary<T | U>(STATUS_PENDING, fn, () => fallback(), options?.on);
 }
 
 /**
@@ -483,11 +486,11 @@ export function createLoadingBoundary(
  * }
  * ```
  */
-export function createErrorBoundary<U>(
-  fn: () => any,
+export function createErrorBoundary<T, U>(
+  fn: () => T,
   fallback: (error: Accessor<unknown>, reset: () => void) => U
-) {
-  return createCollectionBoundary(STATUS_ERROR, fn, queue => {
+): Accessor<T | U> {
+  return createCollectionBoundary<T | U>(STATUS_ERROR, fn, queue => {
     return fallback(accessor(queue._error!), () => {
       for (const source of queue._sources) recompute(source);
       schedule();

packages/solid/src/client/hydration.ts

@@ -583,10 +583,10 @@ function hydratedCreateSignal(fn?: any, second?: any) {
   return coreSignal((prev: any) => readSerializedOrCompute(fn, prev), second);
 }
 
-function hydratedCreateErrorBoundary<U>(
-  fn: () => any,
+function hydratedCreateErrorBoundary<T, U>(
+  fn: () => T,
   fallback: (error: () => unknown, reset: () => void) => U
-): () => unknown {
+): Accessor<T | U> {
   if (!sharedConfig.hydrating) return coreErrorBoundary(fn, fallback);
   markTopLevelSnapshotScope();
   const parent = getOwner()!;
@@ -922,10 +922,10 @@ export const createSignal: {
  * @internal
  */
 export const createErrorBoundary = ((...args: any[]) =>
-  (_createErrorBoundary || coreErrorBoundary)(...args)) as <U>(
-  fn: () => any,
+  (_createErrorBoundary || coreErrorBoundary)(...args)) as <T, U>(
+  fn: () => T,
   fallback: (error: Accessor<unknown>, reset: () => void) => U
-) => () => unknown;
+) => Accessor<T | U>;
 
 /**
  * Internal primitive that backs `<Reveal>` coordination of sibling loading
@@ -1362,11 +1362,11 @@ function scheduleResumeAfterAssets(
  *
  * @internal
  */
-export function createLoadingBoundary(
-  fn: () => any,
-  fallback: () => any,
+export function createLoadingBoundary<T, U>(
+  fn: () => T,
+  fallback: () => U,
   options?: { on?: () => any }
-): () => unknown {
+): Accessor<T | U> {
   if (!sharedConfig.hydrating) return coreLoadingBoundary(fn, fallback, options);
 
   let settledSerializationResumeQueued = false;
@@ -1494,7 +1494,7 @@ export function createLoadingBoundary(
       return undefined;
     }
     return coreLoadingBoundary(fn, fallback, options);
-  }) as unknown as () => unknown;
+  }) as unknown as Accessor<T | U>;
 }
 
 /**

packages/solid/src/server/hydration.ts

@@ -12,7 +12,7 @@ import {
 } from "./signals.js";
 import { sharedConfig, NoHydrateContext } from "./shared.js";
 import type { SSRTemplateObject, HydrationContext } from "./shared.js";
-import type { Context } from "./signals.js";
+import type { Accessor, Context } from "./signals.js";
 import type { Element as SolidElement } from "../types.js";
 
 export { sharedConfig, NoHydrateContext } from "./shared.js";
@@ -65,15 +65,26 @@ export function ssrHandleError(err: any) {
   throw err;
 }
 
-export function createLoadingBoundary(
-  fn: () => any,
-  fallback: () => any,
+export function createLoadingBoundary<T, U>(
+  fn: () => T,
+  fallback: () => U,
   options?: { on?: () => any }
-): () => unknown {
+): Accessor<T | U> {
   const currentCtx = sharedConfig.context;
   if (!currentCtx) {
     return coreLoadingBoundary(fn, fallback);
   }
+  // Under an SSR context the accessor yields resolved template fragments, not
+  // T/U — the declared signature is the isomorphic contract the renderer and
+  // client share; the SSR plumbing below is cast to it.
+  return ssrLoadingBoundary(currentCtx, fn, fallback) as unknown as Accessor<T | U>;
+}
+
+function ssrLoadingBoundary(
+  currentCtx: HydrationContext,
+  fn: () => any,
+  fallback: () => any
+): () => unknown {
   const ctx = currentCtx;
   const parent = getOwner();
   const parentHandler = parent && runWithOwner(parent, () => getContext(ErrorContext));

packages/solid/src/server/signals.ts

@@ -1584,10 +1584,10 @@ export function runWithBoundaryErrorContext<T>(
 
 export { NoHydrateContext };
 
-export function createErrorBoundary<U>(
-  fn: () => any,
+export function createErrorBoundary<T, U>(
+  fn: () => T,
   fallback: (error: Accessor<unknown>, reset: () => void) => U
-): () => unknown {
+): Accessor<T | U> {
   const ctx = sharedConfig.context;
   const parent = getOwner();
   const owner = createOwner();
@@ -1653,11 +1653,11 @@ export function createErrorBoundary<U>(
   };
 }
 
-export function createLoadingBoundary(
-  fn: () => any,
-  fallback: () => any,
+export function createLoadingBoundary<T, U>(
+  fn: () => T,
+  fallback: () => U,
   options?: { on?: () => any }
-): () => unknown {
+): Accessor<T | U> {
   // On server, try to run fn. If NotReadyError is thrown, return fallback.
   // Full HydrationContext integration happens in the Loading component wrapper.
   try {