cluaupp 0.1.2 → 0.1.5

package/docs/examples/shop.md

@@ -0,0 +1,122 @@
+---
+title: Shop
+sidebar_position: 5
+---
+
+# Shop
+
+The client sends **which product**. The server looks up the price, checks Money, then `Set`. Never let the client send the new balance or the price.
+
+## Catalog header
+
+`src/shared/constants/ShopCatalog.hpp`
+
+Cluaupp has no maps. A function with early returns is the catalog.
+
+```cpp
+#pragma once
+
+const int PRODUCT_HEALTH_PACK = 1;
+const int PRODUCT_SPEED_TOME = 2;
+
+int PriceOf(int productId) {
+	if (productId == PRODUCT_HEALTH_PACK) {
+		return 50;
+	}
+	if (productId == PRODUCT_SPEED_TOME) {
+		return 200;
+	}
+	return 0;
+}
+```
+
+`PriceOf` lives in a header so the **server** is the copy that matters. The client may include it for UI labels, but a patched client cannot change what the server charges.
+
+## Server — `ShopServer.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/ShopCatalog.hpp"
+
+Janitor* janitor = new Janitor();
+NetEvent* Buy = Net::Event("Buy");
+
+void ApplyProduct(Player* player, int productId) {
+	Model* character = player->Character;
+	if (character == nullptr) {
+		return;
+	}
+	Humanoid* humanoid = character->FindFirstChildOfClass("Humanoid");
+	if (humanoid == nullptr) {
+		return;
+	}
+	if (productId == PRODUCT_HEALTH_PACK) {
+		humanoid->Health = humanoid->MaxHealth;
+		return;
+	}
+	if (productId == PRODUCT_SPEED_TOME) {
+		humanoid->WalkSpeed = 24;
+		return;
+	}
+}
+
+void OnBuy(Player* player, int productId) {
+	int price = PriceOf(productId);
+	if (price < 1) {
+		cout::warn << "unknown product " << productId << endl;
+		return;
+	}
+	Data* data = DataService::Server.WaitFor(player);
+	if (data == nullptr) {
+		return;
+	}
+	int money = data->Get(DataService::Server.Paths.Currencies.Money);
+	if (money < price) {
+		cout::ping << player->Name << " cannot afford " << productId << endl;
+		return;
+	}
+	data->Set(DataService::Server.Paths.Currencies.Money, money - price);
+	ApplyProduct(player, productId);
+}
+
+void init() {
+	Buy->On(OnBuy);
+	janitor->Add(Buy);
+}
+```
+
+Debit **before** (or atomically with) the effect. If you grant the item first and the `Set` fails, the player dupes.
+
+## Client — `ShopClient.client.cpp`
+
+```cpp
+#include <cluaupp/roblox.hpp>
+#include <cluaupp/libs/janitor.hpp>
+#include <cluaupp/libs/net.hpp>
+#include "../../../shared/constants/ShopCatalog.hpp"
+
+Janitor* janitor = new Janitor();
+NetEvent* Buy = Net::Event("Buy");
+
+void OnHealthPackClicked() {
+	Buy->FireServer(PRODUCT_HEALTH_PACK);
+}
+
+void init() {
+	return;
+}
+```
+
+Wire `OnHealthPackClicked` to a `TextButton->MouseButton1Click.Connect(OnHealthPackClicked)` when you have the GUI. The remote payload is only the product id.
+
+## Rules
+
+- `productId < 1` / unknown id → `PriceOf` returns `0` → reject.
+- Do not `FireServer(price)` or `FireServer(newMoney)`.
+- [Leaderstats](leaderstats.md) updates from `GetChangedSignal` after `Set`.
+- Same Net name `"Buy"` on both sides.
+
+See [Safety](../cpp-safety.md).

package/docs/examples/sword.md

@@ -0,0 +1,108 @@
+---
+title: Sword (Touched)
+sidebar_position: 7
+---
+
+# Sword (Touched)
+
+Melee that uses a **server** `Touched` on the tool handle. The client can play animations; it must not tell the server how much damage to apply.
+
+Same authority as [combat](combat.md), without a Net remote: while the Tool is equipped, `Touched` runs on the server.
+
+## Config
+
+`src/shared/constants/SwordConfig.hpp`
+
+```cpp
+#pragma once
+
+const double SWORD_COOLDOWN = 0.35;
+const int SWORD_DAMAGE = 18;
+```
+
+## Script inside the Tool
+
+Put the source next to the Tool so `script->Parent` is the `Tool`. Use **`.legacy.server.cpp`** so Cluaupp emits a 1:1 Script (no Main/Controller split) that Rojo can parent under `ClassicSword`.
+
+`src/server/tools/Sword.legacy.server.cpp`
+
+```cpp
+#include <cluaupp/roblox.hpp>
+#include "../../shared/constants/SwordConfig.hpp"
+
+Players* Players = GetService<Players>();
+Tool* tool = script->Parent;
+
+void OnTouched(Instance* hit) {
+	if (hit == nullptr) {
+		return;
+	}
+
+	Player* attacker = Players->GetPlayerFromCharacter(tool->Parent);
+	if (attacker == nullptr) {
+		return;
+	}
+
+	NumberValue* last = attacker->FindFirstChild("LastSwordAt");
+	if (last != nullptr) {
+		if (tick() - last->Value < SWORD_COOLDOWN) {
+			return;
+		}
+	}
+
+	Instance* model = hit->FindFirstAncestorOfClass("Model");
+	if (model == nullptr) {
+		return;
+	}
+	Player* victim = Players->GetPlayerFromCharacter(model);
+	if (victim == nullptr) {
+		return;
+	}
+	if (victim == attacker) {
+		return;
+	}
+
+	Humanoid* humanoid = model->FindFirstChildOfClass("Humanoid");
+	if (humanoid == nullptr) {
+		return;
+	}
+	if (humanoid->Health <= 0) {
+		return;
+	}
+
+	if (last == nullptr) {
+		last = new NumberValue(attacker);
+		last->Name = "LastSwordAt";
+	}
+	last->Value = tick();
+	humanoid->TakeDamage(SWORD_DAMAGE);
+}
+
+void init() {
+	BasePart* handle = tool->FindFirstChild("Handle");
+	if (handle == nullptr) {
+		cout::warn << "ClassicSword missing Handle" << endl;
+		return;
+	}
+	handle->Touched.Connect(OnTouched);
+}
+```
+
+`tool->Parent` is the Character while equipped, `nil` in the backpack — `GetPlayerFromCharacter` then fails and the swing is ignored. That is what you want.
+
+## Why `.legacy`
+
+A tagged `Sword.server.cpp` in `src/server/` becomes a service folder in ServerScriptService. A Tool Script must live **under the Tool**. Legacy keeps one file you can Rojo-map into `ClassicSword`.
+
+## Rules
+
+| Do | Do not |
+| --- | --- |
+| `TakeDamage(SWORD_DAMAGE)` on the server | `FireServer(damage)` from a LocalScript |
+| Skip `victim == attacker` | Damage the owner when the handle clips their own parts |
+| Cooldown on the attacker | Trust `Touched` rate (it fires every physics step) |
+| `GetPlayerFromCharacter` | Treat every Humanoid as a player if you only want PvP |
+
+Client: a LocalScript in the same Tool can play an AnimationTrack on `Activated`. It still must not replicate a damage number.
+
+For ranged hits (mouse target → remote), use [combat](combat.md).

package/docs/getting-started.md

@@ -66,7 +66,8 @@ my-game/
     shared/config.h
     shared/config.cpp
   out/                    ← generated Luau (do not edit)
-    server/LeaderStats/     Main, PlayersManager, CacheController, Types
+    server/leaderstats.server.luau
+    client/init.client.luau
     shared/Config.luau
 ```
 
