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

package/types/server/component.d.ts

@@ -1,10 +1,10 @@
-import type { JSX } from "../jsx.js";
+import type { Element as SolidElement } from "../types.js";
 export declare function enableHydration(): void;
 /**
- * A general `Component` has no implicit `children` prop.  If desired, you can
- * specify one as in `Component<{name: String, children: JSX.Element}>`.
+ * A general `Component` has no implicit `children` prop. If desired, specify
+ * one explicitly, e.g. `Component<{ name: string; children: Element }>`.
  */
-export type Component<P extends Record<string, any> = {}> = (props: P) => JSX.Element;
+export type Component<P extends Record<string, any> = {}> = (props: P) => SolidElement;
 /**
  * Extend props to forbid the `children` prop.
  */
@@ -16,10 +16,10 @@ export type VoidProps<P extends Record<string, any> = {}> = P & {
  */
 export type VoidComponent<P extends Record<string, any> = {}> = Component<VoidProps<P>>;
 /**
- * Extend props to allow an optional `children` prop with the usual type in JSX.
+ * Extend props to allow optional Solid children.
  */
 export type ParentProps<P extends Record<string, any> = {}> = P & {
-    children?: JSX.Element;
+    children?: SolidElement;
 };
 /**
  * `ParentComponent` allows an optional `children` prop with the usual type in JSX.
@@ -28,18 +28,18 @@ export type ParentComponent<P extends Record<string, any> = {}> = Component<Pare
 /**
  * Extend props to require a `children` prop with the specified type.
  */
-export type FlowProps<P extends Record<string, any> = {}, C = JSX.Element> = P & {
+export type FlowProps<P extends Record<string, any> = {}, C = SolidElement> = P & {
     children: C;
 };
 /**
  * `FlowComponent` requires a `children` prop with the specified type.
  */
-export type FlowComponent<P extends Record<string, any> = {}, C = JSX.Element> = Component<FlowProps<P, C>>;
-export type ValidComponent = keyof JSX.IntrinsicElements | Component<any> | (string & {});
+export type FlowComponent<P extends Record<string, any> = {}, C = SolidElement> = Component<FlowProps<P, C>>;
+export type ValidComponent = Component<any>;
 /**
  * Takes the props of the passed component and returns its type
  */
-export type ComponentProps<T extends ValidComponent> = T extends Component<infer P> ? P : T extends keyof JSX.IntrinsicElements ? JSX.IntrinsicElements[T] : Record<string, unknown>;
+export type ComponentProps<T extends ValidComponent> = T extends Component<infer P> ? P : never;
 /**
  * Type of `props.ref`, for use in `Component` or `props` typing.
  */
@@ -47,7 +47,7 @@ export type Ref<T> = T | ((val: T) => void);
 /**
  * Creates a component. On server, just calls the function directly (no untrack needed).
  */
-export declare function createComponent<T extends Record<string, any>>(Comp: Component<T>, props: T): JSX.Element;
+export declare function createComponent<T extends Record<string, any>>(Comp: Component<T>, props: T): SolidElement;
 /**
  * Lazy load a function component asynchronously.
  * On server, returns a createMemo that throws NotReadyError until the module resolves,

package/types/server/core.d.ts

@@ -1,5 +1,5 @@
 import type { Accessor, EffectOptions } from "./signals.js";
-import type { JSX } from "../jsx.js";
+import type { ArrayElement, Element as SolidElement } from "../types.js";
 import type { FlowComponent } from "./component.js";
 export declare const $DEVCOMP: unique symbol;
 export type NoInfer<T extends any> = [T][T extends any ? 0 : never];
@@ -8,33 +8,38 @@ export type ContextProviderComponent<T> = FlowComponent<{
 }>;
 export interface Context<T> extends ContextProviderComponent<T> {
     id: symbol;
-    defaultValue: T;
+    defaultValue: T | undefined;
 }
 /**
- * Creates a Context to handle a state scoped for the children of a component
- * @param defaultValue optional default to inject into context
+ * Creates a Context to share state with descendants of a Provider.
+ *
+ * - `createContext<T>()` — default-less. `useContext` throws
+ *   `ContextNotFoundError` outside any Provider. Use this for any context
+ *   carrying reactive state.
+ * - `createContext<T>(defaultValue)` — default form. `useContext` falls back
+ *   to `defaultValue` outside a Provider. Reserved for primitive fallbacks
+ *   (theme, locale, frozen config).
+ *
+ * @param defaultValue optional default; only meaningful for primitive fallbacks
  * @param options allows to set a name in dev mode for debugging purposes
- * @returns The context that contains the Provider Component and that can be used with `useContext`
  */
-export declare function createContext<T>(defaultValue?: undefined, options?: EffectOptions): Context<T | undefined>;
-export declare function createContext<T>(defaultValue: T, options?: EffectOptions): Context<T>;
+export declare function createContext<T>(defaultValue?: T, options?: EffectOptions): Context<T>;
 /**
- * Uses a context to receive a scoped state from a parent's Context.Provider
- * @param context Context object made by `createContext`
- * @returns the current or `defaultValue`, if present
+ * Reads the current value of a context. Throws `ContextNotFoundError` if no
+ * Provider is mounted and the context was created without a default.
  */
 export declare function useContext<T>(context: Context<T>): T;
-export type ResolvedJSXElement = Exclude<JSX.Element, JSX.ArrayElement>;
-export type ResolvedChildren = ResolvedJSXElement | ResolvedJSXElement[];
+export type ResolvedElement = Exclude<SolidElement, ArrayElement>;
+export type ResolvedChildren = ResolvedElement | ResolvedElement[];
 export type ChildrenReturn = Accessor<ResolvedChildren> & {
-    toArray: () => ResolvedJSXElement[];
+    toArray: () => ResolvedElement[];
 };
 /**
  * Resolves child elements to help interact with children
  * @param fn an accessor for the children
  * @returns a accessor of the same children, but resolved
  */
-export declare function children(fn: Accessor<JSX.Element>): ChildrenReturn;
+export declare function children(fn: Accessor<SolidElement>): ChildrenReturn;
 /**
  * Pass-through for SSR dynamic expressions.
  * On the client, insert() render effects are transparent (0 owner slots),

package/types/server/flow.d.ts

@@ -1,60 +1,115 @@
-import type { Accessor } from "./signals.js";
-import type { JSX } from "../jsx.js";
+import type { Accessor, RevealOrder } from "./signals.js";
+import type { Element as SolidElement } from "../types.js";
+export type { RevealOrder };
+type NonZeroParams<T extends (...args: any[]) => any> = Parameters<T>["length"] extends 0 ? never : T;
+type ConditionalRenderCallback<T> = (item: Accessor<NonNullable<T>>) => SolidElement;
+type ConditionalRenderChildren<T, F extends ConditionalRenderCallback<T> = ConditionalRenderCallback<T>> = SolidElement | NonZeroParams<F>;
 /**
  * Creates a list of elements from a list
  *
  * @description https://docs.solidjs.com/reference/components/for
  */
-export declare function For<T extends readonly any[], U extends JSX.Element>(props: {
+export declare function For<T extends readonly any[], U extends SolidElement>(props: {
     each: T | undefined | null | false;
-    fallback?: JSX.Element;
+    fallback?: SolidElement;
     keyed?: boolean | ((item: T[number]) => any);
     children: (item: Accessor<T[number]>, index: Accessor<number>) => U;
-}): JSX.Element;
+}): SolidElement;
 /**
  * Creates a list elements from a count
  *
  * @description https://docs.solidjs.com/reference/components/repeat
  */
-export declare function Repeat<T extends JSX.Element>(props: {
+export declare function Repeat<T extends SolidElement>(props: {
     count: number;
     from?: number | undefined;
-    fallback?: JSX.Element;
+    fallback?: SolidElement;
     children: ((index: number) => T) | T;
-}): JSX.Element;
+}): SolidElement;
 /**
  * Conditionally render its children or an optional fallback component
  * @description https://docs.solidjs.com/reference/components/show
  */
-export declare function Show<T>(props: {
+export declare function Show<T, F extends ConditionalRenderCallback<T>>(props: {
     when: T | undefined | null | false;
     keyed?: boolean;
-    fallback?: JSX.Element;
-    children: JSX.Element | ((item: Accessor<NonNullable<T>>) => JSX.Element);
-}): JSX.Element;
+    fallback?: SolidElement;
+    children: ConditionalRenderChildren<T, F>;
+}): SolidElement;
 /**
  * Switches between content based on mutually exclusive conditions
  * @description https://docs.solidjs.com/reference/components/switch-and-match
  */
 export declare function Switch(props: {
-    fallback?: JSX.Element;
-    children: JSX.Element;
-}): JSX.Element;
-export type MatchProps<T> = {
+    fallback?: SolidElement;
+    children: SolidElement;
+}): SolidElement;
+export type MatchProps<T, F extends ConditionalRenderCallback<T> = ConditionalRenderCallback<T>> = {
     when: T | undefined | null | false;
     keyed?: boolean;
-    children: JSX.Element | ((item: Accessor<NonNullable<T>>) => JSX.Element);
+    children: ConditionalRenderChildren<T, F>;
 };
 /**
  * Selects a content based on condition when inside a `<Switch>` control flow
  * @description https://docs.solidjs.com/reference/components/switch-and-match
  */
-export declare function Match<T>(props: MatchProps<T>): JSX.Element;
+export declare function Match<T, F extends ConditionalRenderCallback<T>>(props: MatchProps<T, F>): SolidElement;
 /**
  * Catches uncaught errors inside components and renders a fallback content
  * @description https://docs.solidjs.com/reference/components/error-boundary
  */
 export declare function Errored(props: {
-    fallback: JSX.Element | ((err: any, reset: () => void) => JSX.Element);
-    children: JSX.Element;
-}): JSX.Element;
+    fallback: SolidElement | ((err: any, reset: () => void) => SolidElement);
+    children: SolidElement;
+}): SolidElement;
+/**
+ * Tracks all resources inside a component and renders a fallback until they are all resolved
+ * @description https://docs.solidjs.com/reference/components/suspense
+ */
+export declare function Loading(props: {
+    fallback?: SolidElement;
+    on?: any;
+    children: SolidElement;
+}): SolidElement;
+export type RevealProps = {
+    order?: RevealOrder;
+    collapsed?: boolean;
+    children: SolidElement;
+};
+/**
+ * Coordinates the reveal timing of sibling `<Loading>` boundaries during SSR.
+ *
+ * The `order` prop picks the reveal policy:
+ * - `"sequential"` (default) — boundaries reveal in streamed order; out-of-order
+ *   resolutions have their fragment HTML streamed into templates as data arrives,
+ *   but the swap from fallback to content waits until the frontier reaches them.
+ * - `"together"` — every direct slot holds its fallback until the whole group is
+ *   "minimally ready" (every direct slot has its own first visible content
+ *   available), then the whole group releases in a single activation.
+ * - `"natural"` — each boundary's swap is triggered as its own data resolves. At
+ *   the top level this is equivalent to omitting `<Reveal>`; the mode exists for
+ *   nesting, where the group registers as a single composite slot in an enclosing
+ *   `<Reveal>`.
+ *
+ * The `collapsed` prop is only consulted when `order="sequential"` (the default);
+ * it is ignored under `"together"` and `"natural"`.
+ *
+ * Nesting: a nested `<Reveal>` is held on its fallbacks until its parent releases
+ * the slot it occupies. HTML for resolved fragments still streams through normally;
+ * only the `revealFragments` swap calls are deferred. Once released, the inner
+ * group runs its own `order` locally over whatever is still pending. There is no
+ * escape hatch.
+ *
+ * Engine support:
+ * - `renderToString` fully supports `order="sequential"` (without `collapsed`) and
+ *   `order="natural"` because neither requires streamed activation.
+ * - `order="together"` and `collapsed` rely on streamed activation and require
+ *   `renderToStream` / `renderToStringAsync`. Using them inside a nested `<Reveal>`
+ *   under `renderToString` logs a warning.
+ *
+ * See `documentation/solid-2.0/03-control-flow.md` for the full outer/inner
+ * nesting matrix and the "minimally ready" definition per order.
+ *
+ * @description https://docs.solidjs.com/reference/components/reveal
+ */
+export declare function Reveal(props: RevealProps): SolidElement;

