cluaupp 1.3.0 → 1.4.0

package/include/clpp/libs/keep.clh

@@ -0,0 +1,158 @@
+#pragma once
+
+// Keep — Cluaupp player data. ProfileStore session lock, tagged buffers, trades.
+// Runtime: CluauppLibs.Keep
+// CL++ has no templates inside struct — auto overloads for IntelliSense.
+
+struct DataPath {};
+struct DataProfile {
+	bool IsActive();
+	void Reconcile();
+	void AddUserId(int userId);
+	void Save();
+	bool SaveWait();
+	void EndSession();
+};
+
+struct DataBufferStats {
+	double Bytes;
+	double Messages;
+	double LastPacketBytes;
+	double LastUtilization;
+};
+
+struct OrderedListOptions {
+	string key;
+	string order;
+	int limit;
+};
+
+struct DataOrderList {
+	string Asc;
+	string Desc;
+};
+
+struct DataServiceEnum {
+	DataOrderList OrderList;
+};
+
+struct DataServiceOptions {
+	auto Template;
+	string StoreName;
+	bool UseMock;
+	string KeyPrefix;
+	LuaArray<DataPath> Exclude;
+	bool StrictPaths;
+	bool AutoCreateMissingTables;
+};
+
+struct Data {
+	RBXScriptSignal Changed;
+	bool Destroyed;
+
+	auto Get();
+	auto Get(DataPath path);
+
+	auto GetPersisted();
+	auto GetPersisted(DataPath path);
+
+	auto GetTransient();
+	auto GetTransient(DataPath path);
+
+	bool HasTransient();
+	bool HasTransient(DataPath path);
+
+	void Set(DataPath path, auto value);
+	void SetTransient(DataPath path, auto value);
+
+	auto Update(DataPath path, func fn);
+	auto UpdateTransient(DataPath path, func fn);
+
+	void ClearTransient();
+	void ClearTransient(DataPath path);
+
+	void ArrayInsert(DataPath path, auto value);
+	void ArrayInsert(DataPath path, auto value, int index);
+	void ArrayInsertTransient(DataPath path, auto value);
+	void ArrayInsertTransient(DataPath path, auto value, int index);
+
+	auto ArrayRemove(DataPath path, int index);
+	auto ArrayRemoveTransient(DataPath path, int index);
+
+	auto GetOrderedList(DataPath path, OrderedListOptions options);
+	auto GetOrderedListWithPriority(DataPath path, string key);
+	auto GetOrderedListWithPriority(DataPath path, string key, string order);
+
+	RBXScriptSignal GetChangedSignal(DataPath path);
+	RBXScriptSignal GetPathChangedSignal(DataPath path);
+	RBXScriptSignal GetIndexChangedSignal(DataPath path);
+	RBXScriptSignal GetArrayInsertedSignal(DataPath path);
+	RBXScriptSignal GetArrayRemovedSignal(DataPath path);
+
+	DataPath Typed(DataPath path);
+	void Destroy();
+};
+
+struct DataServiceServer {
+	DataPath Paths;
+	DataServiceServer Init(DataServiceOptions options);
+	Data WaitFor(Player player);
+	Data Get(Player player);
+	bool HasData(Player player);
+	DataProfile GetProfile(Player player);
+	DataBufferStats GetBufferStats();
+	DataBufferStats GetBufferStats(Player player);
+	void Destroy();
+};
+
+struct DataServiceClient {
+	DataPath Paths;
+	Data Init();
+	Data WaitForData();
+	Data Get();
+	DataBufferStats GetBufferStats();
+	void Destroy();
+};
+
+struct KeepStore {
+	static KeepStore New(string name, auto tmpl);
+	static void SetConstant(string name, auto value);
+	DataProfile StartSessionAsync(string key);
+	auto GetAsync(string key);
+	bool MessageAsync(string key, auto message);
+	void RemoveAsync(string key);
+};
+
+struct KeepVersionQuery {
+	auto Get(int index);
+	auto List();
+	auto Next();
+};
+
+struct KeepTradeOffer {
+	string Kind;
+	string Ref;
+	int Amount;
+};
+
+struct KeepTrade {
+	auto Ensure(auto data);
+	string Begin(DataProfile a, DataProfile b);
+	bool Reserve(DataProfile profile, string kind, string ref, int amount, string tradeId);
+	bool Reserve(DataProfile profile, string kind, string ref, int amount, string tradeId, auto extra);
+	bool Commit(KeepStore store, DataProfile a, DataProfile b, LuaArray<KeepTradeOffer> offersA, LuaArray<KeepTradeOffer> offersB);
+	void Abort(DataProfile profile, string tradeId);
+	void AbortIfActive(DataProfile profile);
+	bool SendOffline(KeepStore store, string key, auto payload);
+	void Credit(DataProfile profile, string kind, string ref, int amount, string operationId);
+	bool AlreadyReceived(DataProfile profile, string operationId, string kind, string ref);
+};
+
+struct Keep {
+	static DataServiceServer Server;
+	static DataServiceClient Client;
+	static DataPath Paths;
+	static DataServiceEnum Enum;
+	static KeepStore Store;
+	static KeepTrade Trade;
+};

