solid-js 2.0.0-beta.5 → 2.0.0-beta.7

package/types/server/flow.d.ts

@@ -70,4 +70,13 @@ export declare function Loading(props: {
     on?: any;
     children: JSX.Element;
 }): JSX.Element;
+/**
+ * Coordinates the reveal timing of sibling `<Loading>` boundaries during SSR.
+ * @description https://docs.solidjs.com/reference/components/reveal
+ */
+export declare function Reveal(props: {
+    together?: boolean;
+    collapsed?: boolean;
+    children: JSX.Element;
+}): JSX.Element;
 export {};

package/types/server/hydration.d.ts

@@ -1,6 +1,15 @@
+import type { Context } from "./signals.js";
 import type { JSX } from "../jsx.js";
 export { sharedConfig, NoHydrateContext } from "./shared.js";
 export type { HydrationContext, SSRTemplateObject } from "./shared.js";
+export type ServerRevealGroup = {
+    id: string;
+    register(key: string, options?: {
+        onActivate?: () => void;
+    }): boolean;
+    onResolved(key: string): void;
+};
+export declare const RevealGroupContext: Context<ServerRevealGroup | null>;
 /**
  * Handles errors during SSR rendering.
  * Returns the promise source for NotReadyError (for async handling),

package/types/server/index.d.ts

@@ -1,4 +1,4 @@
-export { $PROXY, $REFRESH, $TRACK, action, createEffect, createMemo, createOptimistic, createOptimisticStore, createErrorBoundary, 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, enableExternalSource, enforceLoadingBoundary, untrack } 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, 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";

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,4 +1,4 @@
-export { createRoot, createOwner, runWithOwner, getOwner, onCleanup, getNextChildId, createContext, setContext, getContext, NotReadyError, NoOwnerError, ContextNotFoundError, isEqual, isWrappable, SUPPORTS_PROXY, enableExternalSource, enforceLoadingBoundary } 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, $REFRESH, $TRACK } from "@solidjs/signals";
 export type { Accessor, ComputeFunction, EffectFunction, EffectBundle, EffectOptions, ExternalSource, ExternalSourceConfig, ExternalSourceFactory, 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";
@@ -15,23 +15,21 @@ interface ServerComputation<T = any> {
 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?: SignalOptions<T>): Signal<T>;
+export declare function createMemo<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, options?: MemoOptions<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 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?: EffectOptions): 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?: SignalOptions<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?: {
+export declare function createProjection<T extends object>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, initialValue: Partial<T>, options?: {
     deferStream?: boolean;
     ssrSource?: string;
 }): Store<T>;
@@ -53,6 +51,10 @@ export declare function createErrorBoundary<U>(fn: () => any, fallback: (error:
 export declare function createLoadingBoundary(fn: () => any, fallback: () => any, options?: {
     on?: () => any;
 }): () => unknown;
+export declare function createRevealOrder<T>(fn: () => T, _options?: {
+    together?: () => boolean;
+    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-cjs/client/component.d.cts

@@ -0,0 +1,75 @@
+import type { JSX } from "../jsx.cjs";
+/**
+ * A general `Component` has no implicit `children` prop.  If desired, you can
+ * specify one as in `Component<{name: String, children: JSX.Element}>`.
+ */
+export type Component<P extends Record<string, any> = {}> = (props: P) => JSX.Element;
+/**
+ * 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 an optional `children` prop with the usual
+ * type in JSX, `JSX.Element` (which allows elements, arrays, strings, etc.).
+ * Use this for components that you want to accept children.
+ */
+export type ParentProps<P extends Record<string, any> = {}> = P & {
+    children?: JSX.Element;
+};
+/**
+ * `ParentComponent` allows an optional `children` prop with the usual
+ * type in JSX, `JSX.Element` (which allows elements, arrays, strings, etc.).
+ * 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.
+ * Note that all JSX <Elements> are of the type `JSX.Element`.
+ */
+export type FlowProps<P extends Record<string, any> = {}, C = JSX.Element> = 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.
+ * Note that all JSX <Elements> are of the type `JSX.Element`.
+ */
+export type FlowComponent<P extends Record<string, any> = {}, C = JSX.Element> = Component<FlowProps<P, C>>;
+export type ValidComponent = keyof JSX.IntrinsicElements | Component<any> | (string & {});
+/**
+ * Takes the props of the passed component and returns its type
+ *
+ * @example
+ * ComponentProps<typeof Portal> // { mount?: Node; useShadow?: boolean; children: JSX.Element }
+ * ComponentProps<'div'> // JSX.HTMLAttributes<HTMLDivElement>
+ */
+export type ComponentProps<T extends ValidComponent> = T extends Component<infer P> ? P : T extends keyof JSX.IntrinsicElements ? JSX.IntrinsicElements[T] : Record<string, unknown>;
+/**
+ * Type of `props.ref`, for use in `Component` or `props` typing.
+ *
+ * @example Component<{ref: Ref<Element>}>
+ */
+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;
+}>, moduleUrl?: string): T & {
+    preload: () => Promise<{
+        default: T;
+    }>;
+    moduleUrl?: string;
+};
+export declare function createUniqueId(): string;

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

