update docs for accuracy

Author: LadyBluenotes

src/routes/reference/reactive-utilities/from.mdx

@@ -61,39 +61,55 @@ Returns an accessor backed by the external source.
 
 ## Behavior
 
+- `from` subscribes to the producer immediately when it runs.
 - A producer function receives a Solid setter and returns a cleanup function.
 - A subscribable source must expose `subscribe()`, and that subscription may return either a cleanup function or an object with `unsubscribe()`.
 - Emitted values are not deduplicated by equality.
-- Returned subscriptions are cleaned up with the current Solid owner when one exists.
+- Cleanup is registered on the current Solid owner when one exists.
+- When `from` runs without an owner, the subscription still starts but is not cleaned up automatically.
 - When `initialValue` is omitted, the accessor can return `undefined`.
 
 ## Examples
 
 ### Create an accessor from a subscribable source
 
-```ts
+```tsx
 import { from } from "solid-js";
 
-const counter = from({
-	subscribe(next) {
-		const interval = setInterval(() => next(Date.now()), 1000);
-		return () => clearInterval(interval);
-	},
-});
+function Clock() {
+	const time = from(
+		{
+			subscribe(next) {
+				const interval = setInterval(
+					() => next(new Date().toLocaleTimeString()),
+					1000
+				);
+				return () => clearInterval(interval);
+			},
+		},
+		""
+	);
+
+	return <div>{time()}</div>;
+}
 ```
 
 ### Create an accessor from a producer function
 
-```ts
+```tsx
 import { from } from "solid-js";
 
-const clock = from((set) => {
-	const interval = setInterval(() => {
-		set((value) => value + 1);
-	}, 1000);
+function Counter() {
+	const count = from((set) => {
+		const interval = setInterval(() => {
+			set((value = 0) => value + 1);
+		}, 1000);
+
+		return () => clearInterval(interval);
+	}, 0);
 
-	return () => clearInterval(interval);
-}, 0);
+	return <div>{count()}</div>;
+}
 ```
 
 ## Related

src/routes/reference/reactive-utilities/get-owner.mdx

@@ -30,7 +30,7 @@ type Owner = unknown;
 function getOwner(): Owner | null;
 ```
 
-The concrete owner shape is internal and is primarily useful with [`runWithOwner`](/reference/reactive-utilities/run-with-owner).
+The `Owner` interface is public, but its concrete shape is mostly useful for advanced interop such as [`runWithOwner`](/reference/reactive-utilities/run-with-owner).
 
 ## Parameters
 
@@ -47,25 +47,29 @@ Returns the current owner or `null` when no owner is active.
 - `getOwner` returns the current owner and does not create or modify ownership.
 - Owners determine cleanup and context lookup for descendant computations.
 - A computation created inside the current scope becomes part of the current owner tree unless ownership is overridden.
-- Components are not computations and do not create owner nodes themselves.
+- Component functions run under an owner created for that subtree.
 - Calling `getOwner` inside component code returns the owner responsible for rendering and disposing that component subtree.
 - Turning off tracking with [`untrack`](/reference/reactive-utilities/untrack) does not create a new owner.
 
 ## Examples
 
 ### Capture an owner for later use
 
-```ts
+```tsx
 import { getOwner, runWithOwner } from "solid-js";
 
-const owner = getOwner();
+function Example() {
+	const owner = getOwner();
 
-if (owner) {
 	queueMicrotask(() => {
-		runWithOwner(owner, () => {
-			console.log("owner restored");
-		});
+		if (owner) {
+			runWithOwner(owner, () => {
+				console.log("owner restored");
+			});
+		}
 	});
+
+	return null;
 }
 ```
 

src/routes/reference/reactive-utilities/merge-props.mdx

@@ -45,6 +45,7 @@ Returns a merged object with lazy reactive property resolution across the provid
 
 ## Behavior
 
+- `mergeProps` is shallow.
 - The last source with a non-`undefined` value for a property wins.
 - Function sources are wrapped so property reads stay reactive.
 - When reactive proxies are involved, the merged result uses proxy-backed property resolution.