package/types/server/hydration.d.ts

@@ -1,6 +1,32 @@
-import type { JSX } from "../jsx.js";
+import type { Context } from "./signals.js";
+import type { Element as SolidElement } from "../types.js";
 export { sharedConfig, NoHydrateContext } from "./shared.js";
 export type { HydrationContext, SSRTemplateObject } from "./shared.js";
+export type ServerRevealGroup = {
+    id: string;
+    /**
+     * Register a child fragment (Loading) or composite child (inner Reveal).
+     * Returns `collapseFallback` (hide fallback visually, used for collapsed-sequential
+     * tail) and `held` (stash `revealFragments` swaps until the parent releases us).
+     * `held` only applies when the caller is a nested Reveal — Loadings ignore it.
+     */
+    register(key: string, options?: {
+        onActivate?: () => void;
+    }): {
+        collapseFallback: boolean;
+        held: boolean;
+    };
+    /** Called by a child when its subtree is fully resolved. */
+    onResolved(key: string): void;
+    /**
+     * Called by a nested Reveal when it becomes "minimally resolved" under its own
+     * order (together: fully resolved; sequential: first registered fragment resolved;
+     * natural: any fragment resolved). Loadings don't fire this — their `onResolved`
+     * implies minimal readiness at the same time.
+     */
+    onMinimallyResolved?(key: string): void;
+};
+export declare const RevealGroupContext: Context<ServerRevealGroup | null>;
 /**
  * Handles errors during SSR rendering.
  * Returns the promise source for NotReadyError (for async handling),
@@ -15,18 +41,17 @@ export declare function ssrHandleError(err: any): Promise<any> | undefined;
  *
  * @description https://docs.solidjs.com/reference/components/suspense
  */
