cluaupp 0.1.0

package/package.json

@@ -0,0 +1,65 @@
+{
+	"name": "cluaupp",
+	"version": "0.1.0",
+	"description": "Cluaupp — the definitive merge of C++ and modern Luau. Source-to-source transpiler with first-class Roblox APIs.",
+	"author": "KartzDev",
+	"license": "MIT",
+	"bin": {
+		"cluaupp": "bin/cluaupp.js",
+		"cluau": "bin/cluaupp.js"
+	},
+	"main": "src/compile.js",
+	"exports": {
+		".": "./src/compile.js",
+		"./package.json": "./package.json"
+	},
+	"files": [
+		"bin",
+		"src",
+		"include",
+		"templates",
+		"runtime",
+		"README.md",
+		"LICENSE",
+		"CHANGELOG.md",
+		"docs"
+	],
+	"scripts": {
+		"cluaupp": "node bin/cluaupp.js",
+		"cluau": "node bin/cluaupp.js",
+		"build": "node bin/cluaupp.js build",
+		"watch": "node bin/cluaupp.js watch",
+		"test": "node test/leaderstats.test.js && node test/understand.test.js && node test/datatypes.test.js && node test/headers.test.js && node test/libs.test.js && node test/runtime-libs.test.js && node test/intellisense.test.js",
+		"generate-api": "node scripts/generate-api.js",
+		"check-highlight": "node scripts/check-highlight.js",
+		"vendor-libs": "node scripts/vendor-libs.js",
+		"docs": "moonwave dev",
+		"docs:build": "moonwave build",
+		"site": "node scripts/generate-api.js && node scripts/check-highlight.js",
+		"dev": "node scripts/dev.js",
+		"stop": "node scripts/stop.js",
+		"prepublishOnly": "npm test"
+	},
+	"engines": {
+		"node": ">=18"
+	},
+	"keywords": [
+		"luau",
+		"roblox",
+		"cpp",
+		"c++",
+		"transpiler",
+		"compiler",
+		"rojo",
+		"cluaupp",
+		"cluau"
+	],
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/KartzRbx/Cluaupp.git"
+	},
+	"bugs": {
+		"url": "https://github.com/KartzRbx/Cluaupp/issues"
+	},
+	"homepage": "https://github.com/KartzRbx/Cluaupp#readme"
+}

package/runtime/ArrayIndexer/init.luau