@@ -0,0 +1,58 @@
+import type { Accessor, EffectOptions } from "@solidjs/signals";
+import type { JSX } from "../jsx.cjs";
+import { FlowComponent } from "./component.cjs";
+export declare const IS_DEV: string | boolean;
+export declare const $DEVCOMP: unique symbol;
+export type NoInfer<T extends any> = [T][T extends any ? 0 : never];
+export type ContextProviderComponent<T> = FlowComponent<{
+    value: T;
+}>;
+export interface Context<T> extends ContextProviderComponent<T> {
+    id: symbol;
+    defaultValue: T;
+}
+/**
+ * Creates a Context to handle a state scoped for the children of a component
+ * ```typescript
+ * interface Context<T> {
+ *   id: symbol;
+ *   Provider: FlowComponent<{ value: T }>;
+ *   defaultValue: T;
+ * }
+ * export function createContext<T>(
+ *   defaultValue?: T,
+ *   options?: { name?: string }
+ * ): Context<T | undefined>;
+ * ```
+ * @param defaultValue optional default to inject into context
+ * @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`
+ *
+ * @description https://docs.solidjs.com/reference/component-apis/create-context
+ */
+export declare function createContext<T>(defaultValue?: undefined, options?: EffectOptions): Context<T | undefined>;
+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
+ *
+ * @description https://docs.solidjs.com/reference/component-apis/use-context
+ */
+export declare function useContext<T>(context: Context<T>): T;
+export type ResolvedJSXElement = Exclude<JSX.Element, JSX.ArrayElement>;
+export type ResolvedChildren = ResolvedJSXElement | ResolvedJSXElement[];
+export type ChildrenReturn = Accessor<ResolvedChildren> & {
+    toArray: () => ResolvedJSXElement[];
+};
+/**
+ * Resolves child elements to help interact with children
+ *
+ * @param fn an accessor for the children
+ * @returns a accessor of the same children, but resolved
+ *
+ * @description https://docs.solidjs.com/reference/component-apis/children
+ */
+export declare function children(fn: Accessor<JSX.Element>): ChildrenReturn;
+export declare function devComponent<P, V>(Comp: (props: P) => V, props: P): V;

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