-export declare function Loading(props: {
-    fallback?: JSX.Element;
-    children: JSX.Element;
-}): JSX.Element;
+export declare function createLoadingBoundary(fn: () => any, fallback: () => any, options?: {
+    on?: () => any;
+}): () => unknown;
 /**
  * Disables hydration for its children during SSR.
  * Elements inside will not receive hydration keys (`_hk`) and signals will not be serialized.
  * Use `Hydration` to re-enable hydration within a `NoHydration` zone.
  */
 export declare function NoHydration(props: {
-    children: JSX.Element;
-}): JSX.Element;
+    children: SolidElement;
+}): SolidElement;
 /**
  * Re-enables hydration within a `NoHydration` zone, establishing a new ID namespace.
  * Pass an `id` prop matching the client's `hydrate({ renderId })` to align hydration keys.
@@ -34,5 +59,5 @@ export declare function NoHydration(props: {
  */
 export declare function Hydration(props: {
     id?: string;
-    children: JSX.Element;
-}): JSX.Element;
+    children: SolidElement;
+}): SolidElement;

package/types/server/index.d.ts

@@ -1,12 +1,10 @@
-export { $PROXY, $TRACK, action, createEffect, createMemo, createOptimistic, createOptimisticStore, createOwner, createProjection, createReaction, createRenderEffect, createRoot, createSignal, createStore, createTrackedEffect, deep, flatten, flush, getNextChildId, getObserver, getOwner, isEqual, isRefreshing, isPending, isWrappable, mapArray, merge, omit, onCleanup, onSettled, latest, reconcile, refresh, repeat, resolve, NotReadyError, runWithOwner, snapshot, storePath, createDeepProxy, untrack } from "./signals.js";
-export type { Accessor, ComputeFunction, EffectFunction, EffectOptions, Merge, NoInfer, NotWrappable, Omit, Owner, Signal, SignalOptions, Setter, Store, SolidStore, StoreNode, StoreSetter, StorePathRange, ArrayFilterFn, CustomPartial, Part, PathSetter, PatchOp } from "./signals.js";
+export { $PROXY, $REFRESH, $TRACK, action, createEffect, createMemo, createOptimistic, createOptimisticStore, createErrorBoundary, createOwner, createProjection, createReaction, createRenderEffect, createRevealOrder, createRoot, createSignal, createStore, createTrackedEffect, deep, flatten, flush, getNextChildId, getObserver, getOwner, isDisposed, isEqual, isRefreshing, isPending, isWrappable, mapArray, merge, omit, onCleanup, onSettled, latest, reconcile, refresh, repeat, resolve, NotReadyError, runWithOwner, snapshot, storePath, createDeepProxy, enableExternalSource, enforceLoadingBoundary, untrack } from "./signals.js";
+export type { Accessor, ComputeFunction, EffectFunction, EffectOptions, ExternalSource, ExternalSourceConfig, ExternalSourceFactory, Merge, NoInfer, NotWrappable, Omit, Owner, Refreshable, Signal, SignalOptions, Setter, Store, SolidStore, StoreNode, StoreSetter, StorePathRange, ArrayFilterFn, CustomPartial, Part, PathSetter, PatchOp } from "./signals.js";
 export { $DEVCOMP, children, createContext, useContext, ssrRunInScope } from "./core.js";