@@ -0,0 +1,144 @@
+--!strict
+--[=[
+	@class ArrayIndexer
+	Type function `Table` — pick one or more keys from a service manifest.
+	`Table<Manifest, "CurrencyService">` is the service, not a generic table.
+]=]
+type ManifestExample = {
+	CurrencyService: { AddCash: () -> (), SubtractCash: () -> () },
+	DataService: { FetchData: () -> (), ClearData: () -> () },
+	PlayerService: { RespawnChar: () -> (), RemoveChar: () -> () },
+}
+export type function Table(list: type, id: type): type
+	if not list:is("table") then
+		error(`[Manifest] list deve ser a manifest table, recebi {list.tag}`)
+	end
+
+	if id:is("any") or id:is("unknown") or id:is("never") then
+		return types.any
+	end
+
+	-- quantas opcoes um tipo descreve (para desempatar intersection)
+	local function largura(t: type): number?
+		local alvo = t
+		if alvo:is("table") then
+			local ix = alvo:readindexer()
+			if not ix then
+				return nil
+			end
+			alvo = ix.result
+		end
+		if alvo:is("singleton") then
+			return 1
+		end
+		if alvo:is("union") then
+			local n = 0
+			for _ in alvo:components() do
+				n += 1
+			end
+			return n
+		end
+		return nil
+	end
+
+	-- 1. INTERSECTION: fica o ramo mais estreito, sem depender de ordem
+	if id:is("intersection") then
+		local melhor, menor = nil, math.huge
+		for _, parte in id:components() do
+			local w = largura(parte)
+			if w and w < menor then
+				menor, melhor = w, parte
+			end
+		end
+		if not melhor then
+			error("[Manifest] intersection sem ramo utilizavel (nenhum singleton, union ou array deles)")
+		end
+		id = melhor
+	end
+
+	-- 2. ARRAY: desce no indexer
+	local fromArray = false
+	if id:is("table") then
+		local indexer = id:readindexer()
+		if not indexer then
+			error("[Manifest] esperava array de chaves, recebi table sem indexer")
+		end
+		fromArray = true
+		id = indexer.result
+	end
+
+	if id:is("string") then
+		error(
+			'[Manifest] WIDENED: as chaves viraram `string`. Use `:: { "A" | "B" }` no literal, ou passe a union direto'
+		)
+	end
+
+	-- 3. CHAVE UNICA e nao veio de array: devolve o servico direto
+	if id:is("singleton") and not fromArray then
+		local alvo = id:value()
+		local prop = list:readproperty(id)
+		if prop then
+			return prop
+		end
+		local disponiveis = {}
+		for key in list:properties() do
+			table.insert(disponiveis, tostring(key:value()))
+		end
+		table.sort(disponiveis)
+		error(`[Manifest] "{alvo}" nao existe. Disponiveis: {table.concat(disponiveis, ", ")}`)
+	end
+
+	-- 4. coleta os pedidos
+	local pedidos = {}
+	if id:is("singleton") then
+		pedidos[id:value()] = true
+	elseif id:is("union") then
+		for _, c in id:components() do
+			if not c:is("singleton") then
+				error(`[Manifest] componentes da union devem ser singleton, recebi {c.tag}`)
+			end
+			pedidos[c:value()] = true
+		end
+	else
+		error(`[Manifest] id deve ser singleton, union de singletons, ou array deles. Recebi {id.tag}`)
+	end
+
+	-- 5. monta o subconjunto
+	local resultado = types.newtable()
+	for key, prop in list:properties() do
+		local nome = key:value()
+		if type(nome) == "string" and pedidos[nome] then
+			pedidos[nome] = nil
+			if prop.read then
+				resultado:setreadproperty(key, prop.read)
+			end
+			if prop.write then
+				resultado:setwriteproperty(key, prop.write)
+			end
+		end
+	end
+
+	-- 6. o que sobrou foi pedido e nao existe
+	local faltando = {}
+	for nome in pedidos do
+		table.insert(faltando, nome)
+	end
+	if #faltando > 0 then
+		table.sort(faltando)
+		local disponiveis = {}
+		for key in list:properties() do
+			table.insert(disponiveis, tostring(key:value()))
+		end
+		table.sort(disponiveis)
+		error(
+			`[Manifest] nao existe(m): {table.concat(faltando, ", ")}. Disponiveis: {table.concat(disponiveis, ", ")}`
+		)
+	end
+
+	return resultado
+end
+
+type CurrencyService = Table<ManifestExample, "CurrencyService"> --> AddCash: () -> (), SubtractCash: () -> ()
+type TwoServices = Table<ManifestExample, "PlayerService" | "DataService"> --> {RespawnChar: () -> (), RemoveChar: () -> ()}, {FetchData: () -> (), ClearData: () -> ()}
+
+return {}

package/runtime/Chrono/Client/ClientClock.luau

