@solidjs/web 2.0.0-beta.8 → 2.0.0-beta.9

package/storage/types/src/index.d.ts

@@ -1,5 +1,5 @@
 import { hydrate as hydrateCore } from "./client.js";
-import { JSX, ComponentProps, ValidComponent } from "solid-js";
+import { JSX, Component, ComponentProps, ValidComponent } from "solid-js";
 export * from "./client.js";
 export * from "./server-mock.js";
 export { For, Show, Switch, Match, Errored, Loading, Repeat, Reveal, NoHydration, Hydration, merge as mergeProps } from "solid-js";
@@ -9,27 +9,70 @@ type MountableElement = Element | Document | ShadowRoot | DocumentFragment | Nod
 export type DynamicProps<T extends ValidComponent, P = ComponentProps<T>> = {
     [K in keyof P]: P[K];
 } & {
-    component: T | undefined;
+    component: T | null | undefined | false;
 };
 /**
- * Renders a component tree into a DOM element and returns a dispose function.
- *
- * The top-level insert runs with `schedule: true` so its initial DOM attach
- * goes through the effect queue rather than executing inline. This lets the
- * mount participate in transitions: if an uncaught async read surfaces during
- * the initial render (no `Loading` ancestor absorbs it), the mount is held by
- * the transition and attaches atomically once all pending settles. On the
- * no-async happy path the tail `flush()` drains the queued callback so the
- * attach is synchronous by the time `render()` returns.
+ * Renders a component tree into a DOM element. Returns a dispose function
+ * that tears the tree down and cleans up reactive scopes when called.
+ *
+ * @example
+ * ```tsx
+ * import { render } from "@solidjs/web";
+ *
+ * const dispose = render(() => <App />, document.getElementById("root")!);
+ *
+ * // Later, to unmount:
+ * dispose();
+ * ```
+ *
+ * @remarks
+ * The top-level insert is queued via `insertOptions: { schedule: true }` so
+ * its initial DOM attach goes through the effect queue rather than executing
+ * inline. This lets the mount participate in transitions: if an uncaught
+ * async read surfaces during the initial render (no `Loading` ancestor
+ * absorbs it), the mount is held by the transition and attaches atomically
+ * once all pending settles. On the no-async happy path the tail `flush()`
+ * drains the queued callback so the attach is synchronous by the time
+ * `render()` returns. The dev enforcement window scopes
+ * `ASYNC_OUTSIDE_LOADING_BOUNDARY` to the initial mount only.
  */
 export declare function render(code: () => JSX.Element, element: MountableElement, init?: unknown, options?: {
     renderId?: string;
 }): () => void;
+/**
+ * Resumes a server-rendered tree on the client, attaching event listeners
+ * and reactive bindings without reconstructing the DOM. Returns a `dispose`
+ * function that tears down reactive scopes (DOM nodes are left in place).
+ *
+ * Use this when the page HTML was produced by `renderToString`,
+ * `renderToStringAsync`, or `renderToStream`. For client-only apps, use
+ * `render` instead.
+ *
+ * Pass `options.renderId` to hydrate one of multiple roots emitted by a
+ * server render that used the same id.
+ *
+ * @example
+ * ```tsx
+ * import { hydrate } from "@solidjs/web";
+ *
+ * hydrate(() => <App />, document.getElementById("root")!);
+ * ```
+ */
 export declare const hydrate: typeof hydrateCore;
 /**
- * Renders components somewhere else in the DOM
+ * Renders its children into a different part of the DOM (modal roots,
+ * tooltips, layers that need to escape an `overflow: hidden` ancestor).
  *
- * Useful for inserting modals and tooltips outside of an cropping layout. If no mount point is given, the portal is inserted in document.body; it is wrapped in a `<div>` unless the target is document.head or `isSVG` is true. setting `useShadow` to true places the element in a shadow root to isolate styles.
+ * If `mount` is omitted, the portal attaches to `document.body`. The portal
+ * still participates in the parent's reactive scope and disposes when the
+ * parent does.
+ *
+ * @example
+ * ```tsx
+ * <Portal mount={document.getElementById("modal-root")!}>
+ *   <Dialog />
+ * </Portal>
+ * ```
  *
  * @description https://docs.solidjs.com/reference/components/portal
  */