@@ -0,0 +1,142 @@
+import type { Accessor } from "@solidjs/signals";
+import type { JSX } from "../jsx.cjs";
+type NonZeroParams<T extends (...args: any[]) => any> = Parameters<T>["length"] extends 0 ? never : T;
+type ConditionalRenderCallback<T> = (item: Accessor<NonNullable<T>>) => JSX.Element;
+type ConditionalRenderChildren<T, F extends ConditionalRenderCallback<T> = ConditionalRenderCallback<T>> = JSX.Element | NonZeroParams<F>;
+/**
+ * Creates a list of elements from a list
+ *
+ * it receives a map function as its child that receives list element and index accessors and returns a JSX-Element; if the list is empty, an optional fallback is returned:
+ * ```typescript
+ * <For each={items} fallback={<div>No items</div>}>
+ *   {(item, index) => <div data-index={index()}>{item()}</div>}
+ * </For>
+ * ```
+ *
+ * @description https://docs.solidjs.com/reference/components/for
+ */
+export declare function For<T extends readonly any[], U extends JSX.Element>(props: {
+    each: T | undefined | null | false;
+    fallback?: JSX.Element;
+    keyed?: boolean | ((item: T[number]) => any);
+    children: (item: Accessor<T[number]>, index: Accessor<number>) => U;
+}): JSX.Element;
+/**
+ * Creates a list elements from a count
+ *
+ * it receives a map function as its child that receives the index and returns a JSX-Element; if the list is empty, an optional fallback is returned:
+ * ```typescript
+ * <Repeat count={items.length} fallback={<div>No items</div>}>
+ *   {(index) => <div data-index={index}>{items[index]}</div>}
+ * </Repeat>
+ * ```
+ *
+ * @description https://docs.solidjs.com/reference/components/repeat
+ */
+export declare function Repeat<T extends JSX.Element>(props: {
+    count: number;
+    from?: number | undefined;
+    fallback?: JSX.Element;
+    children: ((index: number) => T) | T;
+}): JSX.Element;
+/**
+ * Conditionally render its children or an optional fallback component
+ * @description https://docs.solidjs.com/reference/components/show
+ */
+export declare function Show<T, F extends ConditionalRenderCallback<T>>(props: {
+    when: T | undefined | null | false;
+    keyed?: boolean;
+    fallback?: JSX.Element;
+    children: ConditionalRenderChildren<T, F>;
+}): JSX.Element;
+/**
+ * Switches between content based on mutually exclusive conditions
+ * ```typescript
+ * <Switch fallback={<FourOhFour />}>
+ *   <Match when={state.route === 'home'}>
+ *     <Home />
+ *   </Match>
+ *   <Match when={state.route === 'settings'}>
+ *     <Settings />
+ *   </Match>
+ * </Switch>
+ * ```
+ * @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, F extends ConditionalRenderCallback<T> = ConditionalRenderCallback<T>> = {
+    when: T | undefined | null | false;
+    keyed?: boolean;
+    children: ConditionalRenderChildren<T, F>;
+};
+/**
+ * Selects a content based on condition when inside a `<Switch>` control flow
+ * ```typescript
+ * <Match when={condition()}>
+ *   <Content/>
+ * </Match>
+ * ```
+ * @description https://docs.solidjs.com/reference/components/switch-and-match
+ */
+export declare function Match<T, F extends ConditionalRenderCallback<T>>(props: MatchProps<T, F>): JSX.Element;
+/**
+ * Catches uncaught errors inside components and renders a fallback content
+ *
+ * Also supports a callback form that passes the error and a reset function:
+ * ```typescript
+ * <Errored fallback={
+ *   (err, reset) => <div onClick={reset}>Error: {err.toString()}</div>
+ * }>
+ *   <MyComp />
+ * </Errored>
+ * ```
+ * Errors thrown from the fallback can be caught by a parent Errored
+ *
+ * @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;
+/**
+ * Tracks all resources inside a component and renders a fallback until they are all resolved
+ * ```typescript
+ * const AsyncComponent = lazy(() => import('./component'));
+ *
+ * <Loading fallback={<LoadingIndicator />}>
+ *   <AsyncComponent />
+ * </Loading>
+ * ```
+ * @description https://docs.solidjs.com/reference/components/suspense
+ */
+export declare function Loading(props: {
+    fallback?: JSX.Element;
+    on?: any;
+    children: JSX.Element;
+}): JSX.Element;
+/**
+ * Coordinates the reveal timing of sibling `<Loading>` boundaries.
+ *
+ * - **Sequential** (default): boundaries reveal in DOM order as each resolves.
+ * - **Together** (`together`): all boundaries wait until the group is ready, then reveal at once.
+ * - **Collapsed** (`collapsed`, sequential only): only the frontier boundary shows its fallback;
+ *   later boundaries produce nothing until their turn.
+ *
+ * ```typescript
+ * <Reveal>
+ *   <Loading fallback={<Skeleton />}><ProfileHeader /></Loading>
+ *   <Loading fallback={<Skeleton />}><Posts /></Loading>
+ * </Reveal>
+ * ```
+ *
+ * @description https://docs.solidjs.com/reference/components/reveal
+ */
+export declare function Reveal(props: {
+    together?: boolean;
+    collapsed?: boolean;
+    children: JSX.Element;
+}): JSX.Element;
+export {};

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

