cluaupp 0.2.2 → 1.0.0

package/docs/getting-started.md

@@ -1,43 +1,31 @@
 # Getting started
 
-Cluaupp installs from **npm**, the same channel as roblox-ts and most Roblox tooling outside Studio.
+Cluaupp is the **game toolchain**. [CL++](https://kartzrbx.github.io/CLPP/) is the **language**.
 
 ## Requirements
 
 - [Node.js](https://nodejs.org/) 18 or newer
-- [Rojo](https://rojo.space/) **7.7.0** to sync `out/` into Studio (`cluaupp init` writes `rokit.toml`; run `rokit install`)
-- LLVM clangd for C++ IntelliSense (Cursor / VS Code — installed by `cluaupp init`)
+- [Rojo](https://rojo.space/) **7.7.0** (`cluaupp init` writes `rokit.toml`)
+- **`clpp` on PATH** from [KartzRbx/CLPP](https://github.com/KartzRbx/CLPP)
 
-## Install the compiler
+```bash
+cargo install --path .   # inside a CL++ checkout
+clpp install             # VS Code / Cursor language pack
+```
 
-Global (`cluaupp` on your PATH):
+## Install Cluaupp
 
 ```bash
 npm install -g cluaupp
 cluaupp --version
 ```
 
-Without a global install, via `npx`:
+Or:
 
 ```bash
 npx cluaupp init my-game
 ```
 
-As a game dependency:
-
-```bash
-npm install --save-dev cluaupp
-```
-
-```json
-{
-	"scripts": {
-		"build": "cluaupp build",
-		"watch": "cluaupp watch"
-	}
-}
-```
-
 ## First game
 
 ```bash
@@ -48,130 +36,27 @@ cluaupp build
 rojo serve
 ```
 
-In Roblox Studio: install the Rojo plugin and connect to `localhost:34872` (default port).
-
-Generated layout:
-
 ```
 my-game/
   cluaupp.config.json
-  default.project.json    ← Rojo
-  include/cluaupp/roblox.hpp
-  include/cluaupp/libs/
-  libs/                   ← CluauppLibs (Janitor, Fusion, Cmdr, DataService, …)
-  Packages/               ← optional extra Wally
-  wally.toml
+  default.project.json
   src/
-    server/leaderstats.server.cpp
-    client/init.client.cpp
-    shared/config.h
-    shared/config.cpp
+    server/leaderstats.server.clpp
+    client/init.client.clpp
+    shared/config.clp
   out/                    ← generated Luau (do not edit)
-    server/leaderstats.server.luau
-    client/init.client.luau
-    shared/Config.luau
-```
-
-## Datatypes (Vector3, CFrame, UDim2)
-
-```cpp
-#include <cluaupp/roblox.hpp>
-
-void init() {
-	auto* part = new Part(workspace);
-	part->Size = Vector3(8, 1, 8);
-	part->Position = Vector3(0, 10, 0);
-	part->CFrame = CFrame::lookAt(Vector3(0, 10, 0), Vector3(0, 10, -10));
-	part->Color = Color3::fromRGB(255, 0, 0);
-	part->Material = Enum::Material::Plastic;
-
-	auto* frame = new Frame();
-	frame->Size = UDim2::fromScale(1, 1);
-	frame->Position = UDim2(0, 0, 0.5, 0);
-}
+  libs/                   ← CluauppLibs
 ```
 
-This becomes `Vector3.new`, `CFrame.lookAt`, `Color3.fromRGB`, `UDim2.fromScale`, `Enum.Material.Plastic`.
+## Tiny program
 
-Full reference (every class from [create.roblox.com](https://create.roblox.com/docs/reference/engine)): [Cluaupp GitHub Pages](https://kartzrbx.github.io/Cluaupp/).
-
-## How to write
-
-Every `.cpp` / `.h` / `.hpp` file can start with the IntelliSense header. Angle-bracket includes are ignored. Quoted `#include "config.h"` is inlined into the file.
-
-```cpp
-#include <cluaupp/roblox.hpp>
-
-void CreateLeaderstats(Player* player) {
-	if (player->FindFirstChild("leaderstats") != nullptr) {
-		return;
-	}
-
-	auto* leaderstats = new Folder(player);
-	leaderstats->Name = "leaderstats";
-}
+```clpp
+#include <clpp/roblox.clh>
 
 void init() {
-	auto* players = GetService<Players>();
-	for (auto* player : players->GetPlayers()) {
-		CreateLeaderstats(player);
-	}
-	players->PlayerAdded.Connect(CreateLeaderstats);
+	Players* players = GetService<Players>();
+	post("online: " .: players::GetPlayers());
 }
 ```
 
-If a file defines `void init()`, Cluaupp calls `init()` at the end of the `.luau`. Use that in Scripts and LocalScripts.
-
-## IntelliSense
-
-`cluaupp init` writes clangd config and installs LLVM `clang++` plus the clangd editor extension when missing. Then reload the window. Completion is clangd; Cluaupp does not index C++ itself.
-
-```bash
-cluaupp intellisense
-```
-
-`#include <cluaupp/roblox.hpp>` at the top of each source file. The header is **not** compiled to Luau. clangd learns that path from `-Iinclude` in `.clangd`, `compile_flags.txt`, and `compile_commands.json` — it does not read `c_cpp_properties.json`.
-
-See [IntelliSense](intellisense.md).
-
-## Watch
-
-```bash
-cluaupp watch
-```
-
-Saving a `.cpp`, `.h`, or `.hpp` under `src/` rebuilds the project. Keep Rojo running at the same time.
-
-## Libraries
-
-`cluaupp build` copies runtime modules to `libs/` (Rojo: `ReplicatedStorage.CluauppLibs`). Include a header and the compiler injects `require`.
-
-```cpp
-#include <cluaupp/libs/janitor.hpp>
-#include <cluaupp/libs/net.hpp>
-
-void init() {
-	auto* janitor = new Janitor();
-	auto* coins = Net::Event("Coins");
-	janitor->Add(coins);
-}
-```
-
-Wally is optional. Fusion, Cmdr, DataServiceV2, and the rest ship **inside** `libs/` (full GitHub source). See [Libraries](libraries/index.md) — start with [DataService Init](libraries/dataservice.md) and [Janitor](libraries/janitor.md).
-
-See [Libraries](libraries/index.md), [OOP](oop/index.md), [types](cpp-types.md), [safety](cpp-safety.md).
-
-## Next
-
-- [C++ → Luau syntax](syntax.md)
-- [print and cout](print-cout.md)
-- [C++ types](cpp-types.md)
-- [const](cpp-const.md)
-- [Safety](cpp-safety.md)
-- [Organization](cpp-organization.md)
-- [Architecture](architecture.md)
-- [OOP structure](oop/index.md)
-- [Libraries](libraries/index.md)
-- [Examples](examples/index.md)
-- [Roblox API](roblox-api.md)
-- [CLI](cli.md)
+Language course and reference: [kartzrbx.github.io/CLPP](https://kartzrbx.github.io/CLPP/). Migrating `.cpp`: [migration](migration.md).

package/docs/intellisense.md

@@ -1,49 +1,12 @@
 # IntelliSense
 
-C++ completion, hover, and go-to-definition are **clangd**. Cluaupp does not ship a second completion engine.
-
-`cluaupp init` / `cluaupp intellisense` install:
-
-1. [clangd](https://marketplace.visualstudio.com/items?itemName=llvm-vs-code-extensions.vscode-clangd) (`llvm-vs-code-extensions.vscode-clangd`)
-2. LLVM `clang++` when missing (Windows: `winget install --id LLVM.LLVM -e`)
-3. `.clangd`, `compile_flags.txt`, and `compile_commands.json` so clangd finds `include/` (clangd does **not** read `.vscode/c_cpp_properties.json`)
-4. Forced include of `include/cluaupp/roblox.hpp` so `GetService`, `Player`, `Janitor` complete from the real C++ stubs
-
-Tree-sitter is the **compiler** frontend (collect → emit Luau). It is not an editor language server. A homemade tokenizer in the CLI would fight clangd — that path is gone.
-
-Microsoft `ms-vscode.cpptools` is **not** used. Two C++ engines in the same window fight; Cluaupp disables the Microsoft engine (`C_Cpp.intelliSenseEngine: Disabled`).
-
-`cluaupp lsp` only publishes **subset parse errors** (code that clangd may accept as C++ but Cluaupp will not transpile).
-
-## Headers clangd must see
-
-`#include <cluaupp/roblox.hpp>` resolves only if `-Iinclude` is on the clangd compile flags. That maps to `include/cluaupp/roblox.hpp`. Angle-bracket includes are ignored by the transpiler.
-
-`cluaupp init` / `build` / `watch` / `intellisense` rewrite:
-
-- `-Iinclude` and `-Isrc`
-- `-include include/cluaupp/roblox.hpp`
-- one `compile_commands.json` entry per file under `src/`
-
-## Install
+CL++ highlighting, completion, and diagnostics come from **`clpp install`** ([KartzRbx/CLPP](https://github.com/KartzRbx/CLPP) language pack). Cluaupp does not ship clangd or a C++ engine.
 
 ```bash
-cluaupp intellisense
+clpp install
+cluaupp intellisense   # writes files.associations for .clpp / .clp / .clh
 ```
 
-Reload: Command Palette → **Developer: Reload Window**. clangd should attach to `.cpp` files.
-
-`cluaupp build` / `watch` only refresh `compile_commands.json` (no download). They never keep deleted files in the compilation database.
-
-## Config that ships
-
-| File | Role |
-| --- | --- |
-| `.vscode/c_cpp_properties.json` | compiler path (unused by clangd; kept if someone re-enables cpptools) |
-| `.vscode/settings.json` | `C_Cpp.intelliSenseEngine: Disabled`, `clangd.enable: true`, `--compile-commands-dir` |
-| `.vscode/extensions.json` | recommends `llvm-vs-code-extensions.vscode-clangd` |
-| `.clangd` | C++20, `-Iinclude`, skip `out/` and `libs/` |
-| `compile_flags.txt` | fallback flags if a file is not yet in `compile_commands.json` |
-| `compile_commands.json` | one entry per `src/` file |
+Reload the editor. Language id is **`clpp`**, not `cpp`.
 
-`#include <cluaupp/roblox.hpp>` at the top of each source file. The header is not compiled to Luau.
+`cluaupp lsp` can surface `clpp` compile errors over stdio; prefer the official CL++ extension for day-to-day editing.

package/docs/intro.md

@@ -5,33 +5,34 @@ sidebar_position: 1
 
 # Cluaupp
 
-**The definitive merge of C++ and modern Luau.** You write a C++ subset. Cluaupp emits [Luau](https://luau.org/getting-started) with `local` and `const` (and `--!strict` when you opt in), and calls the Roblox API the way Studio does.
+**CL++ on Roblox.** You write [CL++](https://kartzrbx.github.io/CLPP/). Cluaupp runs `clpp`, maps libraries into `ReplicatedStorage.CluauppLibs`, and syncs with Rojo.
 
-This site is built with [Moonwave](https://eryn.io/moonwave/) for local markdown (`npm run docs`). The **public** site is generated into `site/` and deployed to [GitHub Pages](https://kartzrbx.github.io/Cluaupp/) (Learn tabs, OOP, Examples, API). The language is in the same spirit as [roblox-ts](https://roblox-ts.com): a familiar syntax, a restricted subset, readable output.
+This site covers the **toolchain** (`init`, `build`, `watch`, libs). The language course is on the [CL++ site](https://kartzrbx.github.io/CLPP/).
 
 ## What you get
 
-1. A compiler (`cluaupp init` / `build` / `watch`)
-2. Headers for **clangd** (`#include <cluaupp/roblox.hpp>`)
-3. First-party libraries in `ReplicatedStorage.CluauppLibs`
-4. Wally wrappers for DataServiceV2, Fusion, Cmdr, EzVisualz, TopbarPlus, and the rest of your stack
+1. CLI: `cluaupp init` / `build` / `watch`
+2. First-party libraries in `ReplicatedStorage.CluauppLibs`
+3. Rojo project mapping (`out/server`, `out/client`, `out/shared`)
 
 ## First program
 
-```cpp
-#include <cluaupp/roblox.hpp>
-#include <cluaupp/libs/janitor.hpp>
+```clpp
+#include <clpp/roblox.clh>
+#include <clpp/libs/janitor.clh>
 
 void OnPlayer(Player* player) {
-	auto* janitor = new Janitor();
-	janitor->LinkToInstance(player);
-	janitor->Add(player->AncestryChanged.Connect(OnPlayer));
+	guard (player != null) else {
+		return;
+	}
+	Janitor* janitor = new Janitor();
+	janitor::LinkToInstance(player);
 }
 
 void init() {
-	auto* players = GetService<Players>();
-	players->PlayerAdded.Connect(OnPlayer);
+	Players* players = GetService<Players>();
+	players::PlayerAdded~>Connect(OnPlayer);
 }
 ```
 
-Read [Getting started](getting-started.md), then [Examples](examples/index.md), [Libraries](libraries/index.md), and [OOP structure](oop/index.md).
+Read [Getting started](getting-started.md), [syntax](syntax.md), and [migration](migration.md).

package/docs/libraries/dataservice.md

@@ -91,9 +91,12 @@ void OnCurrenciesChanged() {
 }
 
 data->GetChangedSignal(DataService::Server.Paths.Currencies).Connect(OnCurrenciesChanged);
+data->GetChangedSignal(DataService::Server.Paths.Currencies.Coins).Connect([](int coins) {
+	print(coins);
+});
 ```
 
-`GetChangedSignal` fires when that path (or a child) changes. Cluaupp has no lambdas — use a named function.
+`GetChangedSignal` fires when that path (or a child) changes. Use a named function or a lambda (`[](int newValue) { ... }`).
 
 ## Rules
 

package/docs/libraries/index.md

@@ -13,7 +13,8 @@ sidebar_position: 1
 | [Janitor](janitor.md) | Connections, instances, cleanup on leave |
 | [Promise](promise.md) | Delay, Then / Catch / Await |
 | [Net](net.md) | RemoteEvent / RemoteFunction without making remotes |
-| [More libraries](more.md) | FormatNumber, Fusion, Cmdr, Twinkle, MathUtils, … |
+| [Declarative UI](ui.md) | Fusion, Iris, Vide, React/Roact — no JSX |
+| [More libraries](more.md) | FormatNumber, Twinkle, TopbarPlus, EzVisualz, … |
 
 Sources: [runtime/SOURCES.md](https://github.com/KartzRbx/Cluaupp/blob/main/runtime/SOURCES.md). Re-vendor: `node scripts/vendor-libs.js`.
 

package/docs/libraries/more.md

@@ -60,7 +60,9 @@ billboard->SetText("Hello");
 
 ## Fusion / Iris / Cmdr / TopbarPlus / Chrono / EzVisualz / StateMachine / Spring / Display
 
-These are the GitHub systems behind typed `init.luau` borders. Include the matching `<cluaupp/libs/*.hpp>` and call the same names as the upstream README. Cluaupp does not re-document every Fusion `Value` / Cmdr command — use:
+Cluaupp has **no JSX**. Declarative UI is function calls. First-party: Fusion (reactive) and Iris (immediate-mode debug). Vide and Roact/React use the same C++ spelling (`createElement` / `source`), not `<frame />`. Handbook: [Declarative UI](https://kartzrbx.github.io/Cluaupp/docs/ui.html).
+
+Include the matching `<cluaupp/libs/*.hpp>` and call the same names as the upstream README:
 
 | Lib | Header | Upstream |
 | --- | --- | --- |

package/docs/libraries/ui.md

@@ -0,0 +1,76 @@
+---
+title: Declarative UI
+sidebar_position: 5
+---
+
+# Declarative UI
+
+Live handbook (examples, C++ / Luau tabs): **[Declarative UI](https://kartzrbx.github.io/Cluaupp/docs/ui.html)**.
+
+roblox-ts can compile [Roact JSX](https://roblox-ts.com/docs/guides/roact-jsx) because TypeScript has JSX. **Cluaupp does not.** There are no `<frame />` tags. You call the library the way Luau does: functions, designated-initializer tables, lambdas.
+
+## Pick a model
+
+| When you want… | Use | In Cluaupp |
+| --- | --- | --- |
+| A few labels you set by hand | Imperative Instances | `new TextLabel(gui)` |
+| UI that follows state | [Fusion](https://github.com/dphfox/Fusion) | Shipped: `#include <cluaupp/libs/fusion.hpp>` |
+| The same idea, sources | [Vide](https://github.com/centau/vide) | Not shipped — calling convention on the handbook |
+| A virtual tree | Roact / [jsdotlua React](https://github.com/jsdotlua/react) | Not shipped — `createElement`, never JSX |
+| Studio debug panels | [Iris](https://github.com/SirMallard/Iris) | Shipped: `#include <cluaupp/libs/iris.hpp>` |
+| Topbar / fade / rainbow | TopbarPlus, Twinkle, EzVisualz | Shipped — polish Instances you already have |
+
+Fusion and Iris are in CluauppLibs. Vide and React/Roact are **not** vendored.
+
+## JSX → Cluaupp
+
+| roblox-ts JSX | Cluaupp |
+| --- | --- |
+| `<frame Size={u} />` | `React::createElement("Frame", { .Size = u })` |
+| `<textlabel Key="Coins" />` | `.Key = "Coins"` on the props table |
+| `Event={{ Activated: fn }}` | `.Event = { .Activated = fn }` |
+| `<MyButton text="Buy" />` | `React::createElement(MyButton, { .text = "Buy" })` |
+
+## Fusion (shipped)
+
+```cpp
+#include <cluaupp/libs/fusion.hpp>
+
+FusionScope scope = Fusion::scoped();
+FusionState coins = Fusion::Value(0);
+Fusion::New("TextLabel")({
+	.Name = "Coins",
+	.Parent = gui,
+	.Size = UDim2::fromScale(1, 0.1),
+});
+```
+
+Wire `coins(newValue)` from `DataService::Client` `GetChangedSignal(Paths.Currencies.Coins)`. Use `Computed` for strings, `Hydrate` for a ScreenGui that already exists in Studio, `Spring` / `Tween` for motion.
+
+## Vide / React
+
+Same subset: **no JSX**. Vide is `source` / `derive` / `create("TextLabel")({ .Parent = gui })`. React is `createElement("Frame", { .Key = "Child" }, child)` plus `Key`, `Ref`, `Change`, `Event` as table fields. Full copies with C++ / Luau tabs: the [handbook page](https://kartzrbx.github.io/Cluaupp/docs/ui.html).
+
+## Iris (shipped, debug only)
+
+```cpp
+#include <cluaupp/libs/iris.hpp>
+
+void DrawEconomy() {
+	if (Iris::Window("Economy")) {
+		Iris::Text("Coins");
+		Iris::End();
+	}
+}
+
+void init() {
+	Iris::Init();
+	Iris::Connect(DrawEconomy);
+}
+```
+
+Do not use Iris as the live player HUD. Pair every `Window` / `Tree` with `End()`.
+
+## One owner per ScreenGui
+
+Do not mount Fusion and React on the same gui. Twinkle / TopbarPlus / EzVisualz can decorate that owner’s Instances. Client code must not `Set` persisted DataService paths.

package/docs/migration.md

@@ -0,0 +1,38 @@
+# Migrate C++ games to CL++
+
+Cluaupp 1.0 compiles **CL++**, not a C++ subset. Language docs: [kartzrbx.github.io/CLPP](https://kartzrbx.github.io/CLPP/).
+
+## Files
+
+| Before | After |
+| --- | --- |
+| `*.server.cpp` | `*.server.clpp` |
+| `*.client.cpp` | `*.client.clpp` |
+| untagged `*.cpp` | `*.clp` |
+| `*.h` / `*.hpp` | `*.clh` |
+
+`#include <cluaupp/roblox.hpp>` → `#include <clpp/roblox.clh>`  
+`#include <cluaupp/libs/janitor.hpp>` → `#include <clpp/libs/janitor.clh>`  
+Quoted includes: `"leaderstats.h"` → `"leaderstats.clh"`.
+
+## Operators and IO
+
+| Old C++ subset | CL++ | Luau |
+| --- | --- | --- |
+| `player->Name` | `player.Name` | `.` |
+| `player->GetPlayers()` | `player::GetPlayers()` | `:` |
+| `DataService::Server` | `DataService:Server` | `.` |
+| `"hi " + name` | `"hi " .: name` | `..` |
+| `signal.Connect(fn)` | `signal~>Connect(fn)` | Janitor `Add` |
+| `print` / `error` | `post` / `report` | `print` / `error` |
+| `nullptr` | `null` | `nil` |
+| `[](Player* p) { }` | `func [](Player* p) { }` | `function` |
+
+## Workflow
+
+1. Install CL++: [github.com/KartzRbx/CLPP](https://github.com/KartzRbx/CLPP) (`cargo install --path .`).
+2. `clpp install` (editor highlighting + IntelliSense).
+3. Rename sources and apply the table above.
+4. `cluaupp build` — `clpp` must be on PATH (`CLPP_PATH` if needed).
+
+`"architecture": true` (ForeverHD folders) is not generated in 1.0. One source file still becomes one `.luau` file.

package/docs/oop/file-tags.md

@@ -5,44 +5,20 @@ sidebar_position: 2
 
 # File tags
 
-The **filename** decides the Roblox instance. This is the same key idea as roblox-ts (`*.server.ts` → Script).
+The **filename** decides the Roblox instance (same idea as roblox-ts).
 
-| Source | Instance | RunContext |
-| --- | --- | --- |
-| `LeaderstatsServer.server.cpp` | **Script** | **Server** |
-| `DataBoot.client.cpp` | **LocalScript** | Client |
-| `Tools.plugin.cpp` | **Script** | Plugin |
-| `Boot.legacy.cpp` | Script | **Legacy** |
-| `Boot.legacy.server.cpp` | Script | **Legacy** |
-| `Boot.legacy.client.cpp` | LocalScript | Legacy |
-| `Damage.cpp` (no tag) | **ModuleScript** | — |
-| `LeaderstatsServer.h` | **ModuleScript** (types) | — |
-| `LeaderstatsServer.cpp` (sibling of `.h`) | **ModuleScript** (`*Impl`) | — |
-
-## One file in, one file out
-
-Rojo infers the instance from the filename key: `*.server.luau` is a Script, `*.client.luau` is a LocalScript, untagged `.luau` is a ModuleScript.
+| Source | Instance |
+| --- | --- |
+| `LeaderstatsServer.server.clpp` | Script |
+| `Hud.client.clpp` | LocalScript |
+| `Tools.plugin.clpp` | Plugin Script |
+| `damage.clp` (no tag) | ModuleScript |
+| `PlayerData.clh` | ModuleScript |
 
 ```
-src/server/boot/DataBoot.server.cpp  →  out/server/boot/DataBoot.server.luau
-src/client/boot/DataBoot.client.cpp  →  out/client/boot/DataBoot.client.luau
-src/shared/damage.cpp                →  out/shared/Damage.luau
-src/server/services/leaderstats/LeaderstatsServer.h   →  LeaderstatsServer.luau  (export type)
-src/server/services/leaderstats/LeaderstatsServer.cpp →  LeaderstatsServerImpl.luau
+src/server/boot/DataBoot.server.clpp  →  out/server/boot/DataBoot.server.luau
+src/client/hud.client.clpp            →  out/client/hud.client.luau
+src/shared/config.clp                 →  out/shared/config.luau
 ```
 
-`.legacy.server.cpp` still emits a Legacy Script (`boot.server.luau`). `.client.cpp` stays a LocalScript. Do not invent `init.meta.json` on the default 1:1 path.
-
-## Where files live
-
-```
-src/server/.../*.server.cpp   → out/server  (ServerScriptService.Cluaupp)
-src/client/.../*.client.cpp   → out/client  (StarterPlayerScripts.Cluaupp)
-src/shared/.../*.cpp          → out/shared  (ReplicatedStorage.Cluaupp)
-```
-
-Name the **system**, not `init.server.cpp`. `LeaderstatsServer.server.cpp` and `DataBoot.server.cpp` are two files.
-
-## Opt-in planner
-
-`"architecture": true` in `cluaupp.config.json` restores PascalCase service folders (`Main`, Controller, Types). Default is off.
+Language details: [CL++ docs](https://kartzrbx.github.io/CLPP/).

package/docs/oop/index.md

@@ -3,20 +3,27 @@ title: OOP structure
 sidebar_position: 1
 ---
 
-# OOP structure
+# Structs and methods
 
-The **live site** (not just these markdown files) is GitHub Pages:
+Language details: [CL++](https://kartzrbx.github.io/CLPP/). Filename tags decide Script / LocalScript / ModuleScript.
 
-- [Learn → OOP structure](https://kartzrbx.github.io/Cluaupp/learn/index.html)
-- [Guide → OOP](https://kartzrbx.github.io/Cluaupp/guide/oop.html)
-- [Examples](https://kartzrbx.github.io/Cluaupp/guide/examples.html)
+Declare the type in a `.clh`, implement `Class::Method` in a `.clp` / `.clpp`. Capture one service table in `void init()`.
 
-Cluaupp does **not** compile custom C++ `class` types yet. “OOP” here is how you **lay out systems** so Studio gets Script / LocalScript / ModuleScript from the filename tag — the same idea as roblox-ts. Flamework-style Start/Stop folders are opt-in (`"architecture": true`).
+```clpp
+#pragma once
+#include <clpp/roblox.clh>
+#include <clpp/libs/janitor.clh>
+
+struct LeaderstatsServer {
+	static constexpr int STARTING_COINS = 0;
+	Janitor* janitor;
+	string GetPlayerJanitorKey(Player* player);
+	void PlayerEntered(Player* player);
+};
+```
 
 | Page | What you learn |
 | --- | --- |
-| [File tags](file-tags.md) | `.server` / `.client` / `.plugin` / `.legacy` / untagged |
-| [Services](services.md) | One `.server.cpp` → one `.server.luau` |
-| [Modules](modules.md) | Untagged files, structs, named functions as methods |
-
-Planner details: [Architecture](../architecture.md). Folder layout: [Organization](../cpp-organization.md). Full services: [Examples](../examples/index.md).
+| [File tags](file-tags.md) | `.server.clpp` / `.client.clpp` / `.clh` |
+| [Services](services.md) | `init()` singletons |
+| [Modules](modules.md) | shared `.clp` |

package/docs/roblox-api.md

@@ -1,16 +1,10 @@
 # Roblox API
 
-Cluaupp covers the engine API listed on [create.roblox.com](https://create.roblox.com/docs/reference/engine): **925 classes**, **636 enums**, and the datatypes (`Vector3`, `CFrame`, `UDim`, `UDim2`, …).
+Cluaupp uses the official engine. Spell the call in C++; look up members on [create.roblox.com](https://create.roblox.com/docs/reference/engine). The GitHub Pages site is a **language handbook**, not a dump of every Enum item.
 
-The **page-by-page** reference (every property, method, and event, with C++ and Luau) lives on the generated site:
+Handbook: **[Docs](https://kartzrbx.github.io/Cluaupp/docs/)** · [Roblox in Cluaupp](https://kartzrbx.github.io/Cluaupp/docs/engine.html)
 
-**[Cluaupp docs (GitHub Pages)](https://kartzrbx.github.io/Cluaupp/)**
-
-- [Datatypes](https://kartzrbx.github.io/Cluaupp/api/datatypes/)
-- [Classes](https://kartzrbx.github.io/Cluaupp/api/classes/)
-- [Enums](https://kartzrbx.github.io/Cluaupp/api/enums/)
-
-In C++, `#include <cluaupp/roblox.hpp>`. The compiler ignores the header and emits real Luau.
+`#include <cluaupp/roblox.hpp>` is IntelliSense. The compiler ignores the header and emits real Luau.
 
 ## Datatypes
 
@@ -20,7 +14,6 @@ part->Position = Vector3(0, 10, 0);
 part->CFrame = CFrame::lookAt(Vector3(0, 10, 0), Vector3(0, 10, -10));
 part->Color = Color3::fromRGB(255, 0, 0);
 frame->Size = UDim2::fromScale(1, 1);
-frame->Position = UDim2(0, 0, 0.5, 0);
 auto material = Enum::Material::Plastic;
 ```
 
@@ -30,52 +23,7 @@ part.Position = Vector3.new(0, 10, 0)
 part.CFrame = CFrame.lookAt(Vector3.new(0, 10, 0), Vector3.new(0, 10, -10))
 part.Color = Color3.fromRGB(255, 0, 0)
 frame.Size = UDim2.fromScale(1, 1)
-frame.Position = UDim2.new(0, 0, 0.5, 0)
 local material = Enum.Material.Plastic
 ```
 
-| C++ | Luau |
-| --- | --- |
-| `Vector3(x, y, z)` | `Vector3.new(x, y, z)` |
-| `Vector2(x, y)` | `Vector2.new(x, y)` |
-| `CFrame(x, y, z)` | `CFrame.new(x, y, z)` |
-| `CFrame::lookAt(from, look)` | `CFrame.lookAt(from, look)` |
-| `UDim(scale, offset)` | `UDim.new(scale, offset)` |
-| `UDim2(xs, xo, ys, yo)` | `UDim2.new(xs, xo, ys, yo)` |
-| `UDim2::fromScale(x, y)` | `UDim2.fromScale(x, y)` |
-| `UDim2::fromOffset(x, y)` | `UDim2.fromOffset(x, y)` |
-| `Color3::fromRGB(r, g, b)` | `Color3.fromRGB(r, g, b)` |
-| `Color3::fromHSV(h, s, v)` | `Color3.fromHSV(h, s, v)` |
-| `BrickColor("Bright red")` | `BrickColor.new("Bright red")` |
-| `Enum::Material::Plastic` | `Enum.Material.Plastic` |
-| `Rect(x0, y0, x1, y1)` | `Rect.new(x0, y0, x1, y1)` |
-| `Ray(origin, direction)` | `Ray.new(origin, direction)` |
-| `NumberRange(min, max)` | `NumberRange.new(min, max)` |
-| `TweenInfo(time, style)` | `TweenInfo.new(time, style)` |
-
-## Instances and services
-
-```cpp
-auto* part = new Part(workspace);
-auto* players = GetService<Players>();
-player->FindFirstChild("leaderstats");
-players->GetPlayers();
-```
-
-```luau
-local part: Part = Instance.new("Part")
-part.Parent = workspace
-local players: Players = game:GetService("Players")
-player:FindFirstChild("leaderstats")
-players:GetPlayers()
-```
-
-`new Class(parent)` is for creatable classes (`Instance.new`). Services use `GetService<Name>()`.
-
-Generated headers (official client dump):
-
-- `include/cluaupp/datatypes.hpp`
-- `include/cluaupp/generated/enums.hpp`
-- `include/cluaupp/generated/instances.hpp`
-
-To regenerate: `npm run generate-api` in the `cluau/` folder.
+Every enum is `Enum::Name::Item` → `Enum.Name.Item`. Services are `GetService<Players>()`. Instances are `new Folder(parent)` and `player->FindFirstChild("x")`.