cluaupp 0.1.4 → 0.1.5

package/CHANGELOG.md

@@ -1,9 +1,18 @@
 # Changelog
 
+## 0.1.5
+
+- Default emit is one tagged `.cpp` → one `.server.luau` / `.client.luau`. `"architecture": true` keeps the old ForeverHD service folders.
+- `--!strict` is opt-in: `#pragma strict`, `#pragma nstrict`, or `"strict": true` in config (default `false`).
+- `.h` / `.hpp` emit type ModuleScripts (`export type` + typed table). A sibling `.cpp` becomes `*Impl.luau`; the header binds those functions.
+- Shared `#include` modules `require` game-rooted paths (`ReplicatedStorage.Cluaupp...` / `ServerScriptService.Cluaupp...`).
+
 ## 0.1.4
 
 - Quoted `#include "Header.h"` of project files becomes `const Header = require(...)`. Header-only structs emit a constructor (`TemplateData()`); const headers bind `PLAYER_DATA_VERSION` from the module. Boot scripts require services (`LeaderstatsServer:init()`).
 - Keep `const` for injected `require` / `GetService` and `const function` for C++ functions (not `local`).
+- `init.meta.json` stays pure JSON. Library `require` injection no longer prepends Luau onto Rojo meta files (which made `rojo serve` fail with a JSONC parse error).
+- Server services emit `init.server.luau` + `init.meta.json` with **only** `RunContext.Server`. Rojo forbids `className` when an `init.*` script exists (the folder is already a Script, not a Folder). `init.luau` is pruned so the instance is not a ModuleScript.
 
 ## 0.1.3
 

package/README.md