@@ -122,13 +123,15 @@ If a file defines `void init()`, Cluaupp calls `init()` at the end of the `.luau
 
 ## IntelliSense
 
-`cluaupp init` copies `include/cluaupp/roblox.hpp`, `.vscode/c_cpp_properties.json`, and `compile_flags.txt` (clangd). `cluaupp build` refreshes `include/cluaupp/` so completions stay in sync with the compiler.
+`cluaupp init` writes the C++ IntelliSense config and installs Microsoft `ms-vscode.cpptools` (via VSIX on Cursor). Then reload the window.
 
-In this repo the include path is `cluau/include` (and `game/include`). After opening a `.cpp` file, complete `Player`, `FindFirstChild`, `GetPlayers`, and `Vector3`.
+```bash
+cluaupp intellisense
+```
 
-The header is **not** compiled to Luau; it only feeds the C++ language server. Use `#include <cluaupp/roblox.hpp>` at the top of each source file.
+`#include <cluaupp/roblox.hpp>` at the top of each source file. The header is **not** compiled to Luau.
 
-Reload the window (Command Palette → **Developer: Reload Window**) if completions were missing before the include path existed.
+See [IntelliSense](intellisense.md).
 
 ## Watch
 
@@ -153,17 +156,21 @@ void init() {
 }
 ```
 
-Wally is optional. Fusion, Cmdr, DataServiceV2, and the rest ship **inside** `libs/` (full GitHub source). See [Libraries](libraries.md).
+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.md), [types](cpp-types.md), [safety](cpp-safety.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)

package/docs/intellisense.md

@@ -0,0 +1,31 @@
+# IntelliSense
+
+`cluaupp init` and `cluaupp intellisense` install the same setup that works in Cursor:
+
+1. Microsoft [C/C++](https://marketplace.visualstudio.com/items?itemName=ms-vscode.cpptools) (`ms-vscode.cpptools`)
+2. `.vscode/c_cpp_properties.json` — LLVM `clang++`, C++20, `include/` + `src/`, `compile_commands.json`
+3. Forced include of `include/cluaupp/roblox.hpp` so `GetService`, `Player`, `Janitor` complete
+4. The Cluaupp completion engine (Roblox APIs + your `struct`s)
+
+Cursor’s marketplace does not list `ms-vscode.cpptools`. Cluaupp downloads the official VSIX from [vscode-cpptools releases](https://github.com/microsoft/vscode-cpptools/releases) and runs `cursor --install-extension`.
+
+## Install
+
+```bash
+cluaupp intellisense
+```
+
+Reload: Command Palette → **Developer: Reload Window**. Status bar `{} C++` should read **IntelliSense: Ready**.
+
+`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, include path, `compileCommands` |
+| `.vscode/settings.json` | `C_Cpp.intelliSenseEngine: default`, `clangd.enable: false` |
+| `.vscode/extensions.json` | recommends `ms-vscode.cpptools` |
+| `compile_commands.json` | one entry per `src/` file |
+
+`#include <cluaupp/roblox.hpp>` at the top of each source file. The header is not compiled to Luau.