@@ -0,0 +1,96 @@
+import { createErrorBoundary as coreErrorBoundary, createMemo as coreMemo, createSignal as coreSignal, createOptimistic as coreOptimistic, createRenderEffect as coreRenderEffect, createEffect as coreEffect, $REFRESH, type ProjectionOptions, type Store, type StoreSetter, type Context } from "@solidjs/signals";
+import { JSX } from "../jsx.cjs";
+type HydrationSsrFields = {
+    deferStream?: boolean;
+    ssrSource?: "server" | "hybrid" | "initial" | "client";
+};
+declare module "@solidjs/signals" {
+    interface MemoOptions<T> extends HydrationSsrFields {
+    }
+    interface SignalOptions<T> extends HydrationSsrFields {
+    }
+    interface EffectOptions extends HydrationSsrFields {
+    }
+}
+export type HydrationProjectionOptions = ProjectionOptions & {
+    ssrSource?: "server" | "hybrid" | "initial" | "client";
+};
+export type HydrationContext = {};
+export declare const NoHydrateContext: Context<boolean>;
+type SharedConfig = {
+    hydrating: boolean;
+    resources?: {
+        [key: string]: any;
+    };
+    load?: (id: string) => Promise<any> | any;
+    has?: (id: string) => boolean;
+    gather?: (key: string) => void;
+    cleanupFragment?: (id: string) => void;
+    loadModuleAssets?: (mapping: Record<string, string>) => Promise<void> | undefined;
+    registry?: Map<string, Element>;
+    completed?: WeakSet<Element> | null;
+    events?: any[] | null;
+    verifyHydration?: () => void;
+    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> & {
+    [$REFRESH]: any;
+};
+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> & {
+        [$REFRESH]: any;
+    }, 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> & {
+        [$REFRESH]: any;
+    }, set: StoreSetter<T>];
+};
+export declare const createRenderEffect: typeof coreRenderEffect;
+export declare const createEffect: typeof coreEffect;
+/**
+ * Tracks all resources inside a component and renders a fallback until they are all resolved
+ * ```typescript
+ * const AsyncComponent = lazy(() => import('./component'));
+ *
+ * <Loading fallback={<LoadingIndicator />}>
+ *   <AsyncComponent />
+ * </Loading>
+ * ```
+ * @description https://docs.solidjs.com/reference/components/suspense
+ */
+export declare function createLoadingBoundary(fn: () => any, fallback: () => any, options?: {
+    on?: () => any;
+}): () => unknown;
+/**
+ * Disables hydration for its children on the client.
+ * During hydration, skips the subtree entirely (returns undefined so DOM is left untouched).
+ * After hydration, renders children fresh.
+ */
+export declare function NoHydration(props: {
+    children: JSX.Element;
+}): JSX.Element;
+/**
+ * Re-enables hydration within a NoHydration zone (passthrough on client).
+ */
+export declare function Hydration(props: {
+    id?: string;
+    children: JSX.Element;
+}): JSX.Element;
+export {};

