solid-js 2.0.0-beta.7 → 2.0.0-beta.8

package/dist/server.js

@@ -128,7 +128,7 @@ function createMemo(compute, options) {
     }
   }
   const ssrSource = options?.ssrSource;
-  if (ssrSource === "initial" || ssrSource === "client") {
+  if (ssrSource === "client") {
     comp.computed = true;
   } else if (!options?.lazy) {
     update();
@@ -324,7 +324,7 @@ function closeAsyncIterator(iter, value) {
 }
 function serverEffect(compute, effectFn, options) {
   const ssrSource = options?.ssrSource;
-  if (ssrSource === "client" || ssrSource === "initial") {
+  if (ssrSource === "client") {
     createOwner();
     return;
   }
@@ -405,7 +405,7 @@ function createProjection(fn, initialValue, options) {
   const ctx = sharedConfig.context;
   const owner = createOwner();
   const [state] = createStore(initialValue);
-  if (options?.ssrSource === "initial" || options?.ssrSource === "client") {
+  if (options?.ssrSource === "client") {
     return state;
   }
   let disposed = false;
@@ -825,12 +825,6 @@ function ssrHandleError(err) {
   }
   throw err;
 }
-class InvalidTopLevelAsyncReadError extends Error {
-  constructor() {
-    super("Async values must be read within a tracking scope (JSX, a memo, or an effect's compute function).");
-    this.name = "InvalidTopLevelAsyncReadError";
-  }
-}
 function createLoadingBoundary(fn, fallback, options) {
   const currentCtx = sharedConfig.context;
   if (!currentCtx) {
@@ -845,6 +839,7 @@ function createLoadingBoundary(fn, fallback, options) {
   o.id = id + "00";
   let done;
   let handledRenderError;
+  let retryPromise;
   let serializeBuffer = [];
   const bufferedCtx = Object.create(ctx);
   bufferedCtx.serialize = (id, value, deferStream) => {
@@ -888,21 +883,26 @@ function createLoadingBoundary(fn, fallback, options) {
   function runDiscovery() {
     o.dispose(false);
     serializeBuffer = [];
+    retryPromise = undefined;
     return runLoadingPhase(() => {
       try {
         return ctx.resolve(fn());
       } catch (err) {
-        if (err instanceof NotReadyError) throw new InvalidTopLevelAsyncReadError();
+        if (err instanceof NotReadyError) {
+          retryPromise = err.source;
+          return undefined;
+        }
         throw err;
       }
     });
   }
   let ret = runDiscovery();
-  if (!ret?.p?.length) {
+  if (!retryPromise && !ret?.p?.length) {
     commitBoundaryState();
     return () => ret;
   }
-  const collapseFallback = revealGroup ? revealGroup.register(id) : false;
+  const regResult = revealGroup ? revealGroup.register(id) : null;
+  const collapseFallback = regResult?.collapseFallback ?? false;
   if (collapseFallback && !ctx.async) {
     commitBoundaryState();
     ctx.serialize(id, "$$f");
@@ -923,6 +923,10 @@ function createLoadingBoundary(fn, fallback, options) {
     done = ctx.registerFragment(id, regOpts);
     (async () => {
       try {
+        while (retryPromise) {
+          await retryPromise.catch(() => {});
+          ret = runDiscovery();
+        }
         commitBoundaryState();
         while (ret.p.length) {
           await Promise.all(ret.p).catch(() => {});
@@ -1025,15 +1029,16 @@ function Loading(props) {
 function Reveal(props) {
   const o = createOwner();
   const id = o.id;
-  const together = !!props.together;
-  const collapsed = !!props.collapsed;
+  const order = props.order ?? "sequential";
+  const collapsed = order === "sequential" && !!props.collapsed;
   if (!sharedConfig.context?.async) {
     const parent = getOwner();
     const parentGroup = parent ? runWithOwner(parent, () => getContext(RevealGroupContext)) : null;
     let collapsedByParent = false;
     if (parentGroup) {
-      collapsedByParent = parentGroup.register(id);
-      if (collapsed || together) console.warn("Nested <Reveal> with collapsed/together won't coordinate correctly with renderToString. Use renderToStream for full support.");
+      const reg = parentGroup.register(id);
+      collapsedByParent = reg.collapseFallback;
+      if (order === "together" || collapsed) console.warn("Nested <Reveal> with collapsed/together won't coordinate correctly with renderToString. Use renderToStream for full support.");
     }
     let count = 0;
     return runWithOwner(o, () => {
@@ -1041,8 +1046,11 @@ function Reveal(props) {
         id,
         register(_key) {
           count++;
-          if (collapsedByParent) return true;
-          return !together && collapsed && count > 1;
+          const collapseFallback = collapsedByParent || order === "sequential" && collapsed && count > 1;
+          return {
+            collapseFallback,
+            held: false
+          };
         },
         onResolved() {}
       });
@@ -1052,58 +1060,129 @@ function Reveal(props) {
   const ctx = sharedConfig.context;
   const keys = [];
   const resolved = new Set();
+  const minimallyResolved = new Set();
   const composites = new Map();
+  const activated = new Set();
+  const stash = [];
+  const collapsedLeafKeys = [];
   let frontier = 0;
+  let heldByParent = false;
+  let collapsedByParent = false;
+  let selfMinimallyResolved = false;
+  let notifiedParentDone = false;
   const parent = getOwner();
   const parentGroup = parent ? runWithOwner(parent, () => getContext(RevealGroupContext)) : null;
-  let collapsedByParent = false;
   if (parentGroup) {
-    collapsedByParent = parentGroup.register(id, {
+    const reg = parentGroup.register(id, {
       onActivate: () => {
-        collapsedByParent = false;
-        advanceFrontier();
+        if (!heldByParent) return;
+        heldByParent = false;
+        if (collapsedByParent) {
+          collapsedByParent = false;
+          if (collapsedLeafKeys.length) {
+            ctx.revealFallbacks?.([...collapsedLeafKeys]);
+            collapsedLeafKeys.length = 0;
+          }
+        }
+        if (order === "sequential") advanceFrontier();else if (order === "together") checkTogetherRelease();else naturalRelease();
       }
     });
+    collapsedByParent = reg.collapseFallback;
+    heldByParent = reg.held;
   }
   function notifyParentIfDone() {
+    if (notifiedParentDone) return;
     if (parentGroup && resolved.size === keys.length) {
+      notifiedParentDone = true;
       parentGroup.onResolved(id);
     }
   }
+  function activateComposite(key) {
+    if (activated.has(key)) return;
+    activated.add(key);
+    composites.get(key)();
+  }
+  function updateSelfMinimallyResolved() {
+    if (selfMinimallyResolved) return;
+    if (keys.length === 0) selfMinimallyResolved = true;else if (order === "together") selfMinimallyResolved = minimallyResolved.size === keys.length;else if (order === "sequential") selfMinimallyResolved = minimallyResolved.has(keys[0]);
+    else selfMinimallyResolved = resolved.size > 0;
+    if (selfMinimallyResolved) parentGroup?.onMinimallyResolved?.(id);
+  }
   function advanceFrontier() {
+    if (heldByParent) return;
     while (frontier < keys.length && resolved.has(keys[frontier])) {
-      if (!composites.has(keys[frontier])) ctx.revealFragments?.([keys[frontier]]);
+      const k = keys[frontier];
+      if (composites.has(k)) activateComposite(k);else ctx.revealFragments?.([k]);
       frontier++;
     }
     if (frontier < keys.length) {
-      const activate = composites.get(keys[frontier]);
-      if (activate) activate();else if (!together && collapsed) ctx.revealFallbacks?.(keys.slice(frontier));
+      const k = keys[frontier];
+      if (composites.has(k)) activateComposite(k);else if (order === "sequential" && collapsed) ctx.revealFallbacks?.([k]);
     }
     notifyParentIfDone();
   }
+  function checkTogetherRelease() {
+    if (order !== "together" || heldByParent) return;
+    if (minimallyResolved.size < keys.length) return;
+    if (stash.length) {
+      ctx.revealFragments?.([...stash]);
+      stash.length = 0;
+    }
+    composites.forEach((_, key) => activateComposite(key));
+    notifyParentIfDone();
+  }
+  function naturalRelease() {
+    if (stash.length) {
+      ctx.revealFragments?.([...stash]);
+      stash.length = 0;
+    }
+    composites.forEach((_, key) => activateComposite(key));
+    notifyParentIfDone();
+  }
   return runWithOwner(o, () => {
     setContext(RevealGroupContext, {
       id,
       register(key, options) {
         keys.push(key);
-        if (options?.onActivate) composites.set(key, options.onActivate);
-        if (collapsedByParent) return true;
-        return !together && collapsed && keys.length > 1;
+        const isComposite = !!options?.onActivate;
+        if (isComposite) composites.set(key, options.onActivate);
+        const selfCollapse = order === "sequential" && collapsed && keys.length > 1;
+        const collapseFallback = collapsedByParent || selfCollapse;
+        if (collapseFallback && !isComposite) collapsedLeafKeys.push(key);
+        let held = heldByParent;
+        if (!held) {
+          if (order === "together") held = true;else if (order === "sequential" && keys.length > 1) held = true;
+        }
+        return {
+          collapseFallback,
+          held
+        };
       },
       onResolved(key) {
         resolved.add(key);
-        if (collapsedByParent) {
-          notifyParentIfDone();
-          return;
-        }
-        if (together) {
-          if (resolved.size === keys.length) {
-            ctx.revealFragments?.(id);
-            notifyParentIfDone();
+        const isLeaf = !composites.has(key);
+        if (isLeaf) {
+          if (order === "together") {
+            stash.push(key);
+          } else if (order === "natural" && heldByParent) {
+            stash.push(key);
+          } else if (order === "natural") {
+            ctx.revealFragments?.([key]);
           }
+          markMinimallyResolved(key);
+          if (order === "sequential" && !heldByParent) advanceFrontier();
+          if (order === "natural") updateSelfMinimallyResolved();
         } else {
-          advanceFrontier();
+          if (!heldByParent) {
+            if (order === "sequential") advanceFrontier();else if (order === "natural") activateComposite(key);
+          }
+          if (order === "together") checkTogetherRelease();
+          if (order === "natural") updateSelfMinimallyResolved();
         }
+        notifyParentIfDone();
+      },
+      onMinimallyResolved(key) {
+        markMinimallyResolved(key);
       }
     });
     const result = props.children;
@@ -1112,6 +1191,12 @@ function Reveal(props) {
     }
     return result;
   });
+  function markMinimallyResolved(key) {
+    if (minimallyResolved.has(key)) return;
+    minimallyResolved.add(key);
+    updateSelfMinimallyResolved();
+    if (order === "together") checkTogetherRelease();
+  }
 }
 
 const DEV = undefined;

package/dist/solid.cjs

@@ -277,9 +277,12 @@ function hydrateSignalFromAsyncIterable(coreFn, compute, options) {
       return it;
     }
   };
-  return coreFn(() => iterable, options);
+  return coreFn(prev => {
+    subFetch(compute, prev);
+    return iterable;
+  }, options);
 }
-function hydrateStoreFromAsyncIterable(coreFn, initialValue, options) {
+function hydrateStoreFromAsyncIterable(coreFn, fn, initialValue, options) {
   const parent = signals.getOwner();
   const expectedId = signals.peekNextChildId(parent);
   if (!sharedConfig.has(expectedId)) return null;
@@ -289,6 +292,10 @@ function hydrateStoreFromAsyncIterable(coreFn, initialValue, options) {
   let isFirst = true;
   let buffered = null;
   return coreFn(draft => {
+    const {
+      proxy
+    } = createShadowDraft(draft);
+    subFetch(fn, proxy);
     const process = res => {
       if (res.done) return {
         done: true,
@@ -296,11 +303,16 @@ function hydrateStoreFromAsyncIterable(coreFn, initialValue, options) {
       };
       if (isFirst) {
         isFirst = false;
-        if (Array.isArray(res.value)) {
-          for (let i = 0; i < res.value.length; i++) draft[i] = res.value[i];
-          draft.length = res.value.length;
-        } else {
-          Object.assign(draft, res.value);
+        signals.setSnapshotCapture(false);
+        try {
+          if (Array.isArray(res.value)) {
+            for (let i = 0; i < res.value.length; i++) draft[i] = res.value[i];
+            draft.length = res.value.length;
+          } else {
+            Object.assign(draft, res.value);
+          }
+        } finally {
+          signals.setSnapshotCapture(true);
         }
       } else {
         applyPatches(draft, res.value);
@@ -369,13 +381,6 @@ function hydratedCreateMemo(compute, options) {
     setHydrated(true);
     return memo;
   }
-  if (ssrSource === "initial") {
-    return signals.createMemo(prev => {
-      if (!sharedConfig.hydrating) return compute(prev);
-      subFetch(compute, prev);
-      return prev;
-    }, options);
-  }
   const aiResult = hydrateSignalFromAsyncIterable(signals.createMemo, compute, options);
   if (aiResult !== null) return aiResult;
   return signals.createMemo(prev => readSerializedOrCompute(compute, prev), options);
@@ -395,13 +400,6 @@ function hydratedCreateSignal(fn, second) {
     setHydrated(true);
     return sig;
   }
-  if (ssrSource === "initial") {
-    return signals.createSignal(prev => {
-      if (!sharedConfig.hydrating) return fn(prev);
-      subFetch(fn, prev);
-      return prev;
-    }, second);
-  }
   const aiResult = hydrateSignalFromAsyncIterable(signals.createSignal, fn, second);
   if (aiResult !== null) return aiResult;
   return signals.createSignal(prev => readSerializedOrCompute(fn, prev), second);
@@ -441,13 +439,6 @@ function hydratedCreateOptimistic(fn, second) {
     setHydrated(true);
     return sig;
   }
-  if (ssrSource === "initial") {
-    return signals.createOptimistic(prev => {
-      if (!sharedConfig.hydrating) return fn(prev);
-      subFetch(fn, prev);
-      return prev;
-    }, second);
-  }
   const aiResult = hydrateSignalFromAsyncIterable(signals.createOptimistic, fn, second);
   if (aiResult !== null) return aiResult;
   return signals.createOptimistic(prev => readSerializedOrCompute(fn, prev), second);
@@ -491,7 +482,7 @@ function hydrateStoreLikeFn(coreFn, fn, initialValue, options, ssrSource) {
     setHydrated(true);
     return result;
   }
-  const aiResult = hydrateStoreFromAsyncIterable(coreFn, initialValue, options);
+  const aiResult = hydrateStoreFromAsyncIterable(coreFn, fn, initialValue, options);
   if (aiResult !== null) return aiResult;
   return coreFn(wrapStoreFn(fn), initialValue, options);
 }
@@ -499,21 +490,18 @@ function hydratedCreateStore(first, second, third) {
   if (typeof first !== "function" || !sharedConfig.hydrating) return signals.createStore(first, second, third);
   markTopLevelSnapshotScope();
   const ssrSource = third?.ssrSource;
-  if (ssrSource === "initial") return signals.createStore(second ?? {});
   return hydrateStoreLikeFn(signals.createStore, first, second ?? {}, third, ssrSource);
 }
 function hydratedCreateOptimisticStore(first, second, third) {
   if (typeof first !== "function" || !sharedConfig.hydrating) return signals.createOptimisticStore(first, second, third);
   markTopLevelSnapshotScope();
   const ssrSource = third?.ssrSource;
-  if (ssrSource === "initial") return signals.createOptimisticStore(second ?? {});
   return hydrateStoreLikeFn(signals.createOptimisticStore, first, second ?? {}, third, ssrSource);
 }
 function hydratedCreateProjection(fn, initialValue, options) {
   if (!sharedConfig.hydrating) return signals.createProjection(fn, initialValue, options);
   markTopLevelSnapshotScope();
   const ssrSource = options?.ssrSource;
-  if (ssrSource === "initial") return signals.createProjection(draft => draft, initialValue, options);
   return hydrateStoreLikeFn(signals.createProjection, fn, initialValue, options, ssrSource);
 }
 function hydratedEffect(coreFn, compute, effectFn, options) {
@@ -535,14 +523,6 @@ function hydratedEffect(coreFn, compute, effectFn, options) {
     setHydrated(true);
     return;
   }
-  if (ssrSource === "initial") {
-    coreFn(prev => {
-      if (!sharedConfig.hydrating) return compute(prev);
-      subFetch(compute, prev);
-      return prev;
-    }, effectFn, options);
-    return;
-  }
   markTopLevelSnapshotScope();
   coreFn(prev => readSerializedOrCompute(compute, prev), effectFn, options);
 }
@@ -854,7 +834,7 @@ function Loading(props) {
 }
 function Reveal(props) {
   return signals.createRevealOrder(() => props.children, {
-    together: () => !!props.together,
+    order: () => props.order ?? "sequential",
     collapsed: () => !!props.collapsed
   });
 }

package/dist/solid.js

@@ -276,9 +276,12 @@ function hydrateSignalFromAsyncIterable(coreFn, compute, options) {
       return it;
     }
   };
-  return coreFn(() => iterable, options);
+  return coreFn(prev => {
+    subFetch(compute, prev);
+    return iterable;
+  }, options);
 }
-function hydrateStoreFromAsyncIterable(coreFn, initialValue, options) {
+function hydrateStoreFromAsyncIterable(coreFn, fn, initialValue, options) {
   const parent = getOwner();
   const expectedId = peekNextChildId(parent);
   if (!sharedConfig.has(expectedId)) return null;
@@ -288,6 +291,10 @@ function hydrateStoreFromAsyncIterable(coreFn, initialValue, options) {
   let isFirst = true;
   let buffered = null;
   return coreFn(draft => {
+    const {
+      proxy
+    } = createShadowDraft(draft);
+    subFetch(fn, proxy);
     const process = res => {
       if (res.done) return {
         done: true,
@@ -295,11 +302,16 @@ function hydrateStoreFromAsyncIterable(coreFn, initialValue, options) {
       };
       if (isFirst) {
         isFirst = false;
-        if (Array.isArray(res.value)) {
-          for (let i = 0; i < res.value.length; i++) draft[i] = res.value[i];
-          draft.length = res.value.length;
-        } else {
-          Object.assign(draft, res.value);
+        setSnapshotCapture(false);
+        try {
+          if (Array.isArray(res.value)) {
+            for (let i = 0; i < res.value.length; i++) draft[i] = res.value[i];
+            draft.length = res.value.length;
+          } else {
+            Object.assign(draft, res.value);
+          }
+        } finally {
+          setSnapshotCapture(true);
         }
       } else {
         applyPatches(draft, res.value);
@@ -368,13 +380,6 @@ function hydratedCreateMemo(compute, options) {
     setHydrated(true);
     return memo;
   }
-  if (ssrSource === "initial") {
-    return createMemo$1(prev => {
-      if (!sharedConfig.hydrating) return compute(prev);
-      subFetch(compute, prev);
-      return prev;
-    }, options);
-  }
   const aiResult = hydrateSignalFromAsyncIterable(createMemo$1, compute, options);
   if (aiResult !== null) return aiResult;
   return createMemo$1(prev => readSerializedOrCompute(compute, prev), options);
@@ -394,13 +399,6 @@ function hydratedCreateSignal(fn, second) {
     setHydrated(true);
     return sig;
   }
-  if (ssrSource === "initial") {
-    return createSignal$1(prev => {
-      if (!sharedConfig.hydrating) return fn(prev);
-      subFetch(fn, prev);
-      return prev;
-    }, second);
-  }
   const aiResult = hydrateSignalFromAsyncIterable(createSignal$1, fn, second);
   if (aiResult !== null) return aiResult;
   return createSignal$1(prev => readSerializedOrCompute(fn, prev), second);
@@ -440,13 +438,6 @@ function hydratedCreateOptimistic(fn, second) {
     setHydrated(true);
     return sig;
   }
-  if (ssrSource === "initial") {
-    return createOptimistic$1(prev => {
-      if (!sharedConfig.hydrating) return fn(prev);
-      subFetch(fn, prev);
-      return prev;
-    }, second);
-  }
   const aiResult = hydrateSignalFromAsyncIterable(createOptimistic$1, fn, second);
   if (aiResult !== null) return aiResult;
   return createOptimistic$1(prev => readSerializedOrCompute(fn, prev), second);
@@ -490,7 +481,7 @@ function hydrateStoreLikeFn(coreFn, fn, initialValue, options, ssrSource) {
     setHydrated(true);
     return result;
   }
-  const aiResult = hydrateStoreFromAsyncIterable(coreFn, initialValue, options);
+  const aiResult = hydrateStoreFromAsyncIterable(coreFn, fn, initialValue, options);
   if (aiResult !== null) return aiResult;
   return coreFn(wrapStoreFn(fn), initialValue, options);
 }
@@ -498,21 +489,18 @@ function hydratedCreateStore(first, second, third) {
   if (typeof first !== "function" || !sharedConfig.hydrating) return createStore$1(first, second, third);
   markTopLevelSnapshotScope();
   const ssrSource = third?.ssrSource;
-  if (ssrSource === "initial") return createStore$1(second ?? {});
   return hydrateStoreLikeFn(createStore$1, first, second ?? {}, third, ssrSource);
 }
 function hydratedCreateOptimisticStore(first, second, third) {
   if (typeof first !== "function" || !sharedConfig.hydrating) return createOptimisticStore$1(first, second, third);
   markTopLevelSnapshotScope();
   const ssrSource = third?.ssrSource;
-  if (ssrSource === "initial") return createOptimisticStore$1(second ?? {});
   return hydrateStoreLikeFn(createOptimisticStore$1, first, second ?? {}, third, ssrSource);
 }
 function hydratedCreateProjection(fn, initialValue, options) {
   if (!sharedConfig.hydrating) return createProjection$1(fn, initialValue, options);
   markTopLevelSnapshotScope();
   const ssrSource = options?.ssrSource;
-  if (ssrSource === "initial") return createProjection$1(draft => draft, initialValue, options);
   return hydrateStoreLikeFn(createProjection$1, fn, initialValue, options, ssrSource);
 }
 function hydratedEffect(coreFn, compute, effectFn, options) {
@@ -534,14 +522,6 @@ function hydratedEffect(coreFn, compute, effectFn, options) {
     setHydrated(true);
     return;
   }
-  if (ssrSource === "initial") {
-    coreFn(prev => {
-      if (!sharedConfig.hydrating) return compute(prev);
-      subFetch(compute, prev);
-      return prev;
-    }, effectFn, options);
-    return;
-  }
   markTopLevelSnapshotScope();
   coreFn(prev => readSerializedOrCompute(compute, prev), effectFn, options);
 }
@@ -853,7 +833,7 @@ function Loading(props) {
 }
 function Reveal(props) {
   return createRevealOrder(() => props.children, {
-    together: () => !!props.together,
+    order: () => props.order ?? "sequential",
     collapsed: () => !!props.collapsed
   });
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "solid-js",
   "description": "A declarative JavaScript library for building user interfaces.",
-  "version": "2.0.0-beta.7",
+  "version": "2.0.0-beta.8",
   "author": "Ryan Carniato",
   "license": "MIT",
   "homepage": "https://solidjs.com",
@@ -126,7 +126,7 @@
     "performance"
   ],
   "dependencies": {
-    "@solidjs/signals": "^2.0.0-beta.7",
+    "@solidjs/signals": "^2.0.0-beta.8",
     "csstype": "^3.1.0",
     "seroval": "~1.5.0",
     "seroval-plugins": "~1.5.0"

package/types/client/flow.d.ts

@@ -1,4 +1,5 @@
-import type { Accessor } from "@solidjs/signals";
+import type { Accessor, RevealOrder } from "@solidjs/signals";
+export type { RevealOrder };
 import type { JSX } from "../jsx.js";
 type NonZeroParams<T extends (...args: any[]) => any> = Parameters<T>["length"] extends 0 ? never : T;
 type ConditionalRenderCallback<T> = (item: Accessor<NonNullable<T>>) => JSX.Element;
@@ -117,26 +118,46 @@ export declare function Loading(props: {
     on?: any;
     children: JSX.Element;
 }): JSX.Element;
+export type RevealProps = {
+    order?: RevealOrder;
+    collapsed?: boolean;
+    children: JSX.Element;
+};
 /**
  * Coordinates the reveal timing of sibling `<Loading>` boundaries.
  *
- * - **Sequential** (default): boundaries reveal in DOM order as each resolves.
- * - **Together** (`together`): all boundaries wait until the group is ready, then reveal at once.
- * - **Collapsed** (`collapsed`, sequential only): only the frontier boundary shows its fallback;
- *   later boundaries produce nothing until their turn.
+ * The `order` prop picks the reveal policy:
+ * - `"sequential"` (default) — boundaries reveal in registration order; later boundaries
+ *   stay on their fallback until earlier ones resolve.
+ * - `"together"` — every direct slot stays on its fallback until the whole group is
+ *   "minimally ready" (every direct slot has its own first visible content available),
+ *   then the group releases in one cohesive reveal.
+ * - `"natural"` — each boundary reveals as its own data resolves. At the top level
+ *   this is equivalent to omitting `<Reveal>`; the mode exists for nesting, where
+ *   the group registers as a single composite slot in an enclosing `<Reveal>`.
+ *
+ * The `collapsed` prop is only consulted when `order="sequential"` (the default);
+ * it is ignored under `"together"` and `"natural"`. When set, tail boundaries past
+ * the frontier suppress their own fallback output.
+ *
+ * Nested `<Reveal>` groups compose: the inner group is one slot in the outer order
+ * and is held on its fallbacks until the outer releases the slot. Once released, the
+ * inner group runs its own `order` locally over whatever is still pending. There is
+ * no escape hatch — nesting under an outer group means participating in its ordering.
+ * See `documentation/solid-2.0/03-control-flow.md` for the full nesting matrix and the
+ * "minimally ready" definition per order.
  *
  * ```typescript
- * <Reveal>
+ * <Reveal order="sequential">
  *   <Loading fallback={<Skeleton />}><ProfileHeader /></Loading>
- *   <Loading fallback={<Skeleton />}><Posts /></Loading>
+ *   <Reveal order="natural">
+ *     <Loading fallback={<Skeleton />}><PostA /></Loading>
+ *     <Loading fallback={<Skeleton />}><PostB /></Loading>
+ *   </Reveal>
+ *   <Loading fallback={<Skeleton />}><Comments /></Loading>
  * </Reveal>
  * ```
  *
  * @description https://docs.solidjs.com/reference/components/reveal
  */
-export declare function Reveal(props: {
-    together?: boolean;
-    collapsed?: boolean;
-    children: JSX.Element;
-}): JSX.Element;
-export {};
+export declare function Reveal(props: RevealProps): JSX.Element;