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

package/dist/dev.js

@@ -1,5 +1,5 @@
-import { getContext, createMemo as createMemo$1, flatten, getOwner, createRoot, setContext, untrack, setStrictRead, createLoadBoundary, onCleanup, isDisposed, runWithOwner, createOwner, createEffect as createEffect$1, createOptimistic as createOptimistic$1, createOptimisticStore as createOptimisticStore$1, createProjection as createProjection$1, createRenderEffect as createRenderEffect$1, createSignal as createSignal$1, createStore as createStore$1, setSnapshotCapture, releaseSnapshotScope, getNextChildId, createErrorBoundary as createErrorBoundary$1, markSnapshotScope, flush, clearSnapshots, peekNextChildId, mapArray, repeat } from '@solidjs/signals';
-export { $PROXY, $TRACK, NotReadyError, action, createOwner, createReaction, createRoot, createTrackedEffect, deep, flatten, flush, getNextChildId, getObserver, getOwner, isEqual, isPending, isRefreshing, isWrappable, latest, mapArray, merge, omit, onCleanup, onSettled, reconcile, refresh, repeat, resolve, runWithOwner, snapshot, storePath, untrack } from '@solidjs/signals';
+import { getContext, createMemo as createMemo$1, flatten, createRoot, setContext, getOwner, untrack, createOwner, runWithOwner, createEffect as createEffect$1, createErrorBoundary as createErrorBoundary$1, createLoadingBoundary as createLoadingBoundary$1, createOptimistic as createOptimistic$1, createOptimisticStore as createOptimisticStore$1, createProjection as createProjection$1, createRenderEffect as createRenderEffect$1, createSignal as createSignal$1, createStore as createStore$1, setSnapshotCapture, releaseSnapshotScope, getNextChildId, onCleanup, isDisposed, peekNextChildId, clearSnapshots, flush, markSnapshotScope, mapArray, repeat, createRevealOrder, DEV as DEV$1 } from '@solidjs/signals';
+export { $PROXY, $REFRESH, $TRACK, NotReadyError, action, createOwner, createReaction, createRevealOrder, createRoot, createTrackedEffect, deep, enableExternalSource, enforceLoadingBoundary, flatten, flush, getNextChildId, getObserver, getOwner, isDisposed, isEqual, isPending, isRefreshing, isWrappable, latest, mapArray, merge, omit, onCleanup, onSettled, reconcile, refresh, repeat, resolve, runWithOwner, snapshot, storePath, untrack } from '@solidjs/signals';
 
 const $DEVCOMP = Symbol("COMPONENT_DEV" );
 function createContext(defaultValue, options) {
@@ -18,10 +18,10 @@ function useContext(context) {
   return getContext(context);
 }
 function children(fn) {
-  const c = createMemo$1(fn, undefined, {
+  const c = createMemo$1(fn, {
     lazy: true
   });
-  const memo = createMemo$1(() => flatten(c()), undefined, {
+  const memo = createMemo$1(() => flatten(c()), {
     name: "children",
     lazy: true
   } );
@@ -34,30 +34,19 @@ function children(fn) {
 function devComponent(Comp, props) {
   return createRoot(() => {
     const owner = getOwner();
-    owner._props = props;
-    owner._name = Comp.name;
-    owner._component = Comp;
-    return untrack(() => {
-      Object.assign(Comp, {
-        [$DEVCOMP]: true
-      });
-      setStrictRead(`<${Comp.name || "Anonymous"}>`);
-      try {
-        return Comp(props);
-      } finally {
-        setStrictRead(false);
-      }
+    owner._component = {
+      fn: Comp,
+      props,
+      name: Comp.name
+    };
+    Object.assign(Comp, {
+      [$DEVCOMP]: true
     });
+    return untrack(() => Comp(props), `<${Comp.name || "Anonymous"}>`);
   }, {
     transparent: true
   });
 }
-function registerGraph(value) {
-  const owner = getOwner();
-  if (!owner) return;
-  if (owner.sourceMap) owner.sourceMap.push(value);else owner.sourceMap = [value];
-  value.graph = owner;
-}
 
 const NoHydrateContext = {
   id: Symbol("NoHydrateContext"),
@@ -99,6 +88,7 @@ function drainHydrationCallbacks() {
   setTimeout(() => {
     if (sharedConfig.verifyHydration) sharedConfig.verifyHydration();
     if (globalThis._$HY) globalThis._$HY.done = true;
+    sharedConfig.registry?.clear();
   });
 }
 function checkHydrationComplete() {
@@ -116,23 +106,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();
@@ -160,11 +137,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 = 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) {
@@ -181,118 +214,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 = getOwner();
   const expectedId = 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] = createSignal$1(firstValue);
-  const result = coreFn(() => get(), firstValue, options);
-  scheduleIteratorConsumption(iter, v => {
-    set(() => v);
-    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 = getOwner();
   const expectedId = 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;
+        setSnapshotCapture(false);
+        try {
+          if (Array.isArray(res.value)) {
+            for (let i = 0; i < res.value.length; i++) draft[i] = res.value[i];
+            draft.length = res.value.length;
+          } else {
+            Object.assign(draft, res.value);
+          }
+        } finally {
+          setSnapshotCapture(true);
+        }
+      } else {
+        applyPatches(draft, res.value);
+      }
+      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 createMemo$1(compute, value, options);
+function hydratedCreateMemo(compute, options) {
+  if (!sharedConfig.hydrating || options?.transparent) {
+    return createMemo$1(compute, options);
+  }
   markTopLevelSnapshotScope();
   const ssrSource = options?.ssrSource;
   if (ssrSource === "client") {
-    const [hydrated, setHydrated] = createSignal$1(false);
+    const [hydrated, setHydrated] = createSignal$1(false, {
+      ownedWrite: true
+    });
     const memo = createMemo$1(prev => {
-      if (!hydrated()) return prev ?? value;
+      if (!hydrated()) return prev;
       return compute(prev);
-    }, value, options);
+    }, options);
     setHydrated(true);
     return memo;
   }
-  if (ssrSource === "initial") {
-    return createMemo$1(prev => {
-      if (!sharedConfig.hydrating) return compute(prev);
-      subFetch(compute, prev);
-      return prev ?? value;
-    }, value, options);
-  }
-  const aiResult = hydrateSignalFromAsyncIterable(createMemo$1, compute, value, options);
+  const aiResult = hydrateSignalFromAsyncIterable(createMemo$1, compute, options);
   if (aiResult !== null) return aiResult;
-  return createMemo$1(prev => {
-    const o = 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 createSignal$1(fn, second, third);
+  return createMemo$1(prev => readSerializedOrCompute(compute, prev), options);
+}
+function hydratedCreateSignal(fn, second) {
+  if (typeof fn !== "function" || !sharedConfig.hydrating) return createSignal$1(fn, second);
   markTopLevelSnapshotScope();
-  const ssrSource = third?.ssrSource;
+  const ssrSource = second?.ssrSource;
   if (ssrSource === "client") {
-    const [hydrated, setHydrated] = createSignal$1(false);
+    const [hydrated, setHydrated] = createSignal$1(false, {
+      ownedWrite: true
+    });
     const sig = createSignal$1(prev => {
-      if (!hydrated()) return prev ?? second;
+      if (!hydrated()) return prev;
       return fn(prev);
-    }, second, third);
+    }, second);
     setHydrated(true);
     return sig;
   }
-  if (ssrSource === "initial") {
-    return createSignal$1(prev => {
-      if (!sharedConfig.hydrating) return fn(prev);
-      subFetch(fn, prev);
-      return prev ?? second;
-    }, second, third);
-  }
-  const aiResult = hydrateSignalFromAsyncIterable(createSignal$1, fn, second, third);
+  const aiResult = hydrateSignalFromAsyncIterable(createSignal$1, fn, second);
   if (aiResult !== null) return aiResult;
-  return createSignal$1(prev => {
-    if (!sharedConfig.hydrating) return fn(prev);
-    const o = 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 createSignal$1(prev => readSerializedOrCompute(fn, prev), second);
 }
 function hydratedCreateErrorBoundary(fn, fallback) {
   if (!sharedConfig.hydrating) return createErrorBoundary$1(fn, fallback);
@@ -314,127 +440,113 @@ function hydratedCreateErrorBoundary(fn, fallback) {
   }
   return createErrorBoundary$1(fn, fallback);
 }
-function hydratedCreateOptimistic(fn, second, third) {
-  if (typeof fn !== "function" || !sharedConfig.hydrating) return createOptimistic$1(fn, second, third);
+function hydratedCreateOptimistic(fn, second) {
+  if (typeof fn !== "function" || !sharedConfig.hydrating) return createOptimistic$1(fn, second);
   markTopLevelSnapshotScope();
-  const ssrSource = third?.ssrSource;
+  const ssrSource = second?.ssrSource;
   if (ssrSource === "client") {
-    const [hydrated, setHydrated] = createSignal$1(false);
+    const [hydrated, setHydrated] = createSignal$1(false, {
+      ownedWrite: true
+    });
     const sig = createOptimistic$1(prev => {
-      if (!hydrated()) return prev ?? second;
+      if (!hydrated()) return prev;
       return fn(prev);
-    }, second, third);
+    }, second);
     setHydrated(true);
     return sig;
   }
-  if (ssrSource === "initial") {
-    return createOptimistic$1(prev => {
-      if (!sharedConfig.hydrating) return fn(prev);
-      subFetch(fn, prev);
-      return prev ?? second;
-    }, second, third);
-  }
-  const aiResult = hydrateSignalFromAsyncIterable(createOptimistic$1, fn, second, third);
+  const aiResult = hydrateSignalFromAsyncIterable(createOptimistic$1, fn, second);
   if (aiResult !== null) return aiResult;
-  return createOptimistic$1(prev => {
-    const o = 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 createOptimistic$1(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] = createSignal$1(false, {
+      ownedWrite: true
+    });
+    const result = coreFn(draft => {
+      if (!hydrated()) return;
+      return fn(draft);
+    }, initialValue, options);
+    setHydrated(true);
+    return result;
   }
-  return draft => {
-    const o = 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] = createSignal$1(false, {
+      ownedWrite: true
+    });
+    const result = coreFn(draft => {
+      const o = 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 createStore$1(first, second, third);
   markTopLevelSnapshotScope();
   const ssrSource = third?.ssrSource;
-  if (ssrSource === "client" || ssrSource === "initial") {
-    return createStore$1(second ?? {}, undefined, third);
-  }
-  const aiResult = hydrateStoreFromAsyncIterable(createStore$1, second ?? {}, third);
-  if (aiResult !== null) return aiResult;
-  return createStore$1(wrapStoreFn(first, ssrSource), second, third);
+  return hydrateStoreLikeFn(createStore$1, first, second ?? {}, third, ssrSource);
 }
 function hydratedCreateOptimisticStore(first, second, third) {
   if (typeof first !== "function" || !sharedConfig.hydrating) return createOptimisticStore$1(first, second, third);
   markTopLevelSnapshotScope();
   const ssrSource = third?.ssrSource;
-  if (ssrSource === "client" || ssrSource === "initial") {
-    return createOptimisticStore$1(second ?? {}, undefined, third);
-  }
-  const aiResult = hydrateStoreFromAsyncIterable(createOptimisticStore$1, second ?? {}, third);
-  if (aiResult !== null) return aiResult;
-  return createOptimisticStore$1(wrapStoreFn(first, ssrSource), second, third);
+  return hydrateStoreLikeFn(createOptimisticStore$1, first, second ?? {}, third, ssrSource);
 }
 function hydratedCreateProjection(fn, initialValue, options) {
   if (!sharedConfig.hydrating) return createProjection$1(fn, initialValue, options);
   markTopLevelSnapshotScope();
   const ssrSource = options?.ssrSource;
-  if (ssrSource === "client" || ssrSource === "initial") {
-    return createProjection$1(draft => draft, initialValue, options);
-  }
-  const aiResult = hydrateStoreFromAsyncIterable(createStore$1, initialValue, options);
-  if (aiResult !== null) return aiResult[0];
-  return createProjection$1(wrapStoreFn(fn, ssrSource), initialValue, options);
+  return hydrateStoreLikeFn(createProjection$1, 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] = createSignal$1(false);
+    const [hydrated, setHydrated] = createSignal$1(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 = 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(createRenderEffect$1, compute, effectFn, value, options);
+function hydratedCreateRenderEffect(compute, effectFn, options) {
+  return hydratedEffect(createRenderEffect$1, compute, effectFn, options);
 }
-function hydratedCreateEffect(compute, effectFn, value, options) {
-  return hydratedEffect(createEffect$1, compute, effectFn, value, options);
+function hydratedCreateEffect(compute, effectFn, options) {
+  return hydratedEffect(createEffect$1, compute, effectFn, options);
 }
 function enableHydration() {
   _createMemo = hydratedCreateMemo;
@@ -493,24 +605,6 @@ const createStore = (...args) => (_createStore || createStore$1)(...args);
 const createOptimisticStore = (...args) => (_createOptimisticStore || createOptimisticStore$1)(...args);
 const createRenderEffect = (...args) => (_createRenderEffect || createRenderEffect$1)(...args);
 const createEffect = (...args) => (_createEffect || createEffect$1)(...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() {
   setSnapshotCapture(false);
   const [s, set] = createSignal$1(undefined, {
@@ -526,7 +620,7 @@ function resumeBoundaryHydration(o, id, set) {
     checkHydrationComplete();
     return;
   }
-  sharedConfig.gather(id);
+  sharedConfig.gather?.(id);
   _hydratingValue = true;
   markSnapshotScope(o);
   _snapshotRootOwner = o;
@@ -538,38 +632,65 @@ function resumeBoundaryHydration(o, id, set) {
   flush();
   checkHydrationComplete();
 }
-function Loading(props) {
-  if (!sharedConfig.hydrating) return createLoadBoundary(() => props.children, () => props.fallback);
+function initBoundaryResume(o, id) {
+  _pendingBoundaries++;
+  onCleanup(() => {
+    if (!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 createLoadingBoundary$1(fn, fallback, options);
+  let settledSerializationResumeQueued = false;
   return createMemo$1(() => {
     const o = 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++;
-        onCleanup(() => {
-          if (!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();
-            runWithOwner(o, () => {
-              throw err;
-            });
-          });
+          waitAndResume(p, resume, assetPromise);
         } else {
           const afterAssets = () => {
             _pendingBoundaries--;
@@ -578,16 +699,26 @@ function Loading(props) {
           };
           if (assetPromise) assetPromise.then(() => queueMicrotask(afterAssets));else queueMicrotask(afterAssets);
         }
-        return props.fallback;
+        return fallback();
       }
     }
-    if (assetPromise) {
-      _pendingBoundaries++;
-      const set = createBoundaryTrigger();
-      assetPromise.then(() => resumeBoundaryHydration(o, id, set));
+    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 && !sharedConfig.has(id)) {
+      const [, resume] = initBoundaryResume(o, id);
+      assetPromise.then(resume);
       return undefined;
     }
-    return createLoadBoundary(() => props.children, () => props.fallback);
+    return createLoadingBoundary$1(fn, fallback, options);
   });
 }
 function NoHydration(props) {
@@ -661,10 +792,10 @@ function Repeat(props) {
 }
 function Show(props) {
   const keyed = props.keyed;
-  const conditionValue = createMemo$1(() => props.when, undefined, {
+  const conditionValue = createMemo$1(() => props.when, {
     name: "condition value"
   } );
-  const condition = keyed ? conditionValue : createMemo$1(conditionValue, undefined, {
+  const condition = keyed ? conditionValue : createMemo$1(conditionValue, {
     equals: (a, b) => !a === !b,
     name: "condition"
   } );
@@ -673,20 +804,13 @@ function Show(props) {
     if (c) {
       const child = props.children;
       const fn = typeof child === "function" && child.length > 0;
-      return fn ? untrack(() => {
-        setStrictRead("<Show>");
-        try {
-          return child(() => {
-            if (!untrack(condition)) throw narrowedError("Show");
-            return conditionValue();
-          });
-        } finally {
-          setStrictRead(false);
-        }
-      }) : child;
+      return fn ? untrack(() => child(() => {
+        if (!untrack(condition)) throw narrowedError("Show");
+        return conditionValue();
+      }), "<Show>") : child;
     }
     return props.fallback;
-  }, undefined, {
+  }, {
     name: "value"
   } );
 }
@@ -699,10 +823,10 @@ function Switch(props) {
       const index = i;
       const mp = mps[i];
       const prevFunc = func;
-      const conditionValue = createMemo$1(() => prevFunc() ? undefined : mp.when, undefined, {
+      const conditionValue = createMemo$1(() => prevFunc() ? undefined : mp.when, {
         name: "condition value"
       } );
-      const condition = mp.keyed ? conditionValue : createMemo$1(conditionValue, undefined, {
+      const condition = mp.keyed ? conditionValue : createMemo$1(conditionValue, {
         equals: (a, b) => !a === !b,
         name: "condition"
       } );
@@ -716,18 +840,11 @@ function Switch(props) {
     const [index, conditionValue, mp] = sel;
     const child = mp.children;
     const fn = typeof child === "function" && child.length > 0;
-    return fn ? untrack(() => {
-      setStrictRead("<Match>");
-      try {
-        return child(() => {
-          if (untrack(switchFunc)()?.[0] !== index) throw narrowedError("Match");
-          return conditionValue();
-        });
-      } finally {
-        setStrictRead(false);
-      }
-    }) : child;
-  }, undefined, {
+    return fn ? untrack(() => child(() => {
+      if (untrack(switchFunc)()?.[0] !== index) throw narrowedError("Match");
+      return conditionValue();
+    }), "<Match>") : child;
+  }, {
     name: "eval conditions"
   } );
 }
@@ -741,16 +858,24 @@ 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 createRevealOrder(() => props.children, {
+    order: () => props.order ?? "sequential",
+    collapsed: () => !!props.collapsed
+  });
+}
 
 function ssrHandleError() {}
 function ssrRunInScope() {}
-const DevHooks = {};
-const DEV = {
-  hooks: DevHooks,
-  registerGraph
-} ;
+const DEV = DEV$1 ;
 if (globalThis) {
   if (!globalThis.Solid$$) globalThis.Solid$$ = true;else console.warn("You appear to have multiple instances of Solid. This can lead to unexpected behavior.");
 }
 
-export { $DEVCOMP, DEV, Errored, For, Hydration, Loading, Match, NoHydrateContext, NoHydration, Repeat, Show, Switch, children, createComponent, createContext, createEffect, createMemo, createOptimistic, createOptimisticStore, createProjection, createRenderEffect, createSignal, createStore, createUniqueId, enableHydration, lazy, sharedConfig, ssrHandleError, ssrRunInScope, useContext };
+export { $DEVCOMP, DEV, Errored, For, Hydration, Loading, Match, NoHydrateContext, NoHydration, Repeat, Reveal, Show, Switch, children, createComponent, createContext, createEffect, createErrorBoundary, createLoadingBoundary, createMemo, createOptimistic, createOptimisticStore, createProjection, createRenderEffect, createSignal, createStore, createUniqueId, enableHydration, lazy, sharedConfig, ssrHandleError, ssrRunInScope, useContext };