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

package/dist/server.cjs

@@ -28,25 +28,82 @@ function runWithObserver(comp, fn) {
 function getObserver() {
   return Observer;
 }
-function createSignal(first, second, third) {
+function createDeferredPromise() {
+  let settled = false;
+  let resolvePromise;
+  let rejectPromise;
+  const promise = new Promise((resolve, reject) => {
+    resolvePromise = resolve;
+    rejectPromise = reject;
+  });
+  return {
+    promise,
+    resolve(value) {
+      if (settled) return;
+      settled = true;
+      promise.s = 1;
+      promise.v = value;
+      resolvePromise(value);
+    },
+    reject(error) {
+      if (settled) return;
+      settled = true;
+      promise.s = 2;
+      promise.v = error;
+      rejectPromise(error);
+    }
+  };
+}
+function subscribePendingRetry(error, retry) {
+  if (!(error instanceof signals.NotReadyError)) return false;
+  error.source?.then(() => retry(), () => retry());
+  return true;
+}
+function settleServerAsync(initial, rerun, deferred, onSuccess, onError, isDisposed) {
+  let first = true;
+  const attempt = () => {
+    if (isDisposed()) return;
+    let current;
+    try {
+      current = first ? initial : rerun();
+      first = false;
+    } catch (error) {
+      if (subscribePendingRetry(error, attempt)) return;
+      onError(error);
+      deferred.reject(error);
+      return;
+    }
+    Promise.resolve(current).then(value => {
+      if (isDisposed()) return;
+      deferred.resolve(onSuccess(value));
+    }, error => {
+      if (isDisposed()) return;
+      if (subscribePendingRetry(error, attempt)) return;
+      onError(error);
+      deferred.reject(error);
+    });
+  };
+  attempt();
+}
+function createSignal(first, second) {
   if (typeof first === "function") {
-    const opts = third?.deferStream || third?.ssrSource ? {
-      deferStream: third?.deferStream,
-      ssrSource: third?.ssrSource
+    const opts = second?.deferStream || second?.ssrSource ? {
+      deferStream: second?.deferStream,
+      ssrSource: second?.ssrSource
     } : undefined;
-    const memo = createMemo(prev => first(prev), second, opts);
+    const memo = createMemo(prev => first(prev), opts);
     return [memo, () => undefined];
   }
   return [() => first, v => {
     return first = typeof v === "function" ? v(first) : v;
   }];
 }
-function createMemo(compute, value, options) {
+function createMemo(compute, options) {
   const ctx = sharedConfig.context;
   const owner = signals.createOwner();
   const comp = {
     owner,
-    value: value,
+    value: undefined,
     compute: compute,
     error: undefined,
     computed: false,
@@ -57,21 +114,22 @@ function createMemo(compute, value, options) {
   }));
   function update() {
     if (comp.disposed) return;
+    const run = () => signals.runWithOwner(owner, () => runWithObserver(comp, () => comp.compute(comp.value)));
     try {
       comp.error = undefined;
-      const result = signals.runWithOwner(owner, () => runWithObserver(comp, () => comp.compute(comp.value)));
+      const result = run();
       comp.computed = true;
-      processResult(comp, result, owner, ctx, options?.deferStream, options?.ssrSource);
+      processResult(comp, result, owner, ctx, options?.deferStream, options?.ssrSource, run);
     } catch (err) {
       if (err instanceof signals.NotReadyError) {
-        err.source?.then(() => update(), () => update());
+        subscribePendingRetry(err, update);
       }
       comp.error = err;
       comp.computed = true;
     }
   }
   const ssrSource = options?.ssrSource;
-  if (ssrSource === "initial" || ssrSource === "client") {
+  if (ssrSource === "client") {
     comp.computed = true;
   } else if (!options?.lazy) {
     update();
@@ -146,7 +204,7 @@ function createDeepProxy(target, patches, basePath = []) {
   };
   return new Proxy(target, handler);
 }
-function processResult(comp, result, owner, ctx, deferStream, ssrSource) {
+function processResult(comp, result, owner, ctx, deferStream, ssrSource, rerun) {
   if (comp.disposed) return;
   const id = owner.id;
   const noHydrate = signals.getContext(NoHydrateContext, owner);
@@ -160,47 +218,78 @@ function processResult(comp, result, owner, ctx, deferStream, ssrSource) {
       comp.error = result.v;
       return;
     }
-    result.then(v => {
+    const deferred = createDeferredPromise();
+    if (ctx?.async && ctx.serialize && id && !noHydrate) ctx.serialize(id, deferred.promise, deferStream);
+    settleServerAsync(result, () => rerun ? rerun() : result, deferred, value => {
       result.s = 1;
-      result.v = v;
-      if (comp.disposed) return;
-      comp.value = v;
+      result.v = value;
+      comp.value = value;
       comp.error = undefined;
-    }, err => {
+      return value;
+    }, error => {
       result.s = 2;
-      result.v = err;
-      if (comp.disposed) return;
-      comp.error = err;
-    });
-    if (ctx?.async && ctx.serialize && id && !noHydrate) ctx.serialize(id, result, deferStream);
-    comp.error = new signals.NotReadyError(result);
+      result.v = error;
+      comp.error = error;
+    }, () => comp.disposed);
+    comp.error = new signals.NotReadyError(deferred.promise);
     return;
   }
   const iterator = result?.[Symbol.asyncIterator];
   if (typeof iterator === "function") {
-    const iter = iterator.call(result);
     if (ssrSource === "hybrid") {
-      const promise = iter.next().then(v => {
-        promise.s = 1;
-        promise.v = v.value;
-        if (!v.done) closeAsyncIterator(iter);
-        if (comp.disposed) return v.value;
-        comp.value = v.value;
+      let currentResult = result;
+      let iter;
+      const deferred = createDeferredPromise();
+      const runFirst = () => {
+        const source = currentResult ?? (rerun ? rerun() : result);
+        currentResult = undefined;
+        const nextIterator = source?.[Symbol.asyncIterator];
+        if (typeof nextIterator !== "function") {
+          throw new Error("Expected async iterator while retrying server createMemo");
+        }
+        iter = nextIterator.call(source);
+        return iter.next().then(value => {
+          if (!value.done) closeAsyncIterator(iter);
+          return value.value;
+        });
+      };
+      settleServerAsync(runFirst(), runFirst, deferred, value => {
+        comp.value = value;
         comp.error = undefined;
-        return v.value;
-      }, () => {});
-      if (ctx?.async && ctx.serialize && id && !noHydrate) ctx.serialize(id, promise, deferStream);
-      comp.error = new signals.NotReadyError(promise);
+        return value;
+      }, error => {
+        comp.error = error;
+      }, () => comp.disposed);
+      if (ctx?.async && ctx.serialize && id && !noHydrate) ctx.serialize(id, deferred.promise, deferStream);
+      comp.error = new signals.NotReadyError(deferred.promise);
     } else {
-      const firstNext = iter.next();
-      const firstReady = firstNext.then(r => {
-        if (comp.disposed) return;
-        if (!r.done) {
-          comp.value = r.value;
+      let currentResult = result;
+      let iter;
+      let firstResult;
+      const deferred = createDeferredPromise();
+      const runFirst = () => {
+        const source = currentResult ?? (rerun ? rerun() : result);
+        currentResult = undefined;
+        const nextIterator = source?.[Symbol.asyncIterator];
+        if (typeof nextIterator !== "function") {
+          throw new Error("Expected async iterator while retrying server createMemo");
+        }
+        iter = nextIterator.call(source);
+        return iter.next().then(value => {
+          firstResult = value;
+          return Promise.resolve();
+        });
+      };
+      settleServerAsync(runFirst(), runFirst, deferred, () => {
+        const resolved = firstResult;
+        if (resolved && !resolved.done) {
+          comp.value = resolved.value;
         }
         comp.error = undefined;
-        return Promise.resolve();
-      }, () => {});
+        return undefined;
+      }, error => {
+        comp.error = error;
+      }, () => comp.disposed);
       if (ctx?.async && ctx.serialize && id && !noHydrate) {
         let tappedFirst = true;
         const tapped = {
@@ -208,7 +297,10 @@ function processResult(comp, result, owner, ctx, deferStream, ssrSource) {
             next() {
               if (tappedFirst) {
                 tappedFirst = false;
-                return firstNext.then(r => r);
+                return deferred.promise.then(() => firstResult?.done ? {
+                  done: true,
+                  value: undefined
+                } : firstResult);
               }
               return iter.next().then(r => r);
             },
@@ -219,7 +311,7 @@ function processResult(comp, result, owner, ctx, deferStream, ssrSource) {
         };
         ctx.serialize(id, tapped, deferStream);
       }
-      comp.error = new signals.NotReadyError(firstReady);
+      comp.error = new signals.NotReadyError(deferred.promise);
     }
     return;
   }
@@ -231,9 +323,9 @@ function closeAsyncIterator(iter, value) {
     returned.then(undefined, () => {});
   }
 }
-function serverEffect(compute, effectFn, value, options) {
+function serverEffect(compute, effectFn, options) {
   const ssrSource = options?.ssrSource;
-  if (ssrSource === "client" || ssrSource === "initial") {
+  if (ssrSource === "client") {
     signals.createOwner();
     return;
   }
@@ -241,7 +333,7 @@ function serverEffect(compute, effectFn, value, options) {
   const owner = signals.createOwner();
   const comp = {
     owner,
-    value: value,
+    value: undefined,
     compute: compute,
     error: undefined,
     computed: true,
@@ -253,19 +345,19 @@ function serverEffect(compute, effectFn, value, options) {
     }));
   }
   try {
-    const result = signals.runWithOwner(owner, () => runWithObserver(comp, () => compute(value)));
+    const result = signals.runWithOwner(owner, () => runWithObserver(comp, () => compute(undefined)));
     if (ssrSource) {
       processResult(comp, result, owner, ctx, options?.deferStream, ssrSource);
     }
-    effectFn?.(ssrSource ? comp.value ?? result : result, value);
+    effectFn?.(ssrSource ? comp.value ?? result : result, undefined);
   } catch (err) {
   }
 }
-function createEffect(compute, effect, value, options) {
-  serverEffect(compute, undefined, value, options);
+function createEffect(compute, effect, options) {
+  serverEffect(compute, undefined, options);
 }
-function createRenderEffect(compute, effectFn, value, options) {
-  serverEffect(compute, effectFn, value, options);
+function createRenderEffect(compute, effectFn, options) {
+  serverEffect(compute, effectFn, options);
 }
 function createTrackedEffect(compute, options) {
   const o = signals.getOwner();
@@ -276,8 +368,8 @@ function createReaction(effectFn, options) {
     tracking();
   };
 }
-function createOptimistic(first, second, third) {
-  return createSignal(first, second, third);
+function createOptimistic(first, second) {
+  return createSignal(first, second);
 }
 function setProperty(state, property, value) {
   if (state[property] === value) return;
@@ -287,7 +379,7 @@ function setProperty(state, property, value) {
 }
 function createStore(first, second) {
   if (typeof first === "function") {
-    const store = createProjection(first, second ?? {});
+    const store = createProjection(first, second);
     return [store, fn => fn(store)];
   }
   const state = first;
@@ -310,11 +402,11 @@ function createPendingProxy(state, source) {
     pending = false;
   }];
 }
-function createProjection(fn, initialValue = {}, options) {
+function createProjection(fn, initialValue, options) {
   const ctx = sharedConfig.context;
   const owner = signals.createOwner();
   const [state] = createStore(initialValue);
-  if (options?.ssrSource === "initial" || options?.ssrSource === "client") {
+  if (options?.ssrSource === "client") {
     return state;
   }
   let disposed = false;
@@ -325,43 +417,69 @@ function createProjection(fn, initialValue = {}, options) {
   const useProxy = ssrSource !== "hybrid";
   const patches = [];
   const draft = useProxy ? createDeepProxy(state, patches) : state;
-  const result = signals.runWithOwner(owner, () => fn(draft));
+  const runProjection = () => signals.runWithOwner(owner, () => fn(draft));
+  const result = runProjection();
   const iteratorFn = result?.[Symbol.asyncIterator];
   if (typeof iteratorFn === "function") {
-    const iter = iteratorFn.call(result);
     if (ssrSource === "hybrid") {
-      const promise = iter.next().then(r => {
-        promise.s = 1;
-        if (!r.done) closeAsyncIterator(iter);
-        if (disposed) {
-          promise.v = state;
-          return state;
+      let currentResult = result;
+      let iter;
+      const deferred = createDeferredPromise();
+      const [pending, markReady] = createPendingProxy(state, deferred.promise);
+      const runFirst = () => {
+        const source = currentResult ?? runProjection();
+        currentResult = undefined;
+        const nextIterator = source?.[Symbol.asyncIterator];
+        if (typeof nextIterator !== "function") {
+          throw new Error("Expected async iterator while retrying server createProjection");
         }
-        if (r.value !== undefined && r.value !== state) {
-          Object.assign(state, r.value);
+        iter = nextIterator.call(source);
+        return iter.next().then(r => {
+          if (!r.done) closeAsyncIterator(iter);
+          return r.value;
+        });
+      };
+      settleServerAsync(runFirst(), runFirst, deferred, value => {
+        if (value !== undefined && value !== state) {
+          Object.assign(state, value);
         }
-        promise.v = state;
         markReady();
         return state;
-      }, () => {});
-      if (ctx?.async && !signals.getContext(NoHydrateContext) && owner.id) ctx.serialize(owner.id, promise, options?.deferStream);
-      const [pending, markReady] = createPendingProxy(state, promise);
+      }, error => {
+        markReady();
+      }, () => disposed);
+      if (ctx?.async && !signals.getContext(NoHydrateContext) && owner.id) ctx.serialize(owner.id, deferred.promise, options?.deferStream);
       return pending;
     } else {
-      const firstNext = iter.next();
-      const firstReady = firstNext.then(r => {
-        if (disposed) return;
+      let currentResult = result;
+      let iter;
+      let firstResult;
+      const deferred = createDeferredPromise();
+      const [pending, markReady] = createPendingProxy(state, deferred.promise);
+      const runFirst = () => {
+        const source = currentResult ?? runProjection();
+        currentResult = undefined;
+        const nextIterator = source?.[Symbol.asyncIterator];
+        if (typeof nextIterator !== "function") {
+          throw new Error("Expected async iterator while retrying server createProjection");
+        }
+        iter = nextIterator.call(source);
+        return iter.next().then(value => {
+          firstResult = value;
+          return Promise.resolve();
+        });
+      };
+      settleServerAsync(runFirst(), runFirst, deferred, () => {
         patches.length = 0;
-        if (!r.done) {
-          if (r.value !== undefined && r.value !== draft) {
-            Object.assign(state, r.value);
-          }
+        const resolved = firstResult;
+        if (resolved && !resolved.done && resolved.value !== undefined && resolved.value !== draft) {
+          Object.assign(state, resolved.value);
         }
         markReady(JSON.parse(JSON.stringify(state)));
-        return Promise.resolve();
-      }, () => {
+        return undefined;
+      }, error => {
         markReady();
-      });
+      }, () => disposed);
       if (ctx?.async && !signals.getContext(NoHydrateContext) && owner.id) {
         let tappedFirst = true;
         const tapped = {
@@ -369,8 +487,8 @@ function createProjection(fn, initialValue = {}, options) {
             next() {
               if (tappedFirst) {
                 tappedFirst = false;
-                return firstNext.then(r => {
-                  if (r.done) return {
+                return deferred.promise.then(() => {
+                  if (firstResult?.done) return {
                     done: true,
                     value: undefined
                   };
@@ -408,26 +526,22 @@ function createProjection(fn, initialValue = {}, options) {
         };
         ctx.serialize(owner.id, tapped, options?.deferStream);
       }
-      const [pending, markReady] = createPendingProxy(state, firstReady);
       return pending;
     }
   }
   if (result instanceof Promise) {
-    const promise = result.then(v => {
-      promise.s = 1;
-      if (disposed) {
-        promise.v = state;
-        return state;
-      }
-      if (v !== undefined && v !== state) {
-        Object.assign(state, v);
+    const deferred = createDeferredPromise();
+    const [pending, markReady] = createPendingProxy(state, deferred.promise);
+    settleServerAsync(result, () => runProjection(), deferred, value => {
+      if (value !== undefined && value !== state) {
+        Object.assign(state, value);
       }
-      promise.v = state;
       markReady();
       return state;
-    }, () => {});
-    if (ctx?.async && !signals.getContext(NoHydrateContext) && owner.id) ctx.serialize(owner.id, promise, options?.deferStream);
-    const [pending, markReady] = createPendingProxy(state, promise);
+    }, error => {
+      markReady();
+    }, () => disposed);
+    if (ctx?.async && !signals.getContext(NoHydrateContext) && owner.id) ctx.serialize(owner.id, deferred.promise, options?.deferStream);
     return pending;
   }
   if (result !== undefined && result !== state && result !== draft) {
@@ -625,10 +739,10 @@ function useContext(context) {
   return signals.getContext(context);
 }
 function children(fn) {
-  const c = createMemo(fn, undefined, {
+  const c = createMemo(fn, {
     lazy: true
   });
-  const memo = createMemo(() => signals.flatten(c()), undefined, {
+  const memo = createMemo(() => signals.flatten(c()), {
     lazy: true
   });
   memo.toArray = () => {
@@ -712,12 +826,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) {
@@ -732,6 +840,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) => {
@@ -775,21 +884,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 signals.NotReadyError) throw new InvalidTopLevelAsyncReadError();
+        if (err instanceof signals.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");
@@ -810,6 +924,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(() => {});
@@ -912,15 +1030,16 @@ function Loading(props) {
 function Reveal(props) {
   const o = signals.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 = signals.getOwner();
     const parentGroup = parent ? signals.runWithOwner(parent, () => signals.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 signals.runWithOwner(o, () => {
@@ -928,8 +1047,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() {}
       });
@@ -939,58 +1061,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 = signals.getOwner();
   const parentGroup = parent ? signals.runWithOwner(parent, () => signals.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 signals.runWithOwner(o, () => {
     signals.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;
@@ -999,6 +1192,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;