solid-js 2.0.0-beta.1 → 2.0.0-beta.11

package/dist/server.cjs

@@ -8,13 +8,149 @@ const NoHydrateContext = {
 };
 const sharedConfig = {
   getNextContextId() {
-    const o = signals.getOwner();
+    const o = getOwner();
     if (!o) throw new Error(`getNextContextId cannot be used under non-hydrating context`);
-    if (signals.getContext(NoHydrateContext)) return undefined;
-    return signals.getNextChildId(o);
+    if (getContext(NoHydrateContext)) return undefined;
+    return getNextChildId(o);
   }
 };
 
+const defaultSSRContext = {};
+let currentOwner = null;
+const OWNER_POOL_MAX = 4096;
+const ownerPool = [];
+function formatChildId(prefix, id) {
+  const num = id.toString(36);
+  const len = num.length - 1;
+  return prefix + (len ? String.fromCharCode(64 + len) : "") + num;
+}
+function nextChildIdFor(owner, consume) {
+  let counter = owner;
+  while (counter._transparent && counter._parent) counter = counter._parent;
+  if (counter.id != null) {
+    return formatChildId(counter.id, counter._childCount++ );
+  }
+  throw new Error("Cannot get child id from owner without an id");
+}
+function getNextChildId(owner) {
+  return nextChildIdFor(owner);
+}
+function createOwner(options) {
+  const parent = currentOwner;
+  const transparent = options?.transparent ?? false;
+  const id = options?.id ?? (transparent ? parent?.id : parent?.id != null ? nextChildIdFor(parent) : undefined);
+  const ctx = parent?._context ?? defaultSSRContext;
+  let owner;
+  if (ownerPool.length) {
+    owner = ownerPool.pop();
+    owner.id = id;
+    owner._transparent = transparent;
+    owner._disposal = null;
+    owner._parent = parent;
+    owner._context = ctx;
+    owner._childCount = 0;
+    owner._firstChild = null;
+    owner._nextSibling = null;
+    owner._disposed = false;
+  } else {
+    owner = {
+      id,
+      _transparent: transparent,
+      _disposal: null,
+      _parent: parent,
+      _context: ctx,
+      _childCount: 0,
+      _firstChild: null,
+      _nextSibling: null,
+      _disposed: false
+    };
+  }
+  if (parent) {
+    const lastChild = parent._firstChild;
+    if (lastChild) owner._nextSibling = lastChild;
+    parent._firstChild = owner;
+  }
+  return owner;
+}
+function runWithOwner(owner, fn) {
+  const prev = currentOwner;
+  currentOwner = owner;
+  try {
+    return fn();
+  } finally {
+    currentOwner = prev;
+  }
+}
+function getOwner() {
+  return currentOwner;
+}
+function isDisposed(owner) {
+  return owner._disposed;
+}
+function onCleanup(fn) {
+  const o = currentOwner;
+  if (!o) return fn;
+  if (!o._disposal) o._disposal = fn;else if (Array.isArray(o._disposal)) o._disposal.push(fn);else o._disposal = [o._disposal, fn];
+  return fn;
+}
+function getContext(context, owner = currentOwner) {
+  if (!owner) throw new signals.NoOwnerError();
+  const map = owner._context;
+  const stored = map[context.id];
+  const value = stored !== undefined ? stored : context.defaultValue;
+  if (value === undefined) throw new signals.ContextNotFoundError();
+  return value;
+}
+function setContext(context, value, owner = currentOwner) {
+  if (!owner) throw new signals.NoOwnerError();
+  const o = owner;
+  o._context = {
+    ...o._context,
+    [context.id]: value === undefined ? context.defaultValue : value
+  };
+}
+function disposeOwner(owner, self = true) {
+  const node = owner;
+  if (node._disposed) return;
+  if (!node._firstChild && !node._disposal) {
+    if (self) {
+      node._disposed = true;
+      if (ownerPool.length < OWNER_POOL_MAX) {
+        node._parent = null;
+        node._nextSibling = null;
+        ownerPool.push(node);
+      }
+    }
+    return;
+  }
+  if (self) node._disposed = true;
+  let child = node._firstChild;
+  while (child) {
+    const next = child._nextSibling;
+    disposeOwner(child, true);
+    child = next;
+  }
+  node._firstChild = null;
+  node._childCount = 0;
+  const d = node._disposal;
+  if (d) {
+    if (Array.isArray(d)) {
+      for (let i = 0, len = d.length; i < len; i++) d[i]();
+    } else {
+      d();
+    }
+    node._disposal = null;
+  }
+  if (self && ownerPool.length < OWNER_POOL_MAX) {
+    node._parent = null;
+    node._nextSibling = null;
+    ownerPool.push(node);
+  }
+}
+function createRoot(init, options) {
+  const owner = createOwner(options);
+  return runWithOwner(owner, () => init(() => disposeOwner(owner)));
+}
 let Observer = null;
 function runWithObserver(comp, fn) {
   const prev = Observer;
@@ -28,68 +164,116 @@ 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 ssrSource = third?.ssrSource;
-    if (ssrSource === "initial" || ssrSource === "client") {
-      signals.createOwner();
-      let value = second;
-      return [() => value, v => {
-        return value = typeof v === "function" ? v(value) : v;
-      }];
-    }
-    const memoOpts = third?.deferStream || ssrSource ? {
-      deferStream: third?.deferStream,
-      ssrSource
+    const opts = second?.deferStream || second?.ssrSource ? {
+      deferStream: second?.deferStream,
+      ssrSource: second?.ssrSource
     } : undefined;
-    const memo = createMemo(p => {
-      let value = first(p ? p[0]() : second);
-      return [() => value, v => {
-        return value = typeof v === "function" ? v(value) : v;
-      }];
-    }, undefined, memoOpts);
-    return [() => memo()[0](), v => memo()[1](v)];
+    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) {
+  if (options?.sync) {
+    return createSyncMemo(compute, options);
+  }
   const ctx = sharedConfig.context;
-  const owner = signals.createOwner();
+  const owner = createOwner();
   const comp = {
     owner,
-    value: value,
+    value: undefined,
     compute: compute,
     error: undefined,
     computed: false,
     disposed: false
   };
-  signals.runWithOwner(owner, () => signals.onCleanup(() => {
+  runWithOwner(owner, () => onCleanup(() => {
     comp.disposed = true;
   }));
   function update() {
     if (comp.disposed) return;
+    const run = () => 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());
+        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();
   }
-  return () => {
+  const read = () => {
     if (!comp.computed) {
       update();
     }
@@ -98,6 +282,44 @@ function createMemo(compute, value, options) {
     }
     return comp.value;
   };
+  read[signals.$REFRESH] = comp;
+  return read;
+}
+function createSyncMemo(compute, options) {
+  const owner = createOwner();
+  let value;
+  let error;
+  let cached = false;
+  function pull() {
+    const prev = currentOwner;
+    currentOwner = owner;
+    try {
+      value = compute(value);
+      error = undefined;
+      cached = true;
+      return value;
+    } catch (err) {
+      if (err instanceof signals.NotReadyError) throw err;
+      error = err;
+      cached = true;
+      throw err;
+    } finally {
+      currentOwner = prev;
+    }
+  }
+  if (!options?.lazy) {
+    try {
+      pull();
+    } catch {
+    }
+  }
+  return () => {
+    if (cached) {
+      if (error !== undefined) throw error;
+      return value;
+    }
+    return pull();
+  };
 }
 function createDeepProxy(target, patches, basePath = []) {
   const childProxies = new Map();
@@ -159,120 +381,172 @@ 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 uninitialized = comp.value === undefined;
-  const noHydrate = signals.getContext(NoHydrateContext, owner);
+  const noHydrate = getContext(NoHydrateContext, owner);
   if (result instanceof Promise) {
-    result.then(v => {
-      result.s = 1;
-      result.v = v;
-      if (comp.disposed) return;
-      comp.value = v;
+    if (result.s === 1) {
+      comp.value = result.v;
       comp.error = undefined;
-    }, () => {});
-    if (ctx?.async && ctx.serialize && id && !noHydrate) ctx.serialize(id, result, deferStream);
-    if (uninitialized) {
-      comp.error = new signals.NotReadyError(result);
+      return;
     }
+    if (result.s === 2) {
+      comp.error = result.v;
+      return;
+    }
+    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 = value;
+      comp.value = value;
+      comp.error = undefined;
+      return value;
+    }, error => {
+      result.s = 2;
+      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 (comp.disposed) return;
-        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;
-      }, () => {});
-      if (ctx?.async && ctx.serialize && id && !noHydrate) ctx.serialize(id, promise, deferStream);
-      if (uninitialized) {
-        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;
-          comp.error = undefined;
+      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");
         }
-      }, () => {});
-      let servedFirst = false;
-      const tapped = {
-        [Symbol.asyncIterator]: () => ({
-          next() {
-            if (!servedFirst) {
-              servedFirst = true;
-              return firstNext.then(r => {
-                if (!r.done && !comp.disposed) comp.value = r.value;
-                return r;
-              });
-            }
-            return iter.next().then(r => r);
-          }
-        })
+        iter = nextIterator.call(source);
+        return iter.next().then(value => {
+          firstResult = value;
+          return Promise.resolve();
+        });
       };
-      if (ctx?.async && ctx.serialize && id && !noHydrate) ctx.serialize(id, tapped, deferStream);
-      if (uninitialized) {
-        comp.error = new signals.NotReadyError(firstReady);
+      settleServerAsync(runFirst(), runFirst, deferred, () => {
+        const resolved = firstResult;
+        if (resolved && !resolved.done) {
+          comp.value = resolved.value;
+        }
+        comp.error = undefined;
+        return undefined;
+      }, error => {
+        comp.error = error;
+      }, () => comp.disposed);
+      if (ctx?.async && ctx.serialize && id && !noHydrate) {
+        let tappedFirst = true;
+        const tapped = {
+          [Symbol.asyncIterator]: () => ({
+            next() {
+              if (tappedFirst) {
+                tappedFirst = false;
+                return deferred.promise.then(() => firstResult?.done ? {
+                  done: true,
+                  value: undefined
+                } : firstResult);
+              }
+              return iter.next().then(r => r);
+            },
+            return(value) {
+              return iter.return?.(value);
+            }
+          })
+        };
+        ctx.serialize(id, tapped, deferStream);
       }
+      comp.error = new signals.NotReadyError(deferred.promise);
     }
     return;
   }
   comp.value = result;
 }
-function serverEffect(compute, effectFn, value, options) {
+function closeAsyncIterator(iter, value) {
+  const returned = iter.return?.(value);
+  if (returned && typeof returned.then === "function") {
+    returned.then(undefined, () => {});
+  }
+}
+function serverEffect(compute, effectFn, options) {
   const ssrSource = options?.ssrSource;
-  if (ssrSource === "client" || ssrSource === "initial") {
-    signals.createOwner();
+  if (ssrSource === "client") {
+    createOwner();
     return;
   }
   const ctx = sharedConfig.context;
-  const owner = signals.createOwner();
+  const owner = createOwner();
   const comp = {
     owner,
-    value: value,
+    value: undefined,
     compute: compute,
     error: undefined,
     computed: true,
     disposed: false
   };
   if (ssrSource) {
-    signals.runWithOwner(owner, () => signals.onCleanup(() => {
+    runWithOwner(owner, () => onCleanup(() => {
       comp.disposed = true;
     }));
   }
   try {
-    const result = signals.runWithOwner(owner, () => runWithObserver(comp, () => compute(value)));
+    const result = 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();
-  if (o?.id != null) signals.getNextChildId(o);
+  const o = getOwner();
+  if (o?.id != null) getNextChildId(o);
 }
 function createReaction(effectFn, options) {
   return tracking => {
     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;
@@ -282,7 +556,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;
@@ -305,115 +579,146 @@ 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 owner = createOwner();
   const [state] = createStore(initialValue);
-  if (options?.ssrSource === "initial" || options?.ssrSource === "client") {
+  if (options?.ssrSource === "client") {
     return state;
   }
   let disposed = false;
-  signals.runWithOwner(owner, () => signals.onCleanup(() => {
+  runWithOwner(owner, () => onCleanup(() => {
     disposed = true;
   }));
   const ssrSource = options?.ssrSource;
   const useProxy = ssrSource !== "hybrid";
   const patches = [];
   const draft = useProxy ? createDeepProxy(state, patches) : state;
-  const result = signals.runWithOwner(owner, () => fn(draft));
+  const runProjection = () => 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 (disposed) {
-          promise.v = state;
-          return;
+      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();
-      }, () => {});
-      if (ctx?.async && !signals.getContext(NoHydrateContext) && owner.id) ctx.serialize(owner.id, promise, options?.deferStream);
-      const [pending, markReady] = createPendingProxy(state, promise);
+        return state;
+      }, error => {
+        markReady();
+      }, () => disposed);
+      if (ctx?.async && !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 undefined;
+      }, error => {
         markReady();
-      });
-      let servedFirst = false;
-      const tapped = {
-        [Symbol.asyncIterator]: () => ({
-          next() {
-            if (!servedFirst) {
-              servedFirst = true;
-              return firstNext.then(r => {
-                if (!r.done && !disposed) return {
-                  done: false,
-                  value: state
+      }, () => disposed);
+      if (ctx?.async && !getContext(NoHydrateContext) && owner.id) {
+        let tappedFirst = true;
+        const tapped = {
+          [Symbol.asyncIterator]: () => ({
+            next() {
+              if (tappedFirst) {
+                tappedFirst = false;
+                return deferred.promise.then(() => {
+                  if (firstResult?.done) return {
+                    done: true,
+                    value: undefined
+                  };
+                  return {
+                    done: false,
+                    value: JSON.parse(JSON.stringify(state))
+                  };
+                });
+              }
+              return iter.next().then(r => {
+                if (disposed) return {
+                  done: true,
+                  value: undefined
                 };
+                const flushed = patches.splice(0);
+                if (!r.done) {
+                  if (r.value !== undefined && r.value !== draft) {
+                    Object.assign(state, r.value);
+                  }
+                  return {
+                    done: false,
+                    value: flushed
+                  };
+                }
                 return {
-                  done: r.done,
+                  done: true,
                   value: undefined
                 };
               });
+            },
+            return(value) {
+              return iter.return?.(value);
             }
-            return iter.next().then(r => {
-              if (disposed) return {
-                done: true,
-                value: undefined
-              };
-              const flushed = patches.splice(0);
-              if (!r.done) {
-                if (r.value !== undefined && r.value !== draft) {
-                  Object.assign(state, r.value);
-                }
-                return {
-                  done: false,
-                  value: flushed
-                };
-              }
-              return {
-                done: true,
-                value: undefined
-              };
-            });
-          }
-        })
-      };
-      if (ctx?.async && !signals.getContext(NoHydrateContext) && owner.id) ctx.serialize(owner.id, tapped, options?.deferStream);
-      const [pending, markReady] = createPendingProxy(state, firstReady);
+          })
+        };
+        ctx.serialize(owner.id, tapped, options?.deferStream);
+      }
       return pending;
     }
   }
   if (result instanceof Promise) {
-    const promise = result.then(v => {
-      promise.s = 1;
-      if (disposed) {
-        promise.v = state;
-        return;
-      }
-      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();
-    }, () => {});
-    if (ctx?.async && !signals.getContext(NoHydrateContext) && owner.id) ctx.serialize(owner.id, promise, options?.deferStream);
-    const [pending, markReady] = createPendingProxy(state, promise);
+      return state;
+    }, error => {
+      markReady();
+    }, () => disposed);
+    if (ctx?.async && !getContext(NoHydrateContext) && owner.id) ctx.serialize(owner.id, deferred.promise, options?.deferStream);
     return pending;
   }
   if (result !== undefined && result !== state && result !== draft) {
@@ -440,72 +745,129 @@ function deep(store) {
   return store;
 }
 function mapArray(list, mapFn, options = {}) {
-  const parent = signals.createOwner();
-  return () => {
+  return createMemo(() => {
     const items = list();
-    let s = [];
+    const s = [];
     if (items && items.length) {
-      signals.runWithOwner(parent, () => {
+      const parent = currentOwner;
+      const origId = parent.id;
+      const origChildCount = parent._childCount;
+      try {
         for (let i = 0, len = items.length; i < len; i++) {
-          const o = signals.createOwner();
-          s.push(signals.runWithOwner(o, () => mapFn(() => items[i], () => i)));
+          if (origId !== undefined) {
+            parent.id = formatChildId(origId, origChildCount + i);
+          }
+          parent._childCount = 0;
+          s.push(mapFn(() => items[i], () => i));
         }
-      });
+      } finally {
+        parent.id = origId;
+        parent._childCount = origChildCount + items.length;
+      }
     } else if (options.fallback) {
-      s = [signals.runWithOwner(parent, () => {
-        const fo = signals.createOwner();
-        return signals.runWithOwner(fo, () => options.fallback());
-      })];
+      const fo = createOwner();
+      s.push(runWithOwner(fo, () => options.fallback()));
     }
     return s;
-  };
+  }, {
+    sync: true
+  });
 }
 function repeat(count, mapFn, options = {}) {
-  const owner = signals.createOwner();
-  const len = count();
-  const offset = options.from?.() || 0;
-  let s = [];
-  if (len) {
-    signals.runWithOwner(owner, () => {
+  return createMemo(() => {
+    const len = count();
+    const offset = options.from?.() || 0;
+    if (!len) {
+      if (!options.fallback) return [];
+      const fo = createOwner();
+      return [runWithOwner(fo, () => options.fallback())];
+    }
+    const out = new Array(len);
+    const parent = currentOwner;
+    const origId = parent.id;
+    const origChildCount = parent._childCount;
+    try {
       for (let i = 0; i < len; i++) {
-        const itemOwner = signals.createOwner();
-        s.push(signals.runWithOwner(itemOwner, () => mapFn(i + offset)));
+        if (origId !== undefined) {
+          parent.id = formatChildId(origId, origChildCount + i);
+        }
+        parent._childCount = 0;
+        out[i] = mapFn(i + offset);
       }
-    });
-  } else if (options.fallback) {
-    s = [signals.runWithOwner(owner, () => {
-      const fo = signals.createOwner();
-      return signals.runWithOwner(fo, () => options.fallback());
-    })];
-  }
-  return () => s;
+    } finally {
+      parent.id = origId;
+      parent._childCount = origChildCount + len;
+    }
+    return out;
+  }, {
+    sync: true
+  });
 }
 const ErrorContext = {
   id: Symbol("ErrorContext"),
   defaultValue: null
 };
+function runWithBoundaryErrorContext(owner, render, onError, context, boundaryId) {
+  const prevCtx = sharedConfig.context;
+  const prevBoundary = context?._currentBoundaryId;
+  if (context) {
+    sharedConfig.context = context;
+    if (boundaryId !== undefined) context._currentBoundaryId = boundaryId;
+  }
+  try {
+    return runWithOwner(owner, () => {
+      const parentHandler = getContext(ErrorContext);
+      setContext(ErrorContext, err => onError(err, parentHandler));
+      return render();
+    });
+  } finally {
+    if (context) {
+      if (boundaryId !== undefined) context._currentBoundaryId = prevBoundary;
+      sharedConfig.context = prevCtx;
+    }
+  }
+}
 function createErrorBoundary(fn, fallback) {
   const ctx = sharedConfig.context;
-  const owner = signals.createOwner();
-  const parent = signals.getOwner();
-  if (parent?.id != null) signals.getNextChildId(parent);
-  owner.id = owner.id + "0";
-  return signals.runWithOwner(owner, () => {
+  const parent = getOwner();
+  const owner = createOwner();
+  const resolve = () => {
+    const resolved = ctx.resolve(runWithOwner(createOwner(), fn));
+    if (resolved?.p?.length) throw new signals.NotReadyError(Promise.all(resolved.p));
+    return resolved;
+  };
+  const renderFallback = err => ctx ? runWithOwner(parent, () => {
+    const fallbackOwner = createOwner();
+    return runWithOwner(fallbackOwner, () => fallback(err, () => {}));
+  }) : fallback(err, () => {});
+  const serializeError = err => {
+    if (ctx && owner.id && !runWithOwner(owner, () => getContext(NoHydrateContext))) {
+      ctx.serialize(owner.id, err);
+    }
+  };
+  const handleError = err => {
+    serializeError(err);
+    return renderFallback(err);
+  };
+  return () => {
     let result;
-    signals.setContext(ErrorContext, err => {
-      if (ctx && !signals.getContext(NoHydrateContext) && owner.id) ctx.serialize(owner.id, err);
-      result = fallback(err, () => {});
-    });
+    let handled = false;
+    if (ctx) disposeOwner(owner, false);
     try {
-      result = fn();
+      result = ctx ? runWithBoundaryErrorContext(owner, resolve, err => {
+        if (err instanceof signals.NotReadyError) throw err;
+        handled = true;
+        result = handleError(err);
+        throw err;
+      }) : runWithOwner(owner, fn);
     } catch (err) {
-      if (ctx && !signals.getContext(NoHydrateContext) && owner.id) ctx.serialize(owner.id, err);
-      result = fallback(err, () => {});
+      if (err instanceof signals.NotReadyError) throw err;
+      result = handled ? result : handleError(err);
     }
-    return () => result;
-  });
+    return result;
+  };
 }
-function createLoadBoundary(fn, fallback) {
+function createLoadingBoundary$1(fn, fallback, options) {
   try {
     const result = fn();
     return () => result;
@@ -516,6 +878,10 @@ function createLoadBoundary(fn, fallback) {
     throw err;
   }
 }
+function createRevealOrder(fn, _options) {
+  const o = createOwner();
+  return runWithOwner(o, fn);
+}
 function untrack(fn) {
   return fn();
 }
@@ -540,23 +906,23 @@ function latest(fn) {
 function isRefreshing() {
   return false;
 }
-function refresh(fn) {
-  return fn();
+function refresh(_target) {
+  return undefined;
 }
 function action(fn) {
   return fn;
 }
 function onSettled(callback) {
-  const o = signals.getOwner();
-  if (o?.id != null) signals.getNextChildId(o);
+  const o = getOwner();
+  if (o?.id != null) getNextChildId(o);
 }
 
 const $DEVCOMP = Symbol("solid-dev-component");
 function createContext(defaultValue, options) {
   const id = Symbol(options && options.name || "");
   function provider(props) {
-    return signals.createRoot(() => {
-      signals.setContext(provider, props.value);
+    return createRoot(() => {
+      setContext(provider, props.value);
       return children(() => props.children);
     });
   }
@@ -565,14 +931,15 @@ function createContext(defaultValue, options) {
   return provider;
 }
 function useContext(context) {
-  return signals.getContext(context);
+  return getContext(context);
 }
 function children(fn) {
-  const c = createMemo(fn, undefined, {
+  const c = createMemo(fn, {
     lazy: true
   });
-  const memo = createMemo(() => signals.flatten(c()), undefined, {
-    lazy: true
+  const memo = createMemo(() => signals.flatten(c()), {
+    lazy: true,
+    sync: true
   });
   memo.toArray = () => {
     const v = memo();
@@ -580,9 +947,6 @@ function children(fn) {
   };
   return memo;
 }
-function ssrRunInScope(fn) {
-  return fn;
-}
 
 function enableHydration() {}
 function createComponent(Comp, props) {
@@ -600,7 +964,7 @@ function lazy(fn, moduleUrl) {
     return p;
   };
   const wrap = props => {
-    const noHydrate = signals.getContext(NoHydrateContext);
+    const noHydrate = getContext(NoHydrateContext);
     if (!noHydrate && !moduleUrl) {
       throw new Error("lazy() used in SSR without a moduleUrl. " + "All lazy() components require a moduleUrl for correct hydration. " + "This is typically injected by the bundler plugin.");
     }
@@ -626,6 +990,8 @@ function lazy(fn, moduleUrl) {
     return createMemo(() => {
       if (!p.v) throw new signals.NotReadyError(p);
       return p.v(props);
+    }, {
+      sync: true
     });
   };
   wrap.preload = load;
@@ -633,9 +999,163 @@ function lazy(fn, moduleUrl) {
   return wrap;
 }
 function createUniqueId() {
-  const o = signals.getOwner();
+  const o = getOwner();
   if (!o) throw new Error(`createUniqueId cannot be used outside of a reactive context`);
-  return signals.getNextChildId(o);
+  return getNextChildId(o);
+}
+
+const RevealGroupContext = {
+  id: Symbol("RevealGroupContext"),
+  defaultValue: null
+};
+function ssrHandleError(err) {
+  if (err instanceof signals.NotReadyError) {
+    return err.source;
+  }
+  const handler = getContext(ErrorContext);
+  if (handler) {
+    handler(err);
+    return;
+  }
+  throw err;
+}
+function createLoadingBoundary(fn, fallback, options) {
+  const currentCtx = sharedConfig.context;
+  if (!currentCtx) {
+    return createLoadingBoundary$1(fn, fallback);
+  }
+  const ctx = currentCtx;
+  const parent = getOwner();
+  const parentHandler = parent && runWithOwner(parent, () => getContext(ErrorContext));
+  const revealGroup = parent && runWithOwner(parent, () => getContext(RevealGroupContext));
+  const o = createOwner();
+  const id = o.id;
+  o.id = id + "00";
+  let done;
+  let handledRenderError;
+  let retryPromise;
+  let serializeBuffer = [];
+  const bufferedCtx = Object.create(ctx);
+  bufferedCtx.serialize = (id, value, deferStream) => {
+    serializeBuffer.push([id, value, deferStream]);
+  };
+  bufferedCtx._currentBoundaryId = id;
+  function flushSerializeBuffer() {
+    for (const args of serializeBuffer) ctx.serialize(args[0], args[1], args[2]);
+    serializeBuffer = [];
+  }
+  function commitBoundaryState() {
+    flushSerializeBuffer();
+    const modules = ctx.getBoundaryModules?.(id);
+    if (modules) ctx.serialize(id + "_assets", modules);
+  }
+  function runLoadingPhase(render) {
+    handledRenderError = undefined;
+    return runWithBoundaryErrorContext(o, render, (err, parentHandler) => {
+      handledRenderError = err;
+      if (done?.(undefined, err)) throw err;
+      if (parentHandler) {
+        parentHandler(err);
+        return;
+      }
+      throw err;
+    }, bufferedCtx, id);
+  }
+  function finalizeError(err) {
+    if (handledRenderError === err) {
+      handledRenderError = undefined;
+      return;
+    }
+    if (done?.(undefined, err)) return;
+    if (!parentHandler) throw err;
+    try {
+      runWithOwner(parent, () => parentHandler(err));
+    } catch (caught) {
+      if (caught !== err) throw caught;
+    }
+  }
+  function runDiscovery() {
+    disposeOwner(o, false);
+    serializeBuffer = [];
+    retryPromise = undefined;
+    return runLoadingPhase(() => {
+      try {
+        return ctx.resolve(fn());
+      } catch (err) {
+        if (err instanceof signals.NotReadyError) {
+          retryPromise = err.source;
+          return undefined;
+        }
+        throw err;
+      }
+    });
+  }
+  let ret = runDiscovery();
+  if (!retryPromise && !ret?.p?.length) {
+    commitBoundaryState();
+    return () => ret;
+  }
+  const regResult = revealGroup ? revealGroup.register(id) : null;
+  const collapseFallback = regResult?.collapseFallback ?? false;
+  if (collapseFallback && !ctx.async) {
+    commitBoundaryState();
+    ctx.serialize(id, "$$f");
+    return () => undefined;
+  }
+  const fallbackOwner = createOwner({
+    id
+  });
+  const fallbackResult = runWithOwner(fallbackOwner, () => {
+    if (!ctx.async) return fallback();
+    const tpl = collapseFallback ? [`<template id="pl-${id}">`, `</template><!--pl-${id}-->`] : [`<template id="pl-${id}"></template>`, `<!--pl-${id}-->`];
+    return ctx.ssr(tpl, ctx.escape(fallback()));
+  });
+  if (ctx.async) {
+    const regOpts = revealGroup ? {
+      revealGroup: revealGroup.id
+    } : undefined;
+    done = ctx.registerFragment(id, regOpts);
+    (async () => {
+      try {
+        while (retryPromise) {
+          await retryPromise.catch(() => {});
+          ret = runDiscovery();
+        }
+        commitBoundaryState();
+        while (ret && ret.p && ret.p.length) {
+          const pending = ret;
+          await Promise.all(pending.p).catch(() => {});
+          ret = runLoadingPhase(() => ctx.ssr(pending.t, ...pending.h));
+        }
+        flushSerializeBuffer();
+        done(ret && Array.isArray(ret.t) ? ret.t[0] : ret && ret.t);
+        if (revealGroup) revealGroup.onResolved(id);
+      } catch (err) {
+        finalizeError(err);
+      }
+    })();
+    return () => fallbackResult;
+  }
+  commitBoundaryState();
+  ctx.serialize(id, "$$f");
+  return () => fallbackResult;
+}
+function NoHydration(props) {
+  const o = createOwner();
+  return runWithOwner(o, () => {
+    setContext(NoHydrateContext, true);
+    return props.children;
+  });
+}
+function Hydration(props) {
+  if (!getContext(NoHydrateContext)) return props.children;
+  const o = createOwner({
+    id: props.id ?? ""
+  });
+  return runWithOwner(o, () => {
+    setContext(NoHydrateContext, false);
+    return props.children;
+  });
 }
 
 function For(props) {
@@ -645,7 +1165,7 @@ function For(props) {
   } : {
     keyed: props.keyed
   };
-  return createMemo(mapArray(() => props.each, props.children, options));
+  return mapArray(() => props.each, props.children, options);
 }
 function Repeat(props) {
   const options = "fallback" in props ? {
@@ -655,10 +1175,10 @@ function Repeat(props) {
   return repeat(() => props.count, index => typeof props.children === "function" ? props.children(index) : props.children, options);
 }
 function Show(props) {
-  const o = signals.getOwner();
+  const o = getOwner();
   if (o?.id != null) {
-    signals.getNextChildId(o);
-    if (!props.keyed) signals.getNextChildId(o);
+    getNextChildId(o);
+    if (!props.keyed) getNextChildId(o);
   }
   return createMemo(() => {
     const when = props.when;
@@ -670,12 +1190,14 @@ function Show(props) {
       return child;
     }
     return props.fallback;
+  }, {
+    sync: true
   });
 }
 function Switch(props) {
   const chs = children(() => props.children);
-  const o = signals.getOwner();
-  if (o?.id != null) signals.getNextChildId(o);
+  const o = getOwner();
+  if (o?.id != null) getNextChildId(o);
   return createMemo(() => {
     let conds = chs();
     if (!Array.isArray(conds)) conds = [conds];
@@ -687,6 +1209,8 @@ function Switch(props) {
       }
     }
     return props.fallback;
+  }, {
+    sync: true
   });
 }
 function Match(props) {
@@ -698,106 +1222,180 @@ function Errored(props) {
     return typeof f === "function" && f.length ? f(err, reset) : f;
   });
 }
-
-function ssrHandleError(err) {
-  if (err instanceof signals.NotReadyError) {
-    return err.source;
-  }
-  const handler = signals.getContext(ErrorContext);
-  if (handler) {
-    handler(err);
-    return;
-  }
-  throw err;
-}
 function Loading(props) {
-  const ctx = sharedConfig.context;
-  if (!ctx) {
-    return createLoadBoundary(() => props.children, () => props.fallback);
-  }
-  const o = signals.createOwner();
+  return createLoadingBoundary(() => props.children, () => props.fallback);
+}
+function Reveal(props) {
+  const o = createOwner();
   const id = o.id;
-  o.id = id + "00";
-  let runPromise;
-  let serializeBuffer = [];
-  const origSerialize = ctx.serialize;
-  function runInitially() {
-    o.dispose(false);
-    serializeBuffer = [];
-    ctx.serialize = (id, p, deferStream) => {
-      serializeBuffer.push([id, p, deferStream]);
-    };
-    const prevBoundary = ctx._currentBoundaryId;
-    ctx._currentBoundaryId = id;
-    const result = signals.runWithOwner(o, () => {
-      try {
-        return ctx.resolve(props.children);
-      } catch (err) {
-        runPromise = ssrHandleError(err);
+  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) {
+      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, () => {
+      setContext(RevealGroupContext, {
+        id,
+        register(_key) {
+          count++;
+          const collapseFallback = collapsedByParent || order === "sequential" && collapsed && count > 1;
+          return {
+            collapseFallback,
+            held: false
+          };
+        },
+        onResolved() {}
+      });
+      return props.children;
+    });
+  }
+  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;
+  if (parentGroup) {
+    const reg = parentGroup.register(id, {
+      onActivate: () => {
+        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();
       }
     });
-    ctx._currentBoundaryId = prevBoundary;
-    ctx.serialize = origSerialize;
-    return result;
+    collapsedByParent = reg.collapseFallback;
+    heldByParent = reg.held;
   }
-  let ret = runInitially();
-  if (!(runPromise || ret?.p?.length)) {
-    for (const args of serializeBuffer) origSerialize(args[0], args[1], args[2]);
-    serializeBuffer = [];
-    const modules = ctx.getBoundaryModules?.(id);
-    if (modules) ctx.serialize(id + "_assets", modules);
-    return ret;
+  function notifyParentIfDone() {
+    if (notifiedParentDone) return;
+    if (parentGroup && resolved.size === keys.length) {
+      notifiedParentDone = true;
+      parentGroup.onResolved(id);
+    }
   }
-  const fallbackOwner = signals.createOwner({
-    id
-  });
-  signals.getNextChildId(fallbackOwner);
-  if (ctx.async) {
-    const done = ctx.registerFragment(id);
-    (async () => {
-      try {
-        while (runPromise) {
-          o.dispose(false);
-          await runPromise;
-          runPromise = undefined;
-          ret = runInitially();
+  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])) {
+      const k = keys[frontier];
+      if (composites.has(k)) activateComposite(k);else ctx.revealFragments?.([k]);
+      frontier++;
+    }
+    if (frontier < keys.length) {
+      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);
+        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;
         }
-        for (const args of serializeBuffer) origSerialize(args[0], args[1], args[2]);
-        serializeBuffer = [];
-        while (ret.p.length) {
-          await Promise.all(ret.p);
-          ret = signals.runWithOwner(o, () => ctx.ssr(ret.t, ...ret.h));
+        return {
+          collapseFallback,
+          held
+        };
+      },
+      onResolved(key) {
+        resolved.add(key);
+        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 {
+          if (!heldByParent) {
+            if (order === "sequential") advanceFrontier();else if (order === "natural") activateComposite(key);
+          }
+          if (order === "together") checkTogetherRelease();
+          if (order === "natural") updateSelfMinimallyResolved();
         }
-        done(ret.t[0]);
-      } catch (err) {
-        done(undefined, err);
+        notifyParentIfDone();
+      },
+      onMinimallyResolved(key) {
+        markMinimallyResolved(key);
       }
-    })();
-    return signals.runWithOwner(fallbackOwner, () => ctx.ssr([`<template id="pl-${id}"></template>`, `<!--pl-${id}-->`], ctx.escape(props.fallback)));
-  }
-  for (const args of serializeBuffer) origSerialize(args[0], args[1], args[2]);
-  serializeBuffer = [];
-  const modules = ctx.getBoundaryModules?.(id);
-  if (modules) ctx.serialize(id + "_assets", modules);
-  ctx.serialize(id, "$$f");
-  return signals.runWithOwner(fallbackOwner, () => props.fallback);
-}
-function NoHydration(props) {
-  const o = signals.createOwner();
-  return signals.runWithOwner(o, () => {
-    signals.setContext(NoHydrateContext, true);
-    return props.children;
-  });
-}
-function Hydration(props) {
-  if (!signals.getContext(NoHydrateContext)) return props.children;
-  const o = signals.createOwner({
-    id: props.id ?? ""
-  });
-  return signals.runWithOwner(o, () => {
-    signals.setContext(NoHydrateContext, false);
-    return props.children;
+    });
+    const result = props.children;
+    if (parentGroup && keys.length === 0) {
+      parentGroup.onResolved(id);
+    }
+    return result;
   });
+  function markMinimallyResolved(key) {
+    if (minimallyResolved.has(key)) return;
+    minimallyResolved.add(key);
+    updateSelfMinimallyResolved();
+    if (order === "together") checkTogetherRelease();
+  }
 }
 
 const DEV = undefined;
@@ -806,6 +1404,10 @@ Object.defineProperty(exports, "$PROXY", {
   enumerable: true,
   get: function () { return signals.$PROXY; }
 });
+Object.defineProperty(exports, "$REFRESH", {
+  enumerable: true,
+  get: function () { return signals.$REFRESH; }
+});
 Object.defineProperty(exports, "$TRACK", {
   enumerable: true,
   get: function () { return signals.$TRACK; }
@@ -814,26 +1416,18 @@ Object.defineProperty(exports, "NotReadyError", {
   enumerable: true,
   get: function () { return signals.NotReadyError; }
 });
-Object.defineProperty(exports, "createOwner", {
+Object.defineProperty(exports, "enableExternalSource", {
   enumerable: true,
-  get: function () { return signals.createOwner; }
+  get: function () { return signals.enableExternalSource; }
 });
-Object.defineProperty(exports, "createRoot", {
+Object.defineProperty(exports, "enforceLoadingBoundary", {
   enumerable: true,
-  get: function () { return signals.createRoot; }
+  get: function () { return signals.enforceLoadingBoundary; }
 });
 Object.defineProperty(exports, "flatten", {
   enumerable: true,
   get: function () { return signals.flatten; }
 });
-Object.defineProperty(exports, "getNextChildId", {
-  enumerable: true,
-  get: function () { return signals.getNextChildId; }
-});
-Object.defineProperty(exports, "getOwner", {
-  enumerable: true,
-  get: function () { return signals.getOwner; }
-});
 Object.defineProperty(exports, "isEqual", {
   enumerable: true,
   get: function () { return signals.isEqual; }
@@ -850,14 +1444,6 @@ Object.defineProperty(exports, "omit", {
   enumerable: true,
   get: function () { return signals.omit; }
 });
-Object.defineProperty(exports, "onCleanup", {
-  enumerable: true,
-  get: function () { return signals.onCleanup; }
-});
-Object.defineProperty(exports, "runWithOwner", {
-  enumerable: true,
-  get: function () { return signals.runWithOwner; }
-});
 Object.defineProperty(exports, "snapshot", {
   enumerable: true,
   get: function () { return signals.snapshot; }
@@ -876,6 +1462,7 @@ exports.Match = Match;
 exports.NoHydrateContext = NoHydrateContext;
 exports.NoHydration = NoHydration;
 exports.Repeat = Repeat;
+exports.Reveal = Reveal;
 exports.Show = Show;
 exports.Switch = Switch;
 exports.action = action;
@@ -884,12 +1471,17 @@ exports.createComponent = createComponent;
 exports.createContext = createContext;
 exports.createDeepProxy = createDeepProxy;
 exports.createEffect = createEffect;
+exports.createErrorBoundary = createErrorBoundary;
+exports.createLoadingBoundary = createLoadingBoundary;
 exports.createMemo = createMemo;
 exports.createOptimistic = createOptimistic;
 exports.createOptimisticStore = createOptimisticStore;
+exports.createOwner = createOwner;
 exports.createProjection = createProjection;
 exports.createReaction = createReaction;
 exports.createRenderEffect = createRenderEffect;
+exports.createRevealOrder = createRevealOrder;
+exports.createRoot = createRoot;
 exports.createSignal = createSignal;
 exports.createStore = createStore;
 exports.createTrackedEffect = createTrackedEffect;
@@ -897,19 +1489,23 @@ exports.createUniqueId = createUniqueId;
 exports.deep = deep;
 exports.enableHydration = enableHydration;
 exports.flush = flush;
+exports.getNextChildId = getNextChildId;
 exports.getObserver = getObserver;
+exports.getOwner = getOwner;
+exports.isDisposed = isDisposed;
 exports.isPending = isPending;
 exports.isRefreshing = isRefreshing;
 exports.latest = latest;
 exports.lazy = lazy;
 exports.mapArray = mapArray;
+exports.onCleanup = onCleanup;
 exports.onSettled = onSettled;
 exports.reconcile = reconcile;
 exports.refresh = refresh;
 exports.repeat = repeat;
 exports.resolve = resolve;
+exports.runWithOwner = runWithOwner;
 exports.sharedConfig = sharedConfig;
 exports.ssrHandleError = ssrHandleError;
-exports.ssrRunInScope = ssrRunInScope;
 exports.untrack = untrack;
 exports.useContext = useContext;