solid-js 1.2.5 → 1.3.0-beta.10

package/types/reactive/signal.d.ts

@@ -1,16 +1,15 @@
 import { requestCallback } from "./scheduler";
 import type { JSX } from "../jsx";
-export declare type Accessor<T> = () => T;
-export declare type Setter<T> = undefined extends T ? <U extends T>(v?: (U extends Function ? never : U) | ((prev?: T) => U)) => U : <U extends T>(v: (U extends Function ? never : U) | ((prev: T) => U)) => U;
 export declare const equalFn: <T>(a: T, b: T) => boolean;
 export declare const $PROXY: unique symbol;
 export declare const NOTPENDING: {};
 export declare var Owner: Owner | null;
-export declare let Transition: Transition | null;
+export declare let Transition: TransitionState | null;
+declare let ExternalSourceFactory: ExternalSourceFactory | null;
 declare global {
     var _$afterUpdate: () => void;
 }
-interface Signal<T> {
+export interface SignalState<T> {
     value?: T;
     observers: Computation<any>[] | null;
     observerSlots: number[] | null;
@@ -19,7 +18,7 @@ interface Signal<T> {
     comparator?: (prev: T, next: T) => boolean;
     name?: string;
 }
-interface Owner {
+export interface Owner {
     owned: Computation<any>[] | null;
     cleanups: (() => void)[] | null;
     owner: Owner | null;
@@ -30,23 +29,20 @@ interface Owner {
     name?: string;
     componentName?: string;
 }
-interface Computation<T> extends Owner {
-    fn: (v?: T) => T;
+export interface Computation<Init, Next extends Init = Init> extends Owner {
+    fn: EffectFunction<Init, Next>;
     state: number;
     tState?: number;
-    sources: Signal<T>[] | null;
+    sources: SignalState<Next>[] | null;
     sourceSlots: number[] | null;
-    value?: T;
+    value?: Init;
     updatedAt: number | null;
     pure: boolean;
     user?: boolean;
     suspense?: SuspenseContextType;
 }
-interface Memo<T> extends Signal<T>, Computation<T> {
-    tOwned?: Computation<any>[];
-}
-interface Transition {
-    sources: Set<Signal<any>>;
+export interface TransitionState {
+    sources: Set<SignalState<any>>;
     effects: Computation<any>[];
     promises: Set<Promise<any>>;
     disposed: Set<Computation<any>>;
@@ -55,6 +51,12 @@ interface Transition {
     running: boolean;
     cb: (() => void)[];
 }
+declare type ExternalSourceFactory = <Prev, Next extends Prev = Prev>(fn: EffectFunction<Prev, Next>, trigger: () => void) => ExternalSource;
+export interface ExternalSource {
+    track: EffectFunction<any, any>;
+    dispose: () => void;
+}
+export declare type RootFunction<T> = (dispose: () => void) => T;
 /**
  * Creates a new non-tracked reactive context that doesn't auto-dispose
  *
@@ -64,11 +66,13 @@ interface Transition {
  *
  * @description https://www.solidjs.com/docs/latest/api#createroot
  */
-export declare function createRoot<T>(fn: (dispose: () => void) => T, detachedOwner?: Owner): T;
-export declare type SignalOptions<T> = {
-    name?: string;
-    equals?: false | ((prev: T, next: T) => boolean);
-};
+export declare function createRoot<T>(fn: RootFunction<T>, detachedOwner?: Owner): T;
+export declare type Accessor<T> = () => T;
+export declare type Setter<T> = undefined extends T ? <U extends T>(value?: (U extends Function ? never : U) | ((prev?: T) => U)) => U : <U extends T>(value: (U extends Function ? never : U) | ((prev: T) => U)) => U;
+export declare type Signal<T> = [get: Accessor<T>, set: Setter<T>];
+export interface SignalOptions<T> extends MemoOptions<T> {
+    internal?: boolean;
+}
 /**
  * Creates a simple reactive state with a getter and setter
  * ```typescript
@@ -92,18 +96,21 @@ export declare type SignalOptions<T> = {
  *
  * @description https://www.solidjs.com/docs/latest/api#createsignal
  */
-export declare function createSignal<T>(): [get: Accessor<T | undefined>, set: Setter<T | undefined>];
-export declare function createSignal<T>(value: T, options?: {
-    equals?: false | ((prev: T, next: T) => boolean);
+export declare function createSignal<T>(): Signal<T | undefined>;
+export declare function createSignal<T>(value: T, options?: SignalOptions<T>): Signal<T>;
+export interface BaseOptions {
     name?: string;
-    internal?: boolean;
-}): [get: Accessor<T>, set: Setter<T>];
+}
+export declare type NoInfer<T extends any> = [T][T extends any ? 0 : never];
+export interface EffectOptions extends BaseOptions {
+}
+export declare type EffectFunction<Prev, Next extends Prev = Prev> = (v: Prev) => Next;
 /**
  * Creates a reactive computation that runs immediately before render, mainly used to write to other reactive primitives
  * ```typescript
- * export function createComputed<T>(
- *   fn: (v: T) => T,
- *   value?: T,
+ * export function createComputed<Next, Init = Next>(
+ *   fn: (v: Init | Next) => Next,
+ *   value?: Init,
  *   options?: { name?: string }
  * ): void;
  * ```
@@ -113,10 +120,8 @@ export declare function createSignal<T>(value: T, options?: {
  *
  * @description https://www.solidjs.com/docs/latest/api#createcomputed
  */
-export declare function createComputed<T>(fn: (v?: T) => T | undefined): void;
-export declare function createComputed<T>(fn: (v: T) => T, value: T, options?: {
-    name?: string;
-}): void;
+export declare function createComputed<Next, Init = Next>(fn: EffectFunction<Init | Next, Next>, value: Init, options?: EffectOptions): void;
+export declare function createComputed<Next, Init = undefined>(..._: undefined extends Init ? [fn: EffectFunction<Init | Next, Next>, value?: Init, options?: EffectOptions] : [fn: EffectFunction<Init | Next, Next>, value: Init, options?: EffectOptions]): void;
 /**
  * Creates a reactive computation that runs during the render phase as DOM elements are created and updated but not necessarily connected
  * ```typescript
@@ -132,10 +137,8 @@ export declare function createComputed<T>(fn: (v: T) => T, value: T, options?: {
  *
  * @description https://www.solidjs.com/docs/latest/api#createrendereffect
  */
-export declare function createRenderEffect<T>(fn: (v?: T) => T | undefined): void;
-export declare function createRenderEffect<T>(fn: (v: T) => T, value: T, options?: {
-    name?: string;
-}): void;
+export declare function createRenderEffect<Next, Init = Next>(fn: EffectFunction<Init | Next, Next>, value: Init, options?: EffectOptions): void;
+export declare function createRenderEffect<Next, Init = undefined>(..._: undefined extends Init ? [fn: EffectFunction<Init | Next, Next>, value?: Init, options?: EffectOptions] : [fn: EffectFunction<Init | Next, Next>, value: Init, options?: EffectOptions]): void;
 /**
  * Creates a reactive computation that runs after the render phase
  * ```typescript
@@ -151,10 +154,14 @@ export declare function createRenderEffect<T>(fn: (v: T) => T, value: T, options
  *
  * @description https://www.solidjs.com/docs/latest/api#createeffect
  */
-export declare function createEffect<T>(fn: (v?: T) => T | undefined): void;
-export declare function createEffect<T>(fn: (v: T) => T, value: T, options?: {
-    name?: string;
-}): void;
+export declare function createEffect<Next, Init = Next>(fn: EffectFunction<Init | Next, Next>, value: Init, options?: EffectOptions): void;
+export declare function createEffect<Next, Init = undefined>(..._: undefined extends Init ? [fn: EffectFunction<Init | Next, Next>, value?: Init, options?: EffectOptions] : [fn: EffectFunction<Init | Next, Next>, value: Init, options?: EffectOptions]): void;
+interface Memo<Prev, Next = Prev> extends SignalState<Next>, Computation<Next> {
+    tOwned?: Computation<Prev | Next, Next>[];
+}
+export interface MemoOptions<T> extends EffectOptions {
+    equals?: false | ((prev: T, next: T) => boolean);
+}
 /**
  * Creates a readonly derived reactive memoized signal
  * ```typescript
@@ -170,25 +177,23 @@ export declare function createEffect<T>(fn: (v: T) => T, value: T, options?: {
  *
  * @description https://www.solidjs.com/docs/latest/api#creatememo
  */
-export declare function createMemo<T>(fn: (v?: T) => T, value?: undefined, options?: {
-    equals?: false | ((prev: T, next: T) => boolean);
-    name?: string;
-}): Accessor<T>;
-export declare function createMemo<T>(fn: (v: T) => T, value: T, options?: {
-    equals?: false | ((prev: T, next: T) => boolean);
-    name?: string;
-}): Accessor<T>;
+export declare function createMemo<Next extends _Next, Init = Next, _Next = Next>(fn: EffectFunction<Init | _Next, Next>, value: Init, options?: MemoOptions<Next>): Accessor<Next>;
+export declare function createMemo<Next extends _Next, Init = undefined, _Next = Next>(..._: undefined extends Init ? [fn: EffectFunction<Init | _Next, Next>, value?: Init, options?: MemoOptions<Next>] : [fn: EffectFunction<Init | _Next, Next>, value: Init, options?: MemoOptions<Next>]): Accessor<Next>;
 export interface Resource<T> extends Accessor<T> {
     loading: boolean;
     error: any;
 }
 export declare type ResourceActions<T> = {
     mutate: Setter<T>;
-    refetch: () => void;
+    refetch: (info?: unknown) => void;
 };
 export declare type ResourceReturn<T> = [Resource<T>, ResourceActions<T>];
 export declare type ResourceSource<S> = S | false | null | (() => S | false | null);
-export declare type ResourceFetcher<S, T> = (k: S, getPrev: Accessor<T>) => T | Promise<T>;
+export declare type ResourceFetcher<S, T> = (k: S, info: ResourceFetcherInfo<T>) => T | Promise<T>;
+export declare type ResourceFetcherInfo<T> = {
+    value: T | undefined;
+    refetching?: unknown;
+};
 export declare type ResourceOptions<T> = T extends undefined ? {
     initialValue?: T;
     name?: string;
@@ -199,14 +204,14 @@ export declare type ResourceOptions<T> = T extends undefined ? {
 /**
  * Creates a resource that wraps a repeated promise in a reactive pattern:
  * ```typescript
- * const [resource, { mutate, refetch }] = crateResource(source, fetcher, options);
+ * const [resource, { mutate, refetch }] = createResource(source, fetcher, options);
  * ```
  * @param source - reactive data function to toggle the request, optional
  * @param fetcher - function that receives the source (or true) and an accessor for the last or initial value and returns a value or a Promise with the value:
  * ```typescript
  * const fetcher: ResourceFetcher<S, T, > = (
  *   sourceOutput: ReturnValue<typeof source>,
- *   getPrev: Accessor<T>
+ *   info: ResourceFetcherInfo<T>
  * ) => T | Promise<T>;
  * ```
  * @param options - an optional object with the initialValue and the name (for debugging purposes)
@@ -221,30 +226,31 @@ export declare type ResourceOptions<T> = T extends undefined ? {
  *
  * @description https://www.solidjs.com/docs/latest/api#createresource
  */
-export declare function createResource<T extends any, S = true>(fetcher: ResourceFetcher<S, T>, options?: ResourceOptions<undefined>): [Resource<T | undefined>, ResourceActions<T | undefined>];
-export declare function createResource<T, S = true>(fetcher: ResourceFetcher<S, T>, options: ResourceOptions<T>): [Resource<T>, ResourceActions<T>];
-export declare function createResource<T, S>(source: ResourceSource<S>, fetcher: ResourceFetcher<S, T>, options?: ResourceOptions<undefined>): [Resource<T | undefined>, ResourceActions<T | undefined>];
-export declare function createResource<T, S>(source: ResourceSource<S>, fetcher: ResourceFetcher<S, T>, options: ResourceOptions<T>): [Resource<T>, ResourceActions<T>];
+export declare function createResource<T, S = true>(fetcher: ResourceFetcher<S, T>, options?: ResourceOptions<undefined>): ResourceReturn<T | undefined>;
+export declare function createResource<T, S = true>(fetcher: ResourceFetcher<S, T>, options: ResourceOptions<T>): ResourceReturn<T>;
+export declare function createResource<T, S>(source: ResourceSource<S>, fetcher: ResourceFetcher<S, T>, options?: ResourceOptions<undefined>): ResourceReturn<T | undefined>;
+export declare function createResource<T, S>(source: ResourceSource<S>, fetcher: ResourceFetcher<S, T>, options: ResourceOptions<T>): ResourceReturn<T>;
+export declare function refetchResources(info?: unknown): void;
+export interface DeferredOptions<T> {
+    equals?: false | ((prev: T, next: T) => boolean);
+    name?: string;
+    timeoutMs?: number;
+}
 /**
  * Creates a reactive computation that only runs and notifies the reactive context when the browser is idle
  * ```typescript
  * export function createDeferred<T>(
  *   fn: (v: T) => T,
- *   value?: T,
  *   options?: { timeoutMs?: number, name?: string, equals?: false | ((prev: T, next: T) => boolean) }
  * ): () => T);
  * ```
  * @param fn a function that receives its previous or the initial value, if set, and returns a new value used to react on a computation
- * @param value an optional initial value for the computation; if set, fn will never receive undefined as first argument
  * @param options allows to set the timeout in milliseconds, use a custom comparison function and set a name in dev mode for debugging purposes
  *
  * @description https://www.solidjs.com/docs/latest/api#createdeferred
  */
-export declare function createDeferred<T>(source: Accessor<T>, options?: {
-    equals?: false | ((prev: T, next: T) => boolean);
-    name?: string;
-    timeoutMs?: number;
-}): Accessor<T>;
+export declare function createDeferred<T>(source: Accessor<T>, options?: DeferredOptions<T>): Accessor<T>;
+export declare type EqualityCheckerFunction<T, U> = (a: U, b: T) => boolean;
 /**
  * Creates a conditional signal that only notifies subscribers when entering or exiting their key matching the value
  * ```typescript
@@ -269,9 +275,7 @@ export declare function createDeferred<T>(source: Accessor<T>, options?: {
  *
  * @description https://www.solidjs.com/docs/latest/api#createselector
  */
-export declare function createSelector<T, U>(source: Accessor<T>, fn?: (a: U, b: T) => boolean, options?: {
-    name?: string;
-}): (key: U) => boolean;
+export declare function createSelector<T, U>(source: Accessor<T>, fn?: EqualityCheckerFunction<T, U>, options?: BaseOptions): (key: U) => boolean;
 /**
  * Holds changes inside the block before the reactive context is updated
  * @param fn wraps the reactive updates that should be batched
@@ -279,7 +283,7 @@ export declare function createSelector<T, U>(source: Accessor<T>, fn?: (a: U, b:
  *
  * @description https://www.solidjs.com/docs/latest/api#batch
  */
-export declare function batch<T>(fn: () => T): T;
+export declare function batch<T>(fn: Accessor<T>): T;
 /**
  * Ignores tracking context inside its scope
  * @param fn the scope that is out of the tracking context
@@ -291,6 +295,10 @@ export declare function untrack<T>(fn: Accessor<T>): T;
 export declare type ReturnTypes<T> = T extends (() => any)[] ? {
     [I in keyof T]: ReturnTypes<T[I]>;
 } : T extends () => any ? ReturnType<T> : never;
+export declare type OnEffectFunction<S, Prev, Next extends Prev = Prev> = (input: ReturnTypes<S>, prevInput: ReturnTypes<S>, v: Prev) => Next;
+export interface OnOptions {
+    defer?: boolean;
+}
 /**
  * on - make dependencies of a computation explicit
  * ```typescript
@@ -303,6 +311,8 @@ export declare type ReturnTypes<T> = T extends (() => any)[] ? {
  * @param deps list of reactive dependencies or a single reactive dependency
  * @param fn computation on input; the current previous content(s) of input and the previous value are given as arguments and it returns a new value
  * @param options optional, allows deferred computation until at the end of the next change
+ * @returns an effect function that is passed into createEffect. For example:
+ *
  * ```typescript
  * createEffect(on(a, (v) => console.log(v, b())));
  *
@@ -315,12 +325,7 @@ export declare type ReturnTypes<T> = T extends (() => any)[] ? {
  *
  * @description https://www.solidjs.com/docs/latest/api#on
  */
-export declare function on<T extends (() => any)[], U>(deps: [...T], fn: (input: ReturnTypes<T>, prevInput: ReturnTypes<T>, prevValue?: U) => U, options?: {
-    defer?: boolean;
-}): (prevValue?: U) => U;
-export declare function on<T extends () => any, U>(deps: T, fn: (input: ReturnType<T>, prevInput: ReturnType<T>, prevValue?: U) => U, options?: {
-    defer?: boolean;
-}): (prevValue?: U) => U;
+export declare function on<S extends Accessor<unknown> | Accessor<unknown>[] | [], Next, Init = unknown>(deps: S, fn: OnEffectFunction<S, Init | Next, Next>, options?: OnOptions): EffectFunction<NoInfer<Init> | NoInfer<Next>, NoInfer<Next>>;
 /**
  * onMount - run an effect only after initial render on mount
  * @param fn an effect that should run only once on mount
@@ -344,11 +349,18 @@ export declare function onCleanup(fn: () => void): () => void;
  * @description https://www.solidjs.com/docs/latest/api#onerror
  */
 export declare function onError(fn: (err: any) => void): void;
-export declare function getListener(): Computation<any> | null;
+export declare function getListener(): Computation<any, any> | null;
 export declare function getOwner(): Owner | null;
 export declare function runWithOwner(o: Owner, fn: () => any): any;
 export declare function enableScheduling(scheduler?: typeof requestCallback): void;
+/**
+ * ```typescript
+ * export function startTransition(fn: () => void, cb?: () => void) => void
+ *
+ * @description https://www.solidjs.com/docs/latest/api#usetransition
+ */
 export declare function startTransition(fn: () => void, cb?: () => void): void;
+export declare type Transition = [Accessor<boolean>, (fn: () => void, cb?: () => void) => void];
 /**
  * ```typescript
  * export function useTransition(): [
@@ -359,7 +371,7 @@ export declare function startTransition(fn: () => void, cb?: () => void): void;
  *
  * @description https://www.solidjs.com/docs/latest/api#usetransition
  */
-export declare function useTransition(): [Accessor<boolean>, (fn: () => void, cb?: () => void) => void];
+export declare function useTransition(): Transition;
 export declare function resumeEffects(e: Computation<any>[]): void;
 export declare function devComponent<T>(Comp: (props: T) => JSX.Element, props: T): JSX.Element;
 export declare function hashValue(v: any): string;
@@ -370,12 +382,13 @@ interface GraphRecord {
     [k: string]: GraphRecord | unknown;
 }
 export declare function serializeGraph(owner?: Owner | null): GraphRecord;
+export declare type ContextProviderComponent<T> = (props: {
+    value: T;
+    children: any;
+}) => any;
 export interface Context<T> {
     id: symbol;
-    Provider: (props: {
-        value: T;
-        children: any;
-    }) => any;
+    Provider: ContextProviderComponent<T>;
     defaultValue: T;
 }
 /**
@@ -413,18 +426,21 @@ export declare function useContext<T>(context: Context<T>): T;
  * @description https://www.solidjs.com/docs/latest/api#children
  */
 export declare function children(fn: Accessor<JSX.Element>): Accessor<JSX.Element>;
-declare type SuspenseContextType = {
+export declare type SuspenseContextType = {
     increment?: () => void;
     decrement?: () => void;
     inFallback?: () => boolean;
     effects?: Computation<any>[];
     resolved?: boolean;
 };
-export declare function getSuspenseContext(): Context<SuspenseContextType> & {
+declare type SuspenseContext = Context<SuspenseContextType> & {
     active?(): boolean;
     increment?(): void;
     decrement?(): void;
 };
-export declare function readSignal(this: Signal<any> | Memo<any>): any;
-export declare function writeSignal(node: Signal<any> | Memo<any>, value: any, isComp?: boolean): any;
+declare let SuspenseContext: SuspenseContext;
+export declare function getSuspenseContext(): SuspenseContext;
+export declare function enableExternalSource(factory: ExternalSourceFactory): void;
+export declare function readSignal(this: SignalState<any> | Memo<any>): any;
+export declare function writeSignal(node: SignalState<any> | Memo<any>, value: any, isComp?: boolean): any;
 export {};

package/types/render/component.d.ts

@@ -1,4 +1,5 @@
 import type { JSX } from "../jsx";
+export declare function enableHydration(): void;
 export declare type PropsWithChildren<P = {}> = P & {
     children?: JSX.Element;
 };
@@ -36,7 +37,9 @@ export declare function splitProps<T extends object, K1 extends keyof T, K2 exte
 export declare function lazy<T extends Component<any>>(fn: () => Promise<{
     default: T;
 }>): T & {
-    preload: () => void;
+    preload: () => Promise<{
+        default: T;
+    }>;
 };
 export declare function createUniqueId(): string;
 export {};

package/types/render/hydration.d.ts

@@ -1,13 +1,14 @@
-declare type HydrationContext = {
+export declare type HydrationContext = {
     id: string;
     count: number;
-    loadResource?: (id: string) => Promise<any>;
 };
 declare type SharedConfig = {
     context?: HydrationContext;
     resources?: {
         [key: string]: any;
     };
+    load?: (id: string) => Promise<any> | undefined;
+    gather?: (key: string) => void;
     registry?: Map<string, Element>;
 };
 export declare const sharedConfig: SharedConfig;

package/types/server/index.d.ts

@@ -1,3 +1,3 @@
-export { createRoot, createSignal, createComputed, createRenderEffect, createEffect, createDeferred, createSelector, createMemo, getListener, onMount, onCleanup, onError, untrack, batch, on, children, createContext, useContext, getOwner, runWithOwner, equalFn, requestCallback, mapArray, observable, from, $PROXY, DEV } from "./reactive";
-export { awaitSuspense, mergeProps, splitProps, createComponent, For, Index, Show, Switch, Match, ErrorBoundary, Suspense, SuspenseList, createResource, enableScheduling, startTransition, useTransition, createUniqueId, lazy, sharedConfig } from "./rendering";
+export { createRoot, createSignal, createComputed, createRenderEffect, createEffect, createDeferred, createSelector, createMemo, getListener, onMount, onCleanup, onError, untrack, batch, on, children, createContext, useContext, getOwner, runWithOwner, equalFn, requestCallback, mapArray, observable, from, $PROXY, DEV, enableExternalSource } from "./reactive";
+export { mergeProps, splitProps, createComponent, For, Index, Show, Switch, Match, ErrorBoundary, Suspense, SuspenseList, createResource, enableScheduling, startTransition, useTransition, createUniqueId, lazy, sharedConfig } from "./rendering";
 export type { Component, Resource } from "./rendering";

package/types/server/reactive.d.ts

@@ -1,9 +1,8 @@
+import type { Accessor, Setter } from "../reactive/signal";
 export declare const equalFn: <T>(a: T, b: T) => boolean;
 export declare const $PROXY: unique symbol;
 export declare const DEV: {};
 export declare let Owner: Owner | null;
-export declare type Accessor<T> = () => T;
-export declare type Setter<T> = undefined extends T ? <U extends T>(v?: (U extends Function ? never : U) | ((prev?: U) => U)) => U : <U extends T>(v: (U extends Function ? never : U) | ((prev: U) => U)) => U;
 interface Owner {
     owner: Owner | null;
     context: any | null;
@@ -71,4 +70,5 @@ export declare function from<T>(producer: ((setter: Setter<T>) => () => void) |
         unsubscribe: () => void;
     };
 }): Accessor<T>;
+export declare function enableExternalSource(factory: any): void;
 export {};

package/types/server/rendering.d.ts

@@ -56,9 +56,9 @@ declare type MatchProps<T> = {
 };
 export declare function Match<T>(props: MatchProps<T>): MatchProps<T>;
 export declare function ErrorBoundary(props: {
-    fallback: string | ((err: any) => string);
+    fallback: string | ((err: any, reset: () => void) => string);
     children: string;
-}): string;
+}): any;
 export interface Resource<T> {
     (): T | undefined;
     loading: boolean;
@@ -82,6 +82,7 @@ export declare function createResource<T, U = true>(fetcher: (k: U, getPrev: ()
 export declare function createResource<T, U>(fn: U | false | (() => U | false), fetcher: (k: U, getPrev: () => T | undefined) => T | Promise<T>, options?: {
     initialValue?: T;
 }): ResourceReturn<T>;
+export declare function refetchResources(info?: unknown): void;
 export declare function lazy(fn: () => Promise<{
     default: any;
 }>): (props: any) => string;
@@ -91,11 +92,13 @@ export declare function useTransition(): [() => boolean, (fn: () => any) => void
 declare type HydrationContext = {
     id: string;
     count: number;
-    writeResource?: (id: string, v: Promise<any>) => void;
+    writeResource?: (id: string, v: Promise<any> | any, error?: boolean) => void;
     resources: Record<string, any>;
     suspense: Record<string, SuspenseContextType>;
+    registerFragment: (v: string) => (v?: string, err?: any) => boolean;
     async?: boolean;
     streaming?: boolean;
+    noHydrate: boolean;
 };
 export declare function SuspenseList(props: {
     children: string;
@@ -103,8 +106,7 @@ export declare function SuspenseList(props: {
     tail?: "collapsed" | "hidden";
 }): string;
 export declare function Suspense(props: {
-    fallback: string;
+    fallback?: string;
     children: string;
 }): any;
-export declare function awaitSuspense(fn: () => any): Promise<unknown>;
 export {};

package/web/dist/dev.cjs

@@ -98,7 +98,7 @@ function render(code, element, init) {
   let disposer;
   solidJs.createRoot(dispose => {
     disposer = dispose;
-    insert(element, code(), element.firstChild ? null : undefined, init);
+    element === document ? code() : insert(element, code(), element.firstChild ? null : undefined, init);
   });
   return () => {
     disposer();
@@ -218,28 +218,21 @@ function assign(node, props, isSVG, skipChildren, prevProps = {}) {
     prevProps[prop] = assignProp(node, prop, value, prevProps[prop], isSVG);
   }
 }
-function hydrate(code, element) {
-  solidJs.sharedConfig.resources = globalThis._$HYDRATION.resources;
-  solidJs.sharedConfig.completed = globalThis._$HYDRATION.completed;
-  solidJs.sharedConfig.events = globalThis._$HYDRATION.events;
+function hydrate$1(code, element, options = {}) {
+  solidJs.sharedConfig.completed = globalThis._$HY.completed;
+  solidJs.sharedConfig.events = globalThis._$HY.events;
+  solidJs.sharedConfig.load = globalThis._$HY.load;
+  solidJs.sharedConfig.gather = root => gatherHydratable(element, root);
+  solidJs.sharedConfig.registry = new Map();
   solidJs.sharedConfig.context = {
-    id: "",
-    count: 0,
-    loadResource: globalThis._$HYDRATION.loadResource
+    id: options.renderId || "",
+    count: 0
   };
-  solidJs.sharedConfig.registry = new Map();
-  gatherHydratable(element);
+  gatherHydratable(element, options.renderId);
   const dispose = render(code, element, [...element.childNodes]);
   solidJs.sharedConfig.context = null;
   return dispose;
 }
-function gatherHydratable(element) {
-  const templates = element.querySelectorAll(`*[data-hk]`);
-  for (let i = 0; i < templates.length; i++) {
-    const node = templates[i];
-    solidJs.sharedConfig.registry.set(node.getAttribute("data-hk"), node);
-  }
-}
 function getNextElement(template) {
   let node, key;
   if (!solidJs.sharedConfig.context || !(node = solidJs.sharedConfig.registry.get(key = getHydrationKey()))) {
@@ -333,7 +326,7 @@ function eventHandler(e) {
   Object.defineProperty(e, "currentTarget", {
     configurable: true,
     get() {
-      return node;
+      return node || document;
     }
   });
   while (node !== null) {
@@ -388,7 +381,12 @@ function insertExpression(parent, value, current, marker, unwrapArray) {
       solidJs.createRenderEffect(() => current = insertExpression(parent, array, current, marker, true));
       return () => current;
     }
-    if (solidJs.sharedConfig.context && current && current.length) return current;
+    if (solidJs.sharedConfig.context && current && current.length) {
+      for (let i = 0; i < array.length; i++) {
+        if (array[i].parentNode) return current = array;
+      }
+      return current;
+    }
     if (array.length === 0) {
       current = cleanChildren(parent, current, marker);
       if (multi) return current;
@@ -405,6 +403,7 @@ function insertExpression(parent, value, current, marker, unwrapArray) {
     }
     current = array;
   } else if (value instanceof Node) {
+    if (solidJs.sharedConfig.context) return current = value.parentNode ? value : current;
     if (Array.isArray(current)) {
       if (multi) return current = cleanChildren(parent, current, marker, value);
       cleanChildren(parent, current, null, value);
@@ -456,6 +455,14 @@ function cleanChildren(parent, current, marker, replacement) {
   } else parent.insertBefore(node, marker);
   return [node];
 }
+function gatherHydratable(element, root) {
+  const templates = element.querySelectorAll(`*[data-hk]`);
+  for (let i = 0; i < templates.length; i++) {
+    const node = templates[i];
+    const key = node.getAttribute("data-hk");
+    if (!root || key.startsWith(root)) solidJs.sharedConfig.registry.set(key, node);
+  }
+}
 function getHydrationKey() {
   const hydrate = solidJs.sharedConfig.context;
   return `${hydrate.id}${hydrate.count++}`;
@@ -469,8 +476,7 @@ function NoHydration(props) {
 
 function renderToString(fn, options) {}
 function renderToStringAsync(fn, options) {}
-function pipeToNodeWritable(fn, writable, options) {}
-function pipeToWritable(fn, writable, options) {}
+function renderToStream(fn, options) {}
 function ssr(template, ...nodes) {}
 function resolveSSRNode(node) {}
 function ssrClassList(value) {}
@@ -486,6 +492,10 @@ const SVG_NAMESPACE = "http://www.w3.org/2000/svg";
 function createElement(tagName, isSVG = false) {
   return isSVG ? document.createElementNS(SVG_NAMESPACE, tagName) : document.createElement(tagName);
 }
+const hydrate = (...args) => {
+  solidJs.enableHydration();
+  return hydrate$1(...args);
+};
 function Portal(props) {
   const {
     useShadow
@@ -630,7 +640,6 @@ exports.clearDelegatedEvents = clearDelegatedEvents;
 exports.delegateEvents = delegateEvents;
 exports.dynamicProperty = dynamicProperty;
 exports.escape = escape;
-exports.gatherHydratable = gatherHydratable;
 exports.generateHydrationScript = generateHydrationScript;
 exports.getHydrationKey = getHydrationKey;
 exports.getNextElement = getNextElement;
@@ -640,9 +649,8 @@ exports.hydrate = hydrate;
 exports.insert = insert;
 exports.isServer = isServer;
 exports.memo = memo;
-exports.pipeToNodeWritable = pipeToNodeWritable;
-exports.pipeToWritable = pipeToWritable;
 exports.render = render;
+exports.renderToStream = renderToStream;
 exports.renderToString = renderToString;
 exports.renderToStringAsync = renderToStringAsync;
 exports.resolveSSRNode = resolveSSRNode;