@@ -0,0 +1,202 @@
+const RunService = game:GetService("RunService")
+
+const Warn = require(script.Parent.Parent.Shared.Warn)
+const Config = require(script.Parent.Parent.Shared.Config)
+const Types = require(script.Parent.Parent.Shared.Types)
+const BufferTracker = require(script.Parent.InterpolationBuffer)
+
+const ClientClocks = {}
+const _ServerOwnedClocks = {}
+
+const function GetBuffer(clientClock: Types.ClientClock): number
+	if clientClock.buffer then
+		return BufferTracker.GetBuffer(clientClock.buffer, clientClock.tickRate)
+	else
+		return clientClock.bufferConst or 0
+	end
+end
+
+const function Clear(clientClock: Types.ClientClock)
+	clientClock.lastClockAt = nil
+	clientClock.lastClockDuration = 0
+	clientClock.renderAt = nil
+
+	if clientClock.buffer then
+		clientClock.buffer.init = false
+	end
+end
+
+const function GetTargetRenderTime(clientClock: Types.ClientClock): number
+	if not clientClock.renderAt then
+		Warn.low("ClientClock: Render time not yet established for", clientClock.name)
+		return 0
+	end
+
+	return clientClock.renderAt
+end
+
+const function GetEstimatedServerTime(clientClock: Types.ClientClock): number
+	if not clientClock.lastClockAt then
+		Warn.low("ClientClock: Estimated server time not yet established for", clientClock.name)
+		return 0
+	end
+
+	return clientClock.lastClockAt + (os.clock() - clientClock.lastClockDuration)
+end
+
+const function CheckHasLastClockAt(clientClock: Types.ClientClock, sendTime: number)
+	if not clientClock.lastClockAt then
+		clientClock.lastClockAt = sendTime
+		clientClock.lastClockDuration = os.clock()
+		clientClock.renderAt = nil
+	end
+end
+
+const function Refresh(clientClock: Types.ClientClock, currentSendTime: number): boolean
+	if not clientClock.lastClockAt then
+		CheckHasLastClockAt(clientClock, currentSendTime)
+		return false
+	end
+
+	if currentSendTime > clientClock.lastClockAt then
+		clientClock.lastClockAt = currentSendTime
+		clientClock.lastClockDuration = os.clock()
+		return true
+	end
+
+	return false
+end
+
+const function OnSnapShot(clientClock: Types.ClientClock, currentSendTime: number)
+	if not clientClock.lastClockAt then
+		CheckHasLastClockAt(clientClock, currentSendTime)
+		return
+	end
+
+	if clientClock.buffer then
+		BufferTracker.Register(clientClock.buffer, currentSendTime)
+	end
+
+	if Refresh(clientClock, currentSendTime) and not clientClock.renderAt then
+		clientClock.renderAt = currentSendTime - GetBuffer(clientClock)
+	end
+end
+
+const function SetTickRate(clientClock: Types.ClientClock, tickRate: number)
+	if clientClock.tickRate == tickRate then
+		return
+	end
+	clientClock.tickRate = tickRate
+	--//Do something here maybe?
+end
+
+const function Destroy(clientClock: Types.ClientClock)
+	ClientClocks[clientClock] = nil
+	if _ServerOwnedClocks[clientClock] then
+		_ServerOwnedClocks[clientClock] = nil
+	end
+end
+
+const function Update(clientClock: Types.ClientClock, dt: number)
+	const now = os.clock()
+	const delay = GetBuffer(clientClock)
+	if not clientClock.lastClockAt then
+		return
+	end
+	const estimatedServerTime = clientClock.lastClockAt + (now - clientClock.lastClockDuration)
+	local renderAt = (clientClock.renderAt or (estimatedServerTime - delay)) + dt
+
+	const renderTimeError = delay - (estimatedServerTime - renderAt)
+
+	if math.abs(renderTimeError) > 0.1 then
+		renderAt = estimatedServerTime - delay
+	elseif renderTimeError > 0.01 then
+		renderAt = math.max(estimatedServerTime - delay, renderAt - 0.1 * dt)
+	elseif renderTimeError < -0.01 then
+		renderAt = math.min(estimatedServerTime - delay, renderAt + 0.1 * dt)
+	end
+
+	clientClock.renderAt = renderAt
+end
+
+const function UpdateBuffer(clientClock: Types.ClientClock, buffer: number?)
+	buffer = if buffer and buffer <= 0 then nil else buffer
+	const currentBuffer = clientClock.bufferConst
+	if currentBuffer == buffer then
+		return
+	end
+	if not buffer then
+		if not clientClock.buffer then
+			clientClock.buffer = BufferTracker.new(clientClock)
+		end
+	else
+		clientClock.buffer = nil
+	end
+	clientClock.bufferConst = buffer
+	clientClock.renderAt = nil
+end
+
+const function new(tickRate: number, name: string, bufferNumber: number?, networkOwner: Player?): Types.ClientClock
+	bufferNumber = if bufferNumber and bufferNumber <= 0 then nil else bufferNumber
+	const self: Types.ClientClock = {
+		name = name,
+		lastClockAt = nil,
+		lastClockDuration = 0,
+		renderAt = nil,
+		tickRate = tickRate,
+		_baseTickRate = tickRate,
+		_owner = networkOwner,
+		buffer = nil,
+		bufferConst = bufferNumber,
+
+		OnSnapShot = OnSnapShot,
+		Refresh = Refresh,
+		GetEstimatedServerTime = GetEstimatedServerTime,
+		GetTargetRenderTime = GetTargetRenderTime,
+		Clear = Clear,
+		SetTickRate = SetTickRate,
+		UpdateBuffer = UpdateBuffer,
+		Destroy = Destroy,
+	}
+	if not bufferNumber then
+		self.buffer = BufferTracker.new(self)
+	end
+
+	if not networkOwner then
+		_ServerOwnedClocks[self] = true
+	end
+
+	ClientClocks[self] = true
+	return self
+end
+
+const function UpdateAll(dt: number)
+	for clientClock, _ in ClientClocks do
+		Update(clientClock, dt)
+	end
+end
+
+Config._WaitForLock(function()
+	if RunService:IsServer() then
+		return
+	end
+	for name, config in Config._EntityConfigs do
+		const clientClocks = config.CLIENT_CLOCK
+		if not clientClocks then
+			Warn.high("Entity Config", name, "is missing client clocks")
+			return
+		end
+		clientClocks.NORMAL = new(config.TICK_RATE, name .. "_NORMAL", config.BUFFER)
+		if config.HALF_TICK_DISTANCE < math.huge then
+			clientClocks.HALF = new(config.TICK_RATE * 2, name .. "_HALF", config.BUFFER)
+		end
+	end
+end)
+
+return {
+	_getBuffer = GetBuffer,
+	new = new,
+	clientClocks = ClientClocks,
+	serverOwnedClocks = _ServerOwnedClocks,
+	UpdateAll = UpdateAll,
+}