package/include/clpp/libs/lens.clh

@@ -0,0 +1,24 @@
+#pragma once
+
+namespace Lens {
+	void Init();
+	void Window(string title, func draw);
+	void Text(string text);
+	bool Button(string label);
+	bool Button(string label, func onClick);
+	bool Checkbox(string label);
+	bool Checkbox(string label, bool value);
+	double Slider(string label, double value);
+	double Slider(string label, double value, double max);
+	double Slider(string label, double value, double min, double max);
+	bool Tree(string label);
+	void Tree(string label, func draw);
+	void Table(string title);
+	void Table(string title, LuaArray<LuaArray<string>> rows);
+	void Plot(string label, LuaArray<double> values);
+	void Search(string query);
+	void Copy(string value);
+	void Value(string label, string value);
+	void Value(string label, double value);
+	void Value(string label, bool value);
+}

package/include/clpp/libs/mint.clh

@@ -0,0 +1,28 @@
+#pragma once
+
+// Mint — number display. .mint codegen calls:
+//   Mint.Compact(value, { Fraction, Suffixes = { {threshold, label} } })
+//   Mint.Percent(value, fraction)
+//   Mint.Group(value, fraction)
+// Suffixes default to thousand-powers K,M,B,T,Qa,Qi,Sx,Sp,Oc,No,Dc,…Novg. Custom lists are { {threshold, label} }.
+// From parses Group/Compact/Scientific/Percent (commas, suffixes, e-notation). Display only.
+
+namespace Mint {
+	string Group(double value);
+	string Group(double value, int fraction);
+	string Comma(double value);
+	string Compact(double value);
+	string Compact(double value, int digits);
+	string Abbreviate(double value);
+	string Abbreviate(double value, int digits);
+	string Percent(double value);
+	string Percent(double value, int fraction);
+	string Scientific(double value);
+	string Scientific(double value, int fraction);
+	string Format(double value);
+	string To(double value);
+	string To(double value, int fraction);
+	double From(string text);
+	double From(string text, LuaArray<auto> suffixes);
+	LuaArray<auto> Suffixes(LuaArray<string> labels);
+}

package/include/clpp/libs/net.clh

@@ -1,37 +1,28 @@
 #pragma once
 
 // Buffer-packed RemoteEvent / RemoteFunction. Names are unique per game.
