cluaupp 0.2.3 → 1.3.0

package/docs/cpp-advanced.md

@@ -1,78 +0,0 @@
----
-title: Advanced Cluaupp
-sidebar_position: 14
----
-
-# Advanced Cluaupp
-
-The subset is intentional. What exists is enough for game scripts; what is missing is listed so you do not fight the compiler.
-
-## Supported
-
-- Functions, prototypes (headers only), `if` / `else` / `while` / range-`for` / `switch` (`case`, `default`, `break`)
-- `struct` types + `Class::` methods in a sibling `.h` / `.cpp`
-- `new Class(parent)`, `GetService<T>()`, `::` statics (`CFrame::lookAt`, `Enum::Material::Plastic`)
-- `static_cast<T>(x)`, `(void)x`, lambdas in `Connect` / `Add`
-- `static` / `constexpr` / `inline` specifiers, `LuaArray<T>`, `string_concat`
-- `->` methods and properties, `.` members, `Connect`
-- `const`, `auto`, `nullptr`, arithmetic, `&&` `||` `!=`, string `+`
-- Quoted includes, `.h` / `.hpp` as sources
-- Libraries via `#include <cluaupp/libs/...>` → `require(CluauppLibs.*)`
-
-## Not supported (yet)
-
-Full C++: templates besides `GetService<T>` / `static_cast` / `LuaArray`, `class` bodies as emitted metatables, `std::`, overloading as two runtimes, C-style `for`, macros, pointer arithmetic, JSX.
-
-If you need a custom type, it is usually a **ModuleScript in shared** (a `.cpp` of functions) or a Wally package, not a C++ class the compiler would lower to a metatable.
-
-## `::` vs `:` vs `.`
-
-| C++ | Luau | When |
-| --- | --- | --- |
-| `CFrame::lookAt(a, b)` | `CFrame.lookAt(a, b)` | datatype / enum / module static |
-| `MathUtils::Lerp(a, b, t)` | `MathUtils.Lerp(a, b, t)` | Cluaupp module function |
-| `Module3D::Attach3D(frame, model)` | `Module3D:Attach3D(frame, model)` | Module3D’s colon API |
-| `player->FindFirstChild("x")` | `player:FindFirstChild("x")` | Instance method |
-| `player->Name` | `player.Name` | property |
-| `janitor->Add(conn)` | `janitor:Add(conn)` | library method |
-
-## Init
-
-If a file defines `void init()`, Cluaupp calls `init()` at the end of the `.luau`. Use that as the Script / LocalScript entry. Shared modules should **not** define `init()` unless you want them to run on require.
-
-## Mixing extra Wally packages
-
-CluauppLibs already contains the full Janitor, Fusion, Cmdr, DataServiceV2, … systems (copied from GitHub into `runtime/`). Add Wally only for packages that are **not** in CluauppLibs. Headers in `include/cluaupp/libs/` match the shipped Luau.
-
-```cpp
-#include <cluaupp/libs/dataservice.hpp>
-
-void Grant(Player* player, int amount) {
-	Data* data = DataService::Server.WaitFor(player);
-	if (data == nullptr) {
-		return;
-	}
-	int coins = data->Get(DataService::Server.Paths.Currencies.Money);
-	data->Set(DataService::Server.Paths.Currencies.Money, coins + amount);
-}
-```
-
-`Paths.Currencies.Money` exists because **your** Template passed to `Init` had that field. Full copies: [Examples](examples/index.md).
-
-## Performance notes
-
-- Prefer `const` and locals over recomputing in `RenderStepped`.
-- `Net` already uses `buffer`. Batch when you can; do not fire per-heartbeat for every NPC.
-- Module3D is a ViewportFrame — fine for shops and inventory, not for cloning the whole map (same advice as the [original Module3D thread](https://devforum.roblox.com/t/module3d-v61-viewportframe-implementation/207383)).
-- Janitor `Cleanup` is O(tracked objects). Link to the Instance that owns the scope instead of a global janitor for the whole server.
-
-## Good C++ conduct that still applies
-
-1. **Initialize everything.** `int coins;` without a value is a bug; write `int coins = 0`.
-2. **Small functions.** One behavior, named after the behavior.
-3. **No magic numbers.** `const int MAX_INVENTORY = 20`.
-4. **Early return.** Flatten `if` pyramids.
-5. **Headers declare, scripts define.** Prototypes in `.h`, bodies in `.cpp`.
-6. **Do not share mutable statics across server and client** — use Net or DataService.
-
-See also: [syntax](syntax.md) (complete subset), [print and cout](print-cout.md), [libraries](libraries/index.md), [OOP](oop/index.md), [examples](examples/index.md), [comparison](comparison.md). Optimization notes on the site: [Optimization](https://kartzrbx.github.io/Cluaupp/docs/optimization.html).

package/docs/cpp-const.md

@@ -1,52 +0,0 @@
----
-title: const and immutability
-sidebar_position: 11
----
-
-# const and immutability
-
-A value that must not change should say so. In C++ that is `const`. Cluaupp emits Luau `const`, not `local x <const>`.
-
-```cpp
-const int STARTING_COINS = 0;
-const double GRAVITY = 196.2;
-```
-
-```luau
-const STARTING_COINS: number = 0
-const GRAVITY: number = 196.2
-```
-
-## Why it is a safety feature
-
-- Leaderstat starting values, product IDs, remote names, and animation speeds are configuration. If they are `local`, a later line can overwrite them by accident.
-- Reviewers see `const` and skip “could this mutate?”.
-- Luau `--!strict` rejects assignment to `const`.
-
-## What to keep mutable
-
-Player-owned numbers (`coins`, `combo`), UI state, and Janitor instances. Everything else defaults to `const` until you have a reason.
-
-```cpp
-const string REMOTE_COINS = "Coins";
-int coins = 0;
-
-void AddCoins(int amount) {
-	coins = coins + amount;
-}
-```
-
-`REMOTE_COINS` is a protocol name — immutable. `coins` is session state — mutable.
-
-## Immutability for tables and Instances
-
-`const` on a pointer does not freeze the Instance. `const Folder* stats` still has a mutable `Name` in Roblox. Treat “do not rebind the variable” and “do not mutate the object” as two separate decisions. For objects, prefer:
-
-- Create, parent, configure once, then only read.
-- Put mutations behind one function (`SetCoins`) instead of writing `coins.Value` from five scripts.
-
-## DataService paths
-
-Path tokens (`"Currencies.Coins"`) should be `const string` or a shared header. Never concatenate remote or datastore keys from user input.
-
-Next: [safety](cpp-safety.md).

package/docs/cpp-organization.md

@@ -1,63 +0,0 @@
----
-title: Organization
-sidebar_position: 13
----
-
-# Organization
-
-A Cluaupp game is laid out like a roblox-ts project on disk. One tagged `.cpp` becomes one Luau instance (`leaderstats.server.luau`, `hud.client.luau`). See [Architecture](architecture.md).
-
-```
-src/
-  server/     → Script (out/server)
-  client/     → LocalScript (out/client)
-  shared/     → ModuleScript (out/shared)
-include/cluaupp/   IntelliSense
-libs/              CluauppLibs (full Janitor, Fusion, Cmdr, DataService, …)
-Packages/          extra Wally packages only
-cluaupp.config.json
-default.project.json
-wally.toml
-```
-
-## Server / client / shared
-
-| Folder | Runs on | Allowed to |
-| --- | --- | --- |
-| `src/server` | Server | DataStore, DataService writes, `Net:Fire` |
-| `src/client` | Client | UI, Module3D, Twinkle, camera, `Net:FireServer` |
-| `src/shared` | Both | types, `const` config, FormatNumber, MathUtils |
-
-If a file needs `DataStoreService`, it is server. If it needs `UserInputService`, it is client. Shared code must compile in both.
-
-## Headers vs scripts
-
-- `.h` / `.hpp` in `src/` are inlined (`#include "config.h"`) and can hold `const` values and prototypes.
-- `#include <cluaupp/...>` is IntelliSense only — never inlined. `cluaupp build` copies those headers into the game `include/` folder. Cursor/clangd also reads `compile_flags.txt`.
-
-Keep config in `src/shared/config.h`:
-
-```cpp
-#pragma once
-const int STARTING_COINS = 0;
-const string REMOTE_COINS = "Coins";
-```
-
-## One module, one job
-
-`leaderstats.server.cpp` creates leaderstats. It does not also open the shop UI. Name files after the system: `inventory.server.cpp`, `shop.client.cpp`.
-
-`*.server.cpp` / `*.client.cpp` are **tags** (the same keys roblox-ts uses). Untagged `.cpp` is a ModuleScript. Set `"architecture": true` only if you want the old PascalCase folder split. See [Architecture](architecture.md) and [OOP structure](oop/index.md).
-
-## CluauppLibs vs extra Wally
-
-| Need | Where |
-| --- | --- |
-| Janitor, Promise, Fusion, Iris, Cmdr, TopbarPlus, Chrono, DataServiceV2, EzVisualz, StateMachine, Spring, Display, Module3D, FormatNumber, Net, MathUtils, Twinkle | `CluauppLibs` (copied on `cluaupp build` from GitHub-vendored `runtime/`) |
-| Some other community package | `wally.toml` → `Packages` |
-
-Do not install a second Janitor from Wally unless you have a reason — CluauppLibs already has howmanysmall/Janitor. DataServiceV2 still bundles its own janitor/quicknet/signal inside the DataService folder.
-
-How-tos: [Libraries](libraries/index.md). Service layout: [OOP](oop/index.md). Copy-paste: [Examples](examples/index.md).
-
-Next: [advanced Cluaupp](cpp-advanced.md).

package/docs/cpp-safety.md

@@ -1,62 +0,0 @@
----
-title: Safety
-sidebar_position: 12
----
-
-# Safety
-
-Safety in Cluaupp is not a sandbox flag. It is a set of habits the compiler and libraries make cheap.
-
-## 1. Never trust the client
-
-[Net](libraries/net.md) lets a client `FireServer`. The server must validate:
-
-```cpp
-void OnBuy(Player* player, int productId) {
-	if (productId < 1) {
-		return;
-	}
-	int price = PriceOf(productId);
-	Data* data = DataService::Server.WaitFor(player);
-	if (data == nullptr) {
-		return;
-	}
-	int coins = data->Get(DataService::Server.Paths.Currencies.Money);
-	if (coins < price) {
-		return;
-	}
-	data->Set(DataService::Server.Paths.Currencies.Money, coins - price);
-}
-```
-
-Do not store coins only on the client. Do not let the client pass the new coin total — pass the *intent* (`productId`). Full systems: [Shop](examples/shop.md), [Combat](examples/combat.md).
-
-## 2. Clean up with Janitor
-
-Every `Connect` that outlives a player, a GUI, or a tool needs a [Janitor](libraries/janitor.md). Leaving a step, destroying a character, or closing a menu should `Cleanup()` or `LinkToInstance`.
-
-```cpp
-auto* janitor = new Janitor();
-janitor->LinkToInstance(player);
-janitor->Add(players->PlayerAdded.Connect(OnPlayer));
-```
-
-Leaked connections duplicate effects: double coins, stacked cameras, lingering highlights.
-
-## 3. Check nil
-
-`FindFirstChild` returns `nullptr`. `WaitForChild` can hang. Prefer `FindFirstChild` plus an early return on the hot path.
-
-## 4. One writer for persisted data
-
-[DataService](libraries/dataservice.md) distinguishes `Get()` (merged, includes transient admin overlays) from `GetPersisted()` (what ProfileStore will save). Use `SetTransient` for test panels so you never persist cheat values. Only the server writes persisted paths. The save **shape** is your Template — the library does not ship `Currencies`.
-
-## 5. Buffers, not ad-hoc strings
-
-`Net` packs arguments into a `buffer`. That is smaller and typed. Do not `JSONEncode` a whole inventory on every heartbeat. Send deltas. Cap array lengths the client can send.
-
-## 6. Names are API
-
-Remote names (`Net::Event("Coins")`) are public protocol. Keep them `const`, short, and unique. Changing a name without a migration breaks old clients.
-
-Next: [organization](cpp-organization.md), [OOP](oop/index.md), [Examples](examples/index.md).

package/docs/cpp-types.md

@@ -1,68 +0,0 @@
----
-title: C++ types in Cluaupp
-sidebar_position: 10
----
-
-# Types
-
-Cluaupp is statically typed in the C++ you write and in the Luau it emits. A type is a contract: what a value is allowed to be, and what you are allowed to do with it.
-
-## Primitive map
-
-| C++ | Luau | Use for |
-| --- | --- | --- |
-| `int`, `float`, `double` | `number` | counts, damage, alpha |
-| `bool` | `boolean` | flags |
-| `string` / `const char*` | `string` | names, paths |
-| `void` | (no return) | procedures |
-| `auto` | inferred | when `new` or `GetService` makes the type obvious |
-| `Player*`, `Folder*`, … | `Player`, `Folder` | Instances |
-| `LuaArray<int>` / `vector<T>` | `{number}` | arrays (Template inventory, `GetPlayers`) |
-| `optional<T>` | `T?` | missing values (prefer `nullptr` on Instances) |
-| `Vector3`, `CFrame`, `UDim2` | same | datatypes |
-
-```cpp
-int coins = 10;
-bool loaded = false;
-auto* folder = new Folder(player);
-```
-
-```luau
-local coins: number = 10
-local loaded: boolean = false
-local folder: Folder = Instance.new("Folder")
-folder.Parent = player
-```
-
-## Pointers are Instances, not memory
-
-In Cluaupp, `Player*` does not mean “heap address”. It means “this is a Roblox Instance of class Player”. `->` becomes `.` for properties and `:` for engine/library methods.
-
-```cpp
-player->Name = "Kartz";
-player->FindFirstChild("leaderstats");
-```
-
-```luau
-player.Name = "Kartz"
-player:FindFirstChild("leaderstats")
-```
-
-There is no pointer arithmetic, no `delete`, no `std::unique_ptr`. Lifetime is Roblox’s: parented Instances live until `Destroy` or until a [Janitor](libraries/janitor.md) cleans them.
-
-## `nullptr`
-
-`nullptr` is `nil`. Always test before using a `FindFirstChild` result:
-
-```cpp
-auto* stats = player->FindFirstChild("leaderstats");
-if (stats == nullptr) {
-	return;
-}
-```
-
-## Why types matter
-
-Typos, wrong arguments, and `nil` indexing are the majority of live-game bugs. `--!strict` plus C++ types catch them in the editor. If a function takes `Player*`, do not pass a `string`. If a value is `const int`, do not assign to it later.
-
-Next: [const and immutability](cpp-const.md).

package/docs/examples/_category_.json

@@ -1,5 +0,0 @@
-{
-	"label": "Examples",
-	"position": 21,
-	"collapsed": false
-}

package/docs/examples/combat.md

@@ -1,239 +0,0 @@
----
-title: Combat (server validation)
-sidebar_position: 4
----
-
-# Combat (server validation)
-
-The client never sends **damage**. It sends **who I want to hit**. The server decides range, cooldown, alive state, and the damage constant.
-
-Pair with [Data boot](data-boot.md) if a kill should grant Money.
-
-## Shared config
-
-`src/shared/constants/CombatConfig.hpp`
-
-```cpp
-#pragma once
-
-const double ATTACK_RANGE = 12;
-const double ATTACK_COOLDOWN = 0.4;
-const int ATTACK_DAMAGE = 12;
-const int KILL_REWARD = 5;
-```
-
-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/data-boot.md

@@ -1,98 +0,0 @@
----
-title: Data boot
-sidebar_position: 2
----
-
-# Data boot
-
-Start DataService **once** on the server and once on the client. Gameplay scripts (`leaderstats`, combat, shop) only `WaitFor` — they do not call `Init`.
-
-The save **shape is yours**. Do not put `Currencies` on the library `DataPath` type. Put it on a shared struct and pass that as `.Template`.
-
-## Shared template
-
-`src/shared/constants/TemplateData.hpp`
-
-```cpp
-#pragma once
-
-struct TemplateData {
-	struct Currencies {
-		int Money = 0;
-		int Level = 1;
-	} Currencies;
-};
-```
-
-`src/server/configurations/PlayerDataVersion.hpp`
-
-```cpp
-#pragma once
-
-const string PLAYER_DATA_VERSION = "PlayerData_v1";
-```
-
-Bump the store name when you **intentionally** wipe saves. Changing a field default in `TemplateData` does not migrate old profiles by itself.
-
-## Server — `DataBoot.server.cpp`
-
-Use `void init()`, not `int main()`. Cluaupp only auto-calls `init()`.
-
-```cpp
-#include <cluaupp/roblox.hpp>
-#include <cluaupp/libs/dataservice.hpp>
-#include "../../shared/constants/TemplateData.hpp"
-#include "../configurations/PlayerDataVersion.hpp"
-
-void init() {
-	TemplateData playerData = TemplateData {};
-	DataService::Server.Init(DataServiceOptions {
-		.Template = playerData,
-		.StoreName = PLAYER_DATA_VERSION,
-		.UseMock = true,
-	});
-}
-```
-
-| Field | In production |
-| --- | --- |
-| `.Template` | Same struct the rest of the game reads through `Paths` |
-| `.StoreName` | Stable DataStore name (version it when you wipe) |
-| `.UseMock` | `true` in Studio so you do not hit the live store |
-
-After `Init`, `DataService::Server.Paths.Currencies.Money` exists because the Template had that table — not because the library shipped those fields.
-
-## Client — `DataBoot.client.cpp`
-
-```cpp
-#include <cluaupp/roblox.hpp>
-#include <cluaupp/libs/dataservice.hpp>
-
-void init() {
-	DataService::Client.Init();
-}
-```
-
-Client `Init` has no Template. The server already owns the document.
-
-## What other scripts do
-
-```cpp
-Data* data = DataService::Server.WaitFor(player);
-if (data == nullptr) {
-	return;
-}
-
-int money = data->Get(DataService::Server.Paths.Currencies.Money);
-```
-
-- Server gameplay: `WaitFor(player)` then `Get` / `Set`.
-- Client HUD: `WaitForData()` then `Get`.
-- Never `Init` twice. A second `Init` fights the first store.
-
-## File tags
-
-`DataBoot.server.cpp` → Script **RunContext Server** (`init.luau` + `init.meta.json`).  
-`DataBoot.client.cpp` → LocalScript (`init.client.luau`).
-
-See [file tags](../oop/file-tags.md).