package/runtime/Chrono/Client/InterpolationBuffer.luau

@@ -0,0 +1,74 @@
+const Warn = require(script.Parent.Parent.Shared.Warn)
+const Config = require(script.Parent.Parent.Shared.Config)
+const Types = require(script.Parent.Parent.Shared.Types)
+
+local MIN_BUFFER
+local MAX_BUFFER
+const ALPHA = 0.1
+
+Config._WaitForLock(function()
+	MIN_BUFFER = Config._GetConfig("MIN_BUFFER")
+	MAX_BUFFER = Config._GetConfig("MAX_BUFFER")
+end)
+const Buffer = {}
+
+function Buffer.new(clientClock: Types.ClientClock)
+	return {
+		init = false,
+		averageLatency = 0,
+		deviation = 0,
+		lastLatency = 0,
+
+		clientClock = clientClock,
+	}
+end
+
+function Buffer.Register(data: Types.InterpolationBuffer, time: number)
+	const clientClock = data.clientClock
+	const clientNow = clientClock:GetEstimatedServerTime()
+	const latency = clientNow - time
+
+	if math.abs(latency) > 1 then
+		clientClock:Clear()
+		Warn.low(data.clientClock.name, ` latency too high, cleared cache to repredict in case of error:! {latency}`)
+	end
+
+	if not data.init then
+		--using the difference between current and last latency, i could smooth out the deviation (the variation in latency, which correlates to packet loss)
+		--this is using statistics https://en.wikipedia.org/wiki/Moving_average
+		data.averageLatency = latency
+		data.deviation = 0
+		data.lastLatency = latency
+		data.init = true
+		return
+	end
+
+	if data.lastLatency then
+		const delta = math.abs(latency - data.lastLatency)
+		--deviation is essentially jitter, and we calculate that using RFC 3550 jitter estimation
+		--see: https://tech.ebu.ch/docs/tech/tech3337.pdf
+		data.deviation = data.deviation + (delta - data.deviation) * ALPHA
+	end
+
+	data.averageLatency = data.averageLatency + (latency - data.averageLatency) * ALPHA
+	data.lastLatency = latency
+end
+
+function Buffer.GetBuffer(data: Types.InterpolationBuffer, tickRate: number)
+	if not data then
+		return MIN_BUFFER
+	end
+
+	const deviationMargin = data.deviation * 2
+	const rawBuffer = tickRate + deviationMargin
+
+	local buffer = if rawBuffer < MIN_BUFFER then MIN_BUFFER + (MIN_BUFFER - rawBuffer) * 0.2 else rawBuffer
+	if buffer > MAX_BUFFER then
+		Warn.low(`Interpolation buffer exceeded max! Was {buffer}, clamped to {MAX_BUFFER} for`, data.clientClock.name)
+		buffer = MAX_BUFFER
+	end
+
+	return buffer
+end
+
+return Buffer