package/docs/intro.md

@@ -5,9 +5,9 @@ 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 `--!strict`, `local`, and `const`, and calls the Roblox API the way Studio does.
+**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.
 
-This site is built with [Moonwave](https://eryn.io/moonwave/) for local markdown docs (`npm run docs`). The public site is the cinematic engine dump at [GitHub Pages](https://kartzrbx.github.io/Cluaupp/). The language is in the same spirit as [roblox-ts](https://roblox-ts.com): a familiar syntax, a restricted subset, readable output.
+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.
 
 ## What you get
 
@@ -34,4 +34,4 @@ void init() {
 }
 ```
 
-Read [Getting started](getting-started.md), then [C++ types](cpp-types.md) and [Libraries](libraries.md).
+Read [Getting started](getting-started.md), then [Examples](examples/index.md), [Libraries](libraries/index.md), and [OOP structure](oop/index.md).

package/docs/libraries/_category_.json

@@ -0,0 +1,5 @@
+{
+	"label": "Libraries",
+	"position": 20,
+	"collapsed": false
+}

package/docs/libraries/dataservice.md

@@ -0,0 +1,104 @@
+---
+title: DataService
+sidebar_position: 2
+---
+
+# DataService
+
+Player profiles (DataServiceV2). Header: `#include <cluaupp/libs/dataservice.hpp>`.
+
+The **save shape is yours**. Do not put `Currencies` / `Money` on the library `DataPath` type. Define a struct in the game (shared header) and pass it as `.Template`.
+
+## 1. Template (shared)
+
+```cpp
+#pragma once
+
+struct TemplateData {
+	struct Currencies {
+		int Money = 0;
+		int Level = 1;
+	} Currencies;
+};
+```
+
+Luau `DataService.Paths` follows this table (`Paths.Currencies.Money`).
+
+## 2. Start the server
+
+Call **once** from a server boot script (`DataBoot.server.cpp`). `void init()` is what Cluaupp runs (not `int main()`).
+
+```cpp
+#include <cluaupp/roblox.hpp>
+#include <cluaupp/libs/dataservice.hpp>
+#include "../../shared/constants/TemplateData.hpp"
+
+void init() {
+	TemplateData playerData = TemplateData {};
+	DataService::Server.Init(DataServiceOptions {
+		.Template = playerData,
+		.StoreName = "PlayerData",
+		.UseMock = true,
+	});
+}
+```
+
+| Field | Meaning |
+| --- | --- |
+| `.Template` | Default document. Must match the save struct. |
+| `.StoreName` | DataStore name (or a version string you own). |
+| `.UseMock` | `true` in Studio / tests so you do not hit the live store. |
+| `.KeyPrefix` | Optional prefix on profile keys. |
+| `.StrictPaths` | Reject unknown path segments. |
+| `.AutoCreateMissingTables` | Create missing nested tables on write. |
+
+## 3. Start the client
+
+```cpp
+#include <cluaupp/roblox.hpp>
+#include <cluaupp/libs/dataservice.hpp>
+
+void init() {
+	DataService::Client.Init();
+}
+```
+
+## 4. Read / wait
+
+```cpp
+Data* data = DataService::Server.WaitFor(player);
+if (data == nullptr) {
+	return;
+}
+
+int money = data->Get(DataService::Server.Paths.Currencies.Money);
+```
+
+- `WaitFor` — yield until the profile exists.
+- `Get(player)` — already loaded or `nullptr`.
+- `data->Get()` with no path — whole table.
+- `GetPersisted` / `GetTransient` — saved vs session-only.
+
+Client: `DataService::Client.WaitForData()` / `Get()`.
+
+## 5. Write and listen
+
+```cpp
+data->Set(DataService::Server.Paths.Currencies.Money, 10);
+
+void OnCurrenciesChanged() {
+	return;
+}
+
+data->GetChangedSignal(DataService::Server.Paths.Currencies).Connect(OnCurrenciesChanged);
+```
+
+`GetChangedSignal` fires when that path (or a child) changes. Cluaupp has no lambdas — use a named function.
+
+## Rules
+
+- Init on **server and client**. Writes that must persist belong on the server.
+- Paths are not a C++ enum in the library. They exist because your Template was passed to `Init`.
+- Keep boot (`Init`) in one file. Keep HUD / leaderstats in another and `WaitFor` there.
+
+Full copies: [Data boot](../examples/data-boot.md), [Leaderstats](../examples/leaderstats.md), [HUD](../examples/hud.md).

package/docs/libraries/index.md

@@ -0,0 +1,22 @@
+---
+title: Using libraries
+sidebar_position: 1
+---
+
+# Libraries
+
+`#include <cluaupp/libs/...hpp>` is IntelliSense. `cluaupp build` copies the real Luau into `libs/` (`ReplicatedStorage.CluauppLibs`). You do not `require` by hand in C++.
+
+| Guide | Use it when |
+| --- | --- |
+| [DataService](dataservice.md) | Player save data, `Init`, `WaitFor`, `GetChangedSignal` |
+| [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, … |
+
+Sources: [runtime/SOURCES.md](https://github.com/KartzRbx/Cluaupp/blob/main/runtime/SOURCES.md). Re-vendor: `node scripts/vendor-libs.js`.
+
+Wally is optional. Do not install a second Janitor from Wally — CluauppLibs already has howmanysmall/Janitor.
+
+Copy-paste systems: [Examples](../examples/index.md).

package/docs/libraries/janitor.md

@@ -0,0 +1,65 @@
+---
+title: Janitor
+sidebar_position: 3
+---
+
+# Janitor
+
+Cleans connections, instances, promises, and threads. Header: `#include <cluaupp/libs/janitor.hpp>`. Runtime is [howmanysmall/Janitor](https://github.com/howmanysmall/Janitor). Types come from `_impl` — there is no fake `Has` method.
+
+## Create and add
+
+```cpp
+auto* janitor = new Janitor();
+
+janitor->Add(Players->PlayerAdded.Connect(OnPlayer));
+janitor->Add(part, "Destroy");
+janitor->Add(print, true);
+```
+
+| Call | Cleanup |
+| --- | --- |
+| `Add(connection)` | `Disconnect` |
+| `Add(instance)` / `Add(instance, "Destroy")` | `Destroy` |
+| `Add(fn, true)` | call the function |
+| `Add(thread, true)` | `task.cancel` |
+
+## Indexed slots (per player)
+
+The third argument is a namespace. Adding again with the same index removes the previous task first.
+
+```cpp
+janitor->Add(sectionJanitor, "Destroy", player->Name);
+
+if (janitor->Get(player->Name)) {
+	janitor->Remove(player->Name);
+}
+```
+
+`Remove` on a missing index is a no-op. There is **no** `Has` — use `Get`.
+
+## Lifetime
+
+```cpp
+janitor->Cleanup();
+janitor->Destroy();
+janitor->LinkToInstance(player);
+```
+
+- `Cleanup` — run every task, janitor stays usable.
+- `Destroy` — cleanup and freeze the object.
+- `LinkToInstance` — cleanup when that Instance is destroyed.
+
+## Promises
+
+```cpp
+#include <cluaupp/libs/promise.hpp>
+
+janitor->AddPromise(Promise::delay(1));
+```
+
+Cleanup cancels or rejects the promise when the janitor runs.
+
+## Pattern
+
+One janitor for the script. A **child** janitor per player, stored under `player->Name`, removed on `PlayerRemoving`. Copy: [Leaderstats](../examples/leaderstats.md).

package/docs/libraries/more.md

@@ -0,0 +1,79 @@
+---
+title: More libraries
+sidebar_position: 6
+---
+
+# More libraries
+
+Same rule: include the header, call the API. `cluaupp build` already put the Luau in `CluauppLibs`.
+
+## FormatNumber
+
+```cpp
+#include <cluaupp/libs/formatnumber.hpp>
+
+print(FormatNumber::Abbreviate(1500));
+print(FormatNumber::Comma(1500));
+```
+
+## MathUtils
+
+```cpp
+#include <cluaupp/libs/math.hpp>
+
+double t = MathUtils::Lerp(0, 1, 0.5);
+```
+
+## Twinkle (UI)
+
+```cpp
+#include <cluaupp/libs/twinkle.hpp>
+
+Twinkle::Fade(frame, true);
+```
+
+## Module3D
+
+```cpp
+#include <cluaupp/libs/module3d.hpp>
+
+Module3D::Attach3D(viewport, model);
+```
+
+## VfxUtil
+
+```cpp
+#include <cluaupp/libs/vfx.hpp>
+
+VfxUtil::Emit(root);
+VfxUtil::Play(emitter);
+```
+
+## StickyBillboard
+
+```cpp
+#include <cluaupp/libs/stickybillboard.hpp>
+
+auto* billboard = StickyBillboard::new_(adornee, gui);
+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:
+
+| Lib | Header | Upstream |
+| --- | --- | --- |
+| Fusion | `fusion.hpp` | [dphfox/Fusion](https://github.com/dphfox/Fusion) |
+| Iris | `iris.hpp` | [SirMallard/Iris](https://github.com/SirMallard/Iris) |
+| Cmdr | `cmdr.hpp` | [evaera/Cmdr](https://github.com/evaera/Cmdr) |
+| TopbarPlus | `topbarplus.hpp` | [1ForeverHD/TopbarPlus](https://github.com/1ForeverHD/TopbarPlus) |
+| Chrono | `chrono.hpp` | [Parihsz/Chrono](https://github.com/Parihsz/Chrono) |
+| EzVisualz | `ezvisual.hpp` | [arxkdev/ezVisualz](https://github.com/arxkdev/ezVisualz) |
+| StateMachine | `statemachine.hpp` | [Prooheckcp/RobloxStateMachine](https://github.com/Prooheckcp/RobloxStateMachine) |
+| Spring | `spring.hpp` | [nightcycle/spring](https://github.com/nightcycle/spring) |
+| Display | `display.hpp` | [nightcycle/display](https://github.com/nightcycle/display) |
+
+## Types-only
+
+`ArrayIndexer` (`Table<Manifest, "Name">`) and `Occlude` (`Keys<Data, "field">`) are used by generated `{Service}Types.luau`. You rarely include them from game C++.

package/docs/libraries/net.md

@@ -0,0 +1,35 @@
+---
+title: Net
+sidebar_position: 5
+---
+
+# Net
+
+Buffer-packed remotes. Header: `#include <cluaupp/libs/net.hpp>`. Same name on server and client — you do not create `RemoteEvent` instances yourself.
+
+```cpp
+#include <cluaupp/roblox.hpp>
+#include <cluaupp/libs/net.hpp>
+#include <cluaupp/libs/janitor.hpp>
+
+void OnCoins(Player* player, int amount) {
+	return;
+}
+
+void init() {
+	auto* janitor = new Janitor();
+	auto* coins = Net::Event("Coins");
+	coins->On(OnCoins);
+	janitor->Add(coins);
+}
+```
+
+| Side | API |
+| --- | --- |
+| Server | `Fire(player, ...)`, `FireAll(...)` |
+| Client | `FireServer(...)` |
+| Both | `On(callback)` |
+
+Functions: `Net::Function("Shop")`, then `Invoke` / `InvokeServer`.
+
+Validate everything the client fires. See [safety](../cpp-safety.md). Full copies: [Combat](../examples/combat.md), [Shop](../examples/shop.md).

package/docs/libraries/promise.md

@@ -0,0 +1,27 @@
+---
+title: Promise
+sidebar_position: 4
+---
+
+# Promise
+
+[evaera/roblox-lua-promise](https://github.com/evaera/roblox-lua-promise). Header: `#include <cluaupp/libs/promise.hpp>`.
+
+C++ names `Then` / `Catch` / `Await` / `Cancel` are aliases of `andThen` / `catch` / `await` / `cancel`.
+
+```cpp
+#include <cluaupp/roblox.hpp>
+#include <cluaupp/libs/promise.hpp>
+
+void AfterWait() {
+	print("1s later");
+}
+
+void init() {
+	Promise::delay(1);
+}
+```
+
+Useful statics: `Promise::delay(seconds)`, `Promise::resolve(value)`, `Promise::reject("err")`.
+
+Cluaupp cannot nest lambdas. Prefer `delay` plus a named callback you already have, or keep promise chains in Luau libraries you call from C++.

package/docs/oop/_category_.json

@@ -0,0 +1,5 @@
+{
+	"label": "OOP structure",
+	"position": 16,
+	"collapsed": false
+}