solid-js 2.0.0-beta.0 → 2.0.0-beta.10

package/dist/solid.cjs

@@ -2,6 +2,7 @@
 
 var signals = require('@solidjs/signals');
 
+const IS_DEV = false;
 const $DEVCOMP = Symbol(0);
 function createContext(defaultValue, options) {
   const id = Symbol(options && options.name || "");
@@ -19,10 +20,10 @@ function useContext(context) {
   return signals.getContext(context);
 }
 function children(fn) {
-  const c = signals.createMemo(fn, undefined, {
+  const c = signals.createMemo(fn, {
     lazy: true
   });
-  const memo = signals.createMemo(() => signals.flatten(c()), undefined, {
+  const memo = signals.createMemo(() => signals.flatten(c()), {
     lazy: true
   });
   memo.toArray = () => {
@@ -32,6 +33,10 @@ function children(fn) {
   return memo;
 }
 
+const NoHydrateContext = {
+  id: Symbol("NoHydrateContext"),
+  defaultValue: false
+};
 const sharedConfig = {
   hydrating: false,
   registry: undefined,
@@ -39,6 +44,7 @@ const sharedConfig = {
   getNextContextId() {
     const o = signals.getOwner();
     if (!o) throw new Error(`getNextContextId cannot be used under non-hydrating context`);
+    if (signals.getContext(NoHydrateContext)) return undefined;
     return signals.getNextChildId(o);
   }
 };
@@ -66,6 +72,7 @@ function drainHydrationCallbacks() {
   if (cbs) for (const cb of cbs) cb();
   setTimeout(() => {
     if (globalThis._$HY) globalThis._$HY.done = true;
+    sharedConfig.registry?.clear();
   });
 }
 function checkHydrationComplete() {
@@ -83,23 +90,10 @@ let _createOptimisticStore;
 let _createRenderEffect;
 let _createEffect;
 class MockPromise {
-  static all() {
-    return new MockPromise();
-  }
-  static allSettled() {
-    return new MockPromise();
-  }
-  static any() {
-    return new MockPromise();
-  }
-  static race() {
-    return new MockPromise();
-  }
-  static reject() {
-    return new MockPromise();
-  }
-  static resolve() {
-    return new MockPromise();
+  static {
+    for (const k of ["all", "allSettled", "any", "race", "reject", "resolve"]) {
+      MockPromise[k] = () => new MockPromise();
+    }
   }
   catch() {
     return new MockPromise();
@@ -127,11 +121,67 @@ function subFetch(fn, prev) {
     Promise = ogPromise;
   }
 }
-function consumeFirstSync(ai) {
-  const iter = ai[Symbol.asyncIterator]();
-  const r = iter.next();
-  const value = !(r instanceof Promise) && !r.done ? r.value : undefined;
-  return [value, iter];
+function syncThenable(value) {
+  return {
+    then(fn) {
+      fn(value);
+    }
+  };
+}
+const NO_HYDRATED_VALUE = Symbol("NO_HYDRATED_VALUE");
+function readHydratedValue(initP, refresh) {
+  if (initP == null) return NO_HYDRATED_VALUE;
+  refresh();
+  if (typeof initP === "object" && initP.s === 2) throw initP.v;
+  return initP?.v ?? initP;
+}
+function readSerializedOrCompute(compute, prev) {
+  if (!sharedConfig.hydrating) return compute(prev);
+  const o = signals.getOwner();
+  let initP;
+  if (sharedConfig.has(o.id)) initP = sharedConfig.load(o.id);
+  const init = readHydratedValue(initP, () => subFetch(compute, prev));
+  return init !== NO_HYDRATED_VALUE ? init : compute(prev);
+}
+function forwardIteratorReturn(it, value) {
+  const returned = it.return?.(value);
+  return returned && typeof returned.then === "function" ? returned : syncThenable(returned ?? {
+    done: true,
+    value
+  });
+}
+function normalizeIterator(it) {
+  let first = true;
+  let buffered = null;
+  return {
+    next() {
+      if (first) {
+        first = false;
+        const r = it.next();
+        return r && typeof r.then === "function" ? r : syncThenable(r);
+      }
+      if (buffered) {
+        const b = buffered;
+        buffered = null;
+        return b;
+      }
+      let latest = it.next();
+      if (latest && typeof latest.then === "function") return latest;
+      while (!latest.done) {
+        const peek = it.next();
+        if (peek && typeof peek.then === "function") {
+          buffered = peek;
+          break;
+        }
+        latest = peek;
+      }
+      return Promise.resolve(latest);
+    },
+    return(value) {
+      buffered = null;
+      return forwardIteratorReturn(it, value);
+    }
+  };
 }
 function applyPatches(target, patches) {
   for (const patch of patches) {
@@ -148,118 +198,211 @@ function applyPatches(target, patches) {
     }
   }
 }
-function scheduleIteratorConsumption(iter, apply) {
-  const consume = () => {
-    while (true) {
-      const n = iter.next();
-      if (n instanceof Promise) {
-        n.then(r => {
-          if (r.done) return;
-          apply(r.value);
-          consume();
-        });
-        return;
+function isAsyncIterable(v) {
+  return v != null && typeof v[Symbol.asyncIterator] === "function";
+}
+function createShadowDraft(realDraft) {
+  const shadow = JSON.parse(JSON.stringify(realDraft));
+  let useShadow = true;
+  return {
+    proxy: new Proxy(shadow, {
+      get(_, prop) {
+        return useShadow ? shadow[prop] : realDraft[prop];
+      },
+      set(_, prop, value) {
+        if (useShadow) {
+          shadow[prop] = value;
+          return true;
+        }
+        return Reflect.set(realDraft, prop, value);
+      },
+      deleteProperty(_, prop) {
+        if (useShadow) {
+          delete shadow[prop];
+          return true;
+        }
+        return Reflect.deleteProperty(realDraft, prop);
+      },
+      has(_, prop) {
+        return prop in (useShadow ? shadow : realDraft);
+      },
+      ownKeys() {
+        return Reflect.ownKeys(useShadow ? shadow : realDraft);
+      },
+      getOwnPropertyDescriptor(_, prop) {
+        return Object.getOwnPropertyDescriptor(useShadow ? shadow : realDraft, prop);
       }
-      if (n.done) break;
-      apply(n.value);
+    }),
+    activate() {
+      useShadow = false;
     }
   };
-  consume();
 }
-function isAsyncIterable(v) {
-  return v != null && typeof v[Symbol.asyncIterator] === "function";
+function wrapFirstYield(iterable, activate) {
+  const srcIt = iterable[Symbol.asyncIterator]();
+  let first = true;
+  return {
+    [Symbol.asyncIterator]() {
+      return {
+        next() {
+          const p = srcIt.next();
+          if (first) {
+            first = false;
+            return p.then(r => {
+              activate();
+              return r.done ? r : {
+                done: false,
+                value: undefined
+              };
+            });
+          }
+          return p;
+        },
+        return(value) {
+          return forwardIteratorReturn(srcIt, value);
+        }
+      };
+    }
+  };
 }
-function hydrateSignalFromAsyncIterable(coreFn, compute, value, options) {
+function hydrateSignalFromAsyncIterable(coreFn, compute, options) {
   const parent = signals.getOwner();
   const expectedId = signals.peekNextChildId(parent);
   if (!sharedConfig.has(expectedId)) return null;
-  const initP = sharedConfig.load(expectedId);
-  if (!isAsyncIterable(initP)) return null;
-  const [firstValue, iter] = consumeFirstSync(initP);
-  const [get, set] = signals.createSignal(firstValue);
-  const result = coreFn(() => get(), firstValue, options);
-  scheduleIteratorConsumption(iter, v => {
-    set(() => v);
-    signals.flush();
-  });
-  return result;
+  const loaded = sharedConfig.load(expectedId);
+  if (!isAsyncIterable(loaded)) return null;
+  const it = normalizeIterator(loaded[Symbol.asyncIterator]());
+  const iterable = {
+    [Symbol.asyncIterator]() {
+      return it;
+    }
+  };
+  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;
-  const initP = sharedConfig.load(expectedId);
-  if (!isAsyncIterable(initP)) return null;
-  const [firstState, iter] = consumeFirstSync(initP);
-  const [store, setStore] = coreFn(() => {}, firstState ?? initialValue, options);
-  scheduleIteratorConsumption(iter, patches => {
-    setStore(d => {
-      applyPatches(d, patches);
-    });
-  });
-  return [store, setStore];
+  const loaded = sharedConfig.load(expectedId);
+  if (!isAsyncIterable(loaded)) return null;
+  const srcIt = loaded[Symbol.asyncIterator]();
+  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,
+        value: undefined
+      };
+      if (isFirst) {
+        isFirst = false;
+        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);
+      }
+      return {
+        done: false,
+        value: undefined
+      };
+    };
+    return {
+      [Symbol.asyncIterator]() {
+        return {
+          next() {
+            if (isFirst) {
+              const r = srcIt.next();
+              return r && typeof r.then === "function" ? {
+                then(fn, rej) {
+                  r.then(v => fn(process(v)), rej);
+                }
+              } : syncThenable(process(r));
+            }
+            if (buffered) {
+              const b = buffered;
+              buffered = null;
+              return b.then(process);
+            }
+            let r = srcIt.next();
+            if (r && typeof r.then === "function") {
+              return r.then(process);
+            }
+            let result = process(r);
+            while (!r.done) {
+              const peek = srcIt.next();
+              if (peek && typeof peek.then === "function") {
+                buffered = peek;
+                break;
+              }
+              r = peek;
+              if (!r.done) result = process(r);
+            }
+            return Promise.resolve(result);
+          },
+          return(value) {
+            buffered = null;
+            return forwardIteratorReturn(srcIt, value);
+          }
+        };
+      }
+    };
+  }, initialValue, options);
 }
-function hydratedCreateMemo(compute, value, options) {
-  if (!sharedConfig.hydrating) return signals.createMemo(compute, value, options);
+function hydratedCreateMemo(compute, options) {
+  if (!sharedConfig.hydrating || options?.transparent) {
+    return signals.createMemo(compute, options);
+  }
   markTopLevelSnapshotScope();
   const ssrSource = options?.ssrSource;
   if (ssrSource === "client") {
-    const [hydrated, setHydrated] = signals.createSignal(false);
+    const [hydrated, setHydrated] = signals.createSignal(false, {
+      ownedWrite: true
+    });
     const memo = signals.createMemo(prev => {
-      if (!hydrated()) return prev ?? value;
+      if (!hydrated()) return prev;
       return compute(prev);
-    }, value, options);
+    }, options);
     setHydrated(true);
     return memo;
   }
-  if (ssrSource === "initial") {
-    return signals.createMemo(prev => {
-      if (!sharedConfig.hydrating) return compute(prev);
-      subFetch(compute, prev);
-      return prev ?? value;
-    }, value, options);
-  }
-  const aiResult = hydrateSignalFromAsyncIterable(signals.createMemo, compute, value, options);
+  const aiResult = hydrateSignalFromAsyncIterable(signals.createMemo, compute, options);
   if (aiResult !== null) return aiResult;
-  return signals.createMemo(prev => {
-    const o = signals.getOwner();
-    if (!sharedConfig.hydrating) return compute(prev);
-    let initP;
-    if (sharedConfig.has(o.id)) initP = sharedConfig.load(o.id);
-    const init = initP?.v ?? initP;
-    return init != null ? (subFetch(compute, prev), init) : compute(prev);
-  }, value, options);
-}
-function hydratedCreateSignal(fn, second, third) {
-  if (typeof fn !== "function" || !sharedConfig.hydrating) return signals.createSignal(fn, second, third);
+  return signals.createMemo(prev => readSerializedOrCompute(compute, prev), options);
+}
+function hydratedCreateSignal(fn, second) {
+  if (typeof fn !== "function" || !sharedConfig.hydrating) return signals.createSignal(fn, second);
   markTopLevelSnapshotScope();
-  const ssrSource = third?.ssrSource;
+  const ssrSource = second?.ssrSource;
   if (ssrSource === "client") {
-    const [hydrated, setHydrated] = signals.createSignal(false);
+    const [hydrated, setHydrated] = signals.createSignal(false, {
+      ownedWrite: true
+    });
     const sig = signals.createSignal(prev => {
-      if (!hydrated()) return prev ?? second;
+      if (!hydrated()) return prev;
       return fn(prev);
-    }, second, third);
+    }, second);
     setHydrated(true);
     return sig;
   }
-  if (ssrSource === "initial") {
-    return signals.createSignal(prev => {
-      if (!sharedConfig.hydrating) return fn(prev);
-      subFetch(fn, prev);
-      return prev ?? second;
-    }, second, third);
-  }
-  const aiResult = hydrateSignalFromAsyncIterable(signals.createSignal, fn, second, third);
+  const aiResult = hydrateSignalFromAsyncIterable(signals.createSignal, fn, second);
   if (aiResult !== null) return aiResult;
-  return signals.createSignal(prev => {
-    if (!sharedConfig.hydrating) return fn(prev);
-    const o = signals.getOwner();
-    let initP;
-    if (sharedConfig.has(o.id)) initP = sharedConfig.load(o.id);
-    const init = initP?.v ?? initP;
-    return init != null ? (subFetch(fn, prev), init) : fn(prev);
-  }, second, third);
+  return signals.createSignal(prev => readSerializedOrCompute(fn, prev), second);
 }
 function hydratedCreateErrorBoundary(fn, fallback) {
   if (!sharedConfig.hydrating) return signals.createErrorBoundary(fn, fallback);
@@ -281,127 +424,113 @@ function hydratedCreateErrorBoundary(fn, fallback) {
   }
   return signals.createErrorBoundary(fn, fallback);
 }
-function hydratedCreateOptimistic(fn, second, third) {
-  if (typeof fn !== "function" || !sharedConfig.hydrating) return signals.createOptimistic(fn, second, third);
+function hydratedCreateOptimistic(fn, second) {
+  if (typeof fn !== "function" || !sharedConfig.hydrating) return signals.createOptimistic(fn, second);
   markTopLevelSnapshotScope();
-  const ssrSource = third?.ssrSource;
+  const ssrSource = second?.ssrSource;
   if (ssrSource === "client") {
-    const [hydrated, setHydrated] = signals.createSignal(false);
+    const [hydrated, setHydrated] = signals.createSignal(false, {
+      ownedWrite: true
+    });
     const sig = signals.createOptimistic(prev => {
-      if (!hydrated()) return prev ?? second;
+      if (!hydrated()) return prev;
       return fn(prev);
-    }, second, third);
+    }, second);
     setHydrated(true);
     return sig;
   }
-  if (ssrSource === "initial") {
-    return signals.createOptimistic(prev => {
-      if (!sharedConfig.hydrating) return fn(prev);
-      subFetch(fn, prev);
-      return prev ?? second;
-    }, second, third);
-  }
-  const aiResult = hydrateSignalFromAsyncIterable(signals.createOptimistic, fn, second, third);
+  const aiResult = hydrateSignalFromAsyncIterable(signals.createOptimistic, fn, second);
   if (aiResult !== null) return aiResult;
-  return signals.createOptimistic(prev => {
-    const o = signals.getOwner();
-    if (!sharedConfig.hydrating) return fn(prev);
-    let initP;
-    if (sharedConfig.has(o.id)) initP = sharedConfig.load(o.id);
-    const init = initP?.v ?? initP;
-    return init != null ? (subFetch(fn, prev), init) : fn(prev);
-  }, second, third);
-}
-function wrapStoreFn(fn, ssrSource) {
-  if (ssrSource === "initial") {
-    return draft => {
-      if (!sharedConfig.hydrating) return fn(draft);
-      subFetch(fn, draft);
-      return undefined;
-    };
+  return signals.createOptimistic(prev => readSerializedOrCompute(fn, prev), second);
+}
+function wrapStoreFn(fn) {
+  return draft => readSerializedOrCompute(() => fn(draft), draft);
+}
+function hydrateStoreLikeFn(coreFn, fn, initialValue, options, ssrSource) {
+  if (ssrSource === "client") {
+    const [hydrated, setHydrated] = signals.createSignal(false, {
+      ownedWrite: true
+    });
+    const result = coreFn(draft => {
+      if (!hydrated()) return;
+      return fn(draft);
+    }, initialValue, options);
+    setHydrated(true);
+    return result;
   }
-  return draft => {
-    const o = signals.getOwner();
-    if (!sharedConfig.hydrating) return fn(draft);
-    let initP;
-    if (sharedConfig.has(o.id)) initP = sharedConfig.load(o.id);
-    const init = initP?.v ?? initP;
-    return init != null ? (subFetch(fn, draft), init) : fn(draft);
-  };
+  if (ssrSource === "hybrid") {
+    const [hydrated, setHydrated] = signals.createSignal(false, {
+      ownedWrite: true
+    });
+    const result = coreFn(draft => {
+      const o = signals.getOwner();
+      if (!hydrated()) {
+        if (sharedConfig.has(o.id)) {
+          const initP = sharedConfig.load(o.id);
+          const init = readHydratedValue(initP, () => subFetch(fn, draft));
+          if (init !== NO_HYDRATED_VALUE) return init;
+        }
+        return fn(draft);
+      }
+      const {
+        proxy,
+        activate
+      } = createShadowDraft(draft);
+      const r = fn(proxy);
+      return isAsyncIterable(r) ? wrapFirstYield(r, activate) : r;
+    }, initialValue, options);
+    setHydrated(true);
+    return result;
+  }
+  const aiResult = hydrateStoreFromAsyncIterable(coreFn, fn, initialValue, options);
+  if (aiResult !== null) return aiResult;
+  return coreFn(wrapStoreFn(fn), initialValue, options);
 }
 function hydratedCreateStore(first, second, third) {
   if (typeof first !== "function" || !sharedConfig.hydrating) return signals.createStore(first, second, third);
   markTopLevelSnapshotScope();
   const ssrSource = third?.ssrSource;
-  if (ssrSource === "client" || ssrSource === "initial") {
-    return signals.createStore(second ?? {}, undefined, third);
-  }
-  const aiResult = hydrateStoreFromAsyncIterable(signals.createStore, second ?? {}, third);
-  if (aiResult !== null) return aiResult;
-  return signals.createStore(wrapStoreFn(first, ssrSource), second, third);
+  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 === "client" || ssrSource === "initial") {
-    return signals.createOptimisticStore(second ?? {}, undefined, third);
-  }
-  const aiResult = hydrateStoreFromAsyncIterable(signals.createOptimisticStore, second ?? {}, third);
-  if (aiResult !== null) return aiResult;
-  return signals.createOptimisticStore(wrapStoreFn(first, ssrSource), second, third);
+  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 === "client" || ssrSource === "initial") {
-    return signals.createProjection(draft => draft, initialValue, options);
-  }
-  const aiResult = hydrateStoreFromAsyncIterable(signals.createStore, initialValue, options);
-  if (aiResult !== null) return aiResult[0];
-  return signals.createProjection(wrapStoreFn(fn, ssrSource), initialValue, options);
+  return hydrateStoreLikeFn(signals.createProjection, fn, initialValue, options, ssrSource);
 }
-function hydratedEffect(coreFn, compute, effectFn, value, options) {
-  if (!sharedConfig.hydrating) return coreFn(compute, effectFn, value, options);
+function hydratedEffect(coreFn, compute, effectFn, options) {
+  if (!sharedConfig.hydrating || options?.transparent) return coreFn(compute, effectFn, options);
   const ssrSource = options?.ssrSource;
   if (ssrSource === "client") {
-    const [hydrated, setHydrated] = signals.createSignal(false);
+    const [hydrated, setHydrated] = signals.createSignal(false, {
+      ownedWrite: true
+    });
     let active = false;
     coreFn(prev => {
-      if (!hydrated()) return value;
+      if (!hydrated()) return prev;
       active = true;
       return compute(prev);
     }, (next, prev) => {
       if (!active) return;
       return effectFn(next, prev);
-    }, value, options);
+    }, options);
     setHydrated(true);
     return;
   }
-  if (ssrSource === "initial") {
-    coreFn(prev => {
-      if (!sharedConfig.hydrating) return compute(prev);
-      subFetch(compute, prev);
-      return prev ?? value;
-    }, effectFn, value, options);
-    return;
-  }
   markTopLevelSnapshotScope();
-  coreFn(prev => {
-    const o = signals.getOwner();
-    if (!sharedConfig.hydrating) return compute(prev);
-    let initP;
-    if (sharedConfig.has(o.id)) initP = sharedConfig.load(o.id);
-    const init = initP?.v ?? initP;
-    return init != null ? (subFetch(compute, prev), init) : compute(prev);
-  }, effectFn, value, options);
+  coreFn(prev => readSerializedOrCompute(compute, prev), effectFn, options);
 }
-function hydratedCreateRenderEffect(compute, effectFn, value, options) {
-  return hydratedEffect(signals.createRenderEffect, compute, effectFn, value, options);
+function hydratedCreateRenderEffect(compute, effectFn, options) {
+  return hydratedEffect(signals.createRenderEffect, compute, effectFn, options);
 }
-function hydratedCreateEffect(compute, effectFn, value, options) {
-  return hydratedEffect(signals.createEffect, compute, effectFn, value, options);
+function hydratedCreateEffect(compute, effectFn, options) {
+  return hydratedEffect(signals.createEffect, compute, effectFn, options);
 }
 function enableHydration() {
   _createMemo = hydratedCreateMemo;
@@ -460,24 +589,6 @@ const createStore = (...args) => (_createStore || signals.createStore)(...args);
 const createOptimisticStore = (...args) => (_createOptimisticStore || signals.createOptimisticStore)(...args);
 const createRenderEffect = (...args) => (_createRenderEffect || signals.createRenderEffect)(...args);
 const createEffect = (...args) => (_createEffect || signals.createEffect)(...args);
-function loadModuleAssets(mapping) {
-  const hy = globalThis._$HY;
-  if (!hy) return;
-  if (!hy.modules) hy.modules = {};
-  if (!hy.loading) hy.loading = {};
-  const pending = [];
-  for (const moduleUrl in mapping) {
-    if (hy.modules[moduleUrl]) continue;
-    const entryUrl = mapping[moduleUrl];
-    if (!hy.loading[moduleUrl]) {
-      hy.loading[moduleUrl] = import(entryUrl).then(mod => {
-        hy.modules[moduleUrl] = mod;
-      });
-    }
-    pending.push(hy.loading[moduleUrl]);
-  }
-  return pending.length ? Promise.all(pending).then(() => {}) : undefined;
-}
 function createBoundaryTrigger() {
   signals.setSnapshotCapture(false);
   const [s, set] = signals.createSignal(undefined, {
@@ -493,7 +604,7 @@ function resumeBoundaryHydration(o, id, set) {
     checkHydrationComplete();
     return;
   }
-  sharedConfig.gather(id);
+  sharedConfig.gather?.(id);
   _hydratingValue = true;
   signals.markSnapshotScope(o);
   _snapshotRootOwner = o;
@@ -505,38 +616,65 @@ function resumeBoundaryHydration(o, id, set) {
   signals.flush();
   checkHydrationComplete();
 }
-function Loading(props) {
-  if (!sharedConfig.hydrating) return signals.createLoadBoundary(() => props.children, () => props.fallback);
+function initBoundaryResume(o, id) {
+  _pendingBoundaries++;
+  signals.onCleanup(() => {
+    if (!signals.isDisposed(o)) return;
+    sharedConfig.cleanupFragment?.(id);
+  });
+  const set = createBoundaryTrigger();
+  return [set, () => resumeBoundaryHydration(o, id, set)];
+}
+function waitAndResume(p, resume, assetPromise) {
+  const waitFor = assetPromise ? Promise.all([p, assetPromise]) : p;
+  waitFor.then(() => {
+    if (p && typeof p === "object") p.s = 1;
+    resume();
+  }, err => {
+    if (p && typeof p === "object") {
+      p.s = 2;
+      p.v = err;
+    }
+    resume();
+  });
+}
+function scheduleResumeAfterAssets(id, resume, assetPromise) {
+  sharedConfig.gather?.(id);
+  const doResume = () => queueMicrotask(resume);
+  if (assetPromise) {
+    assetPromise.then(doResume);
+    return true;
+  }
+  doResume();
+  return false;
+}
+function createLoadingBoundary(fn, fallback, options) {
+  if (!sharedConfig.hydrating) return signals.createLoadingBoundary(fn, fallback, options);
+  let settledSerializationResumeQueued = false;
   return signals.createMemo(() => {
     const o = signals.getOwner();
     const id = o.id;
     let assetPromise;
     if (sharedConfig.hydrating && sharedConfig.has(id + "_assets")) {
       const mapping = sharedConfig.load(id + "_assets");
-      if (mapping && typeof mapping === "object") assetPromise = loadModuleAssets(mapping);
+      if (mapping && typeof mapping === "object") assetPromise = sharedConfig.loadModuleAssets?.(mapping);
     }
     if (sharedConfig.hydrating && sharedConfig.has(id)) {
-      let ref = sharedConfig.load(id);
+      const ref = sharedConfig.load(id);
       let p;
       if (ref) {
-        if (typeof ref !== "object" || ref.s !== 1) p = ref;else sharedConfig.gather(id);
+        if (typeof ref !== "object" || ref.s == null) p = ref;else if (ref.s === 1 || ref.s === 2) sharedConfig.gather?.(id);else p = ref;
+      }
+      if (ref && typeof ref === "object" && ref.s === 1 && p == null && !settledSerializationResumeQueued) {
+        settledSerializationResumeQueued = true;
+        const [, resume] = initBoundaryResume(o, id);
+        if (scheduleResumeAfterAssets(id, resume, assetPromise)) return undefined;
+        return fallback();
       }
       if (p) {
-        _pendingBoundaries++;
-        signals.onCleanup(() => {
-          if (!signals.isDisposed(o)) return;
-          sharedConfig.cleanupFragment?.(id);
-        });
-        const set = createBoundaryTrigger();
+        const [set, resume] = initBoundaryResume(o, id);
         if (p !== "$$f") {
-          const waitFor = assetPromise ? Promise.all([p, assetPromise]) : p;
-          waitFor.then(() => resumeBoundaryHydration(o, id, set), err => {
-            _pendingBoundaries--;
-            checkHydrationComplete();
-            signals.runWithOwner(o, () => {
-              throw err;
-            });
-          });
+          waitAndResume(p, resume, assetPromise);
         } else {
           const afterAssets = () => {
             _pendingBoundaries--;
@@ -545,18 +683,39 @@ function Loading(props) {
           };
           if (assetPromise) assetPromise.then(() => queueMicrotask(afterAssets));else queueMicrotask(afterAssets);
         }
-        return props.fallback;
+        return fallback();
+      }
+    }
+    if (sharedConfig.hydrating && sharedConfig.has(id + "_fr") && !settledSerializationResumeQueued) {
+      settledSerializationResumeQueued = true;
+      const fr = sharedConfig.load(id + "_fr");
+      const [, resume] = initBoundaryResume(o, id);
+      if (fr && typeof fr === "object" && (fr.s === 1 || fr.s === 2)) {
+        if (scheduleResumeAfterAssets(id, resume, assetPromise)) return undefined;
+        return fallback();
       }
+      waitAndResume(fr, resume, assetPromise);
+      return fallback();
     }
-    if (assetPromise) {
-      _pendingBoundaries++;
-      const set = createBoundaryTrigger();
-      assetPromise.then(() => resumeBoundaryHydration(o, id, set));
+    if (assetPromise && !sharedConfig.has(id)) {
+      const [, resume] = initBoundaryResume(o, id);
+      assetPromise.then(resume);
       return undefined;
     }
-    return signals.createLoadBoundary(() => props.children, () => props.fallback);
+    return signals.createLoadingBoundary(fn, fallback, options);
+  });
+}
+function NoHydration(props) {
+  const o = signals.createOwner();
+  return signals.runWithOwner(o, () => {
+    signals.setContext(NoHydrateContext, true);
+    if (sharedConfig.hydrating) return undefined;
+    return props.children;
   });
 }
+function Hydration(props) {
+  return props.children;
+}
 
 function createComponent(Comp, props) {
   return signals.untrack(() => Comp(props || {}));
@@ -585,6 +744,7 @@ function lazy(fn, moduleUrl) {
     }) : "");
   };
   wrap.preload = () => p || ((p = fn()).then(mod => comp = () => mod.default), p);
+  wrap.moduleUrl = moduleUrl;
   return wrap;
 }
 let counter = 0;
@@ -611,8 +771,8 @@ function Repeat(props) {
 }
 function Show(props) {
   const keyed = props.keyed;
-  const conditionValue = signals.createMemo(() => props.when, undefined, undefined);
-  const condition = keyed ? conditionValue : signals.createMemo(conditionValue, undefined, {
+  const conditionValue = signals.createMemo(() => props.when, undefined);
+  const condition = keyed ? conditionValue : signals.createMemo(conditionValue, {
     equals: (a, b) => !a === !b
   });
   return signals.createMemo(() => {
@@ -620,18 +780,13 @@ function Show(props) {
     if (c) {
       const child = props.children;
       const fn = typeof child === "function" && child.length > 0;
-      return fn ? signals.untrack(() => {
-        try {
-          return child(() => {
-            if (!signals.untrack(condition)) throw narrowedError("Show");
-            return conditionValue();
-          });
-        } finally {
-        }
-      }) : child;
+      return fn ? signals.untrack(() => child(() => {
+        if (!signals.untrack(condition)) throw narrowedError("Show");
+        return conditionValue();
+      }), IS_DEV) : child;
     }
     return props.fallback;
-  }, undefined, undefined);
+  }, undefined);
 }
 function Switch(props) {
   const chs = children(() => props.children);
@@ -642,8 +797,8 @@ function Switch(props) {
       const index = i;
       const mp = mps[i];
       const prevFunc = func;
-      const conditionValue = signals.createMemo(() => prevFunc() ? undefined : mp.when, undefined, undefined);
-      const condition = mp.keyed ? conditionValue : signals.createMemo(conditionValue, undefined, {
+      const conditionValue = signals.createMemo(() => prevFunc() ? undefined : mp.when, undefined);
+      const condition = mp.keyed ? conditionValue : signals.createMemo(conditionValue, {
         equals: (a, b) => !a === !b
       });
       func = () => prevFunc() || (condition() ? [index, conditionValue, mp] : undefined);
@@ -656,16 +811,11 @@ function Switch(props) {
     const [index, conditionValue, mp] = sel;
     const child = mp.children;
     const fn = typeof child === "function" && child.length > 0;
-    return fn ? signals.untrack(() => {
-      try {
-        return child(() => {
-          if (signals.untrack(switchFunc)()?.[0] !== index) throw narrowedError("Match");
-          return conditionValue();
-        });
-      } finally {
-      }
-    }) : child;
-  }, undefined, undefined);
+    return fn ? signals.untrack(() => child(() => {
+      if (signals.untrack(switchFunc)()?.[0] !== index) throw narrowedError("Match");
+      return conditionValue();
+    }), IS_DEV) : child;
+  }, undefined);
 }
 function Match(props) {
   return props;
@@ -676,6 +826,18 @@ function Errored(props) {
     return typeof f === "function" && f.length ? f(err, reset) : f;
   });
 }
+function Loading(props) {
+  const onOpt = "on" in props ? {
+    on: () => props.on
+  } : undefined;
+  return createLoadingBoundary(() => props.children, () => props.fallback, onOpt);
+}
+function Reveal(props) {
+  return signals.createRevealOrder(() => props.children, {
+    order: () => props.order ?? "sequential",
+    collapsed: () => !!props.collapsed
+  });
+}
 
 function ssrHandleError() {}
 function ssrRunInScope() {}
@@ -685,6 +847,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; }
@@ -705,6 +871,10 @@ Object.defineProperty(exports, "createReaction", {
   enumerable: true,
   get: function () { return signals.createReaction; }
 });
+Object.defineProperty(exports, "createRevealOrder", {
+  enumerable: true,
+  get: function () { return signals.createRevealOrder; }
+});
 Object.defineProperty(exports, "createRoot", {
   enumerable: true,
   get: function () { return signals.createRoot; }
@@ -717,6 +887,14 @@ Object.defineProperty(exports, "deep", {
   enumerable: true,
   get: function () { return signals.deep; }
 });
+Object.defineProperty(exports, "enableExternalSource", {
+  enumerable: true,
+  get: function () { return signals.enableExternalSource; }
+});
+Object.defineProperty(exports, "enforceLoadingBoundary", {
+  enumerable: true,
+  get: function () { return signals.enforceLoadingBoundary; }
+});
 Object.defineProperty(exports, "flatten", {
   enumerable: true,
   get: function () { return signals.flatten; }
@@ -737,6 +915,10 @@ Object.defineProperty(exports, "getOwner", {
   enumerable: true,
   get: function () { return signals.getOwner; }
 });
+Object.defineProperty(exports, "isDisposed", {
+  enumerable: true,
+  get: function () { return signals.isDisposed; }
+});
 Object.defineProperty(exports, "isEqual", {
   enumerable: true,
   get: function () { return signals.isEqual; }
@@ -813,15 +995,21 @@ exports.$DEVCOMP = $DEVCOMP;
 exports.DEV = DEV;
 exports.Errored = Errored;
 exports.For = For;
+exports.Hydration = Hydration;
 exports.Loading = Loading;
 exports.Match = Match;
+exports.NoHydrateContext = NoHydrateContext;
+exports.NoHydration = NoHydration;
 exports.Repeat = Repeat;
+exports.Reveal = Reveal;
 exports.Show = Show;
 exports.Switch = Switch;
 exports.children = children;
 exports.createComponent = createComponent;
 exports.createContext = createContext;
 exports.createEffect = createEffect;
+exports.createErrorBoundary = createErrorBoundary;
+exports.createLoadingBoundary = createLoadingBoundary;
 exports.createMemo = createMemo;
 exports.createOptimistic = createOptimistic;
 exports.createOptimisticStore = createOptimisticStore;