package/runtime/Chrono/Client/ModelResolver.luau

@@ -0,0 +1,53 @@
+const CollectionService = game:GetService("CollectionService")
+
+const Warn = require(script.Parent.Parent.Shared.Warn)
+const Config = require(script.Parent.Parent.Shared.Config)
+const Types = require(script.Parent.Parent.Shared.Types)
+const Entity = require(script.Parent.Parent.Shared.Entity)
+const ModelHelper = require(script.Parent.Parent.Shared.ModelHelper)
+const TAG = ModelHelper.TAG
+const CHRONO_META_NAME = ModelHelper.CHRONO_META_NAME
+
+const RegisteredModels = {}
+
+const function OnInstanceAdded(instance: Instance)
+	const metaStringValue: string? = instance:GetAttribute(CHRONO_META_NAME) :: any
+	if metaStringValue then
+		RegisteredModels[metaStringValue] = instance.Parent :: any
+		Warn.low(
+			`Model with meta {metaStringValue} was added to the game. Entities using this model will now be able to resolve it.`
+		)
+	end
+end
+
+CollectionService:GetInstanceAddedSignal(TAG):Connect(OnInstanceAdded)
+CollectionService:GetInstanceRemovedSignal(TAG):Connect(function(instance)
+	const attribute: string? = instance:GetAttribute(CHRONO_META_NAME) :: any
+	if attribute then
+		RegisteredModels[attribute] = nil
+		Warn.low(
+			`Model with meta {attribute} was removed from the game. Entities using this model will no longer be able to resolve it.`
+		)
+	end
+end)
+for _, instance in CollectionService:GetTagged(TAG) do
+	OnInstanceAdded(instance)
+end
+
+return function(entity: Types.Entity)
+	const model = entity.model
+
+	if model and model.Parent then
+		return
+	end
+
+	const metaData = entity._modelMetaData
+	if not metaData then
+		return
+	end
+	const registered = RegisteredModels[metaData] :: Model | BasePart?
+	if registered and registered ~= model then
+		Entity.SetModel(entity, registered)
+		Warn.low(`Model with meta {metaData} was resolved for entity {entity.id}.`)
+	end
+end

package/runtime/Chrono/Client/Player.luau