@@ -54,17 +55,18 @@ Returns a merged object with lazy reactive property resolution across the provid
 
 ### Basic usage
 
-```ts
+```tsx
 import { mergeProps } from "solid-js";
 
-// default props
-props = mergeProps({ name: "Smith" }, props);
-
-// clone props
-newProps = mergeProps(props);
+function Greeting(props) {
+	const merged = mergeProps({ greeting: "Hello", name: "Smith" }, props);
 
-// merge props
-props = mergeProps(props, otherProps);
+	return (
+		<div>
+			{merged.greeting} {merged.name}
+		</div>
+	);
+}
 ```
 
 ## Related

src/routes/reference/reactive-utilities/run-with-owner.mdx

@@ -58,32 +58,33 @@ Returns the value produced by `fn`, or `undefined` when an error is routed throu
 
 - During the synchronous execution of `fn`, `runWithOwner` restores the provided owner for cleanup, context lookup, and descendant computations created inside `fn`.
 - `runWithOwner` does not restore dependency tracking because the current tracking listener is cleared while `fn` runs.
-- Code after the first `await` in an `async` function runs without reactive dependency tracking.
+- Code after the first `await` in an `async` function runs without the restored owner or reactive dependency tracking.
 
 ## Examples
 
 ### Restore an owner in a callback
 
-```ts
-import { createEffect, getOwner, runWithOwner, useContext } from "solid-js";
-
-const owner = getOwner();
+```tsx
+import { createEffect, getOwner, runWithOwner } from "solid-js";
 
-if (owner) {
-	setTimeout(() => {
-		runWithOwner(owner, () => {
-			const value = useContext(FooContext);
+function Example() {
+	const owner = getOwner();
 
-			createEffect(() => {
-				console.log(value);
+	queueMicrotask(() => {
+		if (owner) {
+			runWithOwner(owner, () => {
+				createEffect(() => {
+					console.log("effect created under the captured owner");
+				});
 			});
-		});
-	}, 1000);
+		}
+	});
+
+	return null;
 }
 ```
 
 ## Related
 
 - [`getOwner`](/reference/reactive-utilities/get-owner)
-- [`useContext`](/reference/component-apis/use-context)
 - [`onCleanup`](/reference/lifecycle/on-cleanup)

src/routes/reference/reactive-utilities/split-props.mdx

@@ -26,10 +26,10 @@ import { splitProps } from "solid-js";
 ## Type
 
 ```ts
-function splitProps<T extends Record<string, unknown>>(
-	props: T,
-	...keys: (readonly (keyof T)[])[]
-): SplitProps<T, typeof keys>;
+function splitProps<
+	T extends Record<any, any>,
+	K extends [readonly (keyof T)[], ...(readonly (keyof T)[])[]],
+>(props: T, ...keys: K): SplitProps<T, K>;
 ```
 
 ## Parameters
@@ -58,6 +58,7 @@ Returns a tuple of reactive subsets followed by a reactive remainder object.
 - A key is assigned to the first matching group only.
 - The last returned object contains keys not included in the provided key arrays.
 - When the source props object is proxy-backed, the returned objects use proxy-backed property access.
+- `splitProps` separates props into groups without destructuring them into non-reactive locals.
 
 ## Examples
 

src/routes/reference/reactive-utilities/start-transition.mdx

@@ -46,7 +46,8 @@ Resolves when the transition completes.
 
 ## Behavior
 
-- Updates scheduled inside `fn` run as a transition. Nested calls inside an active transition reuse that transition and return its existing promise, which resolves after transition work completes.
+- On the client, `fn` runs asynchronously in a microtask and its updates run as a transition.
+- Nested calls inside an active transition reuse that transition and return its existing promise, which resolves after transition work completes.
 - On the server, `startTransition(fn)` runs `fn()` synchronously.
 - `startTransition` is the transition-starting function exposed by [`useTransition`](/reference/reactive-utilities/use-transition), without the `pending` accessor.
 