-export type { ChildrenReturn, Context, ContextProviderComponent, ResolvedChildren, ResolvedJSXElement } from "./core.js";
+export type { ChildrenReturn, Context, ContextProviderComponent, ResolvedChildren, ResolvedElement } from "./core.js";
 export * from "./component.js";
 export * from "./flow.js";
-export { sharedConfig, Loading, ssrHandleError, NoHydration, Hydration, NoHydrateContext } from "./hydration.js";
+export type { ArrayElement, Element } from "../types.js";
+export { sharedConfig, createLoadingBoundary, ssrHandleError, NoHydration, Hydration, NoHydrateContext } from "./hydration.js";
 export type { HydrationContext } from "./hydration.js";
-import type { JSX } from "../jsx.js";
-type JSXElement = JSX.Element;
-export type { JSXElement, JSX };
 export declare const DEV: undefined;

package/types/server/shared.d.ts

@@ -19,7 +19,11 @@ export type HydrationContext = {
     escape(value: any): string;
     replace: (id: string, replacement: () => any) => void;
     block: (p: Promise<any>) => void;
-    registerFragment: (v: string) => (v?: string, err?: any) => boolean;
+    registerFragment: (v: string, options?: {
+        revealGroup?: string;
+    }) => (v?: string, err?: any) => boolean;
+    revealFragments?: (groupOrKeys: string | string[]) => void;
+    revealFallbacks?: (groupOrKeys: string | string[]) => void;
     /** 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. */

package/types/server/signals.d.ts

@@ -1,9 +1,9 @@
-export { createRoot, createOwner, runWithOwner, getOwner, onCleanup, getNextChildId, createContext, setContext, getContext, NotReadyError, NoOwnerError, ContextNotFoundError, isEqual, isWrappable, SUPPORTS_PROXY } from "@solidjs/signals";
+export { createRoot, createOwner, runWithOwner, getOwner, isDisposed, onCleanup, getNextChildId, createContext, setContext, getContext, NotReadyError, NoOwnerError, ContextNotFoundError, isEqual, isWrappable, SUPPORTS_PROXY, enableExternalSource, enforceLoadingBoundary } from "@solidjs/signals";
 export { flatten } from "@solidjs/signals";
-export { snapshot, merge, omit, storePath, $PROXY, $TRACK } from "@solidjs/signals";
-export type { Accessor, ComputeFunction, EffectFunction, EffectBundle, EffectOptions, MemoOptions, NoInfer, SignalOptions, Setter, Signal, Owner, Maybe, Store, StoreSetter, StoreNode, NotWrappable, SolidStore, Merge, Omit, Context, ContextRecord, IQueue, StorePathRange, ArrayFilterFn, CustomPartial, Part, PathSetter } from "@solidjs/signals";
+export { snapshot, merge, omit, storePath, $PROXY, $REFRESH, $TRACK } from "@solidjs/signals";
+export type { Accessor, ComputeFunction, EffectFunction, EffectBundle, EffectOptions, ExternalSource, ExternalSourceConfig, ExternalSourceFactory, MemoOptions, NoInfer, SignalOptions, Setter, Signal, Owner, Refreshable, Maybe, Store, StoreSetter, StoreNode, NotWrappable, SolidStore, Merge, Omit, Context, ContextRecord, IQueue, StorePathRange, ArrayFilterFn, CustomPartial, Part, PathSetter } from "@solidjs/signals";
 import type { Accessor, ComputeFunction, EffectFunction, EffectBundle, EffectOptions, MemoOptions, SignalOptions, Signal, Owner, Store, StoreSetter, Context } from "@solidjs/signals";
-import { NoHydrateContext } from "./shared.js";
+import { sharedConfig, NoHydrateContext } from "./shared.js";
 interface ServerComputation<T = any> {
     owner: Owner;
     value: T;
@@ -12,29 +12,46 @@ interface ServerComputation<T = any> {
     computed: boolean;
     disposed: boolean;
 }
+type SsrSourceMode = "server" | "hybrid" | "client";
+type ServerSsrOptions = {
+    deferStream?: boolean;
+    ssrSource?: SsrSourceMode;
+};
+type ServerClientMemoOptions<T> = Omit<MemoOptions<T>, "ssrSource"> & {
+    ssrSource: "client";
+};
+type ServerMemoOptions<T> = Omit<MemoOptions<T>, "ssrSource"> & {
+    ssrSource?: "server" | "hybrid";
+};
+type ServerClientSignalOptions<T> = Omit<SignalOptions<T>, "ssrSource"> & {
+    ssrSource: "client";
+};
+type ServerSignalOptions<T> = Omit<SignalOptions<T>, "ssrSource"> & {
+    ssrSource?: "server" | "hybrid";
+};
 export declare function getObserver(): ServerComputation<any> | null;
 export declare function createSignal<T>(): Signal<T | undefined>;
 export declare function createSignal<T>(value: Exclude<T, Function>, options?: SignalOptions<T>): Signal<T>;
-export declare function createSignal<T>(fn: ComputeFunction<T>, initialValue?: T, options?: SignalOptions<T>): Signal<T>;
-export declare function createMemo<Next extends Prev, Prev = Next>(compute: ComputeFunction<undefined | NoInfer<Prev>, Next>): Accessor<Next>;
-export declare function createMemo<Next extends Prev, Init = Next, Prev = Next>(compute: ComputeFunction<Init | Prev, Next>, value: Init, options?: MemoOptions<Next>): Accessor<Next>;
+export declare function createSignal<T>(fn: ComputeFunction<undefined | NoInfer<T>, T>, options: ServerClientSignalOptions<T>): Signal<T | undefined>;
+export declare function createSignal<T>(fn: ComputeFunction<undefined | NoInfer<T>, T>, options?: ServerSignalOptions<T>): Signal<T>;
+export declare function createMemo<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, options: ServerClientMemoOptions<T>): Accessor<T | undefined>;
+export declare function createMemo<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, options?: ServerMemoOptions<T>): Accessor<T>;
 export type PatchOp = [path: PropertyKey[]] | [path: PropertyKey[], value: any] | [path: PropertyKey[], value: any, insert: 1];
 export declare function createDeepProxy<T extends object>(target: T, patches: PatchOp[], basePath?: PropertyKey[]): T;
