cluaupp 0.2.3 → 1.0.0

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/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

@@ -5,16 +5,14 @@ sidebar_position: 1
 
 # Structs and methods
 
-Live handbook: [Structs and methods](https://kartzrbx.github.io/Cluaupp/docs/structs.html). Singletons: [one table in `init()`](https://kartzrbx.github.io/Cluaupp/docs/singletons.html).
+Language details: [CL++](https://kartzrbx.github.io/CLPP/). Filename tags decide Script / LocalScript / ModuleScript.
 
-Cluaupp does **not** emit C++ `class` metatables. You write a **type** as a `struct` in a sibling header and implement `Class::Method` in the `.cpp`. Filename tags still decide Script / LocalScript / ModuleScript.
+Declare the type in a `.clh`, implement `Class::Method` in a `.clp` / `.clpp`. Capture one service table in `void init()`.
 
-Construct **one** `LeaderstatsServer` in `void init()`, assign `janitor = new Janitor()`, and capture it in `[&]` lambdas. Library singletons already exist (`DataService::Server`) — `Init` once from a boot script. Join strings with `string_concat` or string `+`, not Luau `..`.
-
-```cpp
+```clpp
 #pragma once
-#include <cluaupp/roblox.hpp>
-#include <cluaupp/libs/janitor.hpp>
+#include <clpp/roblox.clh>
+#include <clpp/libs/janitor.clh>
 
 struct LeaderstatsServer {
 	static constexpr int STARTING_COINS = 0;
@@ -24,12 +22,8 @@ struct LeaderstatsServer {
 };
 ```
 
-The stem must match: `LeaderstatsServer.h` next to `LeaderstatsServer.server.cpp`. `#include "leaderstats.h"` from a differently named cpp is a `require`, not the class body.
-
 | 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: [Architecture](../architecture.md). Folder layout: [Organization](../cpp-organization.md). Full copy: [Leaderstats](../examples/leaderstats.md).
+| [File tags](file-tags.md) | `.server.clpp` / `.client.clpp` / `.clh` |
+| [Services](services.md) | `init()` singletons |
+| [Modules](modules.md) | shared `.clp` |

package/docs/syntax.md

@@ -1,262 +1,80 @@
-# C++ → Luau syntax
+# CL++ syntax (Cluaupp)
 
-Cluaupp is not a full C++ compiler. It is a **subset** aimed at Roblox scripts, in the same spirit as roblox-ts (restricted TypeScript → Luau).
+Cluaupp does **not** define the language. Write CL++ (`.clpp` / `.clp` / `.clh`); `clpp` emits Luau. Full course and reference: **[kartzrbx.github.io/CLPP](https://kartzrbx.github.io/CLPP/)**.
 
-Live grid of every construct: **[Language reference](https://kartzrbx.github.io/Cluaupp/docs/reference.html)**.
+## Files
 
-Generated Luau follows the current language: [`local`](https://luau.org/getting-started), `const`, and `const function`. Injected `require` / `GetService` lines are `const`. `--!strict` is emitted only when the file has `#pragma strict` (or `"strict": true` in config). `#pragma nstrict` never emits it.
-
-## Files and includes
-
-- Extensions: `.cpp`, `.cc`, `.cxx`, `.c`, `.h`, `.hpp`, `.hh`
-- Tags: `*.server.cpp` → Script, `*.client.cpp` → LocalScript, `*.plugin.cpp` → Plugin, `*.legacy*` → Legacy, untagged → ModuleScript
-- Quoted `#include "Own.h"` (same stem as the `.cpp`) is **inlined**. Other quoted includes become `require` (Rojo path)
-- `#include <cluaupp/roblox.hpp>` is IntelliSense only. `#include <cluaupp/libs/janitor.hpp>` also injects `require(CluauppLibs.Janitor)`
-- `#pragma once` is ignored. Other macros are not expanded. `//` and `/* */` comments are stripped
-- `using …;` is skipped. `namespace { }` is flattened. `enum` / `template` / `typedef` / `extern` declarations are skipped
-
-## Types
-
-| C++ | Luau |
+| Source | Rojo |
 | --- | --- |
-| `int` / `float` / `double` | `number` |
-| `bool` | `boolean` |
-| `string` | `string` (not `std::string`) |
-| `void` | no return annotation |
-| `auto` / `auto*` | inferred from `new` / `GetService` / datatype ctor |
-| `Player*` / `Folder*` | `Player` / `Folder` (Instance handle, not a heap address) |
-| `LuaArray<T>` / `vector<T>` / `array<T>` / `span<T>` | `{T}` |
-| `optional<T>` | `T?` |
-| `const` / `static constexpr` | Luau `const` |
-| `nullptr` | `nil` |
-| `Vector3` `CFrame` `UDim2` `Color3` | same names (copied values) |
-| `Enum::Material::Plastic` | `Enum.Material.Plastic` |
+| `*.server.clpp` | Script |
+| `*.client.clpp` | LocalScript |
+| `*.plugin.clpp` | Plugin Script |
+| `*.clp` / untagged `.clpp` | ModuleScript |
+| `*.clh` | ModuleScript (types / structs) |
 
-Always initialize: `int coins = 0;` not `int coins;` (uninitialized emits `nil`). There is no `delete`, no `*part`, no `&part`, no `int&`. Numbers copy; Instances mutate through `->`.
+`void init()` is the script entry. There is no `int main()`.
 
-`auto` infers when the value is `new Class(...)`, `GetService<T>()`, or a datatype constructor. Prefer explicit types on parameters and struct fields.
+## Accessors
 
-## Functions
+CL++ does **not** use `->`.
 
-```cpp
-void CreateLeaderstats(Player* player) {
-	return;
-}
+| Write | Meaning | Luau |
+| --- | --- | --- |
+| `player.Name` | property | `.` |
+| `player::FindFirstChild("x")` | method | `:` |
+| `DataService:Server` | table key | `.` |
+| `"hi " .: name` | concat | `..` |
+| `signal~>Connect(fn)` | janitor Connect | `janitor:Add(..., "Disconnect")` |
+| `signal~>Once(fn)` | one-shot | `Once` + janitor |
 
-int doubleCoins(int coins) {
-	return coins;
-}
-```
+`post` / `warn` / `report` → `print` / `warn` / `error`. `null` is `nil`.
 
-```luau
-const function CreateLeaderstats(player: Player)
-	return
-end
+## Exclusive CL++ (compiled by `clpp`)
 
-const function doubleCoins(coins: number): number
-	return coins
-end
-```
-
-- Only functions with a body are emitted from a `.cpp`. Prototypes in a `.h` become `export type` fields
-- No overloading — one name, one emit. No default arguments
-- If `void init()` exists, emit appends `init()` at the end of Scripts / LocalScripts. There is no `int main()`
-- Shared ModuleScripts should not define `init()` unless you want them to run on `require`
-
-## Scopes
-
-- File-level decls become file `local` / `const`
-- Function decls become `local` from that line to the end of the block. Nested `{ }` can shadow
-- In `Class::Method`, `this` is `self`. Bare field names become `self.field`. Bare calls to other methods become `self:Method(...)`. Parameters and locals shadow fields
-- Globals stay bare: `print`, `game`, `workspace`, library types, Instance types, datatypes
-- Instances are not RAII. Leaving a block does not Destroy a Part — use Janitor
-
-## Control flow
-
-```cpp
-if (player->FindFirstChild("leaderstats") != nullptr) {
+```clpp
+guard (player != null) else {
+	warn("Invalid player");
 	return;
-} else {
-	print("ok");
 }
 
-while (true) {
-	print("tick");
-}
-
-for (auto* player : players->GetPlayers()) {
-	CreateLeaderstats(player);
-}
-
-switch (action) {
-case "buy":
-case "purchase":
-	Grant(player);
-	break;
-case "sell":
-	if (amount <= 0) {
-		break;
-	}
-	Take(player);
-	break;
-default:
-	warn("unknown");
-	break;
-}
-```
-
-```luau
-if player:FindFirstChild("leaderstats") ~= nil then
-	return
-else
-	print("ok")
-end
-
-while true do
-	print("tick")
-end
-
-for _, player in players:GetPlayers() do
-	CreateLeaderstats(player)
-end
-
-repeat
-	if action == "buy" or action == "purchase" then
-		Grant(player)
-	elseif action == "sell" then
-		if amount <= 0 then
-			break
-		end
-		Take(player)
-	else
-		warn("unknown")
-	end
-until true
-```
-
-`switch` evaluates the discriminant **once**, then becomes `if` / `elseif` / `else` inside `repeat … until true` so `break` still exits the switch (even from inside an `if`). Stacked `case` labels share a body. There is no C-style fall-through. C-style `for (int i = 0; i < n; i++)` is not supported. No `continue`, no `do/while`, no ternary. `else if (x)` emits a nested `if` inside `else` (not Luau `elseif`).
-
-## Expressions and operators
-
-| C++ | Luau |
-| --- | --- |
-| `nullptr` | `nil` |
-| `true` / `false` | `true` / `false` |
-| `!=` | `~=` |
-| `&&` | `and` |
-| `\|\|` | `or` |
-| `!` | `not` |
-| `==` `+` `-` `*` `/` `<` `>` `<=` `>=` | same (`*` is multiply) |
-| `"text"` | `"text"` |
-| `=` | assignment |
-| `obj->Prop` | `obj.Prop` |
-| `obj->Method(a)` | `obj:Method(a)` if the method is a Roblox / library API |
-| `fn(a)` | `fn(a)` |
-| `signal.Connect(fn)` | `signal:Connect(fn)` |
-| `Type { .Field = value }` | `{ Field = value }` |
-| unary `-` | `-` |
+match (child) {
+	BasePart* p => BindPart(p),
+	Model* m => post("model spawned " .: m.Name),
+	_ => warn("ignored instance")
+};
 
-No `++` `--` `+=`. Write `n = n + 1`. Binary operators in this subset are left-associative — use parentheses when mixing.
-
-Designated initializers become Luau tables:
-
-```cpp
-DataService::Server.Init(DataServiceOptions {
-	.Template = playerData,
-	.StoreName = "PlayerData",
-	.UseMock = true,
+observable int wallet = 100;
+wallet.OnChange(func [](int newValue) {
+	post("Coins changed to: " .: newValue);
 });
-```
-
-```luau
-DataService.Server:Init({
-	Template = playerData,
-	StoreName = "PlayerData",
-	UseMock = true,
-})
-```
-
-## Strings and string_concat
-
-Luau concatenates with `..`. Do not write `..` in a `.cpp`.
-
-- If either side of `+` is a string literal, another concat, or `.Name` / `.Text` / `.DisplayName`, `+` becomes `..`
-- `string_concat(a, b, c)` is variadic: zero args → `""`, one arg → that value, several → `(a .. b .. c)`
-- Declared in `datatypes.hpp` (via `roblox.hpp`)
-
-```cpp
-return player->Name + "_LeaderstatsJanitor";
-return string_concat(player->Name, "_", "LeaderstatsJanitor");
-```
-
-```luau
-return player.Name .. "_LeaderstatsJanitor"
-return (player.Name .. "_" .. "LeaderstatsJanitor")
-```
-
-## print / cout
-
-`print`, `warn`, and `error` work as in Luau. `cout << … << endl` is the C++ spelling — each `<<` is another argument, `endl` ends the line. `cout::warn` / `cout::error` / `cout::ping` pick the Roblox function. `cerr` is `warn`. Full table: [print and cout](print-cout.md).
 
-## `new` and services
-
-```cpp
-auto* coins = new IntValue(leaderstats);
-auto* players = GetService<Players>();
-auto* janitor = new Janitor();
-part->Size = Vector3(8, 1, 8);
-part->CFrame = CFrame::lookAt(from, look);
-part->Material = Enum::Material::Plastic;
-```
-
-```luau
-local coins: IntValue = Instance.new("IntValue")
-coins.Parent = leaderstats
-local players: Players = game:GetService("Players")
-local janitor = Janitor.new()
-part.Size = Vector3.new(8, 1, 8)
-part.CFrame = CFrame.lookAt(from, look)
-part.Material = Enum.Material.Plastic
-```
-
-The first argument of `new Class(parent)` becomes `.Parent` for Instance classes. Libraries use `Janitor.new()`. Datatypes use `Vector3(...)`, not `new`.
-
-## Casts
+signal<Player*, int> OnHit;
+OnHit~>Connect(func [](Player* player, int amount) {
+	post(player.Name .: " dmg " .: amount);
+});
+OnHit::Fire(player, 10);
 
-`static_cast<T>(x)`, `const_cast`, `reinterpret_cast`, `dynamic_cast` emit the argument. `(void)x;` is omitted (silences unused for clangd). Luau has no casts — they do not check ClassName.
+array<string> names = {"Kartz", "Player1"};
+dictionary<string, int> stats = { {"Coins", 100}, {"Gems", 50} };
 
-## Callbacks (events and lambdas)
+spawn { task::wait(1); post("ready"); };
+parallel { post("desync"); };
 
-Signals use `.Connect`. Callbacks may be **named functions** or **lambdas** (`[](Player* player) { ... }`, including `[&]` / `[=]` / `[coinsValue]`). Capture lists are accepted; Luau closures do not copy C++ captures — keep Instances alive with Janitor.
+async Data* FetchData(Player* player) {
+	return await DataService:Server::WaitFor(player);
+}
 
-Passing a method by name from inside `Class::` binds `self`: `function(...) self:OnPlayer(...) end`.
+[[server]]
+void SaveData(Player* player) { post(player.Name); }
 
-```cpp
-players->PlayerAdded.Connect([&](Player* playerEntered) {
-	leaderstatsServer.PlayerEntered(playerEntered);
-});
-game->BindToClose([&]() {
-	leaderstatsServer.janitor->Cleanup();
-});
+[[client]]
+void UpdateUI() { post("ui"); }
 ```
 
-## OOP: structs, methods, singletons
-
-How you write a type: a `struct` (or `class`) in the sibling `.h`, `Class::Method` in the `.cpp`, `void init()` to boot.
-
-- `static constexpr` fields are `const`
-- Fields are `self.field`. `public:` / `private:` are ignored
-- Nested structs with defaults become nested tables (DataService Templates). `LuaArray<T>` fields stay on the table
-- `Class::` methods emit `function Class:Method(...)`
-- Construct **one** service table in `init()` (`LeaderstatsServer leaderstatsServer;`) and capture it in lambdas. That is the game singleton
-- Library singletons already exist: `DataService::Server` / `Client` — `Init` once from a boot script
-- Header-only field structs emit `const function Name()` returning defaults
-- Untagged files of only `Class::` methods `return` the table (ModuleScript)
-
-Stem must match: `LeaderstatsServer.h` next to `LeaderstatsServer.server.cpp`. A differently named include is a `require`, not the class body.
-
-## Not supported
+Fusion HUD uses `Fusion:scoped`, `Fusion:Value`, `Fusion:Computed`, `Fusion:New`. See [`examples/game`](../examples/game) (`combat.server.clpp`, `hud.client.clpp`, `features.clp`, `PlayerData.clh`).
 
-Custom C++ classes as metatables, generic templates besides `GetService<T>` / `static_cast<T>` / `LuaArray<T>` / `string_concat`, pointer arithmetic, `std::` (except mapped aliases), overloading, macros (except `#pragma strict` / `#pragma nstrict` / `#pragma once`), JSX / XML UI tags, C-style `for`, `++` `--` `+=`, `continue`, ternary, `do/while`, `try/catch`, `goto`, `int&` references.
+## What Cluaupp adds after `clpp`
 
-CLI forms: [CLI](cli.md). How to write a type: [OOP](oop/index.md). Full handbook: **[Docs](https://kartzrbx.github.io/Cluaupp/docs/)**.
+- `require(ClppLibs.X)` → `require(ReplicatedStorage.CluauppLibs.X)`
+- `--!strict` from `cluaupp.config.json` / `#pragma strict`
+- `out/` layout for Rojo (`init`, `build`, `watch`)

package/editors/vscode/extension.js

@@ -55,7 +55,7 @@ function activate(context) {
 	});
 
 	const refreshDiagnostics = (document) => {
-		if (!document || document.languageId !== "cpp") {
+		if (!document || (document.languageId !== "clpp" && document.languageId !== "cpp")) {
 			return;
 		}
 		if (typeof loaded.engine.diagnosticsFor !== "function") {

package/editors/vscode/package.json

@@ -1,8 +1,8 @@
 {
 	"name": "cluaupp-diagnostics",
 	"displayName": "Cluaupp",
-	"description": "Cluaupp subset parse errors. C++ completion, hover, and go-to-definition come from clangd + include/cluaupp/roblox.hpp.",
-	"version": "0.2.2",
+	"description": "Cluaupp project diagnostics. Language highlighting and IntelliSense come from clpp install (CL++).",
+	"version": "1.0.0",
 	"publisher": "kartzdev",
 	"engines": {
 		"vscode": "^1.74.0"
@@ -11,14 +11,14 @@
 		"Linters"
 	],
 	"activationEvents": [
-		"onLanguage:cpp"
+		"onLanguage:clpp"
 	],
 	"main": "./extension.js",
 	"contributes": {
 		"commands": [
 			{
 				"command": "cluaupp.restartIntelliSense",
-				"title": "Cluaupp: Reload subset diagnostics"
+				"title": "Cluaupp: Reload CL++ diagnostics"
 			}
 		]
 	}

package/examples/README.md

@@ -1,18 +1,16 @@
 # Sample game
 
-This is the C++ a Cluaupp game looks like — **not** the compiler.
+CL++ sources for a Cluaupp project — **not** the compiler. Language samples: [CL++ examples](https://github.com/KartzRbx/CLPP/tree/main/examples).
 
 | Folder | Rojo | Tag |
 | --- | --- | --- |
-| `src/server/*.server.cpp` | Script | server |
-| `src/client/*.client.cpp` | LocalScript | client |
-| `src/shared/*` | ModuleScript | none |
-
-`src/` of **this repo** is the TypeScript CLI ([roblox-ts](https://github.com/roblox-ts/roblox-ts) does the same). The sample scripts live here so they never mix with `understand.ts`.
+| `src/server/*.server.clpp` | Script | server |
+| `src/client/*.client.clpp` | LocalScript | client |
+| `src/shared/*.clp` / `*.clh` | ModuleScript | none |
 
 ```bash
 cd examples/game
 npx cluaupp build .
 ```
 
-`cluaupp init` copies `templates/game` (the slim scaffold). This folder adds combat / HUD so `SystemUnderstander` has real tokens to score.
+`cluaupp init` copies `templates/game`. This folder adds combat (`guard` / `match` / `signal` / `observable` / `spawn`), a Fusion HUD, `features.clp`, and `PlayerData.clh`.

package/examples/game/.vscode/extensions.json

@@ -1,7 +1,4 @@
 {
-	"recommendations": [
-		"llvm-vs-code-extensions.vscode-clangd"
-	],
 	"unwantedRecommendations": [
 		"ms-vscode.cpptools"
 	]

package/examples/game/.vscode/settings.json

@@ -1,18 +1,10 @@
 {
-	"clangd.enable": true,
-	"clangd.arguments": [
-		"--compile-commands-dir=${workspaceFolder}",
-		"--header-insertion=never",
-		"--query-driver=**/clang++*,**/clang++.exe,**/g++*,**/g++.exe"
-	],
 	"files.associations": {
-		"*.hpp": "cpp",
-		"*.h": "cpp",
-		"*.server.cpp": "cpp",
-		"*.client.cpp": "cpp",
-		"*.plugin.cpp": "cpp",
-		"*.legacy.cpp": "cpp",
-		"*.legacy.server.cpp": "cpp",
-		"*.legacy.client.cpp": "cpp"
+		"*.clpp": "clpp",
+		"*.clp": "clpp",
+		"*.clh": "clpp",
+		"*.server.clpp": "clpp",
+		"*.client.clpp": "clpp",
+		"*.plugin.clpp": "clpp"
 	}
 }

package/examples/game/src/client/hud.client.clpp

@@ -0,0 +1,54 @@
+#pragma strict
+#include <clpp/roblox.clh>
+#include <clpp/libs/fusion.clh>
+
+[[client]]
+void init() {
+	Players* players = GetService<Players>();
+	Player* localPlayer = players.LocalPlayer;
+	guard (localPlayer != null) else {
+		report("LocalPlayer missing");
+		return;
+	}
+
+	Instance* playerGui = localPlayer::WaitForChild("PlayerGui");
+	auto scope = Fusion:scoped();
+	auto Children = Fusion:Children;
+
+	auto coins = Fusion:Value(scope, 0);
+	auto title = Fusion:Computed(scope, func []() {
+		return "Coins: " .: coins();
+	});
+
+	auto newScreenGui = Fusion:New(scope, "ScreenGui");
+	auto newFrame = Fusion:New(scope, "Frame");
+	auto newLabel = Fusion:New(scope, "TextLabel");
+
+	auto label = newLabel({
+		{"Name", "Amount"},
+		{"BackgroundTransparency", 1},
+		{"Size", UDim2.fromScale(1, 1)},
+		{"Text", title},
+		{"TextColor3", Color3.fromRGB(255, 255, 255)},
+		{"TextScaled", true}
+	});
+
+	auto frame = newFrame({
+		{"Name", "Hud"},
+		{"AnchorPoint", Vector2(0, 1)},
+		{"Position", UDim2.fromScale(0, 1)},
+		{"Size", UDim2.fromOffset(220, 64)},
+		{"BackgroundColor3", Color3.fromRGB(28, 18, 48)},
+		{Children, label}
+	});
+
+	newScreenGui({
+		{"Name", "CoinsHud"},
+		{"ResetOnSpawn", false},
+		{"Parent", playerGui},
+		{Children, frame}
+	});
+
+	coins(100);
+	post("hud ready");
+}