package/types-cjs/index.d.cts

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

package/types-cjs/jsx-properties.d.cts

@@ -0,0 +1,95 @@
+/**
+ * Shared type-level helpers used to derive `prop:*` attribute typings from
+ * DOM element interfaces (e.g. `HTMLInputElement`, `HTMLButtonElement`).
+ *
+ * The wrapping of each value (`FunctionMaybe<T>` in `jsx-h.d.ts` vs. the
+ * raw value in `jsx.d.ts`) is applied by each consumer when composing its
+ * own `Properties<T>` mapped type. That way this file stays identical in
+ * both reactive and non-reactive contexts and only needs to exist once.
+ *
+ * originally from
+ * @url https://github.com/potahtml/pota
+ */
+
+/** Base-class properties shared by all elements — skipped from `prop:*`. */
+export type SkipPropsFrom = HTMLUnknownElement & HTMLElement & Element & Node;
+
+/**
+ * Value types allowed on a `prop:*`. Primitives plus the writable
+ * non-primitive DOM-object props worth exposing:
+ *
+ * - `HTMLMediaElement.srcObject`
+ * - `HTMLButtonElement.popoverTargetElement` / `commandForElement` (and the same via
+ *   `PopoverTargetAttributes` mixin on `HTMLInputElement`)
+ */
+export type PropValue =
+  | string
+  | number
+  | boolean
+  | null
+  | MediaStream
+  | MediaSource
+  | Blob
+  | File
+  | Element;
+
+/**
+ * Ergonomics widening for emitted `prop:*` value types:
+ *
+ * - general `string` → `string | number` (HTML coerces numbers)
+ * - string literal unions (`'on' | 'off'`) stay exact, so users still get autocomplete /
+ *   narrowing
+ * - other types pass through unchanged
+ */
+export type WidenPropValue<V> = [V] extends [string]
+  ? string extends V
+    ? string | number
+    : V
+  : V;
+
+/**
+ * Structurally identical → `Y`; distinct → `N`. Used by `IsReadonlyKey` to detect
+ * readonly keys by comparing `Pick<T, K>` with `Readonly<Pick<T, K>>`.
+ */
+export type IfEquals<A, B, Y = unknown, N = never> =
+  (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2 ? Y : N;
+
+/**
+ * True when `K` is readonly on `T`. Singleton-constant properties (e.g.
+ * `tagName: "INPUT"`, `nodeType: 1`) are always `readonly` in `lib.dom.d.ts`, so this
+ * single check covers both readonly and singleton-literal cases.
+ */
+export type IsReadonlyKey<T, K extends keyof T> = IfEquals<
+  Pick<T, K>,
+  Readonly<Pick<T, K>>,
+  true,
+  false
+>;
+
+/**
+ * Resolves to the `prop:K` string literal when `K` is a writable, element-specific
+ * property suitable for a `prop:*` attribute; otherwise resolves to `never` so the
+ * key is filtered out of the resulting mapped type.
+ *
+ * Filters out:
+ *
+ * - base-class keys (via `SkipPropsFrom`)
+ * - aria-* keys (already typed via `AriaAttributes`)
+ * - readonly keys
+ * - keys whose value types fall outside `PropValue`
+ * - the generic `string` index signature (e.g. `HTMLFormElement[name: string]: any`),
+ *   which would otherwise shadow every key with an `any`-typed `prop:*`
+ */
+export type PropKey<T, K extends keyof T> = K extends keyof SkipPropsFrom
+  ? never
+  : K extends string
+    ? string extends K
+      ? never
+      : K extends `aria${string}`
+        ? never
+        : T[K] extends PropValue
+          ? IsReadonlyKey<T, K> extends true
+            ? never
+            : `prop:${K}`
+          : never
+    : never;