solid-js 2.0.0-experimental.14 → 2.0.0-experimental.15

package/dist/solid.js

@@ -1,5 +1,5 @@
-import { getContext, createMemo as createMemo$1, flatten, createRoot, setContext, getOwner, getNextChildId, createSignal as createSignal$1, createLoadBoundary, flush, runWithOwner, untrack, mapArray, repeat, createErrorBoundary } from '@solidjs/signals';
-export { $PROXY, $TRACK, NotReadyError, action, createEffect, createOptimistic, createOptimisticStore, createProjection, createReaction, createRenderEffect, createRoot, createStore, createTrackedEffect, deep, flatten, flush, getObserver, getOwner, isEqual, isPending, isRefreshing, isWrappable, mapArray, merge, omit, onCleanup, onSettled, pending, reconcile, refresh, repeat, resolve, runWithOwner, snapshot, untrack } from '@solidjs/signals';
+import { getContext, createMemo as createMemo$1, flatten, createRoot, setContext, createLoadBoundary, getOwner, onCleanup, isDisposed, runWithOwner, createOptimistic as createOptimistic$1, createOptimisticStore as createOptimisticStore$1, createProjection as createProjection$1, createSignal as createSignal$1, createStore as createStore$1, setSnapshotCapture, releaseSnapshotScope, getNextChildId, createErrorBoundary as createErrorBoundary$1, markSnapshotScope, flush, clearSnapshots, peekNextChildId, untrack, mapArray, repeat } from '@solidjs/signals';
+export { $PROXY, $TRACK, NotReadyError, action, createEffect, createReaction, createRenderEffect, createRoot, createTrackedEffect, deep, flatten, flush, getObserver, getOwner, isEqual, isPending, isRefreshing, isWrappable, mapArray, merge, omit, onCleanup, onSettled, pending, reconcile, refresh, repeat, resolve, runWithOwner, snapshot, untrack } from '@solidjs/signals';
 
 const $DEVCOMP = Symbol(0);
 function createContext(defaultValue, options) {
@@ -37,8 +37,44 @@ const sharedConfig = {
     return getNextChildId(o);
   }
 };
+let _hydrationEndCallbacks = null;
+let _pendingBoundaries = 0;
+let _hydrationDone = false;
+let _snapshotRootOwner = null;
+function markTopLevelSnapshotScope() {
+  if (_snapshotRootOwner) return;
+  let owner = getOwner();
+  if (!owner) return;
+  while (owner._parent) owner = owner._parent;
+  markSnapshotScope(owner);
+  _snapshotRootOwner = owner;
+}
+function drainHydrationCallbacks() {
+  if (_hydrationDone) return;
+  _hydrationDone = true;
+  _doneValue = true;
+  clearSnapshots();
+  setSnapshotCapture(false);
+  flush();
+  const cbs = _hydrationEndCallbacks;
+  _hydrationEndCallbacks = null;
+  if (cbs) for (const cb of cbs) cb();
+  setTimeout(() => {
+    if (globalThis._$HY) globalThis._$HY.done = true;
+  });
+}
+function checkHydrationComplete() {
+  if (_pendingBoundaries === 0) drainHydrationCallbacks();
+}
+let _hydratingValue = false;
+let _doneValue = false;
 let _createMemo;
 let _createSignal;
