cluaupp 1.3.0 → 1.4.1

package/runtime/Sweep/init.luau

@@ -0,0 +1,257 @@
+--!native
+--!optimize 2
+--!strict
+-- Sweep — Cluaupp zelador. Flare sends; Sweep clears.
+-- Auto-detects Disconnect / Destroy / task.cancel / call / Promise cancel.
+-- Indexed Add replaces and cleans the previous task.
+
+local Sweep = {}
+Sweep.__index = Sweep
+
+export type Sweep = typeof(setmetatable(
+	{} :: {
+		CurrentlyCleaning: boolean,
+		_frozen: boolean,
+		_tasks: { any },
+		_methods: { any },
+		_indices: { [any]: number },
+		_links: { RBXScriptConnection },
+	},
+	Sweep
+))
+
+local function typeofOk(value: any): string
+	return typeof(value)
+end
+
+local function cleanupOne(object: any, method: any)
+	if object == nil then
+		return
+	end
+	local kind = typeofOk(object)
+	if method == true or typeofOk(method) == "function" then
+		local fn = if typeofOk(method) == "function" then method else object
+		if typeofOk(fn) == "function" then
+			fn()
+		end
+		return
+	end
+	if typeofOk(method) == "string" then
+		local fn = object[method]
+		if typeofOk(fn) == "function" then
+			if method == "Destroy" and kind == "Instance" then
+				pcall(fn, object)
+			else
+				fn(object)
+			end
+		end
+		return
+	end
+	if kind == "RBXScriptConnection" then
+		if object.Connected then
+			object:Disconnect()
+		end
+		return
+	end
+	if kind == "Instance" then
+		pcall(function()
+			(object :: Instance):Destroy()
+		end)
+		return
+	end
+	if kind == "thread" then
+		pcall(task.cancel, object)
+		return
+	end
+	if kind == "function" then
+		object()
+		return
+	end
+	if kind == "table" then
+		if typeofOk(object.Cancel) == "function" and object.getStatus then
+			pcall(object.Cancel, object)
+			return
+		end
+		if typeofOk(object.Destroy) == "function" then
+			object:Destroy()
+			return
+		end
+		if typeofOk(object.Disconnect) == "function" then
+			object:Disconnect()
+			return
+		end
+		if typeofOk(object.DisconnectAll) == "function" then
+			object:DisconnectAll()
+		end
+	end
+end
+
+local function detect(object: any): any
+	local kind = typeofOk(object)
+	if kind == "RBXScriptConnection" then
+		return "Disconnect"
+	end
+	if kind == "Instance" then
+		return "Destroy"
+	end
+	if kind == "thread" then
+		return true
+	end
+	if kind == "function" then
+		return true
+	end
+	if kind == "table" then
+		if typeofOk(object.Cancel) == "function" and object.getStatus then
+			return "Cancel"
+		end
+		if typeofOk(object.Destroy) == "function" then
+			return "Destroy"
+		end
+		if typeofOk(object.Disconnect) == "function" then
+			return "Disconnect"
+		end
+		if typeofOk(object.DisconnectAll) == "function" then
+			return "DisconnectAll"
+		end
+	end
+	return "Destroy"
+end
+
+function Sweep.new(): Sweep
+	return setmetatable({
+		CurrentlyCleaning = false,
+		_frozen = false,
+		_tasks = {},
+		_methods = {},
+		_indices = {},
+		_links = {},
+	}, Sweep)
+end
+
+function Sweep:Add<T>(object: T, methodName: (boolean | string)?, index: any?): T
+	if self._frozen or self.CurrentlyCleaning then
+		return object
+	end
+	local method: any = methodName
+	if method == nil then
+		method = detect(object)
+	end
+	if index ~= nil then
+		local previous = self._indices[index]
+		if previous then
+			local oldObject = self._tasks[previous]
+			local oldMethod = self._methods[previous]
+			self._tasks[previous] = nil
+			self._methods[previous] = nil
+			self._indices[index] = nil
+			cleanupOne(oldObject, oldMethod)
+		end
+		table.insert(self._tasks, object)
+		table.insert(self._methods, method)
+		self._indices[index] = #self._tasks
+		return object
+	end
+	table.insert(self._tasks, object)
+	table.insert(self._methods, method)
+	return object
+end
+
+function Sweep:Remove(index: any): Sweep
+	local slot = self._indices[index]
+	if not slot then
+		return self
+	end
+	local object = self._tasks[slot]
+	local method = self._methods[slot]
+	self._tasks[slot] = nil
+	self._methods[slot] = nil
+	self._indices[index] = nil
+	cleanupOne(object, method)
+	return self
+end
+
+function Sweep:RemoveNoClean(index: any): Sweep
+	local slot = self._indices[index]
+	if not slot then
+		return self
+	end
+	self._tasks[slot] = nil
+	self._methods[slot] = nil
+	self._indices[index] = nil
+	return self
+end
+
+function Sweep:Get(index: any): any
+	local slot = self._indices[index]
+	if not slot then
+		return nil
+	end
+	return self._tasks[slot]
+end
+
+function Sweep:Cleanup()
+	if self.CurrentlyCleaning then
+		return
+	end
+	self.CurrentlyCleaning = true
+	for i = #self._tasks, 1, -1 do
+		local object = self._tasks[i]
+		local method = self._methods[i]
+		self._tasks[i] = nil
+		self._methods[i] = nil
+		cleanupOne(object, method)
+	end
+	table.clear(self._indices)
+	self.CurrentlyCleaning = false
+end
+
+function Sweep:Destroy()
+	self:Cleanup()
+	self._frozen = true
+	for _, link in self._links do
+		if link.Connected then
+			link:Disconnect()
+		end
+	end
+	table.clear(self._links)
+end
+
+function Sweep:LinkToInstance(object: Instance, allowMultiple: boolean?): RBXScriptConnection
+	if self._frozen then
+		return (nil :: any)
+	end
+	if not allowMultiple then
+		self:Remove("LinkToInstance")
+	end
+	local function onGone()
+		self:Destroy()
+	end
+	local destroying = object.Destroying:Connect(onGone)
+	local ancestry = object.AncestryChanged:Connect(function(_, parent)
+		if parent == nil then
+			onGone()
+		end
+	end)
+	table.insert(self._links, destroying)
+	table.insert(self._links, ancestry)
+	if not allowMultiple then
+		self._indices["LinkToInstance"] = #self._links
+	end
+	return destroying
+end
+
+function Sweep.Is(value: any): boolean
+	return typeof(value) == "table" and getmetatable(value) == Sweep
+end
+
+Sweep.AddPromise = function(self: Sweep, promise: any, index: any?): any
+	return self:Add(promise, "Cancel", index)
+end
+
+setmetatable(Sweep, {
+	__call = function()
+		return Sweep.new()
+	end,
+})
+
+return Sweep

