cluaupp 0.2.3 → 1.0.0

package/docs/examples/combat.md

@@ -3,237 +3,29 @@ title: Combat (server validation)
 sidebar_position: 4
 ---
 
-# Combat (server validation)
+# Combat
 
-The client never sends **damage**. It sends **who I want to hit**. The server decides range, cooldown, alive state, and the damage constant.
+Live source: [`examples/game/src/server/combat.server.clpp`](../../examples/game/src/server/combat.server.clpp). Language: [CL++](https://kartzrbx.github.io/CLPP/).
 
-Pair with [Data boot](data-boot.md) if a kill should grant Money.
+This sample uses exclusive CL++:
 
-## Shared config
+- `guard` / `match` instead of nested null checks
+- `signal<Player*, int> OnHit` and `OnHit~>Connect` / `OnHit::Fire`
+- `observable int combo`
+- `[[server]]` on `WatchWorkspace`
+- `spawn { task::wait(1); … }`
 
-`src/shared/constants/CombatConfig.hpp`
+The client never decides damage. Touched parts fire `OnHit`; the server prints combo and destroys the part.
 
-```cpp
-#pragma once
+```clpp
+#include <clpp/roblox.clh>
+#include <clpp/libs/janitor.clh>
 
-const double ATTACK_RANGE = 12;
-const double ATTACK_COOLDOWN = 0.4;
-const int ATTACK_DAMAGE = 12;
-const int KILL_REWARD = 5;
+struct CombatServer {
+	Janitor* janitor;
+	signal<Player*, int> OnHit;
+	void PlayerEntered(Player* player);
+	void BindPart(BasePart* part);
+	void WatchWorkspace();
+};
 ```
-
-Keep numbers in a header. Both server and client can include range for FX; **only the server** applies `TakeDamage`.
-
-## Server — `CombatServer.server.cpp`
-
-```cpp
-#include <cluaupp/roblox.hpp>
-#include <cluaupp/libs/janitor.hpp>
-#include <cluaupp/libs/net.hpp>
-#include <cluaupp/libs/dataservice.hpp>
-#include "../../../shared/constants/CombatConfig.hpp"
-
-Players* Players = GetService<Players>();
-Janitor* janitor = new Janitor();
-NetEvent* Attack = Net::Event("Attack");
-
-BasePart* RootPart(Model* character) {
-	if (character == nullptr) {
-		return nullptr;
-	}
-	return character->FindFirstChild("HumanoidRootPart");
-}
-
-Humanoid* HumanoidOf(Model* character) {
-	if (character == nullptr) {
-		return nullptr;
-	}
-	return character->FindFirstChildOfClass("Humanoid");
-}
-
-bool InRange(Model* a, Model* b, double maxRange) {
-	BasePart* rootA = RootPart(a);
-	BasePart* rootB = RootPart(b);
-	if (rootA == nullptr) {
-		return false;
-	}
-	if (rootB == nullptr) {
-		return false;
-	}
-	Vector3 delta = rootA->Position - rootB->Position;
-	if (delta.Magnitude > maxRange) {
-		return false;
-	}
-	return true;
-}
-
-bool OnCooldown(Player* attacker) {
-	NumberValue* last = attacker->FindFirstChild("LastAttackAt");
-	if (last == nullptr) {
-		return false;
-	}
-	if (tick() - last->Value < ATTACK_COOLDOWN) {
-		return true;
-	}
-	return false;
-}
-
-void MarkAttack(Player* attacker) {
-	NumberValue* last = attacker->FindFirstChild("LastAttackAt");
-	if (last == nullptr) {
-		last = new NumberValue(attacker);
-		last->Name = "LastAttackAt";
-	}
-	last->Value = tick();
-}
-
-void RewardKill(Player* attacker) {
-	Data* data = DataService::Server.Get(attacker);
-	if (data == nullptr) {
-		return;
-	}
-	int money = data->Get(DataService::Server.Paths.Currencies.Money);
-	data->Set(DataService::Server.Paths.Currencies.Money, money + KILL_REWARD);
-}
-
-void OnAttack(Player* attacker, int targetUserId) {
-	if (attacker == nullptr) {
-		return;
-	}
-	if (targetUserId < 1) {
-		return;
-	}
-	if (OnCooldown(attacker)) {
-		return;
-	}
-
-	Player* target = Players->GetPlayerByUserId(targetUserId);
-	if (target == nullptr) {
-		return;
-	}
-	if (target == attacker) {
-		return;
-	}
-
-	Model* attackerChar = attacker->Character;
-	Model* targetChar = target->Character;
-	Humanoid* attackerHum = HumanoidOf(attackerChar);
-	Humanoid* targetHum = HumanoidOf(targetChar);
-	if (attackerHum == nullptr) {
-		return;
-	}
-	if (targetHum == nullptr) {
-		return;
-	}
-	if (attackerHum->Health <= 0) {
-		return;
-	}
-	if (targetHum->Health <= 0) {
-		return;
-	}
-	if (InRange(attackerChar, targetChar, ATTACK_RANGE) == false) {
-		cout::ping << attacker->Name << " out of range" << endl;
-		return;
-	}
-
-	MarkAttack(attacker);
-	double healthBefore = targetHum->Health;
-	targetHum->TakeDamage(ATTACK_DAMAGE);
-	if (healthBefore > 0) {
-		if (targetHum->Health <= 0) {
-			RewardKill(attacker);
-		}
-	}
-}
-
-void init() {
-	Attack->On(OnAttack);
-	janitor->Add(Attack);
-}
-```
-
-## Client — `CombatClient.client.cpp`
-
-The LocalScript only picks a target and fires. It does **not** pass `ATTACK_DAMAGE`.
-
-```cpp
-#include <cluaupp/roblox.hpp>
-#include <cluaupp/libs/janitor.hpp>
-#include <cluaupp/libs/net.hpp>
-
-Players* Players = GetService<Players>();
-UserInputService* UserInput = GetService<UserInputService>();
-Janitor* janitor = new Janitor();
-NetEvent* Attack = Net::Event("Attack");
-
-Player* PlayerFromPart(Instance* part) {
-	if (part == nullptr) {
-		return nullptr;
-	}
-	Instance* model = part->FindFirstAncestorOfClass("Model");
-	if (model == nullptr) {
-		return nullptr;
-	}
-	Player* fromModel = Players->GetPlayerFromCharacter(model);
-	if (fromModel != nullptr) {
-		return fromModel;
-	}
-	Instance* outer = model->FindFirstAncestorOfClass("Model");
-	if (outer == nullptr) {
-		return nullptr;
-	}
-	return Players->GetPlayerFromCharacter(outer);
-}
-
-void OnInputBegan(InputObject* input, bool gameProcessed) {
-	if (gameProcessed) {
-		return;
-	}
-	if (input->UserInputType != Enum::UserInputType::MouseButton1) {
-		return;
-	}
-	Player* localPlayer = Players->LocalPlayer;
-	if (localPlayer == nullptr) {
-		return;
-	}
-	Mouse* mouse = localPlayer->GetMouse();
-	if (mouse == nullptr) {
-		return;
-	}
-	Player* target = PlayerFromPart(mouse->Target);
-	if (target == nullptr) {
-		return;
-	}
-	if (target == localPlayer) {
-		return;
-	}
-	Attack->FireServer(target->UserId);
-}
-
-void init() {
-	janitor->Add(UserInput->InputBegan.Connect(OnInputBegan));
-}
-```
-
-## What the server rejects
-
-| Client cheat | Server check |
-| --- | --- |
-| `FireServer(99999)` damage | Damage is `ATTACK_DAMAGE` in the header — not an argument |
-| Hit a player across the map | `delta.Magnitude > ATTACK_RANGE` |
-| Spam click | `LastAttackAt` + `ATTACK_COOLDOWN` |
-| Target userId `0` / self | `targetUserId < 1`, `target == attacker` |
-| Hit a dead / missing character | Humanoid nil or `Health <= 0` |
-| Fire before spawn | `Character` / `HumanoidRootPart` missing |
-
-`Net::Event("Attack")` must be the **same string** on both sides. Treat that name as public protocol.
-
-## Cooldown storage
-
-`LastAttackAt` is a `NumberValue` on the Player: session-only, no DataStore. Do not persist combat cadence. For anti-exploit that must survive respawn, use DataService `SetTransient` on a path **you** added to the Template — still not a library field.
-
-## No lambdas
-
-`Attack->On(OnAttack)` needs a named function. The first argument of a server `On` is the `Player` who fired.
-
-See [Net](../libraries/net.md) and [Safety](../cpp-safety.md).

package/docs/examples/hud.md

@@ -5,92 +5,24 @@ sidebar_position: 6
 
 # HUD
 
-Client-only: wait for the replicated profile, write labels, listen for currency changes. No `Set` on persisted paths from the client.
+Live source: [`examples/game/src/client/hud.client.clpp`](../../examples/game/src/client/hud.client.clpp). Fusion API: [CL++](https://kartzrbx.github.io/CLPP/).
 
-Put a ScreenGui named `Hud` in StarterGui with `MoneyLabel` and `LevelLabel` (`TextLabel`).
+Client-only (`[[client]]`). `Fusion:scoped` / `Fusion:Value` / `Fusion:Computed` / `Fusion:New` build a coins label. `guard` fails if `LocalPlayer` is missing.
 
-Define callbacks **above** `init()` or use lambdas in `Connect`.
-
-## `HudClient.client.cpp`
-
-```cpp
-#include <cluaupp/roblox.hpp>
-#include <cluaupp/libs/janitor.hpp>
-#include <cluaupp/libs/dataservice.hpp>
-#include <cluaupp/libs/formatnumber.hpp>
-#include <cluaupp/libs/twinkle.hpp>
-
-Players* Players = GetService<Players>();
-Janitor* janitor = new Janitor();
-
-TextLabel* FindLabel(PlayerGui* playerGui, string name) {
-	if (playerGui == nullptr) {
-		return nullptr;
-	}
-	Instance* gui = playerGui->FindFirstChild("Hud");
-	if (gui == nullptr) {
-		return nullptr;
-	}
-	return gui->FindFirstChild(name);
-}
-
-void Render(Data* data, TextLabel* moneyLabel, TextLabel* levelLabel) {
-	if (data == nullptr) {
-		return;
-	}
-	int money = data->Get(DataService::Client.Paths.Currencies.Money);
-	int level = data->Get(DataService::Client.Paths.Currencies.Level);
-	if (moneyLabel != nullptr) {
-		moneyLabel->Text = FormatNumber::Abbreviate(money);
-	}
-	if (levelLabel != nullptr) {
-		levelLabel->Text = FormatNumber::Comma(level);
-	}
-}
-
-void OnCurrenciesChanged() {
-	Player* player = Players->LocalPlayer;
-	if (player == nullptr) {
-		return;
-	}
-	PlayerGui* playerGui = player->FindFirstChildOfClass("PlayerGui");
-	TextLabel* moneyLabel = FindLabel(playerGui, "MoneyLabel");
-	TextLabel* levelLabel = FindLabel(playerGui, "LevelLabel");
-	Render(DataService::Client.Get(), moneyLabel, levelLabel);
-}
+```clpp
+#include <clpp/roblox.clh>
+#include <clpp/libs/fusion.clh>
 
+[[client]]
 void init() {
-	Player* player = Players->LocalPlayer;
-	if (player == nullptr) {
-		return;
-	}
-	PlayerGui* playerGui = player->FindFirstChildOfClass("PlayerGui");
-	if (playerGui == nullptr) {
-		return;
-	}
-
-	Data* data = DataService::Client.WaitForData();
-	if (data == nullptr) {
-		cout::warn << "HUD: profile missing" << endl;
+	Players* players = GetService<Players>();
+	Player* localPlayer = players.LocalPlayer;
+	guard (localPlayer != null) else {
+		report("LocalPlayer missing");
 		return;
 	}
-
-	TextLabel* moneyLabel = FindLabel(playerGui, "MoneyLabel");
-	TextLabel* levelLabel = FindLabel(playerGui, "LevelLabel");
-	Render(data, moneyLabel, levelLabel);
-
-	if (moneyLabel != nullptr) {
-		Twinkle::Fade(moneyLabel, true);
-	}
-
-	janitor->Add(data->GetChangedSignal(DataService::Client.Paths.Currencies).Connect(OnCurrenciesChanged));
+	auto scope = Fusion:scoped();
+	auto coins = Fusion:Value(scope, 0);
+	coins(100);
 }
 ```
-
-## Rules
-
-- Call `DataService::Client.Init()` in [Data boot](data-boot.md) first. Script order in StarterPlayerScripts is not a contract — `WaitForData` yields until the profile exists.
-- Do not `data->Set` Money from the HUD. Display only.
-- `Twinkle::Fade` is optional. See [more libraries](../libraries/more.md).
-
-`HudClient.client.cpp` is a LocalScript (`init.client.luau`).

package/docs/examples/index.md

@@ -5,28 +5,21 @@ sidebar_position: 1
 
 # Examples
 
-High-quality Cluaupp systems you can copy. Each page is a full service: C++ that the subset actually compiles, server authority, Janitor cleanup, and the file names Studio expects.
+High-quality Cluaupp systems you can copy. Each page is a full service in **CL++**. Live sample: [`examples/game`](../../examples/game). Language reference: [kartzrbx.github.io/CLPP](https://kartzrbx.github.io/CLPP/).
 
-In this repo the live sample is [`examples/game`](../../examples/game) (`src/server`, `src/client`, `src/shared`). Compiler TypeScript is never mixed with game C++. `cluaupp init` still copies [`templates/game`](../../templates/game).
-
-These are **not** dumps of `int main()`. Entry is `void init()`. Types are `struct` + `Class::` methods. Callbacks may be named functions or lambdas. Canonical Leaderstats: [handbook](https://kartzrbx.github.io/Cluaupp/docs/leaderstats.html).
+These are **not** dumps of `int main()`. Entry is `void init()`. Types are `struct` + `Class::` methods. Canonical Leaderstats: [handbook](https://kartzrbx.github.io/Cluaupp/docs/leaderstats.html).
 
 ## Suggested layout
 
 ```
 src/
-  shared/constants/TemplateData.hpp
-  shared/constants/CombatConfig.hpp
-  shared/constants/ShopCatalog.hpp
-  server/boot/DataBoot.server.cpp
-  client/boot/DataBoot.client.cpp
-  server/services/leaderstats/LeaderstatsServer.server.cpp
-  server/services/combat/CombatServer.server.cpp
-  client/controllers/combat/CombatClient.client.cpp
-  server/services/shop/ShopServer.server.cpp
-  client/controllers/shop/ShopClient.client.cpp
-  client/controllers/hud/HudClient.client.cpp
-  server/services/weapons/SwordServer.server.cpp
+  shared/PlayerData.clh
+  shared/config.clp
+  shared/features.clp
+  server/leaderstats.server.clpp
+  server/combat.server.clpp
+  client/init.client.clpp
+  client/hud.client.clpp
 ```
 
 Boot DataService **once**. Other services `WaitFor` after that.

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,132 +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);
-}
-```
-
-This becomes `Vector3.new`, `CFrame.lookAt`, `Color3.fromRGB`, `UDim2.fromScale`, `Enum.Material.Plastic`.
-
-How to spell engine calls: [Roblox in Cluaupp](https://kartzrbx.github.io/Cluaupp/docs/engine.html). Official members: [create.roblox.com](https://create.roblox.com/docs/reference/engine). The complete subset: [Language reference](https://kartzrbx.github.io/Cluaupp/docs/reference.html).
-
-## 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";
-}
-
-void init() {
-	auto* players = GetService<Players>();
-	for (auto* player : players->GetPlayers()) {
-		CreateLeaderstats(player);
-	}
-	players->PlayerAdded.Connect(CreateLeaderstats);
-}
-```
-
-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
+  libs/                   ← CluauppLibs
 ```
 
-`#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`.
+## Tiny program
 
-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>
+```clpp
+#include <clpp/roblox.clh>
 
 void init() {
-	auto* janitor = new Janitor();
-	auto* coins = Net::Event("Coins");
-	janitor->Add(coins);
+	Players* players = GetService<Players>();
+	post("online: " .: players::GetPlayers());
 }
 ```
 
-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
-
-Language handbook (GitHub Pages): **[Docs](https://kartzrbx.github.io/Cluaupp/docs/)** — [every construct](https://kartzrbx.github.io/Cluaupp/docs/reference.html).
-
-- [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,48 +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/`
-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 and is **not licensed for Cursor**. Two C++ engines in the same window fight; Cluaupp recommends only clangd and marks cpptools as unwanted.
-
-`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/settings.json` | `clangd.enable: true`, `--compile-commands-dir` |
-| `.vscode/extensions.json` | recommends `llvm-vs-code-extensions.vscode-clangd`; marks `ms-vscode.cpptools` unwanted |
-| `.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.