-export declare function createEffect<Next>(compute: ComputeFunction<undefined | NoInfer<Next>, Next>, effectFn: EffectFunction<NoInfer<Next>, Next> | EffectBundle<NoInfer<Next>, Next>): void;
-export declare function createEffect<Next, Init = Next>(compute: ComputeFunction<Init | Next, Next>, effect: EffectFunction<Next, Next> | EffectBundle<Next, Next>, value: Init, options?: EffectOptions): void;
-export declare function createRenderEffect<Next>(compute: ComputeFunction<undefined | NoInfer<Next>, Next>, effectFn: EffectFunction<NoInfer<Next>, Next>): void;
-export declare function createRenderEffect<Next, Init = Next>(compute: ComputeFunction<Init | Next, Next>, effectFn: EffectFunction<Next, Next>, value: Init, options?: EffectOptions): void;
-export declare function createTrackedEffect(compute: () => void | (() => void), options?: EffectOptions): void;
+export declare function createEffect<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, effect: EffectFunction<NoInfer<T>, T> | EffectBundle<NoInfer<T>, T>, options?: EffectOptions): void;
+export declare function createRenderEffect<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, effectFn: EffectFunction<NoInfer<T>, T>, options?: EffectOptions): void;
+export declare function createTrackedEffect(compute: () => void | (() => void), options?: {
+    name?: string;
+}): void;
 export declare function createReaction(effectFn: EffectFunction<undefined> | EffectBundle<undefined>, options?: EffectOptions): (tracking: () => void) => void;
 export declare function createOptimistic<T>(): Signal<T | undefined>;
 export declare function createOptimistic<T>(value: Exclude<T, Function>, options?: SignalOptions<T>): Signal<T>;