package/runtime/Trace/init.luau

@@ -0,0 +1,210 @@
+--!optimize 2
+--!strict
+-- Trace — pretty-print values.
+
+local Trace = {}
+
+local DEFAULT_DEPTH = 4
+local DEFAULT_INDENT = "  "
+
+local function formatNumber(value: number): string
+	if value ~= value then
+		return "nan"
+	end
+	if value == math.huge then
+		return "inf"
+	end
+	if value == -math.huge then
+		return "-inf"
+	end
+	return tostring(value)
+end
+
+local function formatVector(prefix: string, ...: number): string
+	local parts = { prefix, "(" }
+	local count = select("#", ...)
+	for i = 1, count do
+		if i > 1 then
+			table.insert(parts, ", ")
+		end
+		table.insert(parts, formatNumber(select(i, ...)))
+	end
+	table.insert(parts, ")")
+	return table.concat(parts)
+end
+
+local function isArray(value: { [any]: any }): boolean
+	local count = 0
+	for key in value do
+		if typeof(key) ~= "number" or key ~= math.floor(key) or key < 1 then
+			return false
+		end
+		count += 1
+	end
+	return count == #value
+end
+
+local function formatValue(value: any, depth: number, maxDepth: number, indentWith: string, seen: { [any]: boolean }): string
+	local kind = typeof(value)
+	if kind == "string" then
+		return string.format("%q", value)
+	end
+	if kind == "number" then
+		return formatNumber(value)
+	end
+	if kind == "boolean" or kind == "nil" then
+		return tostring(value)
+	end
+	if kind == "Instance" then
+		local ok, fullName = pcall(function()
+			return value:GetFullName()
+		end)
+		if ok then
+			return `{value.ClassName}({fullName})`
+		end
+		return `{value.ClassName}({value.Name})`
+	end
+	if kind == "Vector3" then
+		return formatVector("Vector3", value.X, value.Y, value.Z)
+	end
+	if kind == "Vector2" then
+		return formatVector("Vector2", value.X, value.Y)
+	end
+	if kind == "Vector3int16" then
+		return formatVector("Vector3int16", value.X, value.Y, value.Z)
+	end
+	if kind == "Vector2int16" then
+		return formatVector("Vector2int16", value.X, value.Y)
+	end
+	if kind == "CFrame" then
+		local x, y, z, r00, r01, r02, r10, r11, r12, r20, r21, r22 = value:GetComponents()
+		return formatVector("CFrame", x, y, z, r00, r01, r02, r10, r11, r12, r20, r21, r22)
+	end
+	if kind == "Color3" then
+		return formatVector("Color3", value.R, value.G, value.B)
+	end
+	if kind == "UDim" then
+		return formatVector("UDim", value.Scale, value.Offset)
+	end
+	if kind == "UDim2" then
+		return formatVector("UDim2", value.X.Scale, value.X.Offset, value.Y.Scale, value.Y.Offset)
+	end
+	if kind == "Rect" then
+		return formatVector("Rect", value.Min.X, value.Min.Y, value.Max.X, value.Max.Y)
+	end
+	if kind == "NumberRange" then
+		return formatVector("NumberRange", value.Min, value.Max)
+	end
+	if kind == "BrickColor" then
+		return `BrickColor({string.format("%q", value.Name)})`
+	end
+	if kind == "EnumItem" then
+		return tostring(value)
+	end
+	if kind == "buffer" then
+		return `buffer({buffer.len(value)})`
+	end
+	if kind == "table" then
+		if seen[value] then
+			return "<circular>"
+		end
+		if depth >= maxDepth then
+			return "{...}"
+		end
+		seen[value] = true
+		local pad = string.rep(indentWith, depth)
+		local inner = string.rep(indentWith, depth + 1)
+		local parts = { "{" }
+		if isArray(value) then
+			if #value == 0 then
+				seen[value] = nil
+				return "{}"
+			end
+			for index, child in ipairs(value) do
+				table.insert(parts, `\n{inner}[{index}] = {formatValue(child, depth + 1, maxDepth, indentWith, seen)},`)
+			end
+		else
+			local keys = {}
+			for key in value do
+				table.insert(keys, key)
+			end
+			table.sort(keys, function(a, b)
+				if typeof(a) == "number" and typeof(b) == "number" then
+					return a < b
+				end
+				if typeof(a) == "string" and typeof(b) == "string" then
+					return a < b
+				end
+				return tostring(a) < tostring(b)
+			end)
+			if #keys == 0 then
+				seen[value] = nil
+				return "{}"
+			end
+			for _, key in keys do
+				table.insert(
+					parts,
+					`\n{inner}[{formatValue(key, depth + 1, maxDepth, indentWith, seen)}] = {formatValue(value[key], depth + 1, maxDepth, indentWith, seen)},`
+				)
+			end
+		end
+		table.insert(parts, `\n{pad}}`)
+		seen[value] = nil
+		return table.concat(parts)
+	end
+	return `{kind}({tostring(value)})`
+end
+
+local function stringify(value: any, level: number?, maxDepth: number?, indentWith: string?): string
+	return formatValue(value, level or 0, maxDepth or DEFAULT_DEPTH, indentWith or DEFAULT_INDENT, {})
+end
+
+function Trace.display(value: any, level: number?): string
+	return stringify(value, level, DEFAULT_DEPTH, DEFAULT_INDENT)
+end
+
+function Trace.Display(value: any, level: number?): string
+	return stringify(value, level, DEFAULT_DEPTH, DEFAULT_INDENT)
+end
+
+function Trace.Print(value: any)
+	print(Trace.Display(value))
+end
+
+Trace.Dump = Trace.Print
+
+function Trace.builder()
+	local maxDepth = DEFAULT_DEPTH
+	local indentWith = DEFAULT_INDENT
+	local builder = {}
+
+	function builder:MaxDepth(depth: number)
+		maxDepth = math.max(0, depth)
+		return self
+	end
+
+	function builder:Indent(indent: string)
+		indentWith = indent
+		return self
+	end
+
+	function builder:Display(value: any, level: number?): string
+		return stringify(value, level, maxDepth, indentWith)
+	end
+
+	function builder:display(value: any, level: number?): string
+		return stringify(value, level, maxDepth, indentWith)
+	end
+
+	function builder:Print(value: any)
+		print(self:Display(value))
+	end
+
+	function builder:build()
+		return self
+	end
+
+	return builder
+end
+
+return Trace

