migrate store creation and mutable store refs

Author: LadyBluenotes

src/routes/reference/store-utilities/produce.mdx

@@ -1,50 +1,73 @@
 ---
 title: produce
 use_cases: >-
-  immutable updates, immer-style mutations, store modifications, complex state
-  changes, nested updates
+  store updates, nested store changes, draft-style mutations
 tags:
   - store
-  - immutable
   - updates
-  - immer
   - mutations
 version: "1.0"
 description: >-
-  Use Immer-inspired produce API to mutate Solid stores immutably. Simplify
-  complex nested updates with familiar mutation syntax.
+  Create a store modifier that applies changes by mutating a draft value.
 ---
 
-`produce` is an [Immer](https://immerjs.github.io/immer/) inspired API for Solid's Store objects that allows the store to be mutated inside the `produce` function.
+`produce` creates a store modifier that applies changes by mutating a draft value.
+
+## Import
 
 ```ts
 import { produce } from "solid-js/store";
-import type { NotWrappable, Store } from "solid-js/store";
+```
+
+## Type
 
-function produce<T>(
-	fn: (state: T) => void
-): (
-	state: T extends NotWrappable ? T : Store<T>
-) => T extends NotWrappable ? T : Store<T>;
+```ts
+function produce<T>(fn: (state: T) => void): (state: T) => T;
 ```
 
-For use with `createStore`:
+## Parameters
+
+### `fn`
+
+- **Type:** `(state: T) => void`
+
+Function that mutates the provided draft state.
+
+## Return value
+
+- **Type:** `(state: T) => T`
+
+Store modifier function.
+
+## Behavior
+
+- `produce` returns a function that can be passed to store setters or [`modifyMutable`](/reference/store-utilities/modify-mutable).
+- The modifier receives a mutable draft of the current state.
+- Nested properties can be changed inside the modifier.
+
+## Examples
+
+### Basic usage
 
 ```tsx
-import { produce } from "solid-js/store";
+import { createStore, produce } from "solid-js/store";
 
 const [state, setState] = createStore({
 	user: {
 		name: "John",
-		age: 30,
 	},
-	list: ["book", "pen"],
+	list: ["book"],
 });
 
 setState(
 	produce((state) => {
 		state.user.name = "Jane";
-		state.list.push("pencil");
+		state.list.push("pen");
 	})
 );
 ```
+
+## Related
+
+- [`modifyMutable`](/reference/store-utilities/modify-mutable)
+- [`reconcile`](/reference/store-utilities/reconcile)

src/routes/reference/store-utilities/reconcile.mdx

@@ -1,58 +1,83 @@
 ---
 title: reconcile
 use_cases: >-
-  api responses, data synchronization, immutable data diffing, observable
-  subscriptions, large data updates
+  syncing store state, applying immutable data updates, diffing incoming data
 tags:
   - store
   - diffing
-  - api
   - synchronization
-  - immutable
 version: "1.0"
 description: >-
-  Efficiently diff and merge data changes with reconcile. Perfect for syncing
-  API responses or handling immutable data updates.
+  Create a store modifier that reconciles existing state with a new value.
 ---
 
-`reconcile` is designed for diffing data changes in situations where granular updates cannot be applied.
-This is useful when dealing with immutable data from stores or handling large API responses.
+`reconcile` creates a store modifier that reconciles existing state with a new value.
 
-```tsx
+## Import
+
+```ts
 import { reconcile } from "solid-js/store";
-import type { NotWrappable, Store } from "solid-js/store";
+```
 
-function reconcile<T>(
-	value: T | Store<T>,
+## Type
+
+```ts
+function reconcile<T extends U, U>(
+	value: T,
 	options?: {
 		key?: string | null;
 		merge?: boolean;
-	} = { key: "id" }
-): (
-	state: T extends NotWrappable ? T : Store<T>
-) => T extends NotWrappable ? T : Store<T>;
+	}
+): (state: U) => T;
 ```
 
-`reconcile` has a `key` option that can be used when available to match items.
-The `value` accepts either a value of type `T` or a Store containing values of type `T`.
-This represents the data to be reconciled.
+## Parameters
+
+### `value`
+
+- **Type:** `T`
+
+New value to reconcile against the current state.
+
+### `options`
+
+#### `key`
+
+- **Type:** `string | null`
 
-The `reconcile` function helps manage data changes by performing a diffing process, making it particularly handy in scenarios where applying granular updates is challenging or inefficient.
+Key used to match items during reconciliation.
 
-The `key` and `merge` options provide flexibility to customize the reconciliation process based on specific needs.
+#### `merge`
+
+- **Type:** `boolean`
+
+Controls whether reconciliation pushes updates to the leaves instead of replacing non-matching branches.
+
+## Return value
+
+- **Type:** `(state: U) => T`
+
+Store modifier function.
+
+## Behavior
+
+- `reconcile` performs a diff between the current state and `value`.
+- With the default `key`, array items are matched by `"id"`.
+- When `merge` is `false`, non-matching branches can be replaced.
+- When `merge` is `true`, reconciliation pushes updates deeper into the structure.
+
+## Examples
+
+### Basic usage
 
 ```ts