+let _createErrorBoundary;
+let _createOptimistic;
+let _createProjection;
+let _createStore;
+let _createOptimisticStore;
 class MockPromise {
   static all() {
     return new MockPromise();
@@ -74,14 +110,110 @@ function subFetch(fn, prev) {
   try {
     window.fetch = () => new MockPromise();
     Promise = MockPromise;
-    return fn(prev);
+    const result = fn(prev);
+    if (result && typeof result[Symbol.asyncIterator] === "function") {
+      result[Symbol.asyncIterator]().next();
+    }
+    return result;
   } finally {
     window.fetch = ogFetch;
     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 applyPatches(target, patches) {
+  for (const patch of patches) {
+    const path = patch[0];
+    let current = target;
+    for (let i = 0; i < path.length - 1; i++) current = current[path[i]];
+    const key = path[path.length - 1];
+    if (patch.length === 1) {
+      Array.isArray(current) ? current.splice(key, 1) : delete current[key];
+    } else if (patch.length === 3) {
+      current.splice(key, 0, patch[1]);
+    } else {
+      current[key] = patch[1];
+    }
+  }
+}
+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;
+      }
+      if (n.done) break;
+      apply(n.value);
+    }
+  };
+  consume();
+}
+function isAsyncIterable(v) {
+  return v != null && typeof v[Symbol.asyncIterator] === "function";
+}
+function hydrateSignalFromAsyncIterable(coreFn, compute, value, 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;
+}
+function hydrateStoreFromAsyncIterable(coreFn, 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];
+}
 function hydratedCreateMemo(compute, value, options) {
   if (!sharedConfig.hydrating) return createMemo$1(compute, value, options);
+  markTopLevelSnapshotScope();
+  const ssrSource = options?.ssrSource;
+  if (ssrSource === "client") {
+    const [hydrated, setHydrated] = createSignal$1(false);
+    const memo = createMemo$1(prev => {
+      if (!hydrated()) return prev ?? value;
+      return compute(prev);
+    }, value, 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);
+  if (aiResult !== null) return aiResult;
   return createMemo$1(prev => {
     const o = getOwner();
     if (!sharedConfig.hydrating) return compute(prev);
@@ -93,6 +225,26 @@ function hydratedCreateMemo(compute, value, options) {
 }
 function hydratedCreateSignal(fn, second, third) {
   if (typeof fn !== "function" || !sharedConfig.hydrating) return createSignal$1(fn, second, third);
+  markTopLevelSnapshotScope();
+  const ssrSource = third?.ssrSource;
+  if (ssrSource === "client") {
+    const [hydrated, setHydrated] = createSignal$1(false);
+    const sig = createSignal$1(prev => {
+      if (!hydrated()) return prev ?? second;
+      return fn(prev);
+    }, second, third);
+    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);
+  if (aiResult !== null) return aiResult;
   return createSignal$1(prev => {
     if (!sharedConfig.hydrating) return fn(prev);
     const o = getOwner();
@@ -102,17 +254,215 @@ function hydratedCreateSignal(fn, second, third) {
     return init != null ? (subFetch(fn, prev), init) : fn(prev);
   }, second, third);
 }
+function hydratedCreateErrorBoundary(fn, fallback) {
+  if (!sharedConfig.hydrating) return createErrorBoundary$1(fn, fallback);
+  markTopLevelSnapshotScope();
+  const parent = getOwner();
+  const expectedId = peekNextChildId(parent);
+  if (sharedConfig.has(expectedId)) {
+    const err = sharedConfig.load(expectedId);
+    if (err !== undefined) {
+      let hydrated = true;
+      return createErrorBoundary$1(() => {
+        if (hydrated) {
+          hydrated = false;
+          throw err;
+        }
+        return fn();
+      }, fallback);
+    }
+  }
+  return createErrorBoundary$1(fn, fallback);
+}
+function hydratedCreateOptimistic(fn, second, third) {
+  if (typeof fn !== "function" || !sharedConfig.hydrating) return createOptimistic$1(fn, second, third);
+  markTopLevelSnapshotScope();
+  const ssrSource = third?.ssrSource;
+  if (ssrSource === "client") {
+    const [hydrated, setHydrated] = createSignal$1(false);
+    const sig = createOptimistic$1(prev => {
+      if (!hydrated()) return prev ?? second;
+      return fn(prev);
+    }, second, third);
+    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);
+  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 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);
+  };
+}
+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);
+}
+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);
+}
+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);
+}
 function enableHydration() {
   _createMemo = hydratedCreateMemo;
   _createSignal = hydratedCreateSignal;
+  _createErrorBoundary = hydratedCreateErrorBoundary;
+  _createOptimistic = hydratedCreateOptimistic;
+  _createProjection = hydratedCreateProjection;
+  _createStore = hydratedCreateStore;
+  _createOptimisticStore = hydratedCreateOptimisticStore;
+  _hydratingValue = sharedConfig.hydrating;
+  _doneValue = sharedConfig.done;
+  Object.defineProperty(sharedConfig, "hydrating", {
+    get() {
+      return _hydratingValue;
+    },
+    set(v) {
+      const was = _hydratingValue;
+      _hydratingValue = v;
+      if (!was && v) {
+        _hydrationDone = false;
+        _doneValue = false;
+        _pendingBoundaries = 0;
+        setSnapshotCapture(true);
+        _snapshotRootOwner = null;
+      } else if (was && !v) {
+        if (_snapshotRootOwner) {
+          releaseSnapshotScope(_snapshotRootOwner);
+          _snapshotRootOwner = null;
+        }
+        checkHydrationComplete();
+      }
+    },
+    configurable: true,
+    enumerable: true
+  });
+  Object.defineProperty(sharedConfig, "done", {
+    get() {
+      return _doneValue;
+    },
+    set(v) {
+      _doneValue = v;
+      if (v) drainHydrationCallbacks();
+    },
+    configurable: true,
+    enumerable: true
+  });
 }
 const createMemo = (...args) => (_createMemo || createMemo$1)(...args);
 const createSignal = (...args) => (_createSignal || createSignal$1)(...args);