@@ -0,0 +1,113 @@
+const Warn = require(script.Parent.Parent.Shared.Warn)
+const Events = require(script.Parent.Parent.Shared.Events)
+const Entity = require(script.Parent.Parent.Shared.Entity)
+const Holder = require(script.Parent.Parent.Shared.Holder)
+const Types = require(script.Parent.Parent.Shared.Types)
+const Config = require(script.Parent.Parent.Shared.Config)
+
+const LocalPlayer = game:GetService("Players").LocalPlayer
+
+Events.PlayerCharacterRegistered:Connect(function(player: Player, entity: Types.Entity)
+	if Config._GetConfig("PLAYER_REPLICATION") ~= "AUTOMATIC" then
+		return
+	end
+
+	if Entity.GetModelReplicationType(entity) ~= "CUSTOM" then
+		return
+	end
+	if not entity.model then
+		return Warn.high(`No model found for {player}`)
+	end
+
+	if entity.model then
+		if not entity.model:IsA("Model") then
+			return Warn.high(`Model for {player} is not a Model instance.`)
+		end
+		player.Character = entity.model
+	end
+
+	const function newModel(entity, model: Model | BasePart?)
+		if not model then
+			return
+		end
+		if not model:IsA("Model") then
+			Warn.high(`Model for {player} is not a Model instance.`)
+			return
+		end
+		LocalPlayer.Character = entity.model
+		const cf = workspace.CurrentCamera.CFrame
+		workspace.CurrentCamera.CameraSubject = entity.model:FindFirstChildWhichIsA("Humanoid")
+			or entity.model.PrimaryPart
+		workspace.CurrentCamera.CFrame = cf
+		for i, v in model:QueryDescendants("LocalScript") do
+			if v:IsA("LocalScript") and v.Disabled == false then
+				v.Disabled = true
+				v.Disabled = false
+			end
+		end
+	end
+
+	if LocalPlayer == player then
+		Entity.GetEvent(entity, "ModelChanged"):Connect(newModel)
+		newModel(entity, entity.model :: any)
+	end
+end)
+const DeathRemote = script.Parent.Parent.Shared.Remotes.Death
+Config._WaitForLock(function()
+	if Config._GetConfig("PLAYER_REPLICATION") ~= "AUTOMATIC" then
+		return
+	end
+	Events.PlayerOwnedAdded:Connect(function(player: Player, entity: Types.Entity)
+		local prevConnection: RBXScriptConnection?
+		const function newModel(_, model: Model | BasePart?)
+			if prevConnection then
+				prevConnection:Disconnect()
+				prevConnection = nil
+			end
+
+			if not model or not entity.isContextOwner or not model:IsA("Model") then
+				return
+			end
+			const humanoid = model:FindFirstChildWhichIsA("Humanoid")
+
+			if humanoid then
+				prevConnection = humanoid.Died:Connect(function()
+					if not entity.isContextOwner then
+						return
+					end
+					DeathRemote:FireServer(entity.id)
+				end)
+			end
+		end
+		Entity.GetEvent(entity, "ModelChanged"):Connect(newModel)
+		newModel(entity, entity.model)
+		Entity.GetEvent(entity, "Destroying"):Connect(function()
+			if prevConnection then
+				prevConnection:Disconnect()
+				prevConnection = nil
+			end
+		end)
+	end)
+end)
+
+DeathRemote.OnClientEvent:Connect(function(id)
+	const entity = Holder.GetEntityFromId(id)
+	if not entity then
+		return
+	end
+	if entity.isContextOwner then
+		return
+	end
+
+	const model = entity.model
+	if model then
+		task.wait()
+		const humanoid = model:FindFirstChildWhichIsA("Humanoid")
+		if humanoid and humanoid:GetState() ~= Enum.HumanoidStateType.Dead then
+			humanoid.Health = 0
+			humanoid.Health = 10
+			humanoid.Health = 0
+		end
+	end
+end)
+return nil