-// subscribing to an observable
-const unsubscribe = store.subscribe(({ todos }) => (
-  setState('todos', reconcile(todos));
-);
-onCleanup(() => unsubscribe());
+import { createStore, reconcile } from "solid-js/store";
+
+const [state, setState] = createStore({ todos: [] });
 
+setState("todos", reconcile([{ id: 1, title: "Write docs" }]));
 ```
 
-##### Options
+## Related
 
-| Option | Type    | Default | Description                                                                                                                                                                                                                                                            |
-| ------ | ------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| key    | string  | "id"    | Specifies the key to be used for matching items during reconciliation                                                                                                                                                                                                  |
-| merge  | boolean | false   | When merge is false, referential checks are performed where possible to determine equality, and items that are not referentially equal are replaced. When merge is true, all diffing is pushed to the leaves, effectively morphing the previous data to the new value. |
+- [`produce`](/reference/store-utilities/produce)

src/routes/reference/store-utilities/unwrap.mdx

@@ -1,25 +1,61 @@
 ---
 title: unwrap
 use_cases: >-
-  raw data access, proxy removal, debugging, third-party integration, data
-  serialization
+  reading store data without proxies, passing plain data to other APIs
 tags:
   - store
   - proxy
   - data
-  - debugging
-  - utilities
 version: "1.0"
 description: >-
-  Extract raw data from Solid stores without proxy wrapping. Essential for
-  debugging, serialization, or third-party integrations.
+  Remove store proxy wrapping from a store or store subtree.
 ---
 
-`unwrap` returns the underlying data in the store without a proxy.
+`unwrap` removes store proxy wrapping from a store or store subtree.
 
-```tsx
+## Import
+
+```ts
 import { unwrap } from "solid-js/store";
-import type { Store } from "solid-js/store";
+```
+
+## Type
 
-function unwrap(store: Store<T>): T;
+```ts
+function unwrap<T>(item: T): T;
 ```
+
+## Parameters
+
+### `item`
+
+- **Type:** `T`
+
+Store value or store subtree to unwrap.
+
+## Return value
+
+- **Type:** `T`
+
+Unwrapped value.
+
+## Behavior
+
+- Store proxies are removed recursively from returned objects and arrays.
+- Returned objects and arrays are plain values rather than reactive store proxies.
+- Non-proxy input values are returned unchanged.
+
+## Examples
+
+### Basic usage
+
+```ts
+import { createStore, unwrap } from "solid-js/store";
+
+const [state] = createStore({ user: { name: "John" } });
+const user = unwrap(state.user);
+```
+
+## Related
+
+- [`createStore`](/reference/store-utilities/create-store)