@rbxts/covenant 1.0.1 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rbxts/covenant",
-    "version": "1.0.1",
+    "version": "1.0.2",
     "main": "src/init.lua",
     "scripts": {
         "build": "rbxtsc",
@@ -19,9 +19,9 @@
     },
     "homepage": "https://github.com/cuberootmctoasted/covenant#readme",
     "description": "",
-    "types": "src/index.d.ts",
+    "types": "src/covenant.d.ts",
     "files": [
-        "out",
+        "src",
         "!**/*.tsbuildinfo"
     ],
     "publishConfig": {

package/src/covenant.d.ts

@@ -0,0 +1,77 @@
+import { Entity, Id } from "@rbxts/jecs";
+import { CovenantHooks, Discriminator } from "./hooks";
+import { Remove, Delete } from "./stringEnums";
+export type WorldChangesForReplication = Map<string, Delete | Map<string, defined | Remove>>;
+export type WorldChangesForPrediction = Map<string, Map<string, defined | Remove>>;
+export interface CovenantProps {
+    replicationSend: (player: Player, worldChanges: WorldChangesForReplication) => void;
+    replicationSendAll?: (worldChanges: WorldChangesForReplication) => void;
+    replicationConnect: (callback: (worldChanges: WorldChangesForReplication) => void) => void;
+    predictionSend: (worldChanges: WorldChangesForPrediction) => void;
+    predictionConnect: (callback: (player: Player, worldChanges: WorldChangesForPrediction) => void) => void;
+}
+type ComponentPredictionValidator = (player: Player, entity: Entity, newState: unknown, lastState: unknown) => boolean;
+export declare class Covenant {
+    private _world;
+    private systems;
+    private worldChangesForReplication;
+    private worldChangesForPrediction;
+    private underivedStringifiedComponents;
+    private replicatedStringifiedComponents;
+    private predictedStringifiedComponents;
+    private started;
+    private stringifiedComponentSubscribers;
+    private stringifiedComponentValidators;
+    private replicationSend;
+    private replicationConnect;
+    private replicationSendAll;
+    private predictionSend;
+    private predictionConnect;
+    constructor({ replicationSend, replicationConnect, replicationSendAll, predictionSend, predictionConnect, }: CovenantProps);
+    private setupPredictionClient;
+    private setupPredictionServer;
+    private setupPrediction;
+    private setupRelicationServer;
+    private setupReplicationPayload;
+    private setupReplicationClient;
+    private setupReplication;
+    start(): void;
+    private schedule;
+    private worldSet;
+    subscribeComponent<T>(component: Entity<T>, subscriber: (entity: Entity, state: T | undefined, previousState: T | undefined) => void): () => void;
+    private worldDelete;
+    worldComponent<T extends defined>(): Entity<T>;
+    private checkComponentDerived;
+    private defineComponentNetworkBehavior;
+    deriveComponent<T extends defined>({ component, queriedComponents, recipe, replicated, predictionValidator, }: {
+        replicated: boolean;
+        predictionValidator: ComponentPredictionValidator | false;
+        component: Entity<T>;
+        queriedComponents: Entity[][];
+        recipe: (entity: Entity, lastState: T | undefined, updateId: number, hooks: CovenantHooks) => T | undefined;
+    }): void;
+    deriveChildren<T extends defined>({ parentComponent, parentEntityTrackerComponent, childIdentityComponent, getIdentifier, queriedComponents, recipe, replicated, predictionValidator, }: {
+        replicated: boolean;
+        predictionValidator: ComponentPredictionValidator | false;
+        parentComponent: Entity<ReadonlyArray<T>>;
+        parentEntityTrackerComponent: Entity<Map<Discriminator, Entity>>;
+        childIdentityComponent: Entity<T>;
+        getIdentifier: (state: T) => Discriminator;
+        queriedComponents: Entity[][];
+        recipe: (entity: Entity, lastChildrenStates: ReadonlyArray<T>, updateId: number, hooks: CovenantHooks) => ReadonlyArray<T>;
+    }): void;
+    deriveRootEntity<T extends defined>({ identityComponent, recipe, replicated, }: {
+        replicated: boolean;
+        identityComponent: Entity<T>;
+        recipe: (updateId: number, hooks: CovenantHooks) => {
+            statesToCreate: ReadonlyArray<T>;
+            entitiesToDelete: ReadonlyArray<Entity>;
+        };
+    }): void;
+    private worldEntity;
+    worldQuery<T extends Id[]>(...components: T): import("@rbxts/jecs").Query<import("@rbxts/jecs").InferComponents<T>>;
+    worldHas(entity: Entity, ...components: Id[]): boolean;
+    worldGet<T extends [Id] | [Id, Id] | [Id, Id, Id] | [Id, Id, Id, Id]>(entity: Entity, ...components: T): import("@rbxts/jecs").FlattenTuple<[...import("@rbxts/jecs").Nullable<import("@rbxts/jecs").InferComponents<T>>]>;
+    worldContains(entity: Entity): boolean;
+}
+export {};

package/src/covenant.luau

@@ -0,0 +1,841 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local _jecs = TS.import(script, TS.getModule(script, "@rbxts", "jecs").jecs)
+local ChildOf = _jecs.ChildOf
+local pair = _jecs.pair
+local World = _jecs.World
+local _services = TS.import(script, TS.getModule(script, "@rbxts", "services"))
+local Players = _services.Players
+local RunService = _services.RunService
+local createHooks = TS.import(script, script.Parent, "hooks").createHooks
+local _stringEnums = TS.import(script, script.Parent, "stringEnums")
+local Remove = _stringEnums.Remove
+local Delete = _stringEnums.Delete
+local _helpers = TS.import(script, script.Parent, "helpers")
+local compareMaps = _helpers.compareMaps
+local turnArrayWithIdentifierToMap = _helpers.turnArrayWithIdentifierToMap
+-- Map<Entity, Delete | Map<Component, state | Remove>>
+-- Map<Component, Map<Entity, state | Remove>>
+local function createWorldWithRange(minClientEntity, maxClientEntity)
+	local world = World.new()
+	if RunService:IsClient() then
+		world:range(minClientEntity, maxClientEntity)
+	end
+	if RunService:IsServer() then
+		world:range(maxClientEntity)
+	end
+	return world
+end
+local Covenant
+do
+	Covenant = setmetatable({}, {
+		__tostring = function()
+			return "Covenant"
+		end,
+	})
+	Covenant.__index = Covenant
+	function Covenant.new(...)
+		local self = setmetatable({}, Covenant)
+		return self:constructor(...) or self
+	end
+	function Covenant:constructor(_param)
+		local replicationSend = _param.replicationSend
+		local replicationConnect = _param.replicationConnect
+		local replicationSendAll = _param.replicationSendAll
+		local predictionSend = _param.predictionSend
+		local predictionConnect = _param.predictionConnect
+		self._world = createWorldWithRange(1000, 20000)
+		self.systems = {}
+		self.worldChangesForReplication = {}
+		self.worldChangesForPrediction = {}
+		self.underivedStringifiedComponents = {}
+		self.replicatedStringifiedComponents = {}
+		self.predictedStringifiedComponents = {}
+		self.started = false
+		self.stringifiedComponentSubscribers = {}
+		self.stringifiedComponentValidators = {}
+		self.replicationSend = replicationSend
+		self.replicationConnect = replicationConnect
+		self.replicationSendAll = replicationSendAll
+		self.predictionSend = predictionSend
+		self.predictionConnect = predictionConnect
+		self:setupReplication()
+		self:setupPrediction()
+	end
+	function Covenant:setupPredictionClient()
+		self:schedule(RunService.Heartbeat, function()
+			if next(self.worldChangesForPrediction) == nil then
+				return nil
+			end
+			local currentWorldChanges = self.worldChangesForPrediction
+			self.worldChangesForPrediction = {}
+			self.predictionSend(currentWorldChanges)
+		end, math.huge)
+	end
+	function Covenant:setupPredictionServer()
+		self.predictionConnect(function(player, worldChanges)
+			local worldReconciliation = {}
+			-- ▼ ReadonlyMap.forEach ▼
+			local _callback = function(componentChanges, stringifiedComponent)
+				local component = tonumber(stringifiedComponent)
+				local _stringifiedComponentValidators = self.stringifiedComponentValidators
+				local _stringifiedComponent = stringifiedComponent
+				local validator = _stringifiedComponentValidators[_stringifiedComponent]
+				if not validator then
+					return nil
+				end
+				-- ▼ ReadonlyMap.forEach ▼
+				local _callback_1 = function(state, stringifiedEntity)
+					local entity = tonumber(stringifiedEntity)
+					if not self:worldContains(entity) then
+						return nil
+					end
+					local newState = if state == Remove then nil else state
+					local lastState = self:worldGet(entity, component)
+					local valid = validator(player, entity, newState, lastState)
+					if valid then
+						self:worldSet(entity, component, newState)
+					else
+						local _stringifiedEntity = stringifiedEntity
+						local entityReconciliations = worldReconciliation[_stringifiedEntity]
+						local _arg0 = entityReconciliations ~= Delete
+						assert(_arg0)
+						if entityReconciliations == nil then
+							entityReconciliations = {}
+							local _stringifiedEntity_1 = stringifiedEntity
+							local _entityReconciliations = entityReconciliations
+							worldReconciliation[_stringifiedEntity_1] = _entityReconciliations
+						end
+						local _entityReconciliations = entityReconciliations
+						local _exp = stringifiedComponent
+						local _condition = self:worldGet(entity, component)
+						if _condition == nil then
+							_condition = Remove
+						end
+						_entityReconciliations[_exp] = _condition
+					end
+				end
+				for _k, _v in componentChanges do
+					_callback_1(_v, _k, componentChanges)
+				end
+				-- ▲ ReadonlyMap.forEach ▲
+			end
+			for _k, _v in worldChanges do
+				_callback(_v, _k, worldChanges)
+			end
+			-- ▲ ReadonlyMap.forEach ▲
+			if not (next(worldReconciliation) == nil) then
+				self.replicationSend(player, worldReconciliation)
+			end
+		end)
+	end
+	function Covenant:setupPrediction()
+		if RunService:IsClient() then
+			self:setupPredictionClient()
+		end
+		if RunService:IsServer() then
+			self:setupPredictionServer()
+		end
+	end
+	function Covenant:setupRelicationServer()
+		self:schedule(RunService.Heartbeat, function()
+			if next(self.worldChangesForReplication) == nil then
+				return nil
+			end
+			local currentWorldChanges = self.worldChangesForReplication
+			self.worldChangesForReplication = {}
+			if self.replicationSendAll ~= nil then
+				self.replicationSendAll(currentWorldChanges)
+			else
+				local _exp = Players:GetPlayers()
+				-- ▼ ReadonlyArray.forEach ▼
+				local _callback = function(player)
+					self.replicationSend(player, currentWorldChanges)
+				end
+				for _k, _v in _exp do
+					_callback(_v, _k - 1, _exp)
+				end
+				-- ▲ ReadonlyArray.forEach ▲
+			end
+		end, math.huge)
+	end
+	function Covenant:setupReplicationPayload()
+		Players.PlayerAdded:Connect(function(player)
+			task.defer(function()
+				if not player:IsDescendantOf(Players) then
+					return nil
+				end
+				local worldPayload = {}
+				local _exp = self.replicatedStringifiedComponents
+				-- ▼ ReadonlySet.forEach ▼
+				local _callback = function(stringifiedComponent)
+					local component = tonumber(stringifiedComponent)
+					for entity, state in self:worldQuery(component) do
+						local _arg0 = tostring(entity)
+						local entityData = worldPayload[_arg0]
+						if entityData == nil then
+							entityData = {}
+							local _arg0_1 = tostring(entity)
+							local _entityData = entityData
+							worldPayload[_arg0_1] = _entityData
+						end
+						local _arg0_1 = entityData ~= Delete
+						assert(_arg0_1)
+						local _entityData = entityData
+						local _stringifiedComponent = stringifiedComponent
+						_entityData[_stringifiedComponent] = state
+					end
+				end
+				for _v in _exp do
+					_callback(_v, _v, _exp)
+				end
+				-- ▲ ReadonlySet.forEach ▲
+				self.replicationSend(player, worldPayload)
+			end)
+		end)
+	end
+	function Covenant:setupReplicationClient()
+		self.replicationConnect(function(worldChanges)
+			-- ▼ ReadonlyMap.forEach ▼
+			local _callback = function(entityData, stringifiedEntity)
+				local entity = tonumber(stringifiedEntity)
+				if entityData == Delete then
+					self:worldDelete(entity)
+					return nil
+				end
+				-- ▼ ReadonlyMap.forEach ▼
+				local _callback_1 = function(state, stringifiedComponent)
+					local component = tonumber(stringifiedComponent)
+					if state == Remove then
+						self:worldSet(entity, component, nil, true)
+					else
+						self:worldSet(entity, component, state, true)
+					end
+				end
+				for _k, _v in entityData do
+					_callback_1(_v, _k, entityData)
+				end
+				-- ▲ ReadonlyMap.forEach ▲
+			end
+			for _k, _v in worldChanges do
+				_callback(_v, _k, worldChanges)
+			end
+			-- ▲ ReadonlyMap.forEach ▲
+		end)
+	end
+	function Covenant:setupReplication()
+		if RunService:IsServer() then
+			self:setupRelicationServer()
+			self:setupReplicationPayload()
+		end
+		if RunService:IsClient() then
+			self:setupReplicationClient()
+		end
+	end
+	function Covenant:start()
+		local _arg0 = not self.started
+		assert(_arg0, "Already started")
+		local _exp = next(self.underivedStringifiedComponents) == nil
+		-- ▼ ReadonlySet.size ▼
+		local _size = 0
+		for _ in self.underivedStringifiedComponents do
+			_size += 1
+		end
+		-- ▲ ReadonlySet.size ▲
+		local _arg1 = `There are {_size} components that are not derived`
+		assert(_exp, _arg1)
+		self.started = true
+		local _exp_1 = self.systems
+		-- ▼ ReadonlyMap.forEach ▼
+		local _callback = function(systemsOfEvent, event)
+			local _systems = self.systems
+			local _exp_2 = event
+			table.sort(systemsOfEvent, function(a, b)
+				return a.priority < b.priority
+			end)
+			local _systemsOfEvent = systemsOfEvent
+			_systems[_exp_2] = _systemsOfEvent
+			return _systems
+		end
+		for _k, _v in _exp_1 do
+			_callback(_v, _k, _exp_1)
+		end
+		-- ▲ ReadonlyMap.forEach ▲
+		local _exp_2 = self.systems
+		-- ▼ ReadonlyMap.forEach ▼
+		local _callback_1 = function(systemsOfEvent, event)
+			event:Connect(function()
+				-- ▼ ReadonlyArray.forEach ▼
+				local _callback_2 = function(_param)
+					local system = _param.system
+					system()
+				end
+				for _k, _v in systemsOfEvent do
+					_callback_2(_v, _k - 1, systemsOfEvent)
+				end
+				-- ▲ ReadonlyArray.forEach ▲
+			end)
+		end
+		for _k, _v in _exp_2 do
+			_callback_1(_v, _k, _exp_2)
+		end
+		-- ▲ ReadonlyMap.forEach ▲
+	end
+	function Covenant:schedule(event, system, priority)
+		if priority == nil then
+			priority = 0
+		end
+		local _arg0 = not self.started
+		assert(_arg0, "Attempted to schedule system after starting")
+		local _systems = self.systems
+		local _event = event
+		local systemsOfEvent = _systems[_event]
+		if systemsOfEvent == nil then
+			systemsOfEvent = {}
+			local _systems_1 = self.systems
+			local _event_1 = event
+			local _systemsOfEvent = systemsOfEvent
+			_systems_1[_event_1] = _systemsOfEvent
+		end
+		local _systemsOfEvent = systemsOfEvent
+		local _arg0_1 = {
+			system = system,
+			priority = priority,
+		}
+		table.insert(_systemsOfEvent, _arg0_1)
+	end
+	function Covenant:worldSet(entity, component, newState, doNotReconcile)
+		if doNotReconcile == nil then
+			doNotReconcile = false
+		end
+		if not self:worldContains(entity) then
+			self._world:entity(entity)
+		end
+		local lastState = self:worldGet(entity, component)
+		if newState == lastState then
+			return nil
+		end
+		if newState == nil then
+			self._world:remove(entity, component)
+		else
+			self._world:set(entity, component, newState)
+		end
+		local _stringifiedComponentSubscribers = self.stringifiedComponentSubscribers
+		local _arg0 = tostring(component)
+		local _result = _stringifiedComponentSubscribers[_arg0]
+		if _result ~= nil then
+			-- ▼ ReadonlySet.forEach ▼
+			local _callback = function(subscriber)
+				subscriber(entity, newState, lastState)
+			end
+			for _v in _result do
+				_callback(_v, _v, _result)
+			end
+			-- ▲ ReadonlySet.forEach ▲
+		end
+		if doNotReconcile then
+			return nil
+		end
+		local _replicatedStringifiedComponents = self.replicatedStringifiedComponents
+		local _arg0_1 = tostring(component)
+		if _replicatedStringifiedComponents[_arg0_1] ~= nil then
+			local _worldChangesForReplication = self.worldChangesForReplication
+			local _arg0_2 = tostring(entity)
+			local entityChanges = _worldChangesForReplication[_arg0_2]
+			if entityChanges == nil then
+				entityChanges = {}
+				local _worldChangesForReplication_1 = self.worldChangesForReplication
+				local _arg0_3 = tostring(entity)
+				local _entityChanges = entityChanges
+				_worldChangesForReplication_1[_arg0_3] = _entityChanges
+			end
+			if entityChanges ~= Delete then
+				local _entityChanges = entityChanges
+				local _exp = tostring(component)
+				local _condition = newState
+				if _condition == nil then
+					_condition = Remove
+				end
+				_entityChanges[_exp] = _condition
+			end
+		end
+		local _condition = RunService:IsClient()
+		if _condition then
+			local _predictedStringifiedComponents = self.predictedStringifiedComponents
+			local _arg0_2 = tostring(component)
+			_condition = _predictedStringifiedComponents[_arg0_2] ~= nil
+		end
+		if _condition then
+			local _worldChangesForPrediction = self.worldChangesForPrediction
+			local _arg0_2 = tostring(component)
+			local componentChanges = _worldChangesForPrediction[_arg0_2]
+			if componentChanges == nil then
+				componentChanges = {}
+				local _worldChangesForPrediction_1 = self.worldChangesForPrediction
+				local _arg0_3 = tostring(component)
+				local _componentChanges = componentChanges
+				_worldChangesForPrediction_1[_arg0_3] = _componentChanges
+			end
+			local _componentChanges = componentChanges
+			local _exp = tostring(entity)
+			local _condition_1 = newState
+			if _condition_1 == nil then
+				_condition_1 = Remove
+			end
+			_componentChanges[_exp] = _condition_1
+		end
+	end
+	function Covenant:subscribeComponent(component, subscriber)
+		local _stringifiedComponentSubscribers = self.stringifiedComponentSubscribers
+		local _arg0 = tostring(component)
+		local subscribers = _stringifiedComponentSubscribers[_arg0]
+		if subscribers == nil then
+			subscribers = {}
+			local _stringifiedComponentSubscribers_1 = self.stringifiedComponentSubscribers
+			local _arg0_1 = tostring(component)
+			local _subscribers = subscribers
+			_stringifiedComponentSubscribers_1[_arg0_1] = _subscribers
+		end
+		local subscriberElement = subscriber
+		subscribers[subscriberElement] = true
+		return function()
+			subscribers[subscriberElement] = nil
+		end
+	end
+	function Covenant:worldDelete(entity)
+		if not self:worldContains(entity) then
+			return nil
+		end
+		local toDelete = { entity }
+		local processed = {}
+		while #toDelete > 0 do
+			-- ▼ Array.pop ▼
+			local _length = #toDelete
+			local _result = toDelete[_length]
+			toDelete[_length] = nil
+			-- ▲ Array.pop ▲
+			local currentEntity = _result
+			if processed[currentEntity] ~= nil or not self:worldContains(currentEntity) then
+				continue
+			end
+			processed[currentEntity] = true
+			for childEntity in self:worldQuery(pair(ChildOf, currentEntity)) do
+				table.insert(toDelete, childEntity)
+			end
+		end
+		-- ▼ ReadonlySet.forEach ▼
+		local _callback = function(entityToDelete)
+			self._world:delete(entityToDelete)
+			local _worldChangesForReplication = self.worldChangesForReplication
+			local _arg0 = tostring(entityToDelete)
+			_worldChangesForReplication[_arg0] = Delete
+		end
+		for _v in processed do
+			_callback(_v, _v, processed)
+		end
+		-- ▲ ReadonlySet.forEach ▲
+	end
+	function Covenant:worldComponent()
+		local c = self._world:component()
+		return c
+	end
+	function Covenant:checkComponentDerived(component)
+		local _underivedStringifiedComponents = self.underivedStringifiedComponents
+		local _arg0 = tostring(component)
+		local _arg0_1 = _underivedStringifiedComponents[_arg0] ~= nil
+		local _arg1 = `Component {component} is already derived`
+		assert(_arg0_1, _arg1)
+		local _underivedStringifiedComponents_1 = self.underivedStringifiedComponents
+		local _arg0_2 = tostring(component)
+		_underivedStringifiedComponents_1[_arg0_2] = nil
+	end
+	function Covenant:defineComponentNetworkBehavior(component, replicated, predictionValidator)
+		if replicated then
+			local _replicatedStringifiedComponents = self.replicatedStringifiedComponents
+			local _arg0 = tostring(component)
+			_replicatedStringifiedComponents[_arg0] = true
+		end
+		if predictionValidator then
+			local _predictedStringifiedComponents = self.predictedStringifiedComponents
+			local _arg0 = tostring(component)
+			_predictedStringifiedComponents[_arg0] = true
+			local _stringifiedComponentValidators = self.stringifiedComponentValidators
+			local _arg0_1 = tostring(component)
+			local _predictionValidator = predictionValidator
+			_stringifiedComponentValidators[_arg0_1] = _predictionValidator
+		end
+	end
+	function Covenant:deriveComponent(_param)
+		local component = _param.component
+		local queriedComponents = _param.queriedComponents
+		local recipe = _param.recipe
+		local replicated = _param.replicated
+		local predictionValidator = _param.predictionValidator
+		self:checkComponentDerived(component)
+		self:defineComponentNetworkBehavior(component, replicated, predictionValidator)
+		local queryThisComponent = self:worldQuery(component):cached()
+		local willUpdate = true
+		local function indicateUpdate()
+			willUpdate = true
+		end
+		local hooks = createHooks({
+			indicateUpdate = indicateUpdate,
+			subscribeComponent = function(component, subscriber)
+				self:subscribeComponent(component, subscriber)
+			end,
+		})
+		-- ▼ ReadonlyArray.map ▼
+		local _newValue = table.create(#queriedComponents)
+		local _callback = function(components)
+			return self:worldQuery(unpack(components)):cached()
+		end
+		for _k, _v in queriedComponents do
+			_newValue[_k] = _callback(_v, _k - 1, queriedComponents)
+		end
+		-- ▲ ReadonlyArray.map ▲
+		local queries = _newValue
+		local _array = {}
+		local _length = #_array
+		-- ▼ ReadonlyArray.reduce ▼
+		local _result = {}
+		local _callback_1 = function(accum, components)
+			-- ▼ ReadonlyArray.forEach ▼
+			local _callback_2 = function(component)
+				local stringifiedComponent = tostring(component)
+				accum[stringifiedComponent] = true
+			end
+			for _k, _v in components do
+				_callback_2(_v, _k - 1, components)
+			end
+			-- ▲ ReadonlyArray.forEach ▲
+			return accum
+		end
+		for _i = 1, #queriedComponents do
+			_result = _callback_1(_result, queriedComponents[_i], _i - 1, queriedComponents)
+		end
+		-- ▲ ReadonlyArray.reduce ▲
+		for _v in _result do
+			_length += 1
+			_array[_length] = _v
+		end
+		-- ▼ ReadonlyArray.map ▼
+		local _newValue_1 = table.create(#_array)
+		local _callback_2 = function(stringifiedComponent)
+			return tonumber(stringifiedComponent)
+		end
+		for _k, _v in _array do
+			_newValue_1[_k] = _callback_2(_v, _k - 1, _array)
+		end
+		-- ▲ ReadonlyArray.map ▲
+		-- ▼ ReadonlyArray.forEach ▼
+		local _callback_3 = function(component)
+			self:subscribeComponent(component, indicateUpdate)
+		end
+		for _k, _v in _newValue_1 do
+			_callback_3(_v, _k - 1, _newValue_1)
+		end
+		-- ▲ ReadonlyArray.forEach ▲
+		local lastUpdateId = 0
+		local updater = function()
+			lastUpdateId += 1
+			local updateId = lastUpdateId
+			local unhandledStringifiedEntities = {}
+			local handledStringifiedEntities = {}
+			for entity in queryThisComponent do
+				local _arg0 = tostring(entity)
+				unhandledStringifiedEntities[_arg0] = true
+			end
+			-- ▼ ReadonlyArray.forEach ▼
+			local _callback_4 = function(query)
+				for entity in query do
+					local stringifiedEntity = tostring(entity)
+					if handledStringifiedEntities[stringifiedEntity] ~= nil then
+						continue
+					end
+					handledStringifiedEntities[stringifiedEntity] = true
+					unhandledStringifiedEntities[stringifiedEntity] = nil
+					local lastState = self:worldGet(entity, component)
+					local newState = recipe(entity, lastState, updateId, hooks)
+					self:worldSet(entity, component, newState)
+				end
+			end
+			for _k, _v in queries do
+				_callback_4(_v, _k - 1, queries)
+			end
+			-- ▲ ReadonlyArray.forEach ▲
+			-- ▼ ReadonlySet.forEach ▼
+			local _callback_5 = function(stringifiedEntity)
+				local entity = tonumber(stringifiedEntity)
+				self:worldSet(entity, component, nil)
+			end
+			for _v in unhandledStringifiedEntities do
+				_callback_5(_v, _v, unhandledStringifiedEntities)
+			end
+			-- ▲ ReadonlySet.forEach ▲
+		end
+		self:schedule(RunService.Heartbeat, function()
+			if not willUpdate then
+				return nil
+			end
+			willUpdate = false
+			updater()
+		end)
+	end
+	function Covenant:deriveChildren(_param)
+		local parentComponent = _param.parentComponent
+		local parentEntityTrackerComponent = _param.parentEntityTrackerComponent
+		local childIdentityComponent = _param.childIdentityComponent
+		local getIdentifier = _param.getIdentifier
+		local queriedComponents = _param.queriedComponents
+		local recipe = _param.recipe
+		local replicated = _param.replicated
+		local predictionValidator = _param.predictionValidator
+		self:checkComponentDerived(parentComponent)
+		self:checkComponentDerived(parentEntityTrackerComponent)
+		self:checkComponentDerived(childIdentityComponent)
+		self:defineComponentNetworkBehavior(parentComponent, replicated, predictionValidator)
+		local queryParentComponent = self:worldQuery(parentComponent):cached()
+		local willUpdate = true
+		local function indicateUpdate()
+			willUpdate = true
+		end
+		local hooks = createHooks({
+			indicateUpdate = indicateUpdate,
+			subscribeComponent = function(component, subscriber)
+				self:subscribeComponent(component, subscriber)
+			end,
+		})
+		-- ▼ ReadonlyArray.map ▼
+		local _newValue = table.create(#queriedComponents)
+		local _callback = function(components)
+			return self:worldQuery(unpack(components)):cached()
+		end
+		for _k, _v in queriedComponents do
+			_newValue[_k] = _callback(_v, _k - 1, queriedComponents)
+		end
+		-- ▲ ReadonlyArray.map ▲
+		local queries = _newValue
+		local _array = {}
+		local _length = #_array
+		-- ▼ ReadonlyArray.reduce ▼
+		local _result = {}
+		local _callback_1 = function(accum, components)
+			-- ▼ ReadonlyArray.forEach ▼
+			local _callback_2 = function(component)
+				local stringifiedComponent = tostring(component)
+				accum[stringifiedComponent] = true
+			end
+			for _k, _v in components do
+				_callback_2(_v, _k - 1, components)
+			end
+			-- ▲ ReadonlyArray.forEach ▲
+			return accum
+		end
+		for _i = 1, #queriedComponents do
+			_result = _callback_1(_result, queriedComponents[_i], _i - 1, queriedComponents)
+		end
+		-- ▲ ReadonlyArray.reduce ▲
+		for _v in _result do
+			_length += 1
+			_array[_length] = _v
+		end
+		-- ▼ ReadonlyArray.map ▼
+		local _newValue_1 = table.create(#_array)
+		local _callback_2 = function(stringifiedComponent)
+			return tonumber(stringifiedComponent)
+		end
+		for _k, _v in _array do
+			_newValue_1[_k] = _callback_2(_v, _k - 1, _array)
+		end
+		-- ▲ ReadonlyArray.map ▲
+		-- ▼ ReadonlyArray.forEach ▼
+		local _callback_3 = function(component)
+			self:subscribeComponent(component, indicateUpdate)
+		end
+		for _k, _v in _newValue_1 do
+			_callback_3(_v, _k - 1, _newValue_1)
+		end
+		-- ▲ ReadonlyArray.forEach ▲
+		local lastUpdateId = 0
+		local updater = function()
+			lastUpdateId += 1
+			local updateId = lastUpdateId
+			local unhandledStringifiedEntities = {}
+			local handledStringifiedEntities = {}
+			for entity in queryParentComponent do
+				local _arg0 = tostring(entity)
+				unhandledStringifiedEntities[_arg0] = true
+			end
+			-- ▼ ReadonlyArray.forEach ▼
+			local _callback_4 = function(query)
+				for entity in query do
+					local stringifiedEntity = tostring(entity)
+					if handledStringifiedEntities[stringifiedEntity] ~= nil then
+						continue
+					end
+					handledStringifiedEntities[stringifiedEntity] = true
+					unhandledStringifiedEntities[stringifiedEntity] = nil
+					local entityTracker = self:worldGet(entity, parentEntityTrackerComponent)
+					if entityTracker == nil then
+						entityTracker = {}
+						self:worldSet(entity, parentEntityTrackerComponent, entityTracker)
+					end
+					local lastState = self:worldGet(entity, parentComponent) or {}
+					local newState = recipe(entity, lastState, updateId, hooks)
+					self:worldSet(entity, parentComponent, newState)
+					local lastStateMap = turnArrayWithIdentifierToMap(lastState, getIdentifier)
+					local newStateMap = turnArrayWithIdentifierToMap(newState, getIdentifier)
+					local _binding = compareMaps(lastStateMap, newStateMap)
+					local entriesChanged = _binding.entriesChanged
+					local entriesAdded = _binding.entriesAdded
+					local keysRemoved = _binding.keysRemoved
+					-- ▼ ReadonlyArray.forEach ▼
+					local _callback_5 = function(_param_1)
+						local key = _param_1.key
+						local value = _param_1.value
+						local childEntity = self:worldEntity()
+						entityTracker[key] = childEntity
+						self:worldSet(childEntity, childIdentityComponent, value)
+						self._world:add(childEntity, pair(ChildOf, entity))
+					end
+					for _k, _v in entriesAdded do
+						_callback_5(_v, _k - 1, entriesAdded)
+					end
+					-- ▲ ReadonlyArray.forEach ▲
+					-- ▼ ReadonlyArray.forEach ▼
+					local _callback_6 = function(_param_1)
+						local key = _param_1.key
+						local value = _param_1.value
+						local childEntity = entityTracker[key]
+						assert(childEntity ~= 0 and childEntity == childEntity and childEntity)
+						local _arg0 = self:worldContains(childEntity)
+						assert(_arg0)
+						self:worldSet(childEntity, childIdentityComponent, value)
+					end
+					for _k, _v in entriesChanged do
+						_callback_6(_v, _k - 1, entriesChanged)
+					end
+					-- ▲ ReadonlyArray.forEach ▲
+					-- ▼ ReadonlyArray.forEach ▼
+					local _callback_7 = function(key)
+						local _entityTracker = entityTracker
+						local _key = key
+						local childEntity = _entityTracker[_key]
+						assert(childEntity ~= 0 and childEntity == childEntity and childEntity)
+						local _arg0 = self:worldContains(childEntity)
+						assert(_arg0)
+						self:worldDelete(childEntity)
+						local _entityTracker_1 = entityTracker
+						local _key_1 = key
+						_entityTracker_1[_key_1] = nil
+					end
+					for _k, _v in keysRemoved do
+						_callback_7(_v, _k - 1, keysRemoved)
+					end
+					-- ▲ ReadonlyArray.forEach ▲
+				end
+			end
+			for _k, _v in queries do
+				_callback_4(_v, _k - 1, queries)
+			end
+			-- ▲ ReadonlyArray.forEach ▲
+			-- ▼ ReadonlySet.forEach ▼
+			local _callback_5 = function(stringifiedEntity)
+				local entity = tonumber(stringifiedEntity)
+				local children = self:worldGet(entity, parentEntityTrackerComponent)
+				if children ~= nil then
+					-- ▼ ReadonlyMap.forEach ▼
+					local _callback_6 = function(childEntity)
+						self:worldDelete(childEntity)
+					end
+					for _k, _v in children do
+						_callback_6(_v, _k, children)
+					end
+					-- ▲ ReadonlyMap.forEach ▲
+				end
+				self:worldSet(entity, parentComponent, nil)
+				self:worldSet(entity, parentEntityTrackerComponent, nil)
+			end
+			for _v in unhandledStringifiedEntities do
+				_callback_5(_v, _v, unhandledStringifiedEntities)
+			end
+			-- ▲ ReadonlySet.forEach ▲
+		end
+		self:schedule(RunService.Heartbeat, function()
+			if not willUpdate then
+				return nil
+			end
+			willUpdate = false
+			updater()
+		end)
+	end
+	function Covenant:deriveRootEntity(_param)
+		local identityComponent = _param.identityComponent
+		local recipe = _param.recipe
+		local replicated = _param.replicated
+		self:checkComponentDerived(identityComponent)
+		self:defineComponentNetworkBehavior(identityComponent, replicated, false)
+		local willUpdate = true
+		local function indicateUpdate()
+			willUpdate = true
+		end
+		local hooks = createHooks({
+			indicateUpdate = indicateUpdate,
+			subscribeComponent = function(component, subscriber)
+				self:subscribeComponent(component, subscriber)
+			end,
+		})
+		local lastUpdateId = 0
+		local updater = function()
+			lastUpdateId += 1
+			local _binding = recipe(lastUpdateId, hooks)
+			local statesToCreate = _binding.statesToCreate
+			local entitiesToDelete = _binding.entitiesToDelete
+			-- ▼ ReadonlyArray.forEach ▼
+			local _callback = function(state)
+				local entity = self:worldEntity()
+				self:worldSet(entity, identityComponent, state)
+			end
+			for _k, _v in statesToCreate do
+				_callback(_v, _k - 1, statesToCreate)
+			end
+			-- ▲ ReadonlyArray.forEach ▲
+			-- ▼ ReadonlyArray.forEach ▼
+			local _callback_1 = function(entity)
+				self:worldDelete(entity)
+			end
+			for _k, _v in entitiesToDelete do
+				_callback_1(_v, _k - 1, entitiesToDelete)
+			end
+			-- ▲ ReadonlyArray.forEach ▲
+		end
+		self:schedule(RunService.Heartbeat, function()
+			if not willUpdate then
+				return nil
+			end
+			willUpdate = false
+			updater()
+		end)
+	end
+	function Covenant:worldEntity()
+		return self._world:entity()
+	end
+	function Covenant:worldQuery(...)
+		local components = { ... }
+		return self._world:query(unpack(components))
+	end
+	function Covenant:worldHas(entity, ...)
+		local components = { ... }
+		return self._world:has(entity, unpack(components))
+	end
+	function Covenant:worldGet(entity, ...)
+		local components = { ... }
+		return self._world:get(entity, unpack(components))
+	end
+	function Covenant:worldContains(entity)
+		return self._world:contains(entity)
+	end
+end
+return {
+	Covenant = Covenant,
+}

package/src/helpers.d.ts

@@ -0,0 +1,14 @@
+import { Discriminator } from "./hooks";
+export declare function turnArrayWithIdentifierToMap<T extends defined>(array: ReadonlyArray<T>, getIdentifier: (state: T) => Discriminator): Map<defined, T>;
+export declare function compareMaps<TKey extends Discriminator, TValue extends defined>(previousMap: ReadonlyMap<TKey, TValue>, newMap: ReadonlyMap<TKey, TValue>): {
+    entriesAdded: {
+        key: TKey;
+        value: TValue;
+    }[];
+    entriesChanged: {
+        key: TKey;
+        value: TValue;
+        previousValue: TValue;
+    }[];
+    keysRemoved: TKey[];
+};

package/src/helpers.luau

@@ -0,0 +1,70 @@
+-- Compiled with roblox-ts v3.0.0
+local function turnArrayWithIdentifierToMap(array, getIdentifier)
+	local newMap = {}
+	-- ▼ ReadonlyArray.forEach ▼
+	local _callback = function(value)
+		local identifier = getIdentifier(value)
+		local _value = value
+		newMap[identifier] = _value
+	end
+	for _k, _v in array do
+		_callback(_v, _k - 1, array)
+	end
+	-- ▲ ReadonlyArray.forEach ▲
+	return newMap
+end
+local function compareMaps(previousMap, newMap)
+	local entriesAdded = {}
+	local entriesChanged = {}
+	local keysRemoved = {}
+	-- ▼ ReadonlyMap.forEach ▼
+	local _callback = function(value, key)
+		local _previousMap = previousMap
+		local _key = key
+		if not (_previousMap[_key] ~= nil) then
+			local _arg0 = {
+				key = key,
+				value = value,
+			}
+			table.insert(entriesAdded, _arg0)
+		else
+			local _previousMap_1 = previousMap
+			local _key_1 = key
+			local previousValue = _previousMap_1[_key_1]
+			if previousValue ~= value then
+				local _arg0 = {
+					key = key,
+					value = value,
+					previousValue = previousValue,
+				}
+				table.insert(entriesChanged, _arg0)
+			end
+		end
+	end
+	for _k, _v in newMap do
+		_callback(_v, _k, newMap)
+	end
+	-- ▲ ReadonlyMap.forEach ▲
+	-- ▼ ReadonlyMap.forEach ▼
+	local _callback_1 = function(_, key)
+		local _newMap = newMap
+		local _key = key
+		if not (_newMap[_key] ~= nil) then
+			local _key_1 = key
+			table.insert(keysRemoved, _key_1)
+		end
+	end
+	for _k, _v in previousMap do
+		_callback_1(_v, _k, previousMap)
+	end
+	-- ▲ ReadonlyMap.forEach ▲
+	return {
+		entriesAdded = entriesAdded,
+		entriesChanged = entriesChanged,
+		keysRemoved = keysRemoved,
+	}
+end
+return {
+	turnArrayWithIdentifierToMap = turnArrayWithIdentifierToMap,
+	compareMaps = compareMaps,
+}

package/src/hooks.d.ts

@@ -0,0 +1,30 @@
+import { Entity } from "@rbxts/jecs";
+type AsyncResult<T = unknown> = {
+    completed: boolean;
+    value: T | undefined;
+    errorMessage?: string;
+};
+export type Discriminator = Exclude<defined, number>;
+type CovenantHook<T extends (...args: Array<any>) => defined> = (updateId: number, ...args: Parameters<T>) => ReturnType<T>;
+export interface CovenantHooks {
+    useEvent: CovenantHook<(<T extends Array<unknown>>(event: RBXScriptSignal<(...args: T) => void>) => T[])>;
+    useEventImmediately: CovenantHook<(<T extends Array<unknown>, TReturn extends defined>(event: RBXScriptSignal<(...args: T) => void>, callback: (...args: T) => TReturn) => TReturn[])>;
+    useComponentChange: CovenantHook<(<T extends defined>(component: Entity<T>) => {
+        entity: Entity;
+        state: T | undefined;
+        previousState: T | undefined;
+    }[])>;
+    useAsync: CovenantHook<(<T>(asnycFactory: () => T, dependencies: unknown[], discriminator: Discriminator) => AsyncResult<T>)>;
+    useImperative: CovenantHook<(<T extends defined>(dirtyFactory: (indicateUpdate: () => void) => {
+        value: T;
+        cleanup?: () => void;
+    }, dependencies: unknown[], discriminator: Discriminator) => T)>;
+    useChange: CovenantHook<(dependencies: unknown[], discriminator: Discriminator) => boolean>;
+    useInterval: CovenantHook<(seconds: number, trueOnInit: boolean, discriminator: Discriminator) => boolean>;
+}
+interface CovenantHooksProps {
+    indicateUpdate: () => void;
+    subscribeComponent: <T extends defined>(component: Entity<T>, subscriber: (entity: Entity, state: T | undefined, previousState: T | undefined) => void) => void;
+}
+export declare function createHooks(props: CovenantHooksProps): CovenantHooks;
+export {};

package/src/hooks.luau

@@ -0,0 +1,284 @@
+-- Compiled with roblox-ts v3.0.0
+-- eslint-disable-next-line @typescript-eslint/no-explicit-any
+local function withUpdateId(fn)
+	local cache = nil
+	local lastUpdateId = -1
+	return function(id, ...)
+		local args = { ... }
+		if lastUpdateId ~= id then
+			cache = nil
+			lastUpdateId = id
+		end
+		if cache == nil then
+			cache = fn(unpack(args))
+		end
+		return cache
+	end
+end
+local function createUseEvent(_param)
+	local indicateUpdate = _param.indicateUpdate
+	local queues = {}
+	local watchedEvents = {}
+	local hook = function(event)
+		local _event = event
+		if not (watchedEvents[_event] ~= nil) then
+			local _event_1 = event
+			watchedEvents[_event_1] = true
+			local _event_2 = event
+			queues[_event_2] = {}
+			event:Connect(function(...)
+				local args = { ... }
+				local _event_3 = event
+				local _exp = queues[_event_3]
+				local _args = args
+				table.insert(_exp, _args)
+				indicateUpdate()
+			end)
+			return {}
+		end
+		local _event_1 = event
+		local queue = queues[_event_1]
+		if not (#queue == 0) then
+			local _event_2 = event
+			queues[_event_2] = {}
+		end
+		return queue
+	end
+	return withUpdateId(hook)
+end
+local function createUseEventImmediately(_param)
+	local indicateUpdate = _param.indicateUpdate
+	local queues = {}
+	local watchedEvents = {}
+	local hook = function(event, callback)
+		local _event = event
+		if not (watchedEvents[_event] ~= nil) then
+			local _event_1 = event
+			watchedEvents[_event_1] = true
+			local _event_2 = event
+			queues[_event_2] = {}
+			event:Connect(function(...)
+				local args = { ... }
+				local _event_3 = event
+				local _exp = queues[_event_3]
+				local _arg0 = callback(unpack(args))
+				table.insert(_exp, _arg0)
+				indicateUpdate()
+			end)
+			return {}
+		end
+		local _event_1 = event
+		local queue = queues[_event_1]
+		if not (#queue == 0) then
+			local _event_2 = event
+			queues[_event_2] = {}
+		end
+		return queue
+	end
+	return withUpdateId(hook)
+end
+local function createUseComponentChange(_param)
+	local subscribeComponent = _param.subscribeComponent
+	local update = _param.indicateUpdate
+	local queues = {}
+	local watchedStringifiedComponents = {}
+	local hook = function(component)
+		local stringifiedComponent = tostring(component)
+		if not (watchedStringifiedComponents[stringifiedComponent] ~= nil) then
+			watchedStringifiedComponents[stringifiedComponent] = true
+			queues[stringifiedComponent] = {}
+			subscribeComponent(component, function(entity, state, previousState)
+				local _exp = queues[stringifiedComponent]
+				local _arg0 = {
+					entity = entity,
+					state = state,
+					previousState = previousState,
+				}
+				table.insert(_exp, _arg0)
+				update()
+			end)
+			return {}
+		end
+		local queue = queues[stringifiedComponent]
+		if not (#queue == 0) then
+			queues[stringifiedComponent] = {}
+		end
+		return queue
+	end
+	return withUpdateId(hook)
+end
+local function equalsDependencies(a, b)
+	if a == b then
+		return true
+	end
+	if #a ~= #b then
+		return false
+	end
+	for i = 0, #a - 1 do
+		if a[i + 1] ~= b[i + 1] then
+			return false
+		end
+	end
+	return true
+end
+local function executeThread(res, asnycFn, update)
+	res.completed = false
+	local sucess, errMsg = pcall(function()
+		res.value = asnycFn()
+	end)
+	if not sucess and type(errMsg) == "string" then
+		res.errorMessage = errMsg
+	end
+	res.completed = true
+	update()
+end
+local function createUseAsync(_param)
+	local indicateUpdate = _param.indicateUpdate
+	local storage = {}
+	local hook = function(asnycFactory, dependencies, discriminator)
+		local _discriminator = discriminator
+		if not (storage[_discriminator] ~= nil) then
+			local newResult = {
+				completed = false,
+				value = nil,
+			}
+			local thread = coroutine.create(executeThread)
+			coroutine.resume(thread, newResult, asnycFactory, indicateUpdate)
+			local _discriminator_1 = discriminator
+			local _arg1 = {
+				lastDependencies = dependencies,
+				thread = thread,
+				result = newResult,
+			}
+			storage[_discriminator_1] = _arg1
+			return newResult
+		end
+		local _discriminator_1 = discriminator
+		local state = storage[_discriminator_1]
+		if equalsDependencies(state.lastDependencies, dependencies) then
+			return state.result
+		else
+			coroutine.yield(state.thread)
+			coroutine.close(state.thread)
+			local newResult = {
+				completed = false,
+				value = nil,
+			}
+			local newThread = coroutine.create(executeThread)
+			coroutine.resume(newThread, newResult, asnycFactory, indicateUpdate)
+			local _discriminator_2 = discriminator
+			local _arg1 = {
+				lastDependencies = dependencies,
+				thread = newThread,
+				result = newResult,
+			}
+			storage[_discriminator_2] = _arg1
+			return newResult
+		end
+	end
+	return withUpdateId(hook)
+end
+local function createUseImperative(_param)
+	local indicateUpdate = _param.indicateUpdate
+	local storage = {}
+	local hook = function(dirtyFactory, dependencies, discriminator)
+		local _discriminator = discriminator
+		if not (storage[_discriminator] ~= nil) then
+			local _binding = dirtyFactory(indicateUpdate)
+			local value = _binding.value
+			local cleanup = _binding.cleanup
+			local _discriminator_1 = discriminator
+			local _arg1 = {
+				cache = value,
+				cleanup = cleanup,
+				lastDependencies = dependencies,
+			}
+			storage[_discriminator_1] = _arg1
+			return value
+		end
+		local _discriminator_1 = discriminator
+		local state = storage[_discriminator_1]
+		if equalsDependencies(state.lastDependencies, dependencies) then
+			return state.cache
+		else
+			if state.cleanup ~= nil then
+				state.cleanup()
+			end
+			local _binding = dirtyFactory(indicateUpdate)
+			local value = _binding.value
+			local cleanup = _binding.cleanup
+			local _discriminator_2 = discriminator
+			local _arg1 = {
+				cache = value,
+				cleanup = cleanup,
+				lastDependencies = dependencies,
+			}
+			storage[_discriminator_2] = _arg1
+			return value
+		end
+	end
+	return withUpdateId(hook)
+end
+local function createUseChange()
+	local dependenciesStorage = {}
+	local hook = function(dependencies, discriminator)
+		local _discriminator = discriminator
+		if not (dependenciesStorage[_discriminator] ~= nil) then
+			local _discriminator_1 = discriminator
+			local _dependencies = dependencies
+			dependenciesStorage[_discriminator_1] = _dependencies
+			return true
+		end
+		local _discriminator_1 = discriminator
+		local lastDependencies = dependenciesStorage[_discriminator_1]
+		if equalsDependencies(lastDependencies, dependencies) then
+			return false
+		else
+			local _discriminator_2 = discriminator
+			local _dependencies = dependencies
+			dependenciesStorage[_discriminator_2] = _dependencies
+			return true
+		end
+	end
+	return withUpdateId(hook)
+end
+local function createUseInterval(_param)
+	local indicateUpdate = _param.indicateUpdate
+	local nextClocks = {}
+	local hook = function(seconds, trueOnInit, discriminator)
+		local _discriminator = discriminator
+		if not (nextClocks[_discriminator] ~= nil) then
+			local _discriminator_1 = discriminator
+			local _arg1 = os.clock() + seconds
+			nextClocks[_discriminator_1] = _arg1
+			task.delay(seconds, indicateUpdate)
+			return trueOnInit
+		end
+		local _discriminator_1 = discriminator
+		local nextClock = nextClocks[_discriminator_1]
+		if nextClock < os.clock() then
+			return false
+		else
+			local _discriminator_2 = discriminator
+			local _arg1 = os.clock() + seconds
+			nextClocks[_discriminator_2] = _arg1
+			task.delay(seconds, indicateUpdate)
+			return true
+		end
+	end
+	return withUpdateId(hook)
+end
+local function createHooks(props)
+	return {
+		useEvent = createUseEvent(props),
+		useEventImmediately = createUseEventImmediately(props),
+		useComponentChange = createUseComponentChange(props),
+		useAsync = createUseAsync(props),
+		useImperative = createUseImperative(props),
+		useChange = createUseChange(),
+		useInterval = createUseInterval(props),
+	}
+end
+return {
+	createHooks = createHooks,
+}

package/src/index.d.ts

@@ -0,0 +1,2 @@
+import { Covenant } from "./covenant";
+export = Covenant;

package/src/init.luau

@@ -0,0 +1,4 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local Covenant = TS.import(script, script, "covenant").Covenant
+return Covenant

package/src/stringEnums.d.ts

@@ -0,0 +1,6 @@
+export type Remove = "6ggQCh*zYyb&j2";
+export declare const Remove: Remove;
+export type None = "C5@j^TKCart!5R";
+export declare const None: None;
+export type Delete = "A@EB7PVpkBf#VT";
+export declare const Delete: Delete;

package/src/stringEnums.luau

@@ -0,0 +1,9 @@
+-- Compiled with roblox-ts v3.0.0
+local Remove = "6ggQCh*zYyb&j2"
+local None = "C5@j^TKCart!5R"
+local Delete = "A@EB7PVpkBf#VT"
+return {
+	Remove = Remove,
+	None = None,
+	Delete = Delete,
+}