-export declare function createOptimistic<T>(fn: ComputeFunction<T>, initialValue?: T, options?: SignalOptions<T>): Signal<T>;
-export declare function createStore<T extends object>(first: T | Store<T> | ((store: T) => void | T | Promise<void | T>), second?: T | Store<T>): [get: Store<T>, set: StoreSetter<T>];
+export declare function createOptimistic<T>(fn: ComputeFunction<undefined | NoInfer<T>, T>, options: ServerClientSignalOptions<T>): Signal<T | undefined>;
+export declare function createOptimistic<T>(fn: ComputeFunction<undefined | NoInfer<T>, T>, options?: ServerSignalOptions<T>): Signal<T>;
+export declare function createStore<T extends object>(store: T | Store<T>): [get: Store<T>, set: StoreSetter<T>];
+export declare function createStore<T extends object>(fn: (store: T) => void | T | Promise<void | T>, store: Partial<T> | Store<T>): [get: Store<T>, set: StoreSetter<T>];
 export declare const createOptimisticStore: typeof createStore;
-export declare function createProjection<T extends object>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, initialValue?: T, options?: {
-    deferStream?: boolean;
-    ssrSource?: string;
-}): Store<T>;
+export declare function createProjection<T extends object>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, initialValue: Partial<T>, options?: ServerSsrOptions): Store<T>;
 export declare function reconcile<T extends U, U extends object>(value: T): (state: U) => T;
 export declare function deep<T extends object>(store: Store<T>): Store<T>;
 export declare function mapArray<T, U>(list: Accessor<readonly T[] | undefined | null | false>, mapFn: (v: Accessor<T>, i: Accessor<number>) => U, options?: {
@@ -47,9 +64,17 @@ export declare function repeat<T>(count: Accessor<number>, mapFn: (i: number) =>
 }): () => T[];
 declare const ErrorContext: Context<((err: any) => void) | null>;
 export { ErrorContext };
+export declare function runWithBoundaryErrorContext<T>(owner: Owner, render: () => T, onError: (err: any, parentHandler: ((err: any) => void) | null) => void, context?: NonNullable<typeof sharedConfig.context>, boundaryId?: string): T;
 export { NoHydrateContext };
 export declare function createErrorBoundary<U>(fn: () => any, fallback: (error: unknown, reset: () => void) => U): () => unknown;
-export declare function createLoadBoundary(fn: () => any, fallback: () => any): () => unknown;
+export declare function createLoadingBoundary(fn: () => any, fallback: () => any, options?: {
+    on?: () => any;
+}): () => unknown;
+export type RevealOrder = "sequential" | "together" | "natural";
+export declare function createRevealOrder<T>(fn: () => T, _options?: {
+    order?: () => RevealOrder;
+    collapsed?: () => boolean;
+}): T;
 export declare function untrack<T>(fn: () => T): T;
 export declare function flush(): void;
 export declare function resolve<T>(fn: () => T): Promise<T>;

package/types/types.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Renderer-owned object value returned from Solid component trees.
+ *
+ * The concrete rendered value belongs to the active renderer or JSX factory
+ * (`@solidjs/web`, `@solidjs/h`, custom renderers, etc.), so core does not
+ * model DOM nodes or any other platform object here.
+ */
+export type RenderedElement = object & {
+    readonly call?: never;
+    readonly apply?: never;
+    readonly bind?: never;
+};
+export type Element = RenderedElement | ArrayElement | (string & {}) | number | boolean | null | undefined;
+export interface ArrayElement extends Array<Element> {
+}

package/types-cjs/client/component.d.cts

@@ -0,0 +1,120 @@
+import type { Element as SolidElement } from "../types.cjs";
+/**
+ * A general `Component` has no implicit `children` prop. If desired, specify
+ * one explicitly, e.g. `Component<{ name: string; children: Element }>`.
+ */
+export type Component<P extends Record<string, any> = {}> = (props: P) => SolidElement;
+/**
+ * Extend props to forbid the `children` prop.
+ * Use this to prevent accidentally passing `children` to components that
+ * would silently throw them away.
+ */
+export type VoidProps<P extends Record<string, any> = {}> = P & {
+    children?: never;
+};
+/**
+ * `VoidComponent` forbids the `children` prop.
+ * Use this to prevent accidentally passing `children` to components that
+ * would silently throw them away.
+ */
+export type VoidComponent<P extends Record<string, any> = {}> = Component<VoidProps<P>>;
+/**
+ * Extend props to allow optional Solid children.
+ * Use this for components that you want to accept children.
+ */
+export type ParentProps<P extends Record<string, any> = {}> = P & {
+    children?: SolidElement;
+};
+/**
+ * `ParentComponent` allows an optional `children` prop.
+ * Use this for components that you want to accept children.
+ */
+export type ParentComponent<P extends Record<string, any> = {}> = Component<ParentProps<P>>;
+/**
+ * Extend props to require a `children` prop with the specified type.
+ * Use this for components where you need a specific child type,
+ * typically a function that receives specific argument types.
+ */
+export type FlowProps<P extends Record<string, any> = {}, C = SolidElement> = P & {
+    children: C;
+};
+/**
+ * `FlowComponent` requires a `children` prop with the specified type.
+ * Use this for components where you need a specific child type,
+ * typically a function that receives specific argument types.
+ */
+export type FlowComponent<P extends Record<string, any> = {}, C = SolidElement> = Component<FlowProps<P, C>>;
+export type ValidComponent = Component<any>;
+/**
+ * Takes the props of the passed component and returns its type
+ *
+ * Intrinsic element prop extraction is renderer-specific and lives in renderer
+ * packages such as `@solidjs/web`.
+ */
+export type ComponentProps<T extends ValidComponent> = T extends Component<infer P> ? P : never;
+/**
+ * Type of `props.ref`, for use in `Component` or `props` typing.
+ *
+ * @example Component<{ref: Ref<Element>}>
+ */
+export type Ref<T> = T | ((val: T) => void);
+/**
+ * Invokes a component, wrapping the call in `untrack` so that reactive reads
+ * inside the component body don't subscribe the parent computation. Compiled
+ * JSX uses this internally; manual calls are rarely needed unless authoring a
+ * custom JSX factory or renderer.
+ */
+export declare function createComponent<T extends Record<string, any>>(Comp: Component<T>, props: T): SolidElement;
+/**
+ * Defines a code-split component. The returned component triggers its dynamic
+ * import on first render and suspends through any enclosing `<Loading>`
+ * boundary while the chunk is in flight. Call `.preload()` to start the
+ * import early (e.g. on hover).
+ *
+ * @param fn dynamic import returning the module's default export
+ * @param moduleUrl optional module URL used during hydration to look up
+ *   preloaded chunks; usually injected by the bundler integration
+ *
+ * @example
+ * ```tsx
+ * const Profile = lazy(() => import("./Profile"));
+ *
+ * function App() {
+ *   return (
+ *     <Loading fallback={<Spinner />}>
+ *       <Profile id="42" />
+ *     </Loading>
+ *   );
+ * }
+ *
+ * // Preload before the user clicks
+ * <button onMouseEnter={() => Profile.preload()}>Open profile</button>
+ * ```
+ */
+export declare function lazy<T extends Component<any>>(fn: () => Promise<{
+    default: T;
+}>, moduleUrl?: string): T & {
+    preload: () => Promise<{
+        default: T;
+    }>;
+    moduleUrl?: string;
+};
+/**
+ * Returns a stable id string that matches between server-rendered and
+ * client-hydrated trees. Use it for `<label for>`, `aria-labelledby`, and
+ * other attributes that need consistent ids across SSR.
+ *
+ * @example
+ * ```tsx
+ * function Field(props: { label: string }) {
+ *   const id = createUniqueId();
+ *   return (
+ *     <>
+ *       <label for={id}>{props.label}</label>
+ *       <input id={id} />
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+export declare function createUniqueId(): string;