@@ -12,7 +12,7 @@
 [![Node.js](https://img.shields.io/node/v/cluaupp.svg)](https://nodejs.org)
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 
-Source-to-source transpiler: you write a C++ subset, Cluaupp emits modern [Luau](https://luau.org/getting-started) (`--!strict`, `local`, `const`). C++ structure, Luau quality, one language.
+Source-to-source transpiler: you write a C++ subset, Cluaupp emits modern [Luau](https://luau.org/getting-started) (`local`, `const`, optional `--!strict`). C++ structure, Luau quality, one language.
 
 No WASM. No Emscripten. No `lua_call`. Roblox APIs come out as they do in Studio: `game:GetService("Players")`, `player:FindFirstChild("leaderstats")`, `players:GetPlayers()`.
 
@@ -66,12 +66,12 @@ rojo serve
 Connect the Rojo plugin in Roblox Studio. Edit `src/**/*.{cpp,h,hpp}`, run `cluaupp watch` to rebuild on save.
 
 ```
-src/server/*.server.cpp  →  out/server/LeaderStats/   Script + ModuleScripts
-src/client/*.client.cpp  →  out/client/*.client.luau  LocalScript (or a service folder)
-src/shared/config.*      →  out/shared/Config.luau    typed config module
+src/server/*.server.cpp  →  out/server/*.server.luau  Script
+src/client/*.client.cpp  →  out/client/*.client.luau  LocalScript
+src/shared/*.cpp         →  out/shared/*.luau         ModuleScript
 ```
 
-A tiny `leaderstats.server.cpp` becomes `Main` / `PlayersManager` / `CacheController`. A combat `.server.cpp` becomes `CombatController` with your `TakeDamage` logic. Filename tags: `.server.cpp`, `.client.cpp`, `.legacy.server.cpp`, `.legacy.client.cpp`, or no tag (ModuleScript). See [Architecture](docs/architecture.md) and [OOP structure](docs/oop/index.md).
+Filename tags: `.server.cpp`, `.client.cpp`, `.legacy.server.cpp`, `.legacy.client.cpp`, or no tag (ModuleScript). One source file becomes one instance. Set `"architecture": true` only for the old PascalCase folder split. See [Architecture](docs/architecture.md) and [OOP structure](docs/oop/index.md).
 
 ## Documentation
 
@@ -84,7 +84,7 @@ A tiny `leaderstats.server.cpp` becomes `Main` / `PlayersManager` / `CacheContro
 | [Syntax](docs/syntax.md) | C++ subset → Luau (`local`, `const`, types) |
 | [print and cout](docs/print-cout.md) | `cout <<`, `cout::warn`, `endl` |
 | [Roblox API](docs/roblox-api.md) | Vector3, CFrame, UDim2, GetService, Instance.new |
-| [Architecture](docs/architecture.md) | PascalCase services, Types modules, not a 200-line dump |
+| [Architecture](docs/architecture.md) | One file in, one file out; opt-in ForeverHD folders |
 | [OOP structure](docs/oop/index.md) | File tags, services, modules, structs |
 | [Libraries](docs/libraries/index.md) | DataService Init, Janitor, Promise, Net |
 | [Examples](docs/examples/index.md) | Leaderstats, combat validation, shop, HUD, sword |

package/docs/README.md

@@ -10,7 +10,7 @@
 8. [Safety](cpp-safety.md) — client trust, Janitor, Net, DataService
 9. [Organization](cpp-organization.md) — server / client / shared
 10. [Advanced](cpp-advanced.md) — `::` vs `:`, Wally, performance
-11. [Architecture](architecture.md) — PascalCase services, Types modules, vs roblox-ts dumps
+11. [Architecture](architecture.md) — one file in, one file out; opt-in ForeverHD folders
 12. [OOP structure](oop/index.md) — file tags, services, modules, structs
 13. [Libraries](libraries/index.md) — DataService Init, Janitor, Promise, Net, more
 14. [Examples](examples/index.md) — leaderstats, combat validation, shop, HUD, sword

package/docs/architecture.md

@@ -3,54 +3,52 @@ title: Architecture
 sidebar_position: 15
 ---
 
-# Output treated as a Roblox system
+# One file in, one file out
 
-roblox-ts decides **what instance you get** from a filename **key** (the same idea as Rojo):
+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 |
-| --- | --- |
-| `*.server.ts` | Script |
-| `*.client.ts` | LocalScript |
-| no suffix | ModuleScript |
+| 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` |
 
-Flamework then stamps a second key (`@Service` / `@Controller`) so the runtime knows the **role**. Cluaupp does both steps without decorators.
+`DataBoot.client.cpp` becomes `out/client/boot/DataBoot.client.luau` with your `init()` at the end. Shared `#include` modules use `require(ReplicatedStorage.Cluaupp...)`.
 
-1. **Tag** (filename) — where the code runs and whether it is a Script, LocalScript, ModuleScript, or a 1:1 “legacy” dump.
-2. **Intent** (AST) — what the code *is for*: players, cache, combat, input, UI, net, data, … scored from APIs and identifiers, the same idea as intent classification in program analysis (features from the tree, not a 200-line dump).
+`--!strict` is opt-in: put `#pragma strict` in the `.cpp`, or set `"strict": true` in `cluaupp.config.json`.
 
-Leaderstats was the example. A combat `.server.cpp` is a different system and gets Combat folders, not a fake CacheController.
+The ForeverHD-style folder split (`LeaderStats/Main.luau`, …) is **opt-in**: `"architecture": true`.
 
 ## File tags
 
 | Source | Meaning | Output |
 | --- | --- | --- |
-| `combat.server.cpp` | **Script** RunContext Server | `Combat/init.luau` + `init.meta.json` |
-| `hud.client.cpp` | **LocalScript** | `Hud/init.client.luau` |
-| `tools.plugin.cpp` | **Script** RunContext Plugin | `Tools/init.luau` + `init.meta.json` |
-| `boot.legacy.cpp` | Legacy Script | `boot.server.luau` |
+| `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` |
-| `boot.legacy.client.cpp` | Legacy LocalScript | `boot.client.luau` |
-| `boot.legacy.plugin.cpp` | Plugin | `boot.luau` + Plugin meta |
 | `damage.cpp` (no tag) | **ModuleScript** | `Damage.luau` |
 
-Trivial entry files (`init.client.cpp` that only `print`) stay a single LocalScript (`init.client.luau`). The planner does not invent Managers for a hello-world.
+## 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.
 
-## How the planner reasons
+## 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()`.
 
 ```
 filename key  →  server | client | module | legacy
 AST features  →  GetService, Instance.new, methods, identifiers
 intent scores →  combat:2, character:1, …
 roles         →  Main + Managers + Controllers + Types
-user functions→  kept in the matching Controller (not discarded)
-```
-
-Generated files start with that trace:
-
-```luau
--- tag server → Script (service)
--- intents combat:2, character:1
--- roles Main, CombatController, CombatTypes
 ```
 
 | Evidence in the C++ | Role |
@@ -64,54 +62,6 @@ Generated files start with that trace:
 | Domain shapes / stats | `{Service}Types` (`export type`, `return {}`) |
 | Wiring | `Main.Start` / `Main.Stop` |
 
-If the C++ creates Coins/Level, CacheController is generated (higher quality than copying `CreateLeaderstats`). Combat logic is **not** rewritten into leaderstats — `ApplyDamage` stays in `CombatController.luau`.
-
-The domain controller keeps **every** user function. CacheController is generated beside it; it must not delete `SetupPlayerManager` while `init` still calls that name. `GetChangedSignal(Paths.Currencies)` stays in `DataController`.
-
-## What leaderstats becomes
-
-```
-src/server/leaderstats.server.cpp
-```
-
-```
-out/server/LeaderStats/
-  init.luau
-  init.meta.json
-  Main.luau
-  PlayersManager.luau
-  CacheController.luau
-  LeaderStatsTypes.luau
-```
-
-## What combat becomes
-
-```
-src/server/combat.server.cpp   -- TakeDamage, Humanoid
-```
-
-```
-out/server/Combat/
-  init.luau
-  init.meta.json
-  Main.luau
-  CombatController.luau    -- your ApplyDamage / OnHit
-  CombatTypes.luau
-```
-
-No PlayersManager unless you actually listen to players. No CacheController unless you actually create value Instances.
-
-## ForeverHD-style rules
-
-- PascalCase folders and modules; camelCase locals
-- `--!strict` everywhere
-- Public API `Start` / `Stop`. `Start` is idempotent (`Stop` first). Domain `Stop` is `janitor:Cleanup()` (unbind, janitor stays reusable). `OnClose` / `Destroy` stay for `BindToClose`. `PlayersManager.Stop` disconnects and runs `onLeave`. `CacheController.ClearAll` drops the cache.
-- Janitor owns connections in the Manager
-- Module layout in generated Luau (no section banners): requires, types, constants, variables, functions, cleanup, return.
-- Transparent `require(script.Parent.X)`
-
-## Config
-
-`cluaupp.config.json`: `"architecture": true` (default). `"architecture": false` forces 1:1 dumps (or use `.legacy.server.cpp` / `.legacy.client.cpp` per file).
+Switching back to 1:1 deletes the stale `LeaderStats/` / `DataBoot/` folders on the next `cluaupp build`.
 
-How to **write** a service, 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).
+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

@@ -23,13 +23,12 @@ cluaupp init my-game
 
 ## `cluaupp build [folder]`
 
-Transpiles `src/**/*.{cpp,h,hpp}` into `out/`. Script files become PascalCase **service folders** (`LeaderStats/Main.luau`, `PlayersManager.luau`, `CacheController.luau`, `LeaderStatsTypes.luau`) plus `init.luau` and `init.meta.json` (`RunContext.Server`) for Rojo. Shared `const` headers become `Config.luau`.
+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` on every module
-- `#include "file.h"` inlines that header into the current file
+- `--!strict` only with `#pragma strict` or `"strict": true`
+- `#include "file.h"` becomes `require(ReplicatedStorage.Cluaupp...)` / `require(ServerScriptService.Cluaupp...)` for shared/server modules
 - `#include <cluaupp/roblox.hpp>` is ignored
-- `.h` / `.hpp` with a sibling `.cpp` are not emitted twice
-- `new Folder(parent)` in a stats system becomes `CacheController.Ensure`
+- `.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.

package/docs/comparison.md

@@ -6,9 +6,9 @@
 
 Both are source-to-source. Neither goes through WASM. Generated Luau calls the Roblox API directly.
 
-The difference is **what Studio receives**. roblox-ts stops at the filename key (`*.server.ts` → Script). Cluaupp uses that key **and** reads the AST so a combat system is not emitted as a fake leaderstats. See [Architecture](architecture.md).
+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 that on purpose: `const int` in C++ becomes `const x = ...` in Luau.
+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)
 
@@ -33,5 +33,5 @@ is exactly what Studio expects, not a parallel runtime.
 | Goal | Tool |
 | --- | --- |
 | Game in TypeScript | roblox-ts |
-| Game in C++, clear Roblox API, Luau `--!strict` | **Cluaupp** |
+| Game in C++, clear Roblox API | **Cluaupp** |
 | Full native C++ (templates, STL, engines) | not Cluaupp today |

package/docs/config.md

@@ -6,17 +6,17 @@ File: `cluaupp.config.json` at the game root (next to `src/`).
 {
 	"rootDir": "src",
 	"outDir": "out",
-	"strict": true,
-	"architecture": true
+	"strict": false,
+	"architecture": false
 }
 ```
 
 | Field | Default | Effect |
 | --- | --- | --- |
 | `rootDir` | `"src"` | Where the `.cpp` / `.h` / `.hpp` files live |
-| `outDir` | `"out"` | Where services and modules are written |
-| `strict` | `true` | Prefix `--!strict` on every generated file |
-| `architecture` | `true` | Emit PascalCase service folders (`LeaderStats/Main.luau`, …) instead of one dump per `.cpp` |
+| `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.
 
@@ -28,4 +28,4 @@ The template ships `default.project.json` mapping:
 - `out/client` → `StarterPlayer.StarterPlayerScripts.Cluaupp`
 - `out/shared` → `ReplicatedStorage.Cluaupp`
 
-`*.server.cpp` becomes a folder with `init.luau` + `init.meta.json` (`className` Script, `RunContext` Server). `.client` stays LocalScript via `init.client.luau`. A `.legacy.server.cpp` dump is still `*.server.luau` (Legacy).
+`*.server.cpp` becomes `*.server.luau` (Script). `*.client.cpp` becomes `*.client.luau` (LocalScript). Untagged files become ModuleScripts.

package/docs/cpp-organization.md

@@ -5,7 +5,7 @@ sidebar_position: 13
 
 # Organization
 
-A Cluaupp game is laid out like a roblox-ts project on disk. The **output** is not a dump: `cluaupp build` turns each system into a PascalCase service folder (Main, Manager, Controller, Types). See [Architecture](architecture.md).
+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/
@@ -47,7 +47,7 @@ const string REMOTE_COINS = "Coins";
 
 `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. `.legacy.server.cpp` / `.legacy.client.cpp` skip the service split. See [Architecture](architecture.md) and [OOP structure](oop/index.md).
+`*.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
 

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

package/docs/intro.md

@@ -5,7 +5,7 @@ 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 (`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.
 

package/docs/oop/file-tags.md

@@ -16,34 +16,33 @@ The **filename** decides the Roblox instance. This is the same key idea as roblo
 | `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`) | — |
 
-## Server is not Legacy
+## One file in, one file out
 
-`.server.cpp` is **not** `init.server.luau`. Rojo maps `*.server.luau` to a Script with RunContext **Legacy**. Cluaupp emits:
+Rojo infers the instance from the filename key: `*.server.luau` is a Script, `*.client.luau` is a LocalScript, untagged `.luau` is a ModuleScript.
 
 ```
-out/server/LeaderstatsServer/
-  init.luau
-  init.meta.json    -- className Script, RunContext Server
+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
 ```
 
-`.legacy.server.cpp` is the 1:1 dump that *does* become Legacy.
-
-`.client.cpp` stays `init.client.luau` (LocalScript). Do not add `init.meta.json` on the client boot.
+`.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)
-src/client/.../*.client.cpp   → out/client  (StarterPlayerScripts)
-src/shared/.../*.cpp          → out/shared  (ReplicatedStorage)
+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 services.
-
-## Skip the planner
+Name the **system**, not `init.server.cpp`. `LeaderstatsServer.server.cpp` and `DataBoot.server.cpp` are two files.
 
-- `"architecture": false` in `cluaupp.config.json`, or
-- `.legacy.server.cpp` / `.legacy.client.cpp` per file
+## Opt-in planner
 
-Use legacy only when you want one Luau file with no Main / Controller split.
+`"architecture": true` in `cluaupp.config.json` restores PascalCase service folders (`Main`, Controller, Types). Default is off.

package/docs/oop/index.md

@@ -11,12 +11,12 @@ The **live site** (not just these markdown files) is GitHub Pages:
 - [Guide → OOP](https://kartzrbx.github.io/Cluaupp/guide/oop.html)
 - [Examples](https://kartzrbx.github.io/Cluaupp/guide/examples.html)
 
-Cluaupp does **not** compile custom C++ `class` types yet. “OOP” here is how you **lay out systems** so Studio gets services, modules, and lifecycle — the same idea as roblox-ts filename keys + Flamework `@Service`, without decorators.
+Cluaupp does **not** compile custom C++ `class` types yet. “OOP” here is how you **lay out systems** so Studio gets Script / LocalScript / ModuleScript from the filename tag — the same idea as roblox-ts. Flamework-style Start/Stop folders are opt-in (`"architecture": true`).
 
 | Page | What you learn |
 | --- | --- |
 | [File tags](file-tags.md) | `.server` / `.client` / `.plugin` / `.legacy` / untagged |
-| [Services](services.md) | One `.server.cpp` → Main, Controller, Start / Stop |
+| [Services](services.md) | One `.server.cpp` → one `.server.luau` |
 | [Modules](modules.md) | Untagged files, structs, named functions as methods |
 
 Planner details: [Architecture](../architecture.md). Folder layout: [Organization](../cpp-organization.md). Full services: [Examples](../examples/index.md).

package/docs/oop/modules.md

@@ -25,7 +25,9 @@ int DoubleCoins(int coins) {
 out/shared/util/Coins.luau   -- ModuleScript, exported functions
 ```
 
-Shared **data and constants** belong in headers (`#include "TemplateData.hpp"`) — they are inlined. Untagged `.cpp` is for a ModuleScript other Luau can `require`. Prefer headers for data and tagged `.server.cpp` / `.client.cpp` for behavior.
+Quoted `#include "TemplateData.hpp"` is not inlined when the header has a sibling `.cpp` or is a shared module: `cluaupp build` emits `require(ReplicatedStorage.Cluaupp.constants.TemplateData)` / `require(ServerScriptService.Cluaupp.configurations.PlayerDataVersion)` (Rojo roots from `default.project.json`), never `script.Parent.Parent.shared`.
+
+`.h` / `.hpp` are **type modules**. A service header becomes `export type Name = { init: (self: Name) -> (), … }` and a typed table. The sibling `.cpp` is the construction (`NameImpl.luau`); the header `require`s that impl and binds the functions. Data-only structs still emit a constructor so `TemplateData()` works. Untagged `.cpp` without a header is a ModuleScript other Luau can `require`. Prefer headers for the public type, tagged `.server.cpp` / `.client.cpp` for scripts, and the sibling `.cpp` for method bodies.
 
 ## Structs = data, not classes
 

package/docs/oop/services.md

@@ -5,7 +5,7 @@ sidebar_position: 3
 
 # Services
 
-Write **one tagged file per system**. Cluaupp reads the AST and emits a PascalCase folder: `Main`, managers, controllers, `*Types`.
+Write **one tagged file per system**. Cluaupp emits **one** Luau instance: `LeaderstatsServer.server.luau` from `LeaderstatsServer.server.cpp`. It does not invent Main / Controller / Types unless `"architecture": true`.
 
 ## Example: leaderstats
 
@@ -44,29 +44,22 @@ void init() {
 Typical output:
 
 ```
-out/server/LeaderstatsServer/
-  init.luau              -- Script, RunContext Server
-  init.meta.json
-  Main.luau              -- Start / Stop
-  PlayersManager.luau    -- PlayerAdded + Janitor
-  DataController.luau    -- your WaitFor / GetChangedSignal
-  CacheController.luau   -- if you create IntValue folders
-  LeaderstatsServerTypes.luau
+out/server/services/leaderstats/LeaderstatsServer.server.luau
 ```
 
-Your functions stay in the matching controller. The planner does not drop `SetupPlayerManager` because `init` still calls it.
+Your functions stay in that file. `init()` runs at the end. There is no fake `Main` that only forwards to a Controller.
 
 ## Lifecycle
 
-Generated `Main` exposes `Start` / `Stop`. Managers own a Janitor. `Stop` cleans connections.
+You own `init` and Janitor cleanup in the same file. You do not write `class LeaderstatsServer` — name the **file** `LeaderstatsServer.server.cpp` and keep **functions** as the public API.
 
-You do not write `class LeaderstatsServer` — name the **file** `LeaderstatsServer.server.cpp` and keep **functions** as the public API.
+`"architecture": true` is the old ForeverHD split (`Main.Start` / `Main.Stop`, Managers, Types). Leave it off unless you want that.
 
 ## Boot vs gameplay
 
 Keep DataService `Init` in `DataBoot.server.cpp` / `DataBoot.client.cpp`. Keep leaderstats / combat in their own `.server.cpp`. Services `WaitFor` after boot has run.
 
-## What becomes which role
+## Opt-in roles (`"architecture": true`)
 
 | Your C++ | Generated role |
 | --- | --- |
@@ -78,6 +71,6 @@ Keep DataService `Init` in `DataBoot.server.cpp` / `DataBoot.client.cpp`. Keep l
 | `UserInputService` | `InputController` |
 | wiring | `Main.Start` / `Main.Stop` |
 
-A tiny `print` in `init.client.cpp` stays a single LocalScript. The planner does not invent Managers for hello-world.
+A tiny `print` in `init.client.cpp` stays a single LocalScript.
 
 Copy-paste: [Examples](../examples/index.md).

package/docs/syntax.md

@@ -2,15 +2,16 @@
 
 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).
 
-Generated Luau follows the current language: [`--!strict`](https://luau.org/getting-started), `local`, `const`, and `const function`. Injected `require` / `GetService` lines are `const`.
+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).
 
 ## Files
 
 - Extensions: `.cpp`, `.h`, `.hpp` (also `.cc`, `.hh`)
-- Quoted `#include "file.h"` is inlined (C preprocessor)
+- Quoted `#include "file.h"` becomes a Rojo `require` (or is inlined for a header that belongs to the same `.cpp`)
 - `#include <cluaupp/roblox.hpp>` and `<cluaupp/libs/*.hpp>` are IntelliSense only; library headers also inject `require(CluauppLibs.*)`
-- Other `#` lines (`#pragma once`) are ignored
-- Function prototypes (`void foo();`) are skipped; only functions with a body are emitted
+- `#pragma once` is ignored
+- `#pragma strict` / `#pragma nstrict` control `--!strict` for that compilation unit
+- Function prototypes in a `.h` / `.hpp` become `export type` fields (`init: (self: Name) -> ()`). Only `.cpp` files emit function bodies.
 
 ## Functions
 
@@ -199,6 +200,6 @@ Full table and IntelliSense notes: [print and cout](print-cout.md).
 
 ## Not supported yet
 
-Custom C++ classes, generic templates besides `GetService<T>`, pointer arithmetic, `std::`, overloading, macros (except skipping `#` lines).
+Custom C++ classes, generic templates besides `GetService<T>`, pointer arithmetic, `std::`, overloading, macros (except `#pragma strict` / `#pragma nstrict` / `#pragma once`).
 
 If you need one of those patterns, open an issue with the C++ and the expected Luau.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "cluaupp",
-	"version": "0.1.4",
+	"version": "0.1.5",
 	"description": "Cluaupp — the definitive merge of C++ and modern Luau. Source-to-source transpiler with first-class Roblox APIs.",
 	"author": "KartzDev",
 	"license": "MIT",