package/runtime/Ward/init.luau

@@ -0,0 +1,178 @@
+--!native
+--!optimize 2
+--!strict
+-- Ward — server anti-cheat primitives. Rate-limit remotes, cap packet size,
+-- strike on speed/teleport. Does not write Keep; Keep stays server-only.
+
+local Players = game:GetService("Players")
+local RunService = game:GetService("RunService")
+
+local Spark = require(script.Parent.Spark)
+
+local DEFAULT_KICK = 8
+local DEFAULT_RATE = 40
+local DEFAULT_BURST = 80
+local MAX_PACKET = 24 * 1024
+local MAX_SPEED = 220
+local MAX_TELEPORT = 80
+
+local Ward = {}
+Ward.OnStrike = Spark.new()
+Ward.KickAt = DEFAULT_KICK
+Ward.MaxPacketBytes = MAX_PACKET
+Ward.MaxSpeed = MAX_SPEED
+Ward.MaxTeleport = MAX_TELEPORT
+
+type Bucket = {
+	tokens: number,
+	last: number,
+	maxPerSec: number,
+	burst: number,
+}
+
+type Record = {
+	strikes: number,
+	buckets: { [string]: Bucket },
+	lastPos: Vector3?,
+	graceUntil: number,
+	reasons: { [string]: number },
+}
+
+local records: { [Player]: Record } = {}
+local watching = false
+
+local function rec(player: Player): Record
+	local row = records[player]
+	if not row then
+		row = {
+			strikes = 0,
+			buckets = {},
+			lastPos = nil,
+			graceUntil = 0,
+			reasons = {},
+		}
+		records[player] = row
+	end
+	return row
+end
+
+function Ward.Allow(player: Player, channel: string, maxPerSec: number?, burst: number?): boolean
+	if not RunService:IsServer() then
+		return true
+	end
+	if typeof(player) ~= "Instance" or not player:IsA("Player") or player.Parent == nil then
+		return false
+	end
+	if typeof(channel) ~= "string" or channel == "" then
+		return false
+	end
+	local rate = maxPerSec or DEFAULT_RATE
+	local cap = burst or math.max(rate * 2, DEFAULT_BURST)
+	local now = os.clock()
+	local row = rec(player)
+	local bucket = row.buckets[channel]
+	if not bucket then
+		bucket = {
+			tokens = cap,
+			last = now,
+			maxPerSec = rate,
+			burst = cap,
+		}
+		row.buckets[channel] = bucket
+	end
+	local elapsed = math.max(now - bucket.last, 0)
+	bucket.last = now
+	bucket.tokens = math.min(bucket.burst, bucket.tokens + elapsed * bucket.maxPerSec)
+	if bucket.tokens < 1 then
+		Ward.Strike(player, "rate:" .. channel)
+		return false
+	end
+	bucket.tokens -= 1
+	return true
+end
+
+function Ward.Packet(player: Player, bytes: number, maxBytes: number?): boolean
+	if not RunService:IsServer() then
+		return true
+	end
+	local cap = maxBytes or Ward.MaxPacketBytes
+	if typeof(bytes) ~= "number" or bytes ~= bytes or bytes < 0 or bytes > cap then
+		Ward.Strike(player, "packet")
+		return false
+	end
+	return true
+end
+
+function Ward.Strike(player: Player, reason: string): number
+	if not RunService:IsServer() then
+		return 0
+	end
+	if typeof(player) ~= "Instance" or not player:IsA("Player") or player.Parent == nil then
+		return 0
+	end
+	local row = rec(player)
+	row.strikes += 1
+	local label = if typeof(reason) == "string" and reason ~= "" then reason else "unknown"
+	row.reasons[label] = (row.reasons[label] or 0) + 1
+	Ward.OnStrike:Fire(player, label, row.strikes)
+	if row.strikes >= Ward.KickAt then
+		player:Kick("Movement or traffic rejected")
+	end
+	return row.strikes
+end
+
+function Ward.Grace(player: Player, seconds: number)
+	if typeof(player) ~= "Instance" or not player:IsA("Player") then
+		return
+	end
+	local hold = if typeof(seconds) == "number" and seconds > 0 then seconds else 1.5
+	rec(player).graceUntil = os.clock() + hold
+end
+
+function Ward.Clear(player: Player)
+	records[player] = nil
+end
+
+function Ward.Strikes(player: Player): number
+	local row = records[player]
+	return if row then row.strikes else 0
+end
+
+function Ward.WatchMovement()
+	if watching or not RunService:IsServer() then
+		return
+	end
+	watching = true
+	RunService.Heartbeat:Connect(function(dt: number)
+		if dt <= 0 then
+			return
+		end
+		local now = os.clock()
+		for _, player in Players:GetPlayers() do
+			local character = player.Character
+			local root = character and character:FindFirstChild("HumanoidRootPart")
+			if not (root and root:IsA("BasePart")) then
+				continue
+			end
+			local row = rec(player)
+			local pos = root.Position
+			if row.lastPos and now >= row.graceUntil then
+				local dist = (pos - row.lastPos).Magnitude
+				local speed = dist / dt
+				if dist > Ward.MaxTeleport and speed > Ward.MaxSpeed then
+					Ward.Strike(player, "speed")
+					root.CFrame = CFrame.new(row.lastPos)
+					pos = row.lastPos
+				end
+			end
+			row.lastPos = pos
+		end
+	end)
+	Players.PlayerRemoving:Connect(Ward.Clear)
+end
+
+function Ward.Start()
+	Ward.WatchMovement()
+end
+
+return Ward