+const createErrorBoundary = (...args) => (_createErrorBoundary || createErrorBoundary$1)(...args);
+const createOptimistic = (...args) => (_createOptimistic || createOptimistic$1)(...args);
+const createProjection = (...args) => (_createProjection || createProjection$1)(...args);
+const createStore = (...args) => (_createStore || createStore$1)(...args);
+const createOptimisticStore = (...args) => (_createOptimisticStore || createOptimisticStore$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, {
+    equals: false
+  });
+  s();
+  setSnapshotCapture(true);
+  return set;
+}
+function resumeBoundaryHydration(o, id, set) {
+  _pendingBoundaries--;
+  if (isDisposed(o)) {
+    checkHydrationComplete();
+    return;
+  }
+  sharedConfig.gather(id);
+  _hydratingValue = true;
+  markSnapshotScope(o);
+  _snapshotRootOwner = o;
+  set();
+  flush();
+  _snapshotRootOwner = null;
+  _hydratingValue = false;
+  releaseSnapshotScope(o);
+  flush();
+  checkHydrationComplete();
+}
 function Loading(props) {
   if (!sharedConfig.hydrating) return createLoadBoundary(() => props.children, () => props.fallback);
   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 (sharedConfig.hydrating && sharedConfig.has(id)) {
       let ref = sharedConfig.load(id);
       let p;
@@ -120,24 +470,38 @@ function Loading(props) {
         if (typeof ref !== "object" || ref.s !== 1) p = ref;else sharedConfig.gather(id);
       }
       if (p) {
-        const [s, set] = createSignal$1(undefined, {
-          equals: false
+        _pendingBoundaries++;
+        onCleanup(() => {
+          if (!isDisposed(o)) return;
+          sharedConfig.cleanupFragment?.(id);
         });
-        s();
+        const set = createBoundaryTrigger();
         if (p !== "$$f") {
-          p.then(() => {
-            sharedConfig.gather(id);
-            sharedConfig.hydrating = true;
+          const waitFor = assetPromise ? Promise.all([p, assetPromise]) : p;
+          waitFor.then(() => resumeBoundaryHydration(o, id, set), err => {
+            _pendingBoundaries--;
+            checkHydrationComplete();
+            runWithOwner(o, () => {
+              throw err;
+            });
+          });
+        } else {
+          const afterAssets = () => {
+            _pendingBoundaries--;
             set();
-            flush();
-            sharedConfig.hydrating = false;
-          }, err => runWithOwner(o, () => {
-            throw err;
-          }));
-        } else queueMicrotask(set);
+            checkHydrationComplete();
+          };
+          if (assetPromise) assetPromise.then(() => queueMicrotask(afterAssets));else queueMicrotask(afterAssets);
+        }
         return props.fallback;
       }
     }
+    if (assetPromise) {
+      _pendingBoundaries++;
+      const set = createBoundaryTrigger();
+      assetPromise.then(() => resumeBoundaryHydration(o, id, set));
+      return undefined;
+    }
     return createLoadBoundary(() => props.children, () => props.fallback);
   });
 }