@@ -38,18 +81,24 @@ export declare function Portal<T extends boolean = false, S extends boolean = fa
     children: JSX.Element;
 }): Text;
 /**
- * Renders an arbitrary component or element with the given props
+ * Returns a stable `Component` whose identity is driven by a reactive (and
+ * optionally async) `source`. The returned component can be used anywhere a
+ * normal component is used; children and props flow through JSX as usual.
+ *
+ * `source` may return a component, a native tag name (`'input'`, `'textarea'`,
+ * etc.), `undefined`, or a `Promise` of any of the above. A pending promise
+ * propagates as `NotReadyError` through the surrounding reactive scope, so
+ * async swaps compose with `Loading`/Suspense boundaries the same way as
+ * `lazy`.
  *
- * This is a lower level version of the `Dynamic` component, useful for
- * performance optimizations in libraries. Do not use this unless you know
- * what you are doing.
  * ```typescript
- * const element = () => multiline() ? 'textarea' : 'input';
- * createDynamic(element, { value: value() });
+ * const User = dynamic(() => getUserComp(props.id));
+ * return <User>client content</User>;
  * ```
+ *
  * @description https://docs.solidjs.com/reference/components/dynamic
  */
-export declare function createDynamic<T extends ValidComponent>(component: () => T | undefined, props: ComponentProps<T>): JSX.Element;
+export declare function dynamic<T extends ValidComponent>(source: () => T | Promise<T> | null | undefined | false): Component<ComponentProps<T>>;
 /**
  * Renders an arbitrary custom or native component and passes the other props
  * ```typescript

package/storage/types/src/server-mock.d.ts

@@ -1,3 +1,18 @@
+/**
+ * Renders a component tree synchronously to an HTML string. Async reads inside
+ * `<Loading>` boundaries emit their `fallback` content; for full-graph
+ * resolution use `renderToStringAsync` instead.
+ *
+ * Pair the returned HTML with `hydrate()` on the client.
+ *
+ * @example
+ * ```tsx
+ * import { renderToString } from "@solidjs/web";
+ *
+ * const html = renderToString(() => <App />);
+ * res.send(`<!doctype html><html><body><div id="root">${html}</div></body></html>`);
+ * ```
+ */
 export declare function renderToString<T>(fn: () => T, options?: {
     nonce?: string;
     renderId?: string;
@@ -12,6 +27,21 @@ export declare function renderToString<T>(fn: () => T, options?: {
     }>;
     onError?: (err: any) => void;
 }): string;
+/**
+ * Renders a component tree to an HTML string and awaits all async reads in the
+ * subtree before resolving. The returned HTML reflects the fully-settled state
+ * — no `<Loading>` fallbacks appear in the output.
+ *
+ * Use this when you want a complete page in one round-trip. For incremental
+ * streaming with progressive boundary resolution, use `renderToStream`.
+ *
+ * @example
+ * ```tsx
+ * import { renderToStringAsync } from "@solidjs/web";
+ *
+ * const html = await renderToStringAsync(() => <App />);
+ * ```
+ */
 export declare function renderToStringAsync<T>(fn: () => T, options?: {
     timeoutMs?: number;
     nonce?: string;
@@ -27,6 +57,25 @@ export declare function renderToStringAsync<T>(fn: () => T, options?: {
     }>;
     onError?: (err: any) => void;
 }): Promise<string>;
+/**
+ * Streams an HTML response, flushing the synchronous shell first and then
+ * progressively emitting async-resolved fragments as their `<Loading>`
+ * boundaries settle. Good for time-to-first-byte sensitive pages.
+ *
+ * Returns an object with `pipe`/`pipeTo` for piping to a Node `Writable` or
+ * a Web `WritableStream`, plus a `then` for awaiting full completion.
+ *
+ * @example
+ * ```tsx
+ * import { renderToStream } from "@solidjs/web";
+ *
+ * // Node:
+ * renderToStream(() => <App />).pipe(res);
+ *
+ * // Web (Workers / Deno):
+ * await renderToStream(() => <App />).pipeTo(stream.writable);
+ * ```
+ */
 export declare function renderToStream<T>(fn: () => T, options?: {
     nonce?: string;
     renderId?: string;
@@ -54,19 +103,27 @@ export declare function renderToStream<T>(fn: () => T, options?: {
     }) => void;
     pipeTo: (writable: WritableStream) => Promise<void>;
 };
+/** Compiler primitive — emitted by JSX-DOM-Expressions for tagged-template SSR output. Not meant for hand-written code. */
 export declare function ssr(template: string[] | string, ...nodes: any[]): {
     t: string;
 };
+/** Compiler primitive — emitted by JSX-DOM-Expressions for SSR element output. Not meant for hand-written code. */
 export declare function ssrElement(name: string, props: any, children: any, needsId: boolean): {
     t: string;
 };
+/** Compiler primitive — serializes a classList object for SSR output. Not meant for hand-written code. */
 export declare function ssrClassList(value: {
     [k: string]: boolean;
 }): string;
+/** Compiler primitive — serializes a style object for SSR output. Not meant for hand-written code. */
 export declare function ssrStyle(value: {
     [k: string]: string;
 }): string;
+/** Compiler primitive — serializes a boolean attribute for SSR output. Not meant for hand-written code. */
 export declare function ssrAttribute(key: string, value: boolean): string;
+/** Compiler primitive — generates the hydration-key attribute for SSR output. Not meant for hand-written code. */
 export declare function ssrHydrationKey(): string;
+/** Compiler primitive — collapses an SSR-shaped node into its HTML string. Not meant for hand-written code. */
 export declare function resolveSSRNode(node: any): string;
+/** Escapes a string for safe inclusion in HTML output. Useful when constructing SSR fragments by hand. */
 export declare function escape(html: string): string;

package/storage/types-cjs/src/index.d.cts

@@ -1,5 +1,5 @@
 import { hydrate as hydrateCore } from "./client.cjs";
-import { JSX, ComponentProps, ValidComponent } from "solid-js";
+import { JSX, Component, ComponentProps, ValidComponent } from "solid-js";
 export * from "./client.cjs";
 export * from "./server-mock.cjs";
 export { For, Show, Switch, Match, Errored, Loading, Repeat, Reveal, NoHydration, Hydration, merge as mergeProps } from "solid-js";
@@ -9,27 +9,70 @@ type MountableElement = Element | Document | ShadowRoot | DocumentFragment | Nod
 export type DynamicProps<T extends ValidComponent, P = ComponentProps<T>> = {
     [K in keyof P]: P[K];
 } & {
-    component: T | undefined;
+    component: T | null | undefined | false;
 };
 /**
- * Renders a component tree into a DOM element and returns a dispose function.
- *
- * The top-level insert runs with `schedule: true` so its initial DOM attach
- * goes through the effect queue rather than executing inline. This lets the
- * mount participate in transitions: if an uncaught async read surfaces during
- * the initial render (no `Loading` ancestor absorbs it), the mount is held by
- * the transition and attaches atomically once all pending settles. On the
- * no-async happy path the tail `flush()` drains the queued callback so the
- * attach is synchronous by the time `render()` returns.
+ * Renders a component tree into a DOM element. Returns a dispose function
+ * that tears the tree down and cleans up reactive scopes when called.
+ *
+ * @example
+ * ```tsx
+ * import { render } from "@solidjs/web";
+ *
+ * const dispose = render(() => <App />, document.getElementById("root")!);
+ *
+ * // Later, to unmount:
+ * dispose();
+ * ```
+ *
+ * @remarks
+ * The top-level insert is queued via `insertOptions: { schedule: true }` so
+ * its initial DOM attach goes through the effect queue rather than executing
+ * inline. This lets the mount participate in transitions: if an uncaught
+ * async read surfaces during the initial render (no `Loading` ancestor
+ * absorbs it), the mount is held by the transition and attaches atomically
+ * once all pending settles. On the no-async happy path the tail `flush()`
+ * drains the queued callback so the attach is synchronous by the time
+ * `render()` returns. The dev enforcement window scopes
+ * `ASYNC_OUTSIDE_LOADING_BOUNDARY` to the initial mount only.
  */
 export declare function render(code: () => JSX.Element, element: MountableElement, init?: unknown, options?: {
     renderId?: string;
 }): () => void;
+/**
+ * Resumes a server-rendered tree on the client, attaching event listeners
+ * and reactive bindings without reconstructing the DOM. Returns a `dispose`
+ * function that tears down reactive scopes (DOM nodes are left in place).
+ *
+ * Use this when the page HTML was produced by `renderToString`,
+ * `renderToStringAsync`, or `renderToStream`. For client-only apps, use
+ * `render` instead.
+ *
+ * Pass `options.renderId` to hydrate one of multiple roots emitted by a
+ * server render that used the same id.
+ *
+ * @example
+ * ```tsx
+ * import { hydrate } from "@solidjs/web";
+ *
+ * hydrate(() => <App />, document.getElementById("root")!);
+ * ```
+ */
 export declare const hydrate: typeof hydrateCore;
 /**
- * Renders components somewhere else in the DOM
+ * Renders its children into a different part of the DOM (modal roots,
+ * tooltips, layers that need to escape an `overflow: hidden` ancestor).
  *
- * Useful for inserting modals and tooltips outside of an cropping layout. If no mount point is given, the portal is inserted in document.body; it is wrapped in a `<div>` unless the target is document.head or `isSVG` is true. setting `useShadow` to true places the element in a shadow root to isolate styles.
+ * If `mount` is omitted, the portal attaches to `document.body`. The portal
+ * still participates in the parent's reactive scope and disposes when the
+ * parent does.
+ *
+ * @example
+ * ```tsx
+ * <Portal mount={document.getElementById("modal-root")!}>
+ *   <Dialog />
+ * </Portal>
+ * ```
  *
  * @description https://docs.solidjs.com/reference/components/portal
  */
@@ -38,18 +81,24 @@ export declare function Portal<T extends boolean = false, S extends boolean = fa
     children: JSX.Element;
 }): Text;
 /**
- * Renders an arbitrary component or element with the given props
+ * Returns a stable `Component` whose identity is driven by a reactive (and
+ * optionally async) `source`. The returned component can be used anywhere a
+ * normal component is used; children and props flow through JSX as usual.
+ *
+ * `source` may return a component, a native tag name (`'input'`, `'textarea'`,
+ * etc.), `undefined`, or a `Promise` of any of the above. A pending promise
+ * propagates as `NotReadyError` through the surrounding reactive scope, so
+ * async swaps compose with `Loading`/Suspense boundaries the same way as
+ * `lazy`.
  *
- * This is a lower level version of the `Dynamic` component, useful for
- * performance optimizations in libraries. Do not use this unless you know
- * what you are doing.
  * ```typescript
- * const element = () => multiline() ? 'textarea' : 'input';
- * createDynamic(element, { value: value() });
+ * const User = dynamic(() => getUserComp(props.id));
+ * return <User>client content</User>;
  * ```
+ *
  * @description https://docs.solidjs.com/reference/components/dynamic
  */
-export declare function createDynamic<T extends ValidComponent>(component: () => T | undefined, props: ComponentProps<T>): JSX.Element;
+export declare function dynamic<T extends ValidComponent>(source: () => T | Promise<T> | null | undefined | false): Component<ComponentProps<T>>;
 /**
  * Renders an arbitrary custom or native component and passes the other props
  * ```typescript

package/storage/types-cjs/src/server-mock.d.cts

@@ -1,3 +1,18 @@
+/**
+ * Renders a component tree synchronously to an HTML string. Async reads inside
+ * `<Loading>` boundaries emit their `fallback` content; for full-graph
+ * resolution use `renderToStringAsync` instead.
+ *
+ * Pair the returned HTML with `hydrate()` on the client.
+ *
+ * @example
+ * ```tsx
+ * import { renderToString } from "@solidjs/web";
+ *
+ * const html = renderToString(() => <App />);
+ * res.send(`<!doctype html><html><body><div id="root">${html}</div></body></html>`);
+ * ```
+ */
 export declare function renderToString<T>(fn: () => T, options?: {
     nonce?: string;
     renderId?: string;
@@ -12,6 +27,21 @@ export declare function renderToString<T>(fn: () => T, options?: {
     }>;
     onError?: (err: any) => void;
 }): string;
+/**
+ * Renders a component tree to an HTML string and awaits all async reads in the
+ * subtree before resolving. The returned HTML reflects the fully-settled state
+ * — no `<Loading>` fallbacks appear in the output.
+ *
+ * Use this when you want a complete page in one round-trip. For incremental
+ * streaming with progressive boundary resolution, use `renderToStream`.
+ *
+ * @example
+ * ```tsx
+ * import { renderToStringAsync } from "@solidjs/web";
+ *
+ * const html = await renderToStringAsync(() => <App />);
+ * ```
+ */
 export declare function renderToStringAsync<T>(fn: () => T, options?: {
     timeoutMs?: number;
     nonce?: string;
@@ -27,6 +57,25 @@ export declare function renderToStringAsync<T>(fn: () => T, options?: {
     }>;
     onError?: (err: any) => void;
 }): Promise<string>;
+/**
+ * Streams an HTML response, flushing the synchronous shell first and then
+ * progressively emitting async-resolved fragments as their `<Loading>`
+ * boundaries settle. Good for time-to-first-byte sensitive pages.
+ *
+ * Returns an object with `pipe`/`pipeTo` for piping to a Node `Writable` or
+ * a Web `WritableStream`, plus a `then` for awaiting full completion.
+ *
+ * @example
+ * ```tsx
+ * import { renderToStream } from "@solidjs/web";
+ *
+ * // Node:
+ * renderToStream(() => <App />).pipe(res);
+ *
+ * // Web (Workers / Deno):
+ * await renderToStream(() => <App />).pipeTo(stream.writable);
+ * ```
+ */
 export declare function renderToStream<T>(fn: () => T, options?: {
     nonce?: string;
     renderId?: string;
@@ -54,19 +103,27 @@ export declare function renderToStream<T>(fn: () => T, options?: {
     }) => void;
     pipeTo: (writable: WritableStream) => Promise<void>;
 };
+/** Compiler primitive — emitted by JSX-DOM-Expressions for tagged-template SSR output. Not meant for hand-written code. */
 export declare function ssr(template: string[] | string, ...nodes: any[]): {
     t: string;
 };
+/** Compiler primitive — emitted by JSX-DOM-Expressions for SSR element output. Not meant for hand-written code. */
 export declare function ssrElement(name: string, props: any, children: any, needsId: boolean): {
     t: string;
 };
+/** Compiler primitive — serializes a classList object for SSR output. Not meant for hand-written code. */
 export declare function ssrClassList(value: {
     [k: string]: boolean;
 }): string;
+/** Compiler primitive — serializes a style object for SSR output. Not meant for hand-written code. */
 export declare function ssrStyle(value: {
     [k: string]: string;
 }): string;
+/** Compiler primitive — serializes a boolean attribute for SSR output. Not meant for hand-written code. */
 export declare function ssrAttribute(key: string, value: boolean): string;
+/** Compiler primitive — generates the hydration-key attribute for SSR output. Not meant for hand-written code. */
 export declare function ssrHydrationKey(): string;
+/** Compiler primitive — collapses an SSR-shaped node into its HTML string. Not meant for hand-written code. */
 export declare function resolveSSRNode(node: any): string;
+/** Escapes a string for safe inclusion in HTML output. Useful when constructing SSR fragments by hand. */
 export declare function escape(html: string): string;

package/types/client.d.ts

@@ -5,6 +5,8 @@ export const DelegatedEvents: Set<string>;
 export const DOMElements: Set<string>;
 export const SVGElements: Set<string>;
 export const MathMLElements: Set<string>;
+export const VoidElements: Set<string>;
+export const RawTextElements: Set<string>;
 export const Namespaces: Record<string, string>;
 
 type MountableElement = Element | Document | ShadowRoot | DocumentFragment | Node;

package/types/core.d.ts

@@ -1,3 +1,3 @@
 export { getOwner, runWithOwner, createComponent, createRoot as root, sharedConfig, untrack, merge as mergeProps, flatten, ssrHandleError, ssrRunInScope } from "solid-js";
 export declare const effect: (fn: any, effectFn: any, options: any) => void;
-export declare const memo: (fn: any, transparent: any) => any;
+export declare const memo: (fn: any) => import("solid-js").Accessor<any>;

package/types/index.d.ts

@@ -1,5 +1,5 @@
 import { hydrate as hydrateCore } from "./client.js";
-import { JSX, ComponentProps, ValidComponent } from "solid-js";
+import { JSX, Component, ComponentProps, ValidComponent } from "solid-js";
 export * from "./client.js";
 export * from "./server-mock.js";
 export { For, Show, Switch, Match, Errored, Loading, Repeat, Reveal, NoHydration, Hydration, merge as mergeProps } from "solid-js";
@@ -9,27 +9,70 @@ type MountableElement = Element | Document | ShadowRoot | DocumentFragment | Nod
 export type DynamicProps<T extends ValidComponent, P = ComponentProps<T>> = {
     [K in keyof P]: P[K];
 } & {
-    component: T | undefined;
+    component: T | null | undefined | false;
 };
 /**
- * Renders a component tree into a DOM element and returns a dispose function.
- *
- * The top-level insert runs with `schedule: true` so its initial DOM attach
- * goes through the effect queue rather than executing inline. This lets the
- * mount participate in transitions: if an uncaught async read surfaces during
- * the initial render (no `Loading` ancestor absorbs it), the mount is held by
- * the transition and attaches atomically once all pending settles. On the
- * no-async happy path the tail `flush()` drains the queued callback so the
- * attach is synchronous by the time `render()` returns.
+ * Renders a component tree into a DOM element. Returns a dispose function
+ * that tears the tree down and cleans up reactive scopes when called.
+ *
+ * @example
+ * ```tsx
+ * import { render } from "@solidjs/web";
+ *
+ * const dispose = render(() => <App />, document.getElementById("root")!);
+ *
+ * // Later, to unmount:
+ * dispose();
+ * ```
+ *
+ * @remarks
+ * The top-level insert is queued via `insertOptions: { schedule: true }` so
+ * its initial DOM attach goes through the effect queue rather than executing
+ * inline. This lets the mount participate in transitions: if an uncaught
+ * async read surfaces during the initial render (no `Loading` ancestor
+ * absorbs it), the mount is held by the transition and attaches atomically
+ * once all pending settles. On the no-async happy path the tail `flush()`
+ * drains the queued callback so the attach is synchronous by the time
+ * `render()` returns. The dev enforcement window scopes
+ * `ASYNC_OUTSIDE_LOADING_BOUNDARY` to the initial mount only.
  */
 export declare function render(code: () => JSX.Element, element: MountableElement, init?: unknown, options?: {
     renderId?: string;
 }): () => void;
+/**
+ * Resumes a server-rendered tree on the client, attaching event listeners
+ * and reactive bindings without reconstructing the DOM. Returns a `dispose`
+ * function that tears down reactive scopes (DOM nodes are left in place).
+ *
+ * Use this when the page HTML was produced by `renderToString`,
+ * `renderToStringAsync`, or `renderToStream`. For client-only apps, use
+ * `render` instead.
+ *
+ * Pass `options.renderId` to hydrate one of multiple roots emitted by a
+ * server render that used the same id.
+ *
+ * @example
+ * ```tsx
+ * import { hydrate } from "@solidjs/web";
+ *
+ * hydrate(() => <App />, document.getElementById("root")!);
+ * ```
+ */
 export declare const hydrate: typeof hydrateCore;
 /**
- * Renders components somewhere else in the DOM
+ * Renders its children into a different part of the DOM (modal roots,
+ * tooltips, layers that need to escape an `overflow: hidden` ancestor).
  *
- * Useful for inserting modals and tooltips outside of an cropping layout. If no mount point is given, the portal is inserted in document.body; it is wrapped in a `<div>` unless the target is document.head or `isSVG` is true. setting `useShadow` to true places the element in a shadow root to isolate styles.
+ * If `mount` is omitted, the portal attaches to `document.body`. The portal
+ * still participates in the parent's reactive scope and disposes when the
+ * parent does.
+ *
+ * @example
+ * ```tsx
+ * <Portal mount={document.getElementById("modal-root")!}>
+ *   <Dialog />
+ * </Portal>
+ * ```
  *
  * @description https://docs.solidjs.com/reference/components/portal
  */
@@ -38,18 +81,24 @@ export declare function Portal<T extends boolean = false, S extends boolean = fa
     children: JSX.Element;
 }): Text;
 /**
- * Renders an arbitrary component or element with the given props
+ * Returns a stable `Component` whose identity is driven by a reactive (and
+ * optionally async) `source`. The returned component can be used anywhere a
+ * normal component is used; children and props flow through JSX as usual.
+ *
+ * `source` may return a component, a native tag name (`'input'`, `'textarea'`,
+ * etc.), `undefined`, or a `Promise` of any of the above. A pending promise
+ * propagates as `NotReadyError` through the surrounding reactive scope, so
+ * async swaps compose with `Loading`/Suspense boundaries the same way as
+ * `lazy`.
  *
- * This is a lower level version of the `Dynamic` component, useful for
- * performance optimizations in libraries. Do not use this unless you know
- * what you are doing.
  * ```typescript
- * const element = () => multiline() ? 'textarea' : 'input';
- * createDynamic(element, { value: value() });
+ * const User = dynamic(() => getUserComp(props.id));
+ * return <User>client content</User>;
  * ```
+ *
  * @description https://docs.solidjs.com/reference/components/dynamic
  */
-export declare function createDynamic<T extends ValidComponent>(component: () => T | undefined, props: ComponentProps<T>): JSX.Element;
+export declare function dynamic<T extends ValidComponent>(source: () => T | Promise<T> | null | undefined | false): Component<ComponentProps<T>>;
 /**
  * Renders an arbitrary custom or native component and passes the other props
  * ```typescript

package/types/server-mock.d.ts

@@ -1,3 +1,18 @@
+/**
+ * Renders a component tree synchronously to an HTML string. Async reads inside
+ * `<Loading>` boundaries emit their `fallback` content; for full-graph
+ * resolution use `renderToStringAsync` instead.
+ *
+ * Pair the returned HTML with `hydrate()` on the client.
+ *
+ * @example
+ * ```tsx
+ * import { renderToString } from "@solidjs/web";
+ *
+ * const html = renderToString(() => <App />);
+ * res.send(`<!doctype html><html><body><div id="root">${html}</div></body></html>`);
+ * ```
+ */
 export declare function renderToString<T>(fn: () => T, options?: {
     nonce?: string;
     renderId?: string;
@@ -12,6 +27,21 @@ export declare function renderToString<T>(fn: () => T, options?: {
     }>;
     onError?: (err: any) => void;
 }): string;
+/**
+ * Renders a component tree to an HTML string and awaits all async reads in the
+ * subtree before resolving. The returned HTML reflects the fully-settled state
+ * — no `<Loading>` fallbacks appear in the output.
+ *
+ * Use this when you want a complete page in one round-trip. For incremental
+ * streaming with progressive boundary resolution, use `renderToStream`.
+ *
+ * @example
+ * ```tsx
+ * import { renderToStringAsync } from "@solidjs/web";
+ *
+ * const html = await renderToStringAsync(() => <App />);
+ * ```
+ */
 export declare function renderToStringAsync<T>(fn: () => T, options?: {
     timeoutMs?: number;
     nonce?: string;
@@ -27,6 +57,25 @@ export declare function renderToStringAsync<T>(fn: () => T, options?: {
     }>;
     onError?: (err: any) => void;
 }): Promise<string>;
+/**
+ * Streams an HTML response, flushing the synchronous shell first and then
+ * progressively emitting async-resolved fragments as their `<Loading>`
+ * boundaries settle. Good for time-to-first-byte sensitive pages.
+ *
+ * Returns an object with `pipe`/`pipeTo` for piping to a Node `Writable` or
+ * a Web `WritableStream`, plus a `then` for awaiting full completion.
+ *
+ * @example
+ * ```tsx
+ * import { renderToStream } from "@solidjs/web";
+ *
+ * // Node:
+ * renderToStream(() => <App />).pipe(res);
+ *
+ * // Web (Workers / Deno):
+ * await renderToStream(() => <App />).pipeTo(stream.writable);
+ * ```
+ */
 export declare function renderToStream<T>(fn: () => T, options?: {
     nonce?: string;
     renderId?: string;
@@ -54,19 +103,27 @@ export declare function renderToStream<T>(fn: () => T, options?: {
     }) => void;
     pipeTo: (writable: WritableStream) => Promise<void>;
 };
+/** Compiler primitive — emitted by JSX-DOM-Expressions for tagged-template SSR output. Not meant for hand-written code. */
 export declare function ssr(template: string[] | string, ...nodes: any[]): {
     t: string;
 };
+/** Compiler primitive — emitted by JSX-DOM-Expressions for SSR element output. Not meant for hand-written code. */
 export declare function ssrElement(name: string, props: any, children: any, needsId: boolean): {
     t: string;
 };
+/** Compiler primitive — serializes a classList object for SSR output. Not meant for hand-written code. */
 export declare function ssrClassList(value: {
     [k: string]: boolean;
 }): string;
+/** Compiler primitive — serializes a style object for SSR output. Not meant for hand-written code. */
 export declare function ssrStyle(value: {
     [k: string]: string;
 }): string;
+/** Compiler primitive — serializes a boolean attribute for SSR output. Not meant for hand-written code. */
 export declare function ssrAttribute(key: string, value: boolean): string;
+/** Compiler primitive — generates the hydration-key attribute for SSR output. Not meant for hand-written code. */
 export declare function ssrHydrationKey(): string;
+/** Compiler primitive — collapses an SSR-shaped node into its HTML string. Not meant for hand-written code. */
 export declare function resolveSSRNode(node: any): string;
+/** Escapes a string for safe inclusion in HTML output. Useful when constructing SSR fragments by hand. */
 export declare function escape(html: string): string;