update docs for accuracy

Author: LadyBluenotes

public/llms.txt

@@ -71,6 +71,7 @@
 - [<Suspense>](https://docs.solidjs.com/reference/components/suspense)
 - [<SuspenseList>](https://docs.solidjs.com/reference/components/suspense-list)
 - [<Switch> / <Match>](https://docs.solidjs.com/reference/components/switch-and-match)
+- [createDynamic](https://docs.solidjs.com/reference/components/create-dynamic)
 - [@once](https://docs.solidjs.com/reference/jsx-attributes/once)
 - [attr:*](https://docs.solidjs.com/reference/jsx-attributes/attr)
 - [bool:*](https://docs.solidjs.com/reference/jsx-attributes/bool)

src/routes/reference/component-apis/create-unique-id.mdx

@@ -11,12 +11,11 @@ tags:
   - utilities
 version: "1.0"
 description: >-
-  Generate unique IDs that are stable across server and client with
-  createUniqueId. Essential for accessible forms and SSR-compatible components.
+  Generate a unique string for the current render or hydration context.
 ---
 
-The `createUniqueId` function generates a unique ID that remains consistent across both server and client renders.
-It is commonly used with HTML `id` and `for` attributes to ensure stable hydration.
+`createUniqueId` generates a unique string for the current render or hydration context.
+During hydration, matching server and client call order produces matching IDs.
 
 `createUniqueId` does _not_ generate a cryptographically secure ID and is not suitable for security-sensitive data.
 Additionally, it should not be used in scenarios that require uniqueness across a distributed system.
@@ -48,6 +47,11 @@ This function does not take any parameters.
 
 `createUniqueId` returns a unique `string` that is stable across server and client renders.
 
+## Behavior
+
+- During hydration, IDs come from the current hydration context, so matching call order produces matching server and client IDs.
+- Outside hydration context, client-side IDs use a local counter and are unique only within the current Solid runtime instance.
+
 ## Examples
 
 ### Basic Usage
@@ -57,9 +61,17 @@ import { createUniqueId } from "solid-js";
 
 type InputProps = {
 	id?: string;
+	label: string;
 };
 
 function Input(props: InputProps) {
-	return <input id={props.id ?? createUniqueId()} />;
+	const inputId = props.id ?? createUniqueId();
+
+	return (
+		<>
+			<label for={inputId}>{props.label}</label>
+			<input id={inputId} />
+		</>
+	);
 }
 ```

src/routes/reference/component-apis/lazy.mdx

@@ -12,12 +12,11 @@ tags:
   - imports
 version: "1.0"
 description: >-
-  Lazy load components with code splitting to reduce bundle size and improve
-  performance. Components load on-demand and integrate with Suspense.
+  Create a component that loads its module lazily from a dynamic import.
 ---
 
-The `lazy` helper wraps a dynamic import and returns a component that loads on demand.
-Lazy components accept the same props as their eager counterparts and integrate with `<Suspense>` boundaries.
+`lazy` wraps a dynamic import and returns a component that loads its module on demand.
+The returned component accepts the same props as the loaded component and exposes `preload()`.
 
 ## Import
 
@@ -27,10 +26,10 @@ import { lazy } from "solid-js";
 
 ## Type
 
-```tsx
+```ts
 function lazy<T extends Component<any>>(
 	fn: () => Promise<{ default: T }>
-): T & { preload: () => Promise<T> };
+): T & { preload: () => Promise<{ default: T }> };
 ```
 
 ## Parameters
@@ -44,32 +43,42 @@ Dynamic import that resolves to the component module, exposing the component as
 
 ## Return value
 
-`lazy` returns a renderable component compatible with `T`.
-The component exposes a `preload()` method that resolves the underlying module.
+- **Type:** `T & { preload: () => Promise<{ default: T }> }`
+
+Returns a renderable component compatible with `T`.
+The returned component also exposes `preload()`.
+
+`preload()` starts loading the module without rendering the component and returns the resolved module.
 
-| Property  | Type               | Description                                                            |
-| --------- | ------------------ | ---------------------------------------------------------------------- |
-| `preload` | `() => Promise<T>` | Loads the module without rendering and returns the resolved component. |
+## Behavior
+
+- Rendering a lazy component starts loading its module if it has not already been loaded.
+- Inside a [`<Suspense>`](/reference/components/suspense) boundary, the boundary shows its fallback while the module is loading.
+- Without a suspense boundary, the lazy component renders an empty string until the module resolves.
+- `preload()` starts the same module request without rendering the component.
 
 ## Examples
 
 ### Basic usage
 
-```tsx title="app.tsx"
-import { lazy } from "solid-js";
+```tsx
+import { lazy, Suspense } from "solid-js";
 
 const ComponentA = lazy(() => import("./ComponentA"));
 
 function App(props: { title: string }) {
-	return <ComponentA title={props.title} />;
+	return (
+		<Suspense fallback={<p>Loading...</p>}>
+			<ComponentA title={props.title} />
+		</Suspense>
+	);
 }
 ```
 
 ### Preloading nested lazy components
 
 ```tsx
-import { lazy } from "solid-js";
-import type { Component } from "solid-js";
+import { createSignal, lazy, Show, Suspense } from "solid-js";
 
 const Nested = lazy(() => import("./Nested"));
 
@@ -85,14 +94,16 @@ const ComponentWithPreload = () => {
 				Preload Nested Component
 			</button>
 			<Show when={showNested()}>
-				<Nested />
+				<Suspense fallback={<p>Loading nested component...</p>}>
+					<Nested />
+				</Suspense>
 			</Show>
 		</div>
 	);
 };
 ```
 
-## See also
+## Related
 
-- [`Suspense`](https://docs.solidjs.com/reference/components/suspense)
+- [`Suspense`](/reference/components/suspense)
 - [Router preloading guide](/solid-router/advanced-concepts/preloading)

src/routes/reference/secondary-primitives/create-computed.mdx

@@ -11,12 +11,12 @@ tags:
   - tracking
 version: "1.0"
 description: >-
-  Create immediate reactive computations with createComputed. Build custom
-  primitives and handle side effects that respond to dependencies.
+  Create an immediate reactive computation that runs synchronously when created
+  and whenever its dependencies change.
 ---
 
-The `createComputed` function creates a reactive computation that runs _before_ the rendering phase.
-It is primarily used to synchronize state before rendering begins.
+`createComputed` creates an immediate reactive computation.
+It runs synchronously in the current execution context when created, then re-runs whenever its tracked dependencies change.
 
 ## Import
 
@@ -83,41 +83,39 @@ It is used for identification in debugging tools like the [Solid Debugger](https
 
 `createComputed` does not return a value.
 
+## Behavior
+
+- `createComputed` runs immediately when it is created.
+- It tracks reactive reads inside `fn` and re-runs synchronously when those dependencies change.
+- Unlike [`createMemo`](/reference/basic-reactivity/create-memo), it does not expose a derived accessor.
+- `createComputed` is primarily used to build reactive primitives. Application code that derives state usually wants [`createMemo`](/reference/basic-reactivity/create-memo) instead.
+
 ## Examples
 
-### Basic usage
+### Build a writable derived signal
 
 ```tsx
-import { createComputed } from "solid-js";
-import { createStore } from "solid-js/store";
+import { createComputed, createSignal } from "solid-js";
 
-type User = {
-	name?: string;
-};
+function createWritableMemo<T>(fn: () => T) {
+	const [value, setValue] = createSignal(fn());
 
-type UserEditorProps = {
-	user: User;
-};
-
-function UserEditor(props: UserEditorProps) {
-	const [formData, setFormData] = createStore<User>({
-		name: "",
-	});
-
-	// Update the store synchronously when props change.
-	// This prevents a second render cycle.
 	createComputed(() => {
-		setFormData("name", props.user.name);
+		setValue(fn());
 	});
 
+	return value;
+}
+
+function Counter() {
+	const [count, setCount] = createSignal(1);
+	const double = createWritableMemo(() => count() * 2);
+
 	return (
-		<form>
-			<h1>Editing: {formData.name}</h1>
-			<input
-				value={formData.name}
-				onInput={(e) => setFormData("name", e.currentTarget.value)}
-			/>
-		</form>
+		<>
+			<p>{double()}</p>
+			<button onClick={() => setCount((value) => value + 1)}>Increment</button>
+		</>
 	);
 }
 ```

src/routes/reference/server-utilities/get-request-event.mdx

@@ -23,10 +23,7 @@ import { getRequestEvent } from "solid-js/web";
 ## Type
 
 ```ts
-interface RequestEvent {
-	request: Request;
-	locals?: Record<string | number | symbol, any>;
-}
+import type { RequestEvent } from "solid-js/web";
 
 function getRequestEvent(): RequestEvent | undefined;
 ```
@@ -38,7 +35,8 @@ function getRequestEvent(): RequestEvent | undefined;
 ## Behavior
 
 - `getRequestEvent` is for managed server/request scope.
-- When available, the returned event includes the current `Request`. In the server type, it also includes `locals`.
+- When available, the returned event includes the current `Request` as `event.request`.
+- Depending on the server integration, the event can also expose request-scoped fields such as `response`, `locals`, or router state.
 - If no current request event is available, including outside managed async scope, `getRequestEvent` returns `undefined`.
 
 ## Examples
@@ -48,9 +46,11 @@ function getRequestEvent(): RequestEvent | undefined;
 ```ts
 import { getRequestEvent } from "solid-js/web";
 
-const event = getRequestEvent();
+function readAuthorizationHeader() {
+	const event = getRequestEvent();
 
-if (event) {
-	const auth = event.request.headers.get("Authorization");
+	return event?.request.headers.get("Authorization") ?? null;
 }
 ```
+
+This example reads the event during request-scoped server execution.