@@ -145,11 +509,24 @@ function Loading(props) {
 function createComponent(Comp, props) {
   return untrack(() => Comp(props || {}));
 }
-function lazy(fn) {
+function lazy(fn, moduleUrl) {
   let comp;
   let p;
   const wrap = props => {
-    comp = createMemo$1(() => (p || (p = fn())).then(mod => mod.default));
+    if (sharedConfig.hydrating && moduleUrl) {
+      const cached = globalThis._$HY?.modules?.[moduleUrl];
+      if (!cached) {
+        throw new Error(`lazy() module "${moduleUrl}" was not preloaded before hydration. ` + "Ensure it is inside a Loading boundary.");
+      }
+      comp = () => cached.default;
+    }
+    if (!comp) {
+      p || (p = fn());
+      p.then(mod => {
+        comp = () => mod.default;
+      });
+      comp = createMemo$1(() => p.then(mod => mod.default));
+    }
     let Comp;
     return createMemo$1(() => (Comp = comp()) ? untrack(() => {
       return Comp(props);
@@ -191,10 +568,15 @@ function Show(props) {
     if (c) {
       const child = props.children;
       const fn = typeof child === "function" && child.length > 0;
-      return fn ? untrack(() => child(() => {
-        if (!untrack(condition)) throw narrowedError("Show");
-        return conditionValue();
-      })) : child;
+      return fn ? untrack(() => {
+        try {
+          return child(() => {
+            if (!untrack(condition)) throw narrowedError("Show");
+            return conditionValue();
+          });
+        } finally {
+        }
+      }) : child;
     }
     return props.fallback;
   }, undefined, undefined);
@@ -222,10 +604,15 @@ function Switch(props) {
     const [index, conditionValue, mp] = sel;
     const child = mp.children;
     const fn = typeof child === "function" && child.length > 0;
-    return fn ? untrack(() => child(() => {
-      if (untrack(switchFunc)()?.[0] !== index) throw narrowedError("Match");
-      return conditionValue();
-    })) : child;
+    return fn ? untrack(() => {
+      try {
+        return child(() => {
+          if (untrack(switchFunc)()?.[0] !== index) throw narrowedError("Match");
+          return conditionValue();
+        });
+      } finally {
+      }
+    }) : child;
   }, undefined, undefined);
 }
 function Match(props) {
@@ -242,4 +629,4 @@ function ssrHandleError() {}
 function ssrRunInScope() {}
 const DEV = undefined;
 
-export { $DEVCOMP, DEV, Errored, For, Loading, Match, Repeat, Show, Switch, children, createComponent, createContext, createMemo, createSignal, createUniqueId, enableHydration, lazy, sharedConfig, ssrHandleError, ssrRunInScope, useContext };
+export { $DEVCOMP, DEV, Errored, For, Loading, Match, Repeat, Show, Switch, children, createComponent, createContext, createMemo, createOptimistic, createOptimisticStore, createProjection, createSignal, createStore, createUniqueId, enableHydration, lazy, sharedConfig, ssrHandleError, ssrRunInScope, useContext };

package/package.json

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

package/types/client/component.d.ts

@@ -66,7 +66,7 @@ export type Ref<T> = T | ((val: T) => void);
 export declare function createComponent<T extends Record<string, any>>(Comp: Component<T>, props: T): JSX.Element;
 export declare function lazy<T extends Component<any>>(fn: () => Promise<{
     default: T;
-}>): T & {
+}>, moduleUrl?: string): T & {
     preload: () => Promise<{
         default: T;
     }>;

package/types/client/hydration.d.ts

@@ -1,6 +1,18 @@
-import { createMemo as coreMemo, createSignal as coreSignal } from "@solidjs/signals";
+import { createErrorBoundary as coreErrorBoundary, createMemo as coreMemo, createSignal as coreSignal, createOptimistic as coreOptimistic, type ProjectionOptions, type Store, type StoreSetter } from "@solidjs/signals";
 import { JSX } from "../jsx.js";
-export { createStore, createProjection, createOptimistic, createOptimisticStore } from "@solidjs/signals";
+declare module "@solidjs/signals" {
+    interface MemoOptions<T> {
+        deferStream?: boolean;
+        ssrSource?: "server" | "hybrid" | "initial" | "client";
+    }
+    interface SignalOptions<T> {
+        deferStream?: boolean;
+        ssrSource?: "server" | "hybrid" | "initial" | "client";
+    }
+}
+export type HydrationProjectionOptions = ProjectionOptions & {
+    ssrSource?: "server" | "hybrid" | "initial" | "client";
+};
 export type HydrationContext = {};
 type SharedConfig = {
     hydrating: boolean;
@@ -10,14 +22,33 @@ type SharedConfig = {
     load?: (id: string) => Promise<any> | any;
     has?: (id: string) => boolean;
     gather?: (key: string) => void;
+    cleanupFragment?: (id: string) => void;
     registry?: Map<string, Element>;
     done: boolean;
     getNextContextId(): string;
 };
 export declare const sharedConfig: SharedConfig;
+/**
+ * Registers a callback to run once when all hydration completes
+ * (all boundaries hydrated or cancelled). If hydration is already
+ * complete (or not hydrating), fires via queueMicrotask.
+ */
+export declare function onHydrationEnd(callback: () => void): void;
 export declare function enableHydration(): void;
 export declare const createMemo: typeof coreMemo;
 export declare const createSignal: typeof coreSignal;
+export declare const createErrorBoundary: typeof coreErrorBoundary;
+export declare const createOptimistic: typeof coreOptimistic;
+export declare const createProjection: <T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, initialValue?: T, options?: HydrationProjectionOptions) => Store<T>;
+type NoFn<T> = T extends Function ? never : T;
+export declare const createStore: {
+    <T extends object = {}>(store: NoFn<T> | Store<NoFn<T>>): [get: Store<T>, set: StoreSetter<T>];
+    <T extends object = {}>(fn: (store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, store?: NoFn<T> | Store<NoFn<T>>, options?: HydrationProjectionOptions): [get: Store<T>, set: StoreSetter<T>];
+};
+export declare const createOptimisticStore: {
+    <T extends object = {}>(store: NoFn<T> | Store<NoFn<T>>): [get: Store<T>, set: StoreSetter<T>];
+    <T extends object = {}>(fn: (store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, store?: NoFn<T> | Store<NoFn<T>>, options?: HydrationProjectionOptions): [get: Store<T>, set: StoreSetter<T>];
+};
 /**
  * Tracks all resources inside a component and renders a fallback until they are all resolved
  * ```typescript
@@ -33,3 +64,4 @@ export declare function Loading(props: {
     fallback?: JSX.Element;
     children: JSX.Element;
 }): JSX.Element;
+export {};

package/types/server/component.d.ts

@@ -50,11 +50,15 @@ export type Ref<T> = T | ((val: T) => void);
 export declare function createComponent<T extends Record<string, any>>(Comp: Component<T>, props: T): JSX.Element;
 /**
  * Lazy load a function component asynchronously.
- * On server, caches the promise and throws NotReadyError if not yet loaded.
+ * On server, returns a createMemo that throws NotReadyError until the module resolves,
+ * allowing resolveSSRNode to capture it as a fine-grained hole. The memo naturally
+ * scopes the owner so hydration IDs align with the client's createMemo in lazy().
+ * Requires `moduleUrl` for SSR — the bundler plugin injects the module specifier
+ * so the server can look up client chunk URLs from the asset manifest.
  */
 export declare function lazy<T extends Component<any>>(fn: () => Promise<{
     default: T;
-}>): T & {
+}>, moduleUrl?: string): T & {
     preload: () => Promise<{
         default: T;
     }>;

package/types/server/index.d.ts

@@ -1,5 +1,5 @@
-export { $PROXY, $TRACK, action, createEffect, createMemo, createOptimistic, createOptimisticStore, createProjection, createReaction, createRenderEffect, createRoot, createSignal, createStore, createTrackedEffect, deep, flatten, flush, getObserver, getOwner, isEqual, isRefreshing, isPending, isWrappable, mapArray, merge, omit, onCleanup, onSettled, pending, reconcile, refresh, repeat, resolve, NotReadyError, runWithOwner, snapshot, untrack } from "./signals.js";
-export type { Accessor, ComputeFunction, EffectFunction, EffectOptions, Merge, NoInfer, NotWrappable, Omit, Owner, Signal, SignalOptions, Setter, Store, SolidStore, StoreNode, StoreSetter } from "./signals.js";
+export { $PROXY, $TRACK, action, createEffect, createMemo, createOptimistic, createOptimisticStore, createProjection, createReaction, createRenderEffect, createRoot, createSignal, createStore, createTrackedEffect, deep, flatten, flush, getObserver, getOwner, isEqual, isRefreshing, isPending, isWrappable, mapArray, merge, omit, onCleanup, onSettled, pending, reconcile, refresh, repeat, resolve, NotReadyError, runWithOwner, snapshot, createDeepProxy, untrack } from "./signals.js";
+export type { Accessor, ComputeFunction, EffectFunction, EffectOptions, Merge, NoInfer, NotWrappable, Omit, Owner, Signal, SignalOptions, Setter, Store, SolidStore, StoreNode, StoreSetter, PatchOp } from "./signals.js";
 export { $DEVCOMP, children, createContext, useContext, ssrRunInScope } from "./core.js";
 export type { ChildrenReturn, Context, ContextProviderComponent, ResolvedChildren, ResolvedJSXElement } from "./core.js";
 export * from "./component.js";

package/types/server/shared.d.ts

@@ -6,13 +6,34 @@ type SSRTemplateObject = {
 export type HydrationContext = {
     id: string;
     count: number;
-    serialize: (id: string, v: Promise<any> | any, deferStream?: boolean) => void;
+    /**
+     * Serialize a value for client hydration.
+     * In renderToStream (async: true), accepts promises and async iterables.
+     * In renderToString (async: false), only synchronous values are allowed —
+     * passing async values will throw.
+     */
+    serialize: (id: string, v: any, deferStream?: boolean) => void;
     resolve(value: any): SSRTemplateObject;
     ssr(template: string[], ...values: any[]): SSRTemplateObject;
     escape(value: any): string;
     replace: (id: string, replacement: () => any) => void;
     block: (p: Promise<any>) => void;
     registerFragment: (v: string) => (v?: string, err?: any) => boolean;
+    /** Register a client-side asset URL discovered during SSR (e.g. from lazy()). */
+    registerAsset?: (type: "module" | "style", url: string) => void;
+    /** Register a moduleUrl-to-entryUrl mapping for the current boundary. */
+    registerModule?: (moduleUrl: string, entryUrl: string) => void;
+    /** Resolve a module's JS and CSS assets from the asset manifest. Set by dom-expressions. */
+    resolveAssets?: (moduleUrl: string) => {
+        js: string[];
+        css: string[];
+    } | null;
+    /** Retrieve the moduleUrl-to-entryUrl map for a boundary. */
+    getBoundaryModules?: (id: string) => Record<string, string> | null;
+    /** @internal Tracks which Loading boundary is currently rendering. Set by dom-expressions via applyAssetTracking(). */
+    _currentBoundaryId?: string | null;
+    assets: any[];
+    /** True only in renderToStream — enables async data serialization and streaming. */
     async?: boolean;
     noHydrate: boolean;
 };