+// CL++ has no templates inside struct — use auto overloads (IntelliSense).
+
 struct NetEvent {
 	void Fire(Player player);
-	template <typename A>
-	void Fire(Player player, A a);
-	template <typename A, typename B>
-	void Fire(Player player, A a, B b);
-	template <typename A, typename B, typename C>
-	void Fire(Player player, A a, B b, C c);
+	void Fire(Player player, auto a);
+	void Fire(Player player, auto a, auto b);
+	void Fire(Player player, auto a, auto b, auto c);
 	void FireAll();
-	template <typename A>
-	void FireAll(A a);
-	template <typename A, typename B>
-	void FireAll(A a, B b);
+	void FireAll(auto a);
+	void FireAll(auto a, auto b);
 	void FireServer();
-	template <typename A>
-	void FireServer(A a);
-	template <typename A, typename B>
-	void FireServer(A a, B b);
-	void On(void (*callback)());
+	void FireServer(auto a);
+	void FireServer(auto a, auto b);
+	void On(func callback);
 };
 
 struct NetFunction {
-	void On(void (*callback)());
-	template <typename R>
-	R Invoke(Player player);
-	template <typename R, typename A>
-	R Invoke(Player player, A a);
-	template <typename R>
-	R InvokeServer();
-	template <typename R, typename A>
-	R InvokeServer(A a);
+	void On(func callback);
+	auto Invoke(Player player);
+	auto Invoke(Player player, auto a);
+	auto InvokeServer();
+	auto InvokeServer(auto a);
 };
 
 namespace Net {

package/include/clpp/libs/occlude.clh

@@ -0,0 +1,15 @@
+#pragma once
+
+// Occlude — camera → adornee raycast. Pin uses this when Occlude = true.
+
+namespace Occlude {
+	Vector3 Position(Instance adornee);
+	RaycastResult Raycast(WorldRoot world, Camera camera, Instance adornee);
+	RaycastResult Raycast(WorldRoot world, Camera camera, Instance adornee, RaycastParams params);
+	bool IsOccluded(WorldRoot world, Camera camera, Instance adornee);
+	bool IsOccluded(WorldRoot world, Camera camera, Instance adornee, RaycastParams params);
+	bool IsOccluded(WorldRoot world, Camera camera, Instance adornee, RaycastParams params, double slack);
+	bool Visible(WorldRoot world, Camera camera, Instance adornee);
+	bool Visible(WorldRoot world, Camera camera, Instance adornee, RaycastParams params);
+	bool Visible(WorldRoot world, Camera camera, Instance adornee, RaycastParams params, double slack);
+}

package/include/clpp/libs/pin.clh

@@ -0,0 +1,28 @@
+#pragma once
+
+struct PinOptions {
+	string Name;
+	UDim2 Size;
+	Vector3 StudsOffset;
+	Vector3 StudsOffsetWorldSpace;
+	double MaxDistance;
+	double MinDistance;
+	bool AlwaysOnTop;
+	double LightInfluence;
+	Instance Parent;
+	bool Occlude;
+	bool Fade;
+	bool Scale;
+};
+
+struct Pin {
+	static Pin new_(Instance adornee, GuiObject gui);
+	static Pin new_(Instance adornee, GuiObject gui, PinOptions options);
+	void SetText(string text);
+	void SetEnabled(bool enabled);
+	void SetMaxDistance(double distance);
+	void Destroy();
+	Instance Adornee;
+	GuiObject Gui;
+	BillboardGui Billboard;
+};

package/include/clpp/libs/promise.clh

@@ -2,25 +2,21 @@
 
 // evaera/roblox-lua-promise — vendored into CluauppLibs.Promise
 struct Promise {
-	Promise(void (*executor)());
-	template <typename T>
-	static Promise resolve(T value);
+	static Promise New(func executor);
+	static Promise resolve(auto value);
 	static Promise reject(string err);
 	static Promise delay(double seconds);
-	static Promise try_(void (*callback)());
+	static Promise try_(func callback);
 	static Promise all(LuaArray<Promise> list);
 	static Promise race(LuaArray<Promise> list);
-	static Promise retry(void (*callback)(), int times);
-	Promise Then(void (*ok)());
-	Promise Catch(void (*fail)());
-	Promise Finally(void (*callback)());
-	Promise andThen(void (*ok)());
-	Promise catch_(void (*fail)());
-	Promise finally(void (*callback)());
-	template <typename T>
-	T Await();
-	template <typename T>
-	T await();
+	static Promise retry(func callback, int times);
+	Promise Then(func ok);
+	Promise Catch(func fail);
+	Promise Finally(func callback);
+	Promise andThen(func ok);
+	Promise catch_(func fail);
+	Promise finally(func callback);
+	auto Await();
 	void Cancel();
 	void cancel();
 	string GetStatus();

package/include/clpp/libs/roster.clh

@@ -0,0 +1,117 @@
+#pragma once
+
+// Roster — table util + tagged buffer pack. No JSON on the hot path.
+// Pack tags: Nil=0 Bool=1 Number=2 String=3 Table=4 Array=5 Vector3=6 CFrame=7 Color3=8
+// Table = u16 count + key/value pairs. Array = u16 len + values. Methods also work as Roster::X(rawTable).
+
+struct Roster {
+	static Roster New();
+
+	int Size();
+	int Length();
+	bool IsEmpty();
+	auto GetData();
+
+	auto At(int index);
+	int Find(auto value);
+	int Find(auto value, int initPos);
+	int Find(auto value, int initPos, int maxPos);
+	bool Includes(auto value);
+	int Add(auto value);
+	int Push(auto value);
+	auto Pop();
+	auto Shift();
+	int Unshift(auto value);
+	auto RemoveAt(int index);
+
+	Roster Map(func mapper);
+	Roster Filter(func predicate);
+	auto Reduce(func reducer, auto initial);
+	bool Some(func predicate);
+	bool Every(func predicate);
+	void ForEach(func callback);
+	Roster Reverse();
+	Roster Clear();
+	Roster Clone();
+	Roster DeepClone();
+	Roster Keys();
+	Roster Values();
+	Roster Set(auto key, auto value);
+	auto Get(auto key);
+	auto Get(auto key, auto defaultValue);
+	bool Has(auto key);
+
+	Roster Concat(Roster other);
+	Roster Concat(auto other);
+	Roster Slice(int start);
+	Roster Slice(int start, int finish);
+	Roster Unique();
+	Roster Sort();
+	Roster Sort(func comparator);
+	Roster Shuffle();
+	Roster IndexBy(func mapper);
+	Roster IndexBy(string key);
+	Roster GroupBy(func mapper);
+	Roster GroupBy(string key);
+	Roster Merge(Roster other);
+	Roster Merge(auto other);
+	Roster Assign(Roster other);
+	Roster Assign(auto other);
+	Roster Flatten();
+	Roster Flatten(int depth);
+
+	buffer Pack();
+
+	static int Size(auto data);
+	static int Length(auto data);
+	static bool IsEmpty(auto data);
+	static auto At(auto data, int index);
+	static int Find(auto data, auto value);
+	static bool Includes(auto data, auto value);
+	static int Add(auto data, auto value);
+	static int Push(auto data, auto value);
+	static auto Pop(auto data);
+	static auto Shift(auto data);
+	static int Unshift(auto data, auto value);
+	static auto RemoveAt(auto data, int index);
+	static Roster Map(auto data, func mapper);
+	static Roster Filter(auto data, func predicate);
+	static auto Reduce(auto data, func reducer, auto initial);
+	static bool Some(auto data, func predicate);
+	static bool Every(auto data, func predicate);
+	static void ForEach(auto data, func callback);
+	static Roster Reverse(auto data);
+	static Roster Clear(auto data);
+	static Roster Clone(auto data);
+	static Roster DeepClone(auto data);
+	static Roster Keys(auto data);
+	static Roster Values(auto data);
+	static Roster Set(auto data, auto key, auto value);
+	static auto Get(auto data, auto key);
+	static bool Has(auto data, auto key);
+	static Roster Concat(auto data, auto other);
+	static Roster Slice(auto data, int start);
+	static Roster Slice(auto data, int start, int finish);
+	static Roster Unique(auto data);
+	static Roster Sort(auto data);
+	static Roster Sort(auto data, func comparator);
+	static Roster Shuffle(auto data);
+	static Roster IndexBy(auto data, func mapper);
+	static Roster IndexBy(auto data, string key);
+	static Roster GroupBy(auto data, func mapper);
+	static Roster GroupBy(auto data, string key);
+	static Roster Merge(auto data, auto other);
+	static Roster Assign(auto data, auto other);
+	static Roster Flatten(auto data);
+	static Roster Flatten(auto data, int depth);
+
+	static buffer Pack(auto value);
+	static auto Unpack(buffer buf);
+
+	static buffer WriteF64(LuaArray<double> values);
+	static LuaArray<double> ReadF64(buffer buf);
+	static buffer WriteI32(LuaArray<int> values);
+	static LuaArray<int> ReadI32(buffer buf);
+	static buffer WriteString(LuaArray<string> values);
+	static LuaArray<string> ReadString(buffer buf);
+};

package/include/clpp/libs/shift.clh

@@ -0,0 +1,22 @@
+#pragma once
+
+struct ShiftMachine {
+	void ChangeState(string name);
+	string GetState();
+	string GetCurrentState();
+	string GetPreviousState();
+	int GetId();
+	void Guard(string name, func fn);
+	void OnEnter(string name, func fn);
+	void OnLeave(string name, func fn);
+	bool CanEnter(string name);
+	buffer WriteId();
+	void ReadId(buffer buf);
+	auto GetData();
+	void ChangeData(string index, auto value);
+	void Destroy();
+};
+
+namespace Shift {
+	ShiftMachine New();
+}

package/include/clpp/libs/spark.clh

@@ -0,0 +1,28 @@
+#pragma once
+
+// Spark — engine-grade yield-safe signal. ~>Connect is Sweep-owned.
+// O(1) Disconnect, pooled runners, reentrant Fire queue, ConnectParallel.
+
+struct SparkConnection {
+	bool Connected;
+	void Disconnect();
+	void Destroy();
+};
+
+struct Spark {
+	static Spark New();
+	static Spark Wrap(RBXScriptSignal rbx);
+	static bool Is(auto obj);
+	void Fire();
+	void FireDeferred();
+	SparkConnection Connect(func fn);
+	SparkConnection ConnectParallel(func fn);
+	SparkConnection Once(func fn);
+	SparkConnection OnceParallel(func fn);
+	SparkConnection ConnectOnce(func fn);
+	void DisconnectAll();
+	LuaArray<SparkConnection> GetConnections();
+	bool IsDestroyed();
+	void Wait();
+	void Destroy();
+};

package/include/clpp/libs/stage.clh

@@ -0,0 +1,23 @@
+#pragma once
+
+struct Stage {
+	Model Object3D;
+	GuiObject AdornFrame;
+	Camera Camera;
+	bool Visible;
+	ViewportFrame Viewport;
+	WorldModel World;
+	static Stage new_(Instance model);
+	static Stage Attach(GuiObject frame, Instance model);
+	static Stage Attach3D(GuiObject frame, Instance model);
+	void Update();
+	void Update(double dt);
+	void SetCFrame(CFrame newCF);
+	CFrame GetCFrame();
+	void SetDepthMultiplier(double multiplier);
+	double GetDepthMultiplier();
+	void SetActive(bool active);
+	bool GetActive();
+	void Destroy();
+	void End();
+};

package/include/clpp/libs/sweep.clh

@@ -0,0 +1,23 @@
+#pragma once
+
+// Sweep — Cluaupp zelador. Flare sends; Sweep clears.
+// ~> Connect binds to Sweep. Auto-detects Disconnect / Destroy / cancel.
+
+struct Sweep {
+	bool CurrentlyCleaning;
+	static Sweep New();
+	auto Add(auto object);
+	auto Add(auto object, bool callDirectly);
+	auto Add(auto object, string methodName);
+	auto Add(auto object, string methodName, string index);
+	auto AddPromise(auto promise);
+	auto AddPromise(auto promise, string index);
+	Sweep Remove(string index);
+	Sweep RemoveNoClean(string index);
+	auto Get(string index);
+	void Cleanup();
+	void Destroy();
+	RBXScriptConnection LinkToInstance(Instance object);
+	RBXScriptConnection LinkToInstance(Instance object, bool allowMultiple);
+	static bool Is(auto value);
+};

package/include/clpp/libs/trace.clh

@@ -0,0 +1,18 @@
+#pragma once
+
+struct TraceBuilder {
+	TraceBuilder MaxDepth(int depth);
+	TraceBuilder Indent(string indent);
+	string Display(auto value);
+	string display(auto value);
+	void Print(auto value);
+	TraceBuilder build();
+};
+
+namespace Trace {
+	TraceBuilder builder();
+	string Display(auto value);
+	string display(auto value);
+	void Print(auto value);
+	void Dump(auto value);
+}

package/include/clpp/libs/ward.clh

@@ -0,0 +1,18 @@
+#pragma once
+
+// Ward — server anti-cheat. Rate-limit remotes, cap packet size, speed strikes.
+// Runtime: CluauppLibs.Ward. Call Ward.Start() once on the server.
+
+namespace Ward {
+	void Start();
+	void WatchMovement();
+	bool Allow(Player player, string channel);
+	bool Allow(Player player, string channel, int maxPerSec);
+	bool Allow(Player player, string channel, int maxPerSec, int burst);
+	bool Packet(Player player, int bytes);
+	bool Packet(Player player, int bytes, int maxBytes);
+	int Strike(Player player, string reason);
+	void Grace(Player player, double seconds);
+	void Clear(Player player);
+	int Strikes(Player player);
+}

package/include/clpp/libs.clh

@@ -3,22 +3,29 @@
 // require(ReplicatedStorage.CluauppLibs.*). Runtime lives in runtime/.
 
 #include <clpp/generated/instances.clh>
-#include <clpp/libs/janitor.clh>
+#include <clpp/libs/sweep.clh>
+#include <clpp/libs/spark.clh>
 #include <clpp/libs/promise.clh>
 #include <clpp/libs/net.clh>
-#include <clpp/libs/math.clh>
-#include <clpp/libs/formatnumber.clh>
-#include <clpp/libs/module3d.clh>
-#include <clpp/libs/twinkle.clh>
-#include <clpp/libs/dataservice.clh>
-#include <clpp/libs/ezvisual.clh>
-#include <clpp/libs/spring.clh>
-#include <clpp/libs/display.clh>
-#include <clpp/libs/stickybillboard.clh>
-#include <clpp/libs/topbarplus.clh>
-#include <clpp/libs/cmdr.clh>
-#include <clpp/libs/chrono.clh>
-#include <clpp/libs/iris.clh>
-#include <clpp/libs/fusion.clh>
-#include <clpp/libs/statemachine.clh>
-#include <clpp/libs/vfx.clh>
+#include <clpp/libs/flare.clh>
+#include <clpp/libs/keep.clh>
+#include <clpp/libs/mint.clh>
+#include <clpp/libs/axiom.clh>
+#include <clpp/libs/roster.clh>
+#include <clpp/libs/gleam.clh>
+#include <clpp/libs/bloom.clh>
+#include <clpp/libs/lens.clh>
+#include <clpp/libs/crest.clh>
+#include <clpp/libs/pin.clh>
+#include <clpp/libs/stage.clh>
+#include <clpp/libs/coil.clh>
+#include <clpp/libs/helm.clh>
+#include <clpp/libs/shift.clh>
+#include <clpp/libs/hive.clh>
+#include <clpp/libs/ward.clh>
+#include <clpp/libs/ember.clh>
+#include <clpp/libs/echo.clh>
+#include <clpp/libs/guide.clh>
+#include <clpp/libs/trace.clh>
+#include <clpp/libs/arrayindexer.clh>
+#include <clpp/libs/occlude.clh>

package/include/clpp/roblox.clh

@@ -2,6 +2,7 @@
 // Cluaupp — Roblox API stubs for CL++ IntelliSense.
 // Source: official client dump + datatypes from create.roblox.com
 // clpp emits Luau (Vector3.new, Instance.new, :GetPlayers, ...).
+// CL++ has no default arguments — use overloads (wait / wait(seconds)).
 
 #include <clpp/generated/enums.clh>
 #include <clpp/datatypes.clh>
@@ -27,6 +28,15 @@ bool to_bool(auto value);
 
 double tick();
 double time();
-void wait(double seconds = 0);
-void spawn(void (*callback)());
-void delay(double seconds, void (*callback)());
+double wait();
+double wait(double seconds);
+void delay(double seconds, func callback);
+
+namespace task {
+	double wait();
+	double wait(double seconds);
+	void delay(double seconds, func callback);
+	void defer(func callback);
+	void synchronize();
+	void desynchronize();
+}