package/src/cli.ts

@@ -26,7 +26,7 @@ program
 
 program
 	.command("init")
-	.description("create a game (src/server, src/client, src/shared)")
+	.description("create a game (ReplicatedStorage, ServerScriptService, StarterPlayer)")
 	.argument("[folder]", "destination folder", ".")
 	.action(async (folder: string) => {
 		try {

package/src/clpp/contract.ts

@@ -1,4 +1,4 @@
-/** Stable CL++ ↔ Cluaupp contract (CL++ 0.3.2). Cluaupp invokes the `clpp` binary. */
+/** Stable CL++ ↔ Cluaupp contract (CL++ 0.3.2 / 0.3.3). Cluaupp invokes the `clpp` binary. */
 
 export interface CompileRequest {
 	source: string;
@@ -48,4 +48,4 @@ export interface LanguageManifest {
 export const MIN_CLPP_VERSION = "0.3.2";
 
 export const CLPP_INSTALL_HINT =
-	"Install CL++ 0.3.2 (clpp-setup.exe or `clpp setup`) and put `clpp` on PATH. Instances are class names (`Player player`, not `Player*`). Override with CLPP or CLPP_PATH.";
+	"Install CL++ 0.3.2 or newer (clpp-setup.exe or `clpp setup`) and put `clpp` on PATH. 0.3.3 is the same JSON contract. Instances are class names (`Player player`, not `Player*`). Override with CLPP or CLPP_PATH.";

package/src/clpp/paths.ts

@@ -1,5 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
+import { isGeneratedHeader } from "../flare/index.js";
 
 export const SOURCE_EXTS = [".clpp", ".clp", ".clh"];
 
@@ -107,7 +108,7 @@ export function collectSources(dir: string, files: string[] = []): string[] {
 		const full = path.join(dir, entry.name);
 		if (entry.isDirectory()) {
 			collectSources(full, files);
-		} else if (isSourceFile(entry.name)) {
+		} else if (isSourceFile(entry.name) && !isGeneratedHeader(full)) {
 			files.push(full);
 		}
 	}