orchestore 0.1.8 → 0.1.9

package/README.md

@@ -25,9 +25,9 @@ Stay tuned for updates.
 
 ## About
 
-> 🧩 A function-oriented state orchestration architecture built on top of Redux Toolkit.
+> 🧩 A function-oriented state orchestration architecture built on top of Redux Toolkit, inspired by Vuex.
 
-OrcheStore simplifies and automates common state management patterns in React, Redux Toolkit, and TypeScript applications by unifying state and behavior into directly callable runtime modules.
+OrcheStore brings a Vuex-inspired developer experience to React and Redux Toolkit applications by unifying state and behavior into directly callable runtime modules.
 
 Instead of distributing logic across reducers, actions, thunks, selectors, hooks, middleware, and utility files, OrcheStore organizes related functionality into cohesive slice modules.
 
@@ -35,133 +35,124 @@ The goal is simple:
 
 > ⚡ Spend less time wiring state management infrastructure and more time building application features.
 
-## Table of Contents
+## Installation
 
-- [Introduction](#orchestore)
-	- [Core Principles](#core-principles)
-	- [Why OrcheStore?](#why-orchestore)
-	- [Redux Toolkit Comparison](#redux-toolkit-comparison)
-	- [Architecture Overview](#architecture-overview)
-
-- [Quick Example](#quick-example)
-
-- [Slice Layers](#slice-layers)
-	- [name](#name)
-	- [state](#state)
-	- [Mutations](#mutations)
-	- [Methods](#methods)
-	- [Computed State (Planned)](#computed-state-planned)
-	- [Nested Slices](#nested-slices)
-		- [Reusing Slices](#reusing-slices)
-		- [Runtime Paths](#runtime-paths)
-
-- [State Access & Subscriptions](#state-access--subscriptions)
-	- [State Snapshots](#state-snapshots)
-	- [State Subscriptions](#state-subscriptions)
-	- [Draft State](#draft-state)
-
-- [Store Integration](#store-integration)
-	- [Creating the Store](#creating-the-store)
-	- [Store Provider](#store-provider)
-	- [Accessing Slices through Store](#accessing-slices-through-store)
-	- [Accessing Store from Slices](#accessing-store-from-slices)
-	- [Root Store Type Extension (Planned)](#root-store-type-extension-planned)
-
-- [Lineage & Clones](#lineage--clones)
-	- [Automatic Cloning](#automatic-cloning)
-	- [Manual Cloning](#manual-cloning)
-	- [Inspecting a Lineage](#inspecting-a-lineage)
-	- [Definition Type Checking](#definition-type-checking)
-
-- [Global Utilities](#global-utilities)
-	- [Accessing Global Utilities](#accessing-global-utilities)
-	- [Utilities Type Extension](#utilities-type-extension)
-	- [Providing Runtime Utilities](#providing-runtime-utilities)
-	- [Using Global Utilities in Slices](#using-global-utilities-in-slices)
-
-- [TypeScript Inference](#typescript-inference)
-
-- [Status](#status)
+With npm:
 
----
+```bash
+npm install orchestore
+```
 
-## Core Principles
+Or with Yarn:
 
-- Simplify state management architecture
-- Automate repetitive Redux patterns
-- Reduce infrastructure code
-- Centralize state and application logic
-- Provide direct and intuitive APIs
-- Preserve predictable state transitions
-- Maintain strong TypeScript inference
-- Scale naturally through composition
+```bash
+yarn add orchestore
+```
 
-## Why OrcheStore?
+Or with pnpm:
 
-Redux Toolkit significantly improves the Redux developer experience, but many applications still require developers to coordinate logic across multiple concepts:
+```bash
+pnpm add orchestore
+```
+
+**Peer Dependencies**
 
-- reducers
-- action creators
-- thunks
-- selectors
-- middleware
-- hooks
-- utility functions
+OrcheStore requires:
 
-As applications grow, state management often becomes less about solving business problems and more about connecting infrastructure.
+* React 16.9+
+* React DOM 16.9+
 
-OrcheStore reduces that coordination overhead by exposing state management through unified slice modules.
+**Included Dependencies**
 
-A slice is more than a state container. It is a runtime module that can encapsulate:
+`@reduxjs/toolkit` and `react-redux` are installed automatically with OrcheStore.
 
-- state
-- computed state
-- mutations
-- methods
-- selectors
-- child slices
-- shared utilities
+## Table of Contents
 
-This allows state and application logic to evolve together within the same domain boundary.
+* [Introduction](#orchestore)
+  * [Installation](#installation)
+  * [Core Principles](#core-principles)
+  * [Why OrcheStore?](#why-orchestore)
+  * [Architecture Overview](#architecture-overview)
+
+* [Quick Example](#quick-example)
+
+* [Slice Layers](#slice-layers)
+  * [name](#name)
+  * [state](#state)
+  * [Mutations](#mutations)
+  * [Methods](#methods)
+  * [Computed State (Planned)](#computed-state-planned)
+  * [Nested Slices](#nested-slices)
+    * [Accessing Children through Parent Slice](#accessing-children-through-parent-slice)
+    * [Accessing Parent Slice from Children](#accessing-parent-slice-from-children)
+    * [Reusing Slices](#reusing-slices)
+    * [Runtime Paths](#runtime-paths)
+
+* [State Access & Subscriptions](#state-access--subscriptions)
+  * [State Snapshots](#state-snapshots)
+  * [State Subscriptions](#state-subscriptions)
+  * [Draft State](#draft-state)
+
+* [Store Integration](#store-integration)
+  * [Creating the Store](#creating-the-store)
+  * [Store Provider](#store-provider)
+  * [Accessing Slices through Store](#accessing-slices-through-store)
+  * [Accessing Store from Slices](#accessing-store-from-slices)
+
+* [Lineage & Clones](#lineage--clones)
+  * [Manual Cloning](#manual-cloning)
+  * [Automatic Cloning](#automatic-cloning)
+  * [Inspecting a Lineage](#inspecting-a-lineage)
+  * [Definition Type Checking](#definition-type-checking)
+
+* [Utilities](#utilities)
+  * [Accessing Utilities](#accessing-utilities)
+  * [Utilities Type Extension](#utilities-type-extension)
+  * [Providing Runtime Utilities](#providing-runtime-utilities)
+  * [Using Utilities in Slices](#using-utilities-in-slices)
+
+* [TypeScript Inference](#typescript-inference)
+
+* [Status](#status)
+
+---
 
-Many common Redux patterns are automated by default:
+## Core Principles
 
-| Traditional Redux Pattern     | OrcheStore                                      |
-| ----------------------------- | ----------------------------------------------- |
-| Action creators               | Direct callable mutations                       |
-| Thunks                        | Built-in methods                                |
-| Dispatch calls                | Direct function calls                           |
-| `PayloadAction` wrappers      | Native function arguments                       |
-| Cross-slice imports           | Root store access                               |
-| Shared service wiring         | Global utilities                                |
-| Manual state tree composition | Nested slices with automatic cloning & isolation |
-| Complex type declarations     | Automatic inference                             |
-| Instance identity management  | Lineage-based slice model (shared definition, isolated mounts) |
+* Simplify state management architecture
+* Automate repetitive Redux patterns
+* Reduce infrastructure code
+* Centralize state and application logic
+* Provide direct and intuitive APIs
+* Preserve predictable state transitions
+* Maintain strong TypeScript inference
+* Scale naturally through composition
 
-The result is a simpler architecture with fewer moving parts, less boilerplate, and a more direct development experience.
+## Why OrcheStore?
 
-Developers can focus on application behavior rather than framework plumbing.
+Redux Toolkit greatly improves the Redux experience, but applications still often require developers to coordinate reducers, actions, selectors, thunks, hooks, utilities, and state composition.
 
-## Redux Toolkit Comparison
+OrcheStore builds on top of Redux Toolkit and combines these patterns into a unified slice model. A slice can encapsulate state, mutations, methods, computed values, child slices, and shared application utilities within a single module.
 
-OrcheStore builds on top of Redux Toolkit while providing a higher-level API for organizing state and behavior.
+The goal is to reduce framework plumbing and allow application behavior to remain close to the state it operates on.
 
-| Feature                        | OrcheStore | Redux Toolkit |
-| ------------------------------ | ---------- | ------------- |
-| Multiple mutation arguments    | ✅          | ❌             |
-| Direct callable mutations      | ✅          | ❌             |
-| `PayloadAction` wrappers       | ❌          | ✅             |
-| Dispatch required              | ❌          | ✅             |
-| Built-in orchestration methods | ✅          | ❌             |
-| Nested slice composition       | ✅ (isolated context) | ⚠️ Manual (shared state) |
-| Automatic path generation      | ✅          | ⚠️ Manual     |
-| Global utilities               | ✅          | ❌             |
-| Unified slice API              | ✅          | ❌             |
-| Per-slice React hooks          | ✅          | ❌             |
-| Deep TypeScript inference      | ✅          | ⚠️ Partial    |
-| Lineage & cloning model        | ✅          | ❌             |
+| Concern            | Redux Toolkit                            | OrcheStore                                      |
+| ------------------ | ---------------------------------------- | ----------------------------------------------- |
+| State updates      | Actions + dispatch                       | Direct callable mutations                       |
+| Mutation arguments | `PayloadAction` wrappers                 | Native function arguments                       |
+| Async logic        | Separate thunks                          | Built-in methods                                |
+| State selection    | Global store selector hooks              | Global + slice-scoped selection hooks           |
+| Cross-slice access | Imports & wiring                         | Runtime tree access (Root / Parent / Children)  |
+| Shared services    | Manual integration                       | Application-wide utilities                      |
+| State composition  | Manual reducer composition               | Nested slices                                   |
+| Identity model     | Singleton-like slice definition          | Lineage-based identity system                   |
+| Instance reuse     | Function-level reuse of slice reducers   | Reused slices create isolated runtime instances |
+| Cloning model      | Factory pattern required for re-creation | Built-in cloning with lineage tracking          |
+| Exposed API        | Reducers, actions and some helpers       | Direct usable slice APIs                        |
+| Type inference     | Strong                                   | Deep end-to-end inference                       |
+| Developer focus    | Connect infrastructure                   | Implement behavior                              |
 
-OrcheStore does not replace Redux Toolkit. Instead, it builds on top of it by automating common patterns and providing a more cohesive developer experience.
+OrcheStore does not replace Redux Toolkit. It builds on top of it, providing a higher-level API for organizing state and application behavior with stronger automation of Redux patterns and reduced coordination overhead for developers.
 
 ## Architecture Overview
 
@@ -230,6 +221,15 @@ export const counter = createSlice({
 ```tsx
 import { createSlice, createAsyncThunk, type PayloadAction } from "@reduxjs/toolkit";
 
+// Separate APIs for async workflows
+export const incrementAfter = createAsyncThunk(
+	"counter/incrementAfter",
+	async ({ amount, delay }: { amount: number; delay: number }) => {
+		await new Promise((resolve) => setTimeout(resolve, delay));
+		return amount;
+	}
+);
+
 export const counter = createSlice({
 	name: "counter",
 
@@ -251,20 +251,14 @@ export const counter = createSlice({
 			);
 		},
 	},
-});
-
-// Separate APIs for async workflows
-export const incrementAfter = createAsyncThunk(
-	"counter/incrementAfter",
-	async (
-		{ amount, delay }: { amount: number; delay: number },
-		{ dispatch }
-	) => {
-		await new Promise((resolve) => setTimeout(resolve, delay));
 
-		dispatch(counter.actions.increment(amount));
-	}
-);
+	extraReducers: (builder) => {
+		// Handles fulfilled async thunk result
+		builder.addCase(incrementAfter.fulfilled, (state, action) => {
+			state.value += action.payload;
+		});
+	},
+});
 ```
 
 ## Slice Usage
@@ -526,8 +520,10 @@ Methods are the orchestration layer of a slice.
 - receive any number of arguments
 - can return synchronous values or Promises
 - can access:
-	- state, mutations, slibling methods, nested slices (through `this`)
-	- Application-wide utilities (`this.global`)
+  - state, mutations, slibling methods, nested slices (through `this`)
+  - Root store (`this.root`)
+  - Parent slice (`this.parent`)
+  - Application-wide utilities (`this.utils`)
 
 Methods are not serialized, replayable, or represented in Redux DevTools action history.
 
@@ -547,20 +543,9 @@ Methods are designed for centralizing any slice-related logic:
 Methods should NOT:
 
 - include slice-unrelated logic.
+- include UI layer logic.
 - mutate state directly. use mutations instead.
 
-Prefer:
-
-```ts
-this.increment(1);
-```
-
-Instead of:
-
-```ts
-this.getState().value++;
-```
-
 **Example:**
 
 ```ts
@@ -581,7 +566,7 @@ const counter = createSlice({
 		async incrementAfter(amount: number, delay = 1000) {
 			await new Promise((resolve) => setTimeout(resolve, delay));
 			this.increment(amount);
-			this.global.logger.info("Counter incremented");
+			this.utils.logger.info("Counter incremented");
 		},
 	},
 });
@@ -621,27 +606,27 @@ This currently not supported
 
 Slices can be composed by registering other slice instances through the `children` property.
 
-This allows related state and behavior to be organized into a hierarchical structure while preserving full type inference and ownership isolation.
+This allows related state and behavior to be structured into a hierarchical ownership tree, while preserving full type inference, runtime path resolution, and instance isolation.
 
 ```ts
 import { products } from "./productsSlice";
 import { categories } from "./categoriesSlice";
 
 export const shop = createSlice({
-  name: "shop",
+	name: "shop",
 
-  state: {},
+	state: {},
 
-  children: {
-    products,
-    categories,
-  },
+	children: {
+		products,
+		categories,
+	},
 });
 ```
 
-**Accessing Child Slices:**
+### Accessing Children through Parent Slice
 
-Child slices are exposed directly on their parent slice.
+Child slices are exposed directly on their parent slice instance.
 
 ```ts
 shop.products.add(...)
@@ -650,7 +635,7 @@ shop.categories.create(...)
 console.log(shop.products.getState());
 ```
 
-Deeply nested slice hierarchies are fully supported.
+Deeply nested slice trees are fully supported, including recursive composition.
 
 ```ts
 admin.users.permissions.grant(...);
@@ -658,6 +643,16 @@ admin.users.permissions.grant(...);
 console.log(admin.users.permissions.getState());
 ```
 
+### Accessing Parent Slice from Children
+
+Every slice instance has a runtime reference to its parent via `slice.parent`.
+
+This allows also child slices to interact with sibling slices through the parent ownership scope.
+
+```ts
+this.parent.categories.getState().list;
+```
+
 ### Reusing Slices
 
 A slice can be mounted multiple times within the same tree.
@@ -915,7 +910,7 @@ console.log(store.counter.getState());
 
 ## Accessing Store from Slices
 
-Every slice has access to the root store instance through `this.root`.
+Every slice has access to the root store instance via `slice.root`.
 
 ```ts
 this.root.auth.getState().isAuthenticated;
@@ -927,68 +922,103 @@ this.root.auth.getState().isAuthenticated;
 - avoiding circular imports
 - application-wide orchestration
 
-## Root Store Type Extension (Planned)
+---
 
-Overriding `OrcheStore.Slots.root` provides full root store typing throughout the application.
+# Lineage & Clones
 
-> 🐞 Under active development: this currently causes a circular type inference limitation.
+OrcheStore uses a lineage-based model for slice identity.
 
-```ts
-import { createStore } from "orchestore";
+**Why?**
 
-export const store = createStore({
-	slices: {
-		counter,
-	},
-});
+Slices can be used in multiple places in the store tree.
 
-declare module "orchestore" {
-	namespace OrcheStore {
-		interface Slots {
-			root: typeof store; // Bugfix: Causes a circular type inference
-		}
-	}
-}
-```
+When this happens, OrcheStore creates a separate runtime instance for each usage. These instances are called **clones**.
+
+A clone is an independent instance of a slice at runtime. It has its own state and runs separately from other clones, while still remaining part of a shared lineage.
+
+A lineage (or family) is the set of all runtime instances that originate from the same slice definition.
+
+**This means:**
+
+- slices are not singletons
+- a slice can appear multiple times in a tree
+- each clone is fully isolated
+- all instances created from the same definition are linked through lineage
+
+## Manual Cloning
+
+A new detached clone can be created manually from any slice instance.
+
+### 1. Clone without state transformation
 
 ```ts
-this.root; // Before: any
-this.root; // After: fully typed store
+const clone = slice.prototype.clone();
 ```
 
-**Rules:**
+The new instance:
 
-- `root` must be a store instance created using `createStore`
-- `null` and `undefined` are excluded automatically
-	- `typeof store | null | undefined` is equivalent to `typeof store`
-- Invalid types fall back to `any`
+- belongs to the same lineage
+- starts detached from the tree
+- has no mounted path initially
+- has its own ownership context
+- uses the exact initial state of the source slice
 
----
+### 2. Clone with state transformation
 
-# Lineage & Clones
+```ts
+const clone = slice.prototype.clone((state) => newState);
+```
 
-OrcheStore uses a lineage-based model for slice identity.
+The provided function receives the fully resolved initial state (including nested slices) and returns the modified state for the new instance.
 
-**Why?**
+The state transformer:
 
-Slices can be used in multiple places in the store tree.
+- does not affect other lineage members
+- supports nested slice state updates
+- supports immutable updates (returning a new state object)
+- supports mutable updates (Immer-style — no return required)
 
-When this happens, OrcheStore creates a separate runtime instance for each usage. These instances are called **clones**.
+**Example:**
 
-A clone is an independent instance copy of a slice at runtime. It has its own state and runs separately from other clones, while still remaining part of a shared lineage.
+```ts
+const crudSlice = createSlice({
+	name: "CRUD-Slice",
 
-A lineage (or family) is the set of all instances that come from the same slice definition.
+	state: {
+		endpoint: "",
+	},
 
-**This means:**
+	children: {
+		pagination: paginationSlice,
+		dropdown: searchDropdownSlice,
+	},
+});
 
-- slices are not singletons
-- a slice can appear multiple times in a tree
-- each clone is fully isolated
-- all instances cloned from the same slice are linked through lineage
+// Immutable style (returns new state object)
+const productsSlice = crudSlice.prototype.clone((state) => ({
+	...state,
+	endpoint: "api/v1/products",
+
+	dropdown: {
+		...state.dropdown,
+		supported: false,
+	},
+}));
+
+// Immer-style mutation (no return needed)
+const categoriesSlice = crudSlice.prototype.clone((state) => {
+	state.endpoint = "api/v1/categories";
+	state.pagination.supported = false;
+});
+```
 
 ## Automatic Cloning
 
-When a slice is reused through `children` or `slices`, OrcheStore automatically creates a new mounted instance for each usage.
+OrcheStore creates slice instances automatically in two cases:
+
+### 1. Reuse through `children` / `slices`
+
+When a slice is reused through `children` (or `slices`), OrcheStore creates a new mounted instance for each usage.
 
 ```ts
 const paginationSlice = createSlice({ ... });
@@ -1023,36 +1053,49 @@ shopSlice.a !== adminSlice.a;
 shopSlice.b !== adminSlice.a;
 ```
 
-Each instance also receives its own path and its own ownership context:
+Each instance has its own ownership context:
 
 ```ts
-shopSlice.a.path;   // "shop.a"
-shopSlice.b.path;   // "shop.b"
-adminSlice.a.path;  // "admin.a"
+shopSlice.a.path;  // "shop.a"
+shopSlice.b.path;  // "shop.b"
+adminSlice.a.path; // "admin.a"
 ```
 
-Although these instances are independent at runtime, they still belong to the same lineage.
-
-## Manual Cloning
+### 2. Cloning a parent slice (cascade cloning)
 
-A new detached clone can be created manually from any slice instance:
+When a parent slice is cloned or reused, all its nested children are automatically cloned as well.
 
 ```ts
-const clone = slice.prototype.clone();
+const crudSlice = createSlice({
+	name: "CRUD-Slice",
+
+	state: {
+		endpoint: "",
+	},
+
+	children: {
+		pagination: paginationSlice,
+		dropdown: searchDropdownSlice,
+	},
+});
+
+const productsSlice = crudSlice.prototype.clone();
+const categoriesSlice = crudSlice.prototype.clone();
 ```
 
-The new instance:
+Each clone receives its own independent subtree:
 
-- belongs to the same lineage
-- starts detached from the tree
-- has no mounted path initially
-- has its own ownership context
+```ts
+productsSlice.pagination !== categoriesSlice.pagination;
+```
+
+This ensures that both parent and child slices remain fully isolated across all clone instances.
 
 ## Inspecting a Lineage
 
 **Get All Related Instances:**
 
-Returns every instance in the lineage, **including** the current one.
+Returns every instance in the lineage, **including** the current instance.
 
 ```ts
 const lineage = slice.prototype.getLineage();
@@ -1064,9 +1107,9 @@ Useful for:
 - inspecting mounted instances
 - understanding tree distribution
 
-**Get Clones:**
+**Get Sibling Clones:**
 
-Returns all lineage members **except** the current instance.
+Returns every sibling in the lineage, **except** the current instance.
 
 ```ts
 const siblings = slice.prototype.getClones();
@@ -1080,8 +1123,6 @@ Useful for:
 
 ## Definition Type Checking
 
-You can determine whether two slices belong to the same lineage:
-
 You can check whether two slices belong to the same lineage:
 
 ```ts
@@ -1107,19 +1148,20 @@ slice2.prototype.isTypeOf(clone1); // false
 
 ## Summary
 
-- Reusing a slice automatically creates mounted clones.
 - `clone()` creates a new detached lineage member.
+- `clone(stateTransformer)` allows per-instance state customization at creation time.
+- Reusing a slice automatically creates mounted clones.
 - Every clone is isolated at runtime.
 - All clones from the same definition belong to a shared lineage.
 - `getLineage()` returns all instances in a lineage.
-- `getClones()` returns all related instances except the current one.
+- `getClones()` returns all related instances except the current instance.
 - `isTypeOf()` checks whether two instances belong to the same lineage.
 
 ---
 
-# Global Utilities
+# Utilities
 
-Global utilities allow slices and the root store to access shared runtime services through `global`.
+Application-wide utilities allow slices and stores to access shared runtime services through `utils`.
 
 Common use cases include:
 
@@ -1130,28 +1172,33 @@ Common use cases include:
 - runtime values that are difficult to access directly from slices
 - integrations with React hooks and third-party libraries
 
-Utilities are registered using `provideGlobalUtils` and are accessible from any slice or the root store.
+Utilities are registered using `setUtils` and are accessible from any slice or the root store.
 
-## Accessing Global Utilities
+## Accessing Utilities
 
 **Available:**
 
-- Through the exposed store or slice instances
+- Through exposed store and slice instances
 
 ```ts
-store.global;
-slice.global;
+store.utils;
+slice.utils;
+this.utils; // Inside slice methods and mutations
 ```
 
-- Inside slice methods
+- Through `getUtils`
 
 ```ts
-this.global.notify("success", "Saved!");
+import { getUtils } from "orchestore";
+
+const utils = getUtils();
 ```
 
 ## Utilities Type Extension
 
-Overriding `OrcheStore.Slots.global` provides full typing everywhere.
+OrcheStore exposes user-definable type slots through `OrcheStore.Slots`.
+
+By overriding `OrcheStore.Slots.utils`, application-specific utilities become available throughout the framework with full type safety.
 
 ```ts
 import type { NavigateFunction } from "react-router";
@@ -1159,7 +1206,7 @@ import type { NavigateFunction } from "react-router";
 declare module "orchestore" {
 	namespace OrcheStore {
 		interface Slots {
-			global: {
+			utils: {
 				navigate: NavigateFunction;
 
 				notify(type: "info" | "error" | "success", message: string): void;
@@ -1169,30 +1216,43 @@ declare module "orchestore" {
 }
 ```
 
-```ts
-this.global; // Before: any
-this.global; // After: fully typed
-```
+**Notes:**
 
-**Rules:**
+* `OrcheStore.Slots` can be extended using either `declare module "orchestore"` or `declare global`, depending on your project's type organization preferences.
+* If your project uses JavaScript without TypeScript, you can still extend these types by creating a separate declaration file (for example, `orchestore.d.ts`). This allows editors and tooling to provide type checking and IntelliSense while keeping your application code in JavaScript.
+
+**Rules**
+
+* `utils` must resolve to an object type; otherwise, it falls back to `any`.
+* `null` and `undefined` are automatically excluded. For example, `object | null | undefined` resolves to `object`.
+
+**Type Safety**
+
+Before extending `OrcheStore.Slots.utils`, all utility-related APIs are typed as `any`.
+
+After extending `OrcheStore.Slots.utils`, the inferred type is automatically applied throughout the framework, including:
+
+* `store.utils`
+* `slice.utils`
+* `this.utils` inside mutations and methods
+* `getUtils()`
+* `setUtils()`
+* `type Utils`
 
-- `global` must be an object
-- `null` and `undefined` are excluded automatically
-	- `object | null | undefined` is equivalent to `object`
-- Invalid types fall back to `any`
+This provides consistent type safety and IntelliSense across all utility access points without requiring additional type declarations.
 
 ## Providing Runtime Utilities
 
-Global utility values can be registered or updated at runtime.
+Application-wide utility values can be registered or updated at runtime.
 
 ```ts
 import { useEffect } from "react";
 import { useNavigate } from "react-router";
-import { provideGlobalUtils } from "orchestore";
+import { setUtils } from "orchestore";
 import { feedbacks } from "./ui-feedbacks";
 import { store } from "./store";
 
-provideGlobalUtils({
+setUtils({
 	notify(type, message) {
 		feedbacks.notify(type, message);
 	},
@@ -1202,7 +1262,7 @@ export default function App() {
 	const navigate = useNavigate();
 
 	useEffect(() => {
-		provideGlobalUtils({ navigate });
+		setUtils({ navigate });
 	}, [navigate]);
 
 	return (
@@ -1213,9 +1273,9 @@ export default function App() {
 }
 ```
 
-## Using Global Utilities in Slices
+## Using Utilities in Slices
 
-Global utilities can be used anywhere a slice instance is available.
+Application-wide utilities can be used anywhere a slice instance is available.
 
 ```ts
 methods: {
@@ -1225,13 +1285,13 @@ methods: {
 
 			const response = await api.users.add(data);
 
-			this.global.notify("success", "User added successfully!");
+			this.utils.notify("success", "User added successfully!");
 
 			this.setLoading(false);
 
-			this.global.navigate("/users/" + response.id);
+			this.utils.navigate("/users/" + response.id);
 		} catch (error) {
-			this.global.notify("error", "Failed to add user");
+			this.utils.notify("error", "Failed to add user");
 
 			console.error(error);
 		}
@@ -1267,13 +1327,13 @@ const counter = createSlice({
 	},
 
 	children: {
-	  subCounter: createSlice({
-	    name: "subCounter",
+		subCounter: createSlice({
+			name: "subCounter",
 
-	    state: {
-	      value: 0,
-	    },
-	  }),
+			state: {
+				value: 0,
+			},
+		}),
 	},
 });
 ```
@@ -1294,42 +1354,6 @@ counter.incrementAfter(amount: number, delay?: number): Promise<number>;
 
 No manual type declarations required.
 
-## Framework Type Extensions
-
-OrcheStore also exposes user-definable type slots through `OrcheStore.Slots`.
-
-These slots allow application-specific types to be injected into the framework and become available everywhere with full type safety.
-
-| Slot                       | Purpose                 |
-| -------------------------- | ----------------------- |
-| `OrcheStore.Slots.root`   | Root store typing       |
-| `OrcheStore.Slots.global` | Global utilities typing |
-
-```ts
-declare module "orhestore" {
-	namespace OrcheStore {
-		interface Slots {
-			root: typeof store; // Bugfix: Causes a circular type inference
-
-			global: {
-				navigate: NavigateFunction;
-				notify(type: "info" | "error" | "success", message: string): void;
-			};
-		}
-	}
-}
-```
-
-This provides full typing for APIs such as:
-
-```ts
-this.root;
-this.global;
-
-store.global;
-counter.global;
-```
-
 ---
 
 # Status