@@ -55,18 +56,34 @@ Resolves when the transition completes.
 ### Basic usage
 
 ```tsx
-import { createSignal, startTransition } from "solid-js";
+import {
+	Suspense,
+	createResource,
+	createSignal,
+	startTransition,
+} from "solid-js";
 
 function Example() {
-	const [value, setValue] = createSignal("");
+	const [userId, setUserId] = createSignal(1);
+	const [user] = createResource(userId, async (id) => {
+		const response = await fetch(`/api/users/${id}`);
+		return response.json();
+	});
 
-	async function update(next: string) {
+	async function showNextUser() {
 		await startTransition(() => {
-			setValue(next);
+			setUserId(2);
 		});
 	}
 
-	return <button onClick={() => update("next")}>{value()}</button>;
+	return (
+		<>
+			<button onClick={showNextUser}>Load next user</button>
+			<Suspense fallback={<p>Loading user...</p>}>
+				<pre>{JSON.stringify(user(), null, 2)}</pre>
+			</Suspense>
+		</>
+	);
 }
 ```
 

src/routes/reference/reactive-utilities/untrack.mdx

@@ -48,19 +48,24 @@ Returns the value produced by `fn` unchanged.
 ## Behavior
 
 - `untrack` only affects reads inside the provided function. Signals read there do not become dependencies of the surrounding computation.
-- On the server, `untrack` runs through the server runtime's `batch` implementation.
+- `untrack` does not create or restore an owner.
 
 ## Examples
 
-### Read a prop without tracking
+### Read part of an effect without tracking
 
 ```tsx
-import { untrack } from "solid-js";
+import { createEffect, untrack } from "solid-js";
 
 export function Component(props) {
-	const value = untrack(() => props.value);
+	createEffect(() => {
+		console.log(
+			props.id,
+			untrack(() => props.label)
+		);
+	});
 
-	return <div>{value}</div>;
+	return <div>{props.id}</div>;
 }
 ```
 
@@ -86,8 +91,7 @@ function Example() {
 
 ## Notes
 
-Default and initial prop values can be read directly when initializing a signal.
-This pattern commonly appears with names such as `initialName` and `defaultName`.
+Default and initial prop values can be read directly when initializing a signal. This pattern commonly appears with names such as `initialName` and `defaultName`.
 
 ```tsx tab title="initialValue" {5}
 import { createSignal } from "solid-js";

src/routes/reference/reactive-utilities/use-transition.mdx

@@ -48,6 +48,7 @@ Returns a tuple containing:
 ## Behavior
 
 - `start` is the same transition-starting function exposed by [`startTransition`](/reference/reactive-utilities/start-transition).
+- On the client, `start` schedules its callback asynchronously in a microtask.
 - `pending()` reflects whether that transition is still pending.
 - Transition state integrates with Suspense and resource reads under Suspense boundaries.
 - On the server, `pending()` is `false` and transitions run synchronously.
@@ -57,22 +58,34 @@ Returns a tuple containing:
 ### Basic usage
 
 ```tsx
-import { createSignal, useTransition } from "solid-js";
+import {
+	Suspense,
+	createResource,
+	createSignal,
+	useTransition,
+} from "solid-js";
 
 function Example() {
-	const [value, setValue] = createSignal("");
+	const [userId, setUserId] = createSignal(1);
+	const [user] = createResource(userId, async (id) => {
+		const response = await fetch(`/api/users/${id}`);
+		return response.json();
+	});
 	const [pending, start] = useTransition();
 
 	return (
 		<>
 			<button
 				onClick={async () => {
-					await start(() => setValue("next"));
+					await start(() => setUserId(2));
 				}}
 			>
-				Update
+				Load next user
 			</button>
-			<div>{pending() ? "pending" : value()}</div>
+			<div>{pending() ? "Loading transition..." : "Ready"}</div>
+			<Suspense fallback={<p>Loading user...</p>}>
+				<pre>{JSON.stringify(user(), null, 2)}</pre>
+			</Suspense>
 		</>
 	);
 }