cluaupp 0.2.3 → 1.3.0

package/templates/game/libs/TopbarPlus/init.luau

@@ -0,0 +1,8 @@
+--!strict
+-- Cluaupp TopbarPlus — typed border. Public value is Icon.
+
+local Impl = require(script._impl)
+
+export type Icon = Impl.Icon
+
+return Impl

package/templates/game/libs/Twinkle/init.luau

@@ -0,0 +1,157 @@
+--!strict
+--[=[
+	@class Twinkle
+	UI motion without TweenService boilerplate: fade, slide, zoom, bounce, button styles.
+	Inspired by [Twinkle](https://devforum.roblox.com/t/twinkle-free-powerful-ui-animator-module/4512304).
+]=]
+local TweenService = game:GetService("TweenService")
+
+export type HoverType = "Lift" | "Bounce" | "Grow"
+export type PressType = "Shrink" | "Punch"
+export type TweenProps = {
+	BackgroundTransparency: number?,
+	TextTransparency: number?,
+	Position: UDim2?,
+	Size: UDim2?,
+}
+
+local Twinkle = {}
+
+local function tween(inst: Instance, info: TweenInfo, props: TweenProps): Tween
+	local t = TweenService:Create(inst, info, props)
+	t:Play()
+	return t
+end
+
+local function infoOf(speed: number?, style: Enum.EasingStyle?, dir: Enum.EasingDirection?): TweenInfo
+	return TweenInfo.new(speed or 0.25, style or Enum.EasingStyle.Quad, dir or Enum.EasingDirection.Out)
+end
+
+--[=[
+	@within Twinkle
+	@param element GuiObject
+	@param show boolean
+	@param speed number?
+]=]
+function Twinkle.Fade(element: GuiObject, show: boolean, speed: number?)
+	element.Visible = true
+	tween(element, infoOf(speed), { BackgroundTransparency = if show then 0 else 1 })
+	if element:IsA("TextLabel") or element:IsA("TextButton") or element:IsA("TextBox") then
+		tween(element, infoOf(speed), { TextTransparency = if show then 0 else 1 })
+	end
+	if not show then
+		task.delay(speed or 0.25, function()
+			element.Visible = false
+		end)
+	end
+end
+
+--[=[
+	@within Twinkle
+	@param element GuiObject
+	@param show boolean
+	@param speed number?
+]=]
+function Twinkle.FrameSlide(element: GuiObject, show: boolean, speed: number?)
+	local original = element.Position
+	if show then
+		element.Visible = true
+		element.Position = original + UDim2.fromOffset(0, 24)
+		tween(element, infoOf(speed), { Position = original, BackgroundTransparency = 0 })
+	else
+		tween(element, infoOf(speed), { Position = original + UDim2.fromOffset(0, 24), BackgroundTransparency = 1 })
+		task.delay(speed or 0.25, function()
+			element.Visible = false
+			element.Position = original
+		end)
+	end
+end
+
+--[=[
+	@within Twinkle
+	@param element GuiObject
+	@param show boolean
+	@param speed number?
+]=]
+function Twinkle.FrameZoom(element: GuiObject, show: boolean, speed: number?)
+	local original = element.Size
+	if show then
+		element.Visible = true
+		element.Size = UDim2.new(original.X.Scale * 0.9, original.X.Offset, original.Y.Scale * 0.9, original.Y.Offset)
+		tween(element, infoOf(speed, Enum.EasingStyle.Back), { Size = original })
+	else
+		tween(element, infoOf(speed), {
+			Size = UDim2.new(original.X.Scale * 0.9, original.X.Offset, original.Y.Scale * 0.9, original.Y.Offset),
+		})
+		task.delay(speed or 0.25, function()
+			element.Visible = false
+			element.Size = original
+		end)
+	end
+end
+
+--[=[
+	@within Twinkle
+	@param element GuiObject
+	@param speed number?
+	@param bouncePercent number?
+]=]
+function Twinkle.FrameBounce(element: GuiObject, speed: number?, bouncePercent: number?)
+	local original = element.Size
+	local percent = bouncePercent or 0.08
+	local bigger = UDim2.new(
+		original.X.Scale * (1 + percent),
+		original.X.Offset,
+		original.Y.Scale * (1 + percent),
+		original.Y.Offset
+	)
+	local t = tween(element, infoOf(speed or 0.12, Enum.EasingStyle.Quad, Enum.EasingDirection.Out), { Size = bigger })
+	t.Completed:Connect(function()
+		tween(element, infoOf(speed or 0.12, Enum.EasingStyle.Quad, Enum.EasingDirection.In), { Size = original })
+	end)
+end
+
+--[=[
+	@within Twinkle
+	@param element GuiObject
+	@param hoverType string? -- Lift | Bounce | Grow
+	@param pressType string? -- Shrink | Punch
+	@param scalePercent number?
+]=]
+function Twinkle.SetButtonStyle(element: GuiObject, hoverType: HoverType?, pressType: PressType?, scalePercent: number?)
+	local original = element.Size
+	local originalPos = element.Position
+	local percent = scalePercent or 0.06
+	if element:IsA("GuiButton") then
+		element.MouseEnter:Connect(function()
+			if hoverType == "Lift" then
+				tween(element, infoOf(0.12), { Position = originalPos + UDim2.fromOffset(0, -4) })
+			else
+				Twinkle.FrameBounce(element, 0.1, percent)
+			end
+		end)
+		element.MouseLeave:Connect(function()
+			tween(element, infoOf(0.12), { Position = originalPos, Size = original })
+		end)
+		element.MouseButton1Down:Connect(function()
+			if pressType == "Punch" then
+				Twinkle.FrameBounce(element, 0.08, percent * 1.4)
+			else
+				local smaller = UDim2.new(
+					original.X.Scale * (1 - percent),
+					original.X.Offset,
+					original.Y.Scale * (1 - percent),
+					original.Y.Offset
+				)
+				tween(element, infoOf(0.08), { Size = smaller })
+			end
+		end)
+		element.MouseButton1Up:Connect(function()
+			tween(element, infoOf(0.1), { Size = original })
+		end)
+	end
+end
+
+export type Twinkle = typeof(Twinkle)
+
+return Twinkle

package/templates/game/libs/VfxUtil/init.luau

@@ -0,0 +1,164 @@
+--!strict
+--[=[
+	@class VfxUtil
+	Emit, play, stop, scale, and clone visual-effect templates (ParticleEmitter,
+	Beam, Trail, Sound, Animation). There was no public GitHub for
+	lucaschaibub/vfx-util; this is the full Cluaupp system.
+
+	```lua
+	VfxUtil.Emit(attachment, 12)
+	local clone = VfxUtil.CloneOnto(template, character.HumanoidRootPart)
+	VfxUtil.Play(clone)
+	task.delay(2, function()
+		VfxUtil.DestroyAfter(clone, 0.4)
+	end)
+	```
+]=]
+local Debris = game:GetService("Debris")
+
+local VfxUtil = {}
+
+export type EffectInstance = ParticleEmitter | Beam | Trail | Sound | Fire | Smoke | Sparkles
+
+local function isEffect(inst: Instance): boolean
+	return inst:IsA("ParticleEmitter")
+		or inst:IsA("Beam")
+		or inst:IsA("Trail")
+		or inst:IsA("Sound")
+		or inst:IsA("Fire")
+		or inst:IsA("Smoke")
+		or inst:IsA("Sparkles")
+end
+
+local function collect(root: Instance): { Instance }
+	local found = {}
+	if isEffect(root) then
+		table.insert(found, root)
+	end
+	for _, child in root:GetDescendants() do
+		if isEffect(child) then
+			table.insert(found, child)
+		end
+	end
+	return found
+end
+
+--[=[
+	@within VfxUtil
+	@param root Instance -- Attachment, Part, or a folder of emitters
+	@param count number? -- particles to emit; default 8
+]=]
+function VfxUtil.Emit(root: Instance, count: number?)
+	local amount = count or 8
+	for _, inst in collect(root) do
+		if inst:IsA("ParticleEmitter") then
+			inst:Emit(amount)
+		elseif inst:IsA("Sound") then
+			inst:Play()
+		elseif inst:IsA("Beam") or inst:IsA("Trail") then
+			inst.Enabled = true
+		elseif inst:IsA("Fire") or inst:IsA("Smoke") or inst:IsA("Sparkles") then
+			inst.Enabled = true
+		end
+	end
+end
+
+--[=[
+	@within VfxUtil
+	Enables looping emitters / beams / trails and plays sounds.
+]=]
+function VfxUtil.Play(root: Instance)
+	for _, inst in collect(root) do
+		if inst:IsA("ParticleEmitter") or inst:IsA("Beam") or inst:IsA("Trail") then
+			inst.Enabled = true
+		elseif inst:IsA("Sound") then
+			inst:Play()
+		elseif inst:IsA("Fire") or inst:IsA("Smoke") or inst:IsA("Sparkles") then
+			inst.Enabled = true
+		end
+	end
+end
+
+--[=[
+	@within VfxUtil
+]=]
+function VfxUtil.Stop(root: Instance)
+	for _, inst in collect(root) do
+		if inst:IsA("ParticleEmitter") or inst:IsA("Beam") or inst:IsA("Trail") then
+			inst.Enabled = false
+		elseif inst:IsA("Sound") then
+			inst:Stop()
+		elseif inst:IsA("Fire") or inst:IsA("Smoke") or inst:IsA("Sparkles") then
+			inst.Enabled = false
+		end
+	end
+end
+
+--[=[
+	@within VfxUtil
+	@param template Instance
+	@param parent Instance
+	@return Instance
+	Clones a VFX template onto `parent` (Attachment / BasePart / Model).
+]=]
+function VfxUtil.CloneOnto(template: Instance, parent: Instance): Instance
+	local clone = template:Clone()
+	if clone:IsA("Attachment") and parent:IsA("BasePart") then
+		clone.Parent = parent
+	elseif clone:IsA("BasePart") and parent:IsA("Model") then
+		clone.Parent = parent
+	else
+		clone.Parent = parent
+	end
+	return clone
+end
+
+--[=[
+	@within VfxUtil
+	Scales NumberSequence / NumberRange particle sizes by `factor`.
+]=]
+function VfxUtil.Scale(root: Instance, factor: number)
+	for _, inst in collect(root) do
+		if inst:IsA("ParticleEmitter") then
+			local size = inst.Size
+			local keys = {}
+			for index, keypoint in size.Keypoints do
+				keys[index] = NumberSequenceKeypoint.new(keypoint.Time, keypoint.Value * factor, keypoint.Envelope * factor)
+			end
+			inst.Size = NumberSequence.new(keys)
+			local spread = inst.SpreadAngle
+			inst.SpreadAngle = Vector2.new(spread.X * factor, spread.Y * factor)
+		elseif inst:IsA("Sound") then
+			inst.PlaybackSpeed = math.clamp(inst.PlaybackSpeed * factor, 0.1, 4)
+		end
+	end
+end
+
+--[=[
+	@within VfxUtil
+	Stops effects then destroys the instance after `lifetime` seconds.
+]=]
+function VfxUtil.DestroyAfter(root: Instance, lifetime: number?)
+	local delayTime = lifetime or 1
+	task.delay(delayTime * 0.6, function()
+		if root.Parent then
+			VfxUtil.Stop(root)
+		end
+	end)
+	Debris:AddItem(root, delayTime)
+end
+
+--[=[
+	@within VfxUtil
+	One-shot: clone, emit, destroy.
+]=]
+function VfxUtil.Burst(template: Instance, parent: Instance, count: number?, lifetime: number?): Instance
+	local clone = VfxUtil.CloneOnto(template, parent)
+	VfxUtil.Emit(clone, count)
+	VfxUtil.DestroyAfter(clone, lifetime or 2)
+	return clone
+end
+
+export type VfxUtil = typeof(VfxUtil)
+
+return VfxUtil

package/templates/game/src/client/init.client.clpp

@@ -0,0 +1,6 @@
+#pragma strict
+#include <clpp/roblox.clh>
+
+void init() {
+	post("Cluaupp client ok");
+}

package/templates/game/src/server/leaderstats.server.clpp

@@ -0,0 +1,29 @@
+#pragma strict
+#include <clpp/roblox.clh>
+
+void CreateLeaderstats(Player player) {
+	if (player.FindFirstChild("leaderstats") != null) {
+		return;
+	}
+
+	Folder leaderstats = new Folder(player);
+	leaderstats.Name = "leaderstats";
+
+	IntValue coins = new IntValue(leaderstats);
+	coins.Name = "Coins";
+	coins.Value = 0;
+
+	IntValue level = new IntValue(leaderstats);
+	level.Name = "Level";
+	level.Value = 0;
+}
+
+void init() {
+	Players players = GetService<Players>();
+
+	for (Player player in players.GetPlayers()) {
+		CreateLeaderstats(player);
+	}
+
+	players.PlayerAdded~>Connect(CreateLeaderstats);
+}

package/templates/game/src/shared/config.clp

@@ -0,0 +1,6 @@
+#pragma once
+#include <clpp/roblox.clh>
+
+const int STARTING_COINS = 0;
+const string REMOTE_COINS = "Coins";
+const string LEADERSTATS_FOLDER = "leaderstats";

package/docs/README.md

@@ -1,35 +0,0 @@
-# Cluaupp documentation
-
-The live handbook is **[GitHub Pages](https://kartzrbx.github.io/Cluaupp/docs/)** — every construct the CLI accepts, not an Enum dump.
-
-## Start
-
-1. [Intro](intro.md) — what Cluaupp is
-2. [Getting started](getting-started.md) — npm, `init`, Rojo, clangd
-3. [CLI](cli.md) — `init`, `build`, `watch`, `lsp`, `intellisense`, flags
-4. [Config](config.md) — `cluaupp.config.json`
-5. [IntelliSense](intellisense.md) — clangd only
-
-## Language
-
-6. [Syntax](syntax.md) — **complete subset**: files, types, functions, scopes, control, operators, strings, `string_concat`, callbacks, casts, OOP, singletons, unsupported
-7. [print and cout](print-cout.md) — logging
-8. [C++ types](cpp-types.md) — primitives, Instances, `LuaArray`
-9. [const](cpp-const.md) — immutability
-10. [Advanced](cpp-advanced.md) — `::` vs `:`, Wally, optimization notes
-
-## Structure
-
-11. [Organization](cpp-organization.md) — server / client / shared, filename tags
-12. [Architecture](architecture.md) — one file in, one file out
-13. [OOP structure](oop/index.md) — structs, sibling headers, `Class::` methods, singletons
-14. [Safety](cpp-safety.md) — client trust, Janitor, Net, DataService
-
-## Roblox
-
-15. [Libraries](libraries/index.md) — DataService, Janitor, Fusion / Iris / UI
-16. [Examples](examples/index.md) — leaderstats, combat, shop, HUD
-17. [Roblox API](roblox-api.md) — how to spell engine calls (Creator Hub for members)
-18. [Comparison](comparison.md) — roblox-ts and WASM
-
-Moonwave (local): `npx moonwave dev`. Site rebuild: `npm run site`.

package/docs/architecture.md

@@ -1,92 +0,0 @@
----
-title: Architecture
-sidebar_position: 15
----
-
-# One file in, one file out
-
-roblox-ts decides **what instance you get** from a filename **key** (the same idea as Rojo). Cluaupp does the same — and **stops there** by default. It does not invent Main / Controller / Types folders.
-
-| Key | Rojo instance | Default output |
-| --- | --- | --- |
-| `*.server.cpp` | Script | `*.server.luau` |
-| `*.client.cpp` | LocalScript | `*.client.luau` |
-| no suffix | ModuleScript | `Name.luau` |
-| `*.legacy.server.cpp` | Legacy Script | `*.server.luau` |
-
-`DataBoot.client.cpp` becomes `out/client/boot/DataBoot.client.luau` with your `init()` at the end. Shared `#include` modules use `require(ReplicatedStorage.Cluaupp...)`.
-
-`--!strict` is opt-in: put `#pragma strict` in the `.cpp`, or set `"strict": true` in `cluaupp.config.json`.
-
-The ForeverHD-style folder split (`LeaderStats/Main.luau`, …) is **opt-in**: `"architecture": true`.
-
-## SystemUnderstander
-
-Like [roblox-ts](https://github.com/roblox-ts/roblox-ts) (filename **key** first) and [roblox-cs](https://github.com/roblox-csharp/roblox-cs) (scan the AST, then decide), Cluaupp does **not** call a generative model. `src/system-understander.ts` walks the Tree-sitter tree, scores token density against Roblox engine services, and returns a report the emitter may stamp as comments / extra `GetService` lines.
-
-| Step | What happens |
-| --- | --- |
-| `parseFileTag` | `.server.cpp` → Script / Server, `.client.cpp` → LocalScript / Client, no tag → ModuleScript |
-| `namesIn` | identifiers, `GetService<T>`, `new Class`, string literals |
-| `scoreIntents` | evidence count × side weight (server tokens count more on `.server.cpp`) |
-| `determineArchitecture` | score &lt; 2 → utility Module; otherwise Knit-style Controller / Manager / Service. `players` / `cache` stay supporting if combat, UI, or net already has ≥ 2 tokens |
-
-The **Rojo class never changes** because of a role. A HUD LocalScript can be classified as `ViewController` and still emit `hud.client.luau`. Sample sources: [examples/game](../examples/game).
-
-## Compiler pipeline
-
-Cluaupp does not rewrite C++ as text. The CLI parses a Tree-sitter CST, collects symbols (`GetService<T>()`, `#include`, types, constants), then emits Luau in a fixed order:
-
-1. `game:GetService(...)`
-2. `require(...)` (Rojo `default.project.json` when present)
-3. types
-4. constants
-5. functions / script body
-
-Formatting is delegated to StyLua; type sanity to `luau-analyze`. See [CLI](cli.md).
-
-## File tags
-
-| Source | Meaning | Output |
-| --- | --- | --- |
-| `combat.server.cpp` | **Script** | `combat.server.luau` |
-| `hud.client.cpp` | **LocalScript** | `hud.client.luau` |
-| `tools.plugin.cpp` | **Script** RunContext Plugin | `tools.luau` (legacy plugin tag) |
-| `boot.legacy.server.cpp` | Legacy Script | `boot.server.luau` |
-| `damage.cpp` (no tag) | **ModuleScript** | `Damage.luau` |
-
-## What a tagged file becomes
-
-```
-src/server/leaderstats.server.cpp  →  out/server/leaderstats.server.luau
-src/client/boot/DataBoot.client.cpp  →  out/client/boot/DataBoot.client.luau
-src/shared/damage.cpp  →  out/shared/Damage.luau
-```
-
-Scripts and LocalScripts keep your functions and call `init()` at the end. ModuleScripts return a table. There is no invented Main, Controller, or Types file.
-
-## Opt-in: ForeverHD folders (`"architecture": true`)
-
-Set `"architecture": true` in `cluaupp.config.json` to restore the old planner: PascalCase service folders, `Main` / Managers / Controllers / Types, and `require(script.Main):Start()`. Server folders emit `init.server.luau` plus a **pure JSON** `init.meta.json` with only `RunContext.Server` — never `className`, and never library `require` lines (Rojo 7.7 rejects both).
-
-```
-filename key  →  server | client | module | legacy
-AST features  →  GetService, Instance.new, methods, identifiers
-intent scores →  combat:2, character:1, …
-roles         →  Main + Managers + Controllers + Types
-```
-
-| Evidence in the C++ | Role |
-| --- | --- |
-| `PlayerAdded`, `GetPlayers` | `PlayersManager` (Janitor) |
-| `Folder` + `IntValue` / `StringValue` | `CacheController` |
-| `TakeDamage`, `Humanoid`, `Raycast` | `CombatController` (your functions) |
-| `UserInputService`, `InputBegan` | `InputController` |
-| `RemoteEvent`, `Net` | `NetController` |
-| `DataStore`, `DataService` | `DataController` |
-| Domain shapes / stats | `{Service}Types` (`export type`, `return {}`) |
-| Wiring | `Main.Start` / `Main.Stop` |
-
-Switching back to 1:1 deletes the stale `LeaderStats/` / `DataBoot/` folders on the next `cluaupp build`.
-
-How to **write** a system, tags, and module-style OOP: [OOP structure](oop/index.md). Copy-paste systems: [Examples](examples/index.md). Also [organization](cpp-organization.md) and [comparison](comparison.md).

package/docs/cli.md

@@ -1,91 +0,0 @@
-# CLI
-
-```
-cluaupp <command> [folder]
-```
-
-If `[folder]` is omitted, the current directory is used.
-
-The compiler is a **collector-emitter** pipeline: Tree-sitter walks the C++ CST, Rojo maps `#include` to `require`, Luau is emitted in a fixed block order (Services → Requires → Types → Constants → Code), then StyLua / `luau-analyze` can run as post-process.
-
-## `cluaupp init [folder]`
-
-Creates a game from the template:
-
-- `src/server`, `src/client`, `src/shared`
-- `cluaupp.config.json`
-- `default.project.json` (Rojo)
-- `rokit.toml` (Rojo 7.7.0)
-- `include/cluaupp/roblox.hpp` (IntelliSense)
-- `.vscode/` (clangd)
-
-```bash
-cluaupp init .
-cluaupp init my-game
-```
-
-## `cluaupp build [folder]`
-
-Transpiles `src/**/*.{cpp,h,hpp}` into `out/`. One tagged `.cpp` becomes one Luau instance (`leaderstats.server.luau`, `hud.client.luau`). Shared untagged files become ModuleScripts. Set `"architecture": true` for the old PascalCase service folders.
-
-- `--!strict` only with `#pragma strict`, `"strict": true`, or `--strict` on the single-file path
-- `#include "file.h"` becomes `require(...)` resolved from `default.project.json` when present
-- `#include <cluaupp/roblox.hpp>` is ignored
-- `.h` / `.hpp` emit a type ModuleScript (`export type` + typed table). A sibling `.cpp` becomes `*Impl.luau` (the construction); the header binds those functions.
-- A parse error exits with code 1 and `file:line:column`
-- After emit, **orphans in `out/` are removed** (source deleted → matching Luau deleted). `out/` itself is never wiped, so a running Rojo serve keeps the live tree.
-- `libs/` and `include/cluaupp` are synced by writing missing/changed files only. They are **never** deleted as a folder — Rojo 7 unwrap-crashes if `libs/ArrayIndexer` vanishes while serving.
-
-```bash
-cluaupp build
-cluaupp build ./my-game
-cluaupp build --format --analyze
-```
-
-### Single file
-
-```bash
-cluaupp build --input ./src/server/boot.server.cpp --output ./out/boot.server.luau --rojo ./default.project.json
-```
-
-`--format` runs StyLua; `--analyze` runs `luau-analyze`. On the single-file path both run by default (warnings if the binaries are missing). On a project build they are opt-in.
-
-## `cluaupp watch [folder]`
-
-Runs a compile (without copying `libs/`) and rebuilds when anything under `src/` changes, including deletes. Parse errors are printed; the watcher stays alive and **does not write `out/`** until the project compiles cleanly (Studio keeps the last good scripts). A second watcher in the same game exits. Deleted `.cpp` files prune their `out/` artifacts on the next successful compile.
-
-## `cluaupp lsp [folder]`
-
-Stdio JSON-RPC for **Cluaupp subset diagnostics** only. Completion, hover, and definitions are clangd.
-
-## `cluaupp intellisense [folder]`
-
-Alias: `intelisense`. Writes `compile_commands.json`, `.clangd`, and `.vscode` for clangd, and installs LLVM clangd when needed.
-
-## `cluaupp --version` / `cluaupp -v`
-
-Prints the npm package version.
-
-## `cluaupp --help`
-
-Shows usage.
-
-## Suggested npm scripts
-
-```json
-{
-	"scripts": {
-		"build": "cluaupp build",
-		"watch": "cluaupp watch"
-	}
-}
-```
-
-In the Cluaupp development repo:
-
-```bash
-npm run build:cli   # compile the TypeScript CLI
-npm test
-npm run dev         # local gitignored playground in game/ + Rojo
-npm run stop        # stop Rojo
-```

package/docs/comparison.md

@@ -1,37 +0,0 @@
-# Why Cluaupp
-
-## vs roblox-ts
-
-[roblox-ts](https://roblox-ts.com/) transpiles TypeScript → Luau. Cluaupp is the same idea for C++: one language merge, readable output, quality Roblox APIs.
-
-Both are source-to-source. Neither goes through WASM. Generated Luau calls the Roblox API directly.
-
-By default Cluaupp matches that filename key: `*.server.cpp` → one Script, `*.client.cpp` → one LocalScript, untagged → ModuleScript. The ForeverHD folder split is opt-in (`"architecture": true`). See [Architecture](architecture.md).
-
-Current Luau has [`local`, `const`, and `--!strict`](https://luau.org/getting-started). Cluaupp emits `const` from C++ `const`. `--!strict` is opt-in (`#pragma strict` or `"strict": true`).
-
-## vs C++ → WASM → Luau (RBX-CPP / Emscripten)
-
-Compiling real C++ to WASM and translating the binary to Luau works, but the cost shows up in the API:
-
-- Roblox methods become generic calls (`lua_call`, blobs)
-- `GetPlayers()` and `FindFirstChild()` do not come out as they do in Studio
-- Heavy toolchain: Emscripten, CMake, Python, tens of GB of cache
-
-Cluaupp skips that path. You write *script* C++ (the same mental subset as roblox-ts) and the compiler emits readable Luau.
-
-```cpp
-players->GetPlayers()
-player->FindFirstChild("leaderstats")
-GetService<Players>()
-```
-
-is exactly what Studio expects, not a parallel runtime.
-
-## When to use what
-
-| Goal | Tool |
-| --- | --- |
-| Game in TypeScript | roblox-ts |
-| Game in C++, clear Roblox API | **Cluaupp** |
-| Full native C++ (templates, STL, engines) | not Cluaupp today |

package/docs/config.md

@@ -1,31 +0,0 @@
-# Configuration
-
-File: `cluaupp.config.json` at the game root (next to `src/`).
-
-```json
-{
-	"rootDir": "src",
-	"outDir": "out",
-	"strict": false,
-	"architecture": false
-}
-```
-
-| Field | Default | Effect |
-| --- | --- | --- |
-| `rootDir` | `"src"` | Where the `.cpp` / `.h` / `.hpp` files live |
-| `outDir` | `"out"` | Where Luau is written |
-| `strict` | `false` | Prefix `--!strict` on generated files (overridden by `#pragma strict` / `#pragma nstrict`) |
-| `architecture` | `false` | If `true`, emit PascalCase service folders (`LeaderStats/Main.luau`, …) instead of one Luau per `.cpp` |
-
-If the file is missing, those defaults apply.
-
-## Rojo
-
-The template ships `default.project.json` mapping:
-
-- `out/server` → `ServerScriptService.Cluaupp`
-- `out/client` → `StarterPlayer.StarterPlayerScripts.Cluaupp`
-- `out/shared` → `ReplicatedStorage.Cluaupp`
-
-`*.server.cpp` becomes `*.server.luau` (Script). `*.client.cpp` becomes `*.client.luau` (LocalScript). Untagged files become ModuleScripts.