@rbxts/planck 0.2.5 → 1.0.0

package/README.md

@@ -0,0 +1,168 @@
+# Planck, an ECS Scheduler
+
+![GitHub License](https://img.shields.io/github/license/yetanotherclown/planck?style=flat-square)
+[![Documentation](https://img.shields.io/badge/Documentation-02B1E9?style=flat-square&logo=data:image/svg%2bxml;base64,PHN2ZyByb2xlPSJpbWciIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICA8dGl0bGU+TW9vbndhdmU8L3RpdGxlPgogIDxwYXRoIGQ9Ik0xMy43MzkgMTQwLjMzMWMuMjguNDkyLjQ2NSAxLjAwOC44NTEgMS40MzguODczLjk3MyAyLjE3MyAxLjAzMyAzLjI2NC4zOTcuOTg5IDIuMzc1IDMuNTg4IDIuOTgzIDUuODk5IDIuNTQ3LjUzNC0uMSAxLjkxOS0uMyAyLjEzMi0uODYyLTEuNDgzIDAtMy4xMDYuMTctNC4zNjMtLjgxOS0yLjE0Ny0xLjY4OS0uNzE1LTQuNiAxLjM4OC01LjQ3Ny0uMTM4LS40MjYtMS4xNTgtLjM5OC0xLjUzNy0uMzk2LTEuNzYyLjAwNy0yLjk0OCAxLjEwOC0zLjY2OCAyLjYyNy0uNjc1LTEuNzQ4LS4zNTQtMy4yOCAxLjE0LTQuNDg4LjM5Ny0uMzIxLjg0My0uNTM5IDEuMjg5LS43OC4xMTgtLjA2NC4zNDItLjE5Ni4xOC0uMzQxLS4xNjUtLjE0OC0uNTE2LS4xNy0uNzI1LS4yMjJhMTIuMjcyIDEyLjI3MiAwIDAgMC0yLjA4Mi0uMzJjLS44MTktLjA1OC0xLjYyNC0uMDQ0LTIuNDMuMTQ3LTMuMDcuNzI5LTQuMjc2IDMuNTg5LTUuNjM2IDYuMTAzLS41NjcgMS4wNS0xLjA1MSAyLjEyNi0xLjk5OCAyLjkwMi0xLjE1MS45NDQtMi42NzYgMS4xOC00LjExNSAxLS4zNjktLjA0Ni0uNzMtLjEyOC0xLjA5LS4yMTUtLjA4NC0uMDItLjMyNC0uMS0uMzUxLjA0My0uMDQ0LjIzNC43MzEuNDcuODk2LjU0MSAxLjA0NC40NDUgMi4xLjY4OSAzLjIyMi44MjEgMy4wNTkuMzYxIDYuNTMtMS44NTcgNy43MzQtNC42NDZ6IiBzdHlsZT0iZmlsbDojZmZmZmZmO2ZpbGwtb3BhY2l0eToxO3N0cm9rZTpub25lO3N0cm9rZS13aWR0aDouMDQ5NTc0MyIgdHJhbnNmb3JtPSJ0cmFuc2xhdGUoLTEuODg1IC0xMjcuMzEpIi8+Cjwvc3ZnPg==)](https://yetanotherclown.github.io/planck)
+[![Wally Package](https://img.shields.io/badge/Wally-ad4646?style=flat-square&logoSize=auto&logo=data:image/svg%2bxml;base64,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)](https://wally.run/package/yetanotherclown/planck)
+
+An Agnostic Scheduler, inspired by Bevy Schedules and Flecs Pipelines and Phases.
+
+## Installation
+
+You can install Planck with Wally
+
+```toml
+[dependencies]
+Planck = "yetanotherclown/planck@0.2.0"
+```
+
+## What is Planck?
+
+Planck is a standalone scheduler, which allows you to execute code on specific events, with certain conditions, and in a particular order.
+
+This scheduler is library agnostic, which means that it *doesn't matter* which ECS library your using or if you're even using an ECS.
+You can use this with [Jecs], [Matter], [ECR], and other Luau ECS Libraries.
+
+## Does any of this really matter?
+
+Yes, and no.
+Your ECS code should be able to run in any order, without any conditions, and without concern for which event it's running on, as long as *it is* running.
+
+The order of execution, and conditions both serve to *optimize* your code. Some systems don't need to run every frame, which is why we have conditions.
+And the actual order of execution is to reduce latency between changes and effects in your ECS world.
+
+Let's say we have `systemA` and `systemB`. `systemA` modifies data in our world which `systemB` depends on.
+If `systemA` runs *after* `systemB`, then `systemB` will have to wait a whole frame for the modifications to be made.
+This is called being *off-by-a-frame*, and this is why we care about the order of execution.
+
+## What's Next?
+
+You may not completely understand what's written above. That's fine.
+
+For now, you should read the [Official Documentation](https://yetanotherclown.github.io/planck) on how to get started with Planck. These concepts will be explained more in depth as you read.
+
+## Quick Overview
+
+While it's highly suggested you read the documentation, here is a quick overview of Planck's API.
+
+### The Scheduler
+
+This is the core of Planck, this is where you add your Systems and set your Phases, Pipelines, and Run Conditions.
+
+```luau
+local Planck = require("@packages/Planck")
+local Scheduler = Planck.Scheduler
+
+local Jecs = require("@packages/Jecs")
+local World = Jecs.World
+
+local world = World.new()
+local state = {}
+
+local scheduler = Scheduler.new(world, state)
+```
+
+### Systems
+
+Systems are really simple, they are just functions which run on an event or in a loop.
+
+```luau
+local function systemA(world, state)
+    -- ...
+end
+
+return systemA
+```
+
+And to add it to our Scheduler,
+
+```luau
+-- ...
+
+local systemA = require("@shared/systems/systemA")
+
+local scheduler = Scheduler.new(world, state)
+    :addSystem(systemA)
+```
+
+### Phases
+
+Phases are used to split up your frame into different sections, this allows us to schedule our systems to run at different moments of a given frame.
+
+```luau
+local Planck = require("@packages/Planck")
+local Scheduler = Planck.Scheduler
+local Phase = Planck.Phase
+
+-- ...
+
+local systemA = require("@shared/systems/systemA")
+
+local myPhase = Phase.new("myPhase")
+
+local scheduler = Scheduler.new(world, state)
+    :insert(myPhase)
+    :addSystem(systemA, myPhase)
+```
+
+Planck has lots of built-in Phases that should work for most cases,
+→ [Built-in Phases](https://yetanotherclown.github.io/planck/docs/getting_started/phases#built-in-phases)
+
+### Pipelines
+
+Pipelines are ordered groups of Phases, they make working with larger collections of Phases (which all run on the same event) easier.
+
+```luau
+local Phase = Planck.Phase
+local Pipeline = Planck.Pipeline
+local Scheduler = Planck.Scheduler
+
+local PreUpdate = Phase.new()
+local Update = Phase.new()
+local PostUpdate = Phase.new()
+
+local UpdatePipeline = Pipeline.new()
+	:insert(PreUpdate)
+	:insert(Update)
+	:insert(PostUpdate)
+
+local scheduler = scheduler.new(world)
+    :insert(UpdatePipeline, RunService, "Heartbeat")
+```
+
+> [!TIP]
+> The `UpdatePipeline` seen here, already exists in Planck! It's a built-in Pipeline that you can use without any setup.
+> See all [Built-in Phases](https://yetanotherclown.github.io/planck/docs/getting_started/phases#built-in-phases).
+
+### Conditions
+
+When we run all our systems every frame, there are a lot of systems that may not actually need to run. Run Conditions allow us to
+run our Systems, Phases and Pipelines only sometimes.
+
+```luau
+local function condition(world)
+    if someCondition then
+        return true
+    else
+        return false
+    end
+end
+
+local scheduler = Scheduler.new(world)
+    :addRunCondition(systemA, condition)
+    :addRunCondition(somePhase, condition)
+    :addRunCondition(somePipeline, condition)
+```
+
+Conditions can be useful, but you should use them carefully. It's suggested that you read our page on
+[Conditions](https://yetanotherclown.github.io/planck/docs/design/conditions) to see some useful examples and learn when you should use them.
+
+## Inspiration
+
+Planck's API design is heavily influenced by the [Bevy Engine](https://bevyengine.org/), with Schedules, RunConditions, and more.
+Planck also draws inspiration from [Flecs](https://www.flecs.dev/) for Pipelines and Phases.
+
+We're combining the simple, and beloved API of Bevy with the concept of Pipelines and Phases.
+
+[Jecs]: https://ukendio.github.io/jecs
+[Matter]: https://matter-ecs.github.io/matter
+[ECR]: https://centau.github.io/ecr/

package/out/DependencyGraph.luau

@@ -1,6 +1,18 @@
 local AdjacencyMatrix = {}
 AdjacencyMatrix.__index = AdjacencyMatrix
 
+export type AdjacencyMatrix = {
+	matrix: { { number } },
+	length: number,
+	width: number,
+
+	extend: (self: AdjacencyMatrix) -> (),
+	setEdge: (self: AdjacencyMatrix, i: number, j: number, v: number) -> (),
+	toAdjacencyList: (self: AdjacencyMatrix) -> { { number } },
+	topologicalSort: (self: AdjacencyMatrix) -> { number }?,
+	new: () -> AdjacencyMatrix,
+}
+
 function AdjacencyMatrix:__tostring()
 	local s = "\n"
 
@@ -97,14 +109,35 @@ function AdjacencyMatrix:topologicalSort(): { number }?
 	return result
 end
 
-function AdjacencyMatrix.new()
+function AdjacencyMatrix.new(): AdjacencyMatrix
 	return setmetatable({
 		matrix = {},
 		length = 0,
 		width = 0,
-	}, AdjacencyMatrix)
+	}, AdjacencyMatrix) :: any
 end
 
+export type DependencyGraph<T> = {
+	nodes: { T },
+	matrix: AdjacencyMatrix,
+	length: number,
+	width: number,
+
+	getOrderedList: (self: DependencyGraph<T>) -> { T }?,
+	insert: (self: DependencyGraph<T>, node: T) -> DependencyGraph<T>,
+	insertAfter: (
+		self: DependencyGraph<T>,
+		node: T,
+		afterNode: T
+	) -> DependencyGraph<T>,
+	insertBefore: (
+		self: DependencyGraph<T>,
+		node: T,
+		beforeNode: T
+	) -> DependencyGraph<T>,
+	new: () -> DependencyGraph<T>,
+}
+
 local DependencyGraph = {}
 DependencyGraph.__index = DependencyGraph
 
@@ -128,8 +161,12 @@ function DependencyGraph:insertBefore(node, beforeNode)
 		error("Node not found in DependencyGraph:insertBefore(_, unknown)")
 	end
 
-	table.insert(self.nodes, node)
-	local j = #self.nodes
+	local j = table.find(self.nodes, node)
+	if not j then
+		table.insert(self.nodes, node)
+		j = #self.nodes
+	end
+
 	local i = table.find(self.nodes, beforeNode)
 
 	self.matrix:extend()
@@ -143,9 +180,12 @@ function DependencyGraph:insertAfter(node, afterNode)
 		error("Node not found in DependencyGraph:insertAfter(_, unknown)")
 	end
 
-	table.insert(self.nodes, node)
+	local j = table.find(self.nodes, node)
+	if not j then
+		table.insert(self.nodes, node)
+		j = #self.nodes
+	end
 
-	local j = #self.nodes
 	local i = table.find(self.nodes, afterNode)
 
 	self.matrix:extend()
@@ -168,13 +208,13 @@ function DependencyGraph:insert(node)
 	return self
 end
 
-function DependencyGraph.new()
+function DependencyGraph.new<T>(): DependencyGraph<T>
 	return setmetatable({
 		nodes = {},
 		matrix = AdjacencyMatrix.new(),
 		length = 0,
 		width = 0,
-	}, DependencyGraph)
+	}, DependencyGraph) :: any
 end
 
-return DependencyGraph
+return DependencyGraph

package/out/Phase.d.ts

@@ -1,8 +1,21 @@
-declare class Phase {
-    constructor(debugName?: string)
-    static readonly PreStartup: Phase
-    static readonly Startup: Phase
-    static readonly PostStartup: Phase
-}
+/**
+ * Phases represent tags that tell the scheduler when to
+ * schedule a set of systems.
+ */
+export class Phase {
+  /** Runs before the `Startup` Phase. */
+  static PreStartup: Phase;
+  /**
+   * This Phase will run once, the first time the Scheduler is ran,
+   * before any other Phases are ran.
+   */
+  static Startup: Phase;
+  /** Runs after the `Startup` phase. */
+  static PostStartup: Phase;
 
-export = Phase;
+  /**
+   * Creates a new Phase, with an optional name to use for debugging.
+   * When no name is provided, the script and line number will be used.
+   */
+  constructor(name?: string);
+}

package/out/Phase.luau

@@ -38,4 +38,4 @@ Phase.PreStartup = Phase.new("PreStartup")
 Phase.Startup = Phase.new("Startup")
 Phase.PostStartup = Phase.new("PostStartup")
 
-return Phase
+return Phase

package/out/Pipeline.d.ts

@@ -1,11 +1,24 @@
-import Phase from "./Phase";
+import { Phase } from "./Phase";
 
-declare class Pipeline {
-    constructor(debugName?: string)
-    insert(phase: Phase) : Pipeline
-    insertAfter(phase: Phase, after: Phase): Pipeline
-    insertBefore(phase: Phase, before: Phase): Pipeline
-    static readonly Startup: Pipeline
-}
+/**
+ * Pipelines represent a set of ordered Phases. Systems cannot be
+ * assigned to Pipelines themselves, but rather to Phases within
+ * those Pipelines.
+ */
+export class Pipeline {
+  /** A Pipeline containing the `PreStartup`, `Startup`, and `PostStartup` phases. */
+  static Startup: Pipeline;
+
+  /**
+   * Creates a new Pipeline, with an optional name to use for debugging.
+   * When no name is provided, the script and line number will be used.
+   */
+  constructor(name?: string);
 
-export = Pipeline;
+  /** Adds a Phase to the Pipeline, ordering it implicitly. */
+  insert(phase: Phase): this;
+  /** Adds a Phase to the Pipeline after another Phase, ordering it explicitly. */
+  insertAfter(phase: Phase, after: Phase): this;
+  /** Adds a Phase to the Pipeline before another Phase, ordering it explicitly. */
+  insertBefore(phase: Phase, before: Phase): this;
+}

package/out/Pipeline.luau

@@ -1,6 +1,6 @@
 --!nonstrict
-local DependencyGraph = require("./DependencyGraph")
-local Phase = require("./Phase")
+local DependencyGraph = require(script.Parent.DependencyGraph)
+local Phase = require(script.Parent.Phase)
 
 --- @class Pipeline
 ---
@@ -83,4 +83,4 @@ Pipeline.Startup = Pipeline.new()
 	:insert(Phase.Startup)
 	:insert(Phase.PostStartup)
 
-return Pipeline
+return Pipeline

package/out/Scheduler.d.ts

@@ -1,31 +1,209 @@
-import Phase from "./Phase";
-import Pipeline from "./Pipeline";
-import { Hooks, EventInstance, EventLike, System, Plugin, HookFunctionMap, HookFunctionArgs } from "./types";
-
-declare class Scheduler<T extends unknown[]> {
-    /** @hidden */
-    _orderedPhases: Phase[]
-    Hooks: Hooks["Hooks"]
-    cleanup(): void
-    addRunCondition(dependent: System<T>, fn: (...args: T) => boolean): Scheduler<T>
-    replaceSystem(oldSystem: System<T>, newSystem: System<T>): Scheduler<T>
-    removeSystem(system: System<T>): Scheduler<T>
-    editSystem(system: System<T>, phase: Phase): Scheduler<T>
-    addSystem(system: System<T>, phase?: Phase): Scheduler<T>
-    addSystems(systems: System<T>[], phase?: Phase): Scheduler<T>
-    insertBefore(dependent: Phase, before: Phase): Scheduler<T>
-    insertBefore(dependent: Pipeline, before: Phase): Scheduler<T>
-    insertAfter(phase: Phase, after: Phase | Pipeline): Scheduler<T>
-    insertAfter(pipeline: Pipeline, after: Phase | Pipeline): Scheduler<T>
-    insert(dependent: Phase | Pipeline, instance: EventInstance, event?: string): Scheduler<T>
-    insert(dependent: Phase | Pipeline): Scheduler<T>
-    runAll(): Scheduler<T>
-    run(dependent: System<T> | Phase | Pipeline): Scheduler<T>
-    getDeltaTime(): number
-    addPlugin(plugin: Plugin): Scheduler<T>
-    /** @hidden */
-    _addHook<K extends keyof HookFunctionMap>(hook: K, fn: (info: HookFunctionArgs<K, T>) => void): void
-    constructor(...args: T)
+import { Plugin } from ".";
+import { Condition } from "./conditions";
+import { Phase } from "./Phase";
+import { Pipeline } from "./Pipeline";
+import { EventInstance, EventLike, ExtractEvents } from "./utils";
+
+export type SystemFn<T extends unknown[]> = (...args: T) => any;
+export interface SystemTable<T extends unknown[]> {
+  system: SystemFn<T>;
+  phase?: Phase;
+  name?: string;
+  runConditions?: Condition<T>[];
+  [key: string]: any;
 }
+export type System<T extends unknown[]> = SystemTable<T> | SystemFn<T>;
+
+/**
+ * An Object which handles scheduling Systems to run within different
+ * Phases. The order of which Systems run will be defined either
+ * implicitly by when it was added, or explicitly by tagging the system
+ * with a Phase.
+ */
+export class Scheduler<T extends unknown[]> {
+  /**
+   * Creates a new Scheduler, the args passed will be passed to
+   * any System anytime it is ran by the Scheduler.
+   */
+  constructor(...args: T);
+
+  /** Initializes a plugin with the scheduler, see the [Plugin Docs](/docs/plugins) for more information. */
+  addPlugin(plugin: Plugin<T>): this;
+
+  /**
+   * Adds the System to the Scheduler, scheduling it to be ran
+   * implicitly within the provided Phase or on the default Main phase.
+   */
+  addSystem(system: System<T>, phase?: Phase): this;
+
+  /**
+   * Adds the Systems to the Scheduler, scheduling them to be ran
+   * implicitly within the provided Phase or on the default Main phase.
+   */
+  addSystems(systems: System<T>[], phase?: Phase): this;
+
+  /** Changes the Phase that this system is scheduled on. */
+  editSystem(system: System<T>, newPhase: Phase): this;
+
+  /** Removes the System from the Scheduler. */
+  removeSystem(system: System<T>): this;
+
+  /** Replaces the System with a new System. */
+  replaceSystem(system: System<T>, newSystem: System<T>): this;
 
-export = Scheduler;
+  /**
+   * Returns the time since the system was ran last.
+   * This must be used within a registered system.
+   */
+  getDeltaTime(): number;
+
+  /**
+   * Initializes the Phase within the Scheduler, ordering it implicitly by
+   * setting it as a dependent of the previous Phase/Pipeline.
+   */
+  insert(phase: Phase): this;
+  /**
+   * Initializes the Pipeline and it's Phases within the Scheduler,
+   * ordering the Pipeline implicitly by setting it as a dependent
+   * of the previous Phase/Pipeline.
+   */
+  insert(pipeline: Pipeline): this;
+  /**
+   * Initializes the Phase within the Scheduler, ordering it implicitly
+   * by setting it as a dependent of the previous Phase/Pipeline, and
+   * scheduling it to be ran on the specified event.
+   *
+   * ```ts
+   * const myScheduler = new Scheduler()
+   *     .insert(myPhase, RunService, "Heartbeat")
+   * ```
+   */
+  insert<T extends EventInstance>(
+    phase: Phase,
+    instance: T,
+    event: ExtractEvents<T>
+  ): this;
+  /**
+   * Initializes the Phase within the Scheduler, ordering it implicitly
+   * by setting it as a dependent of the previous Phase/Pipeline, and
+   * scheduling it to be ran on the specified event.
+   *
+   * ```ts
+   * const myScheduler = new Scheduler()
+   *     .insert(myPhase, RunService, "Heartbeat")
+   * ```
+   */
+  insert(phase: Phase, instance: EventLike, event: string): this;
+  /**
+   * Initializes the Pipeline and it's Phases within the Scheduler,
+   * ordering the Pipeline implicitly by setting it as a dependent of
+   * the previous Phase/Pipeline, and scheduling it to be ran on the
+   * specified event.
+   *
+   * ```ts
+   * const myScheduler = new Scheduler()
+   *     .insert(myPipeline, RunService, "Heartbeat")
+   * ```
+   */
+  insert<T extends EventInstance>(
+    pipeline: Pipeline,
+    instance: T,
+    event: ExtractEvents<T>
+  ): this;
+  /**
+   * Initializes the Pipeline and it's Phases within the Scheduler,
+   * ordering the Pipeline implicitly by setting it as a dependent of
+   * the previous Phase/Pipeline, and scheduling it to be ran on the
+   * specified event.
+   *
+   * ```ts
+   * const myScheduler = new Scheduler()
+   *     .insert(myPipeline, RunService, "Heartbeat")
+   * ```
+   */
+  insert(pipeline: Pipeline, instance: EventLike, event: string): this;
+
+  /**
+   * Initializes the Phase within the Scheduler, ordering it
+   * explicitly by setting the after Phase/Pipeline as a dependent.
+   */
+  insertAfter(phase: Phase, after: Phase | Pipeline): this;
+  /**
+   * Initializes the Pipeline and it's Phases within the Scheduler,
+   * ordering the Pipeline explicitly by setting the after Phase/Pipeline
+   * as a dependent.
+   */
+  insertAfter(pipeline: Pipeline, after: Phase | Pipeline): this;
+
+  /**
+   * Initializes the Phase within the Scheduler, ordering it
+   * explicitly by setting the before Phase/Pipeline as a dependency.
+   */
+  insertBefore(phase: Phase, before: Phase | Pipeline): this;
+  /**
+   * Initializes the Pipeline and it's Phases within the Scheduler,
+   * ordering the Pipeline explicitly by setting the before Phase/Pipeline
+   * as a dependency.
+   */
+  insertBefore(pipeline: Pipeline, before: Phase | Pipeline): this;
+
+  /**
+   * Adds a Run Condition which the Scheduler will check before
+   * this System is ran.
+   */
+  addRunCondition(system: System<T>, fn: Condition<T>, ...args: any): this;
+  /**
+   * Adds a Run Condition which the Scheduler will check before
+   * any Systems within this Phase are ran.
+   */
+  addRunCondition(phase: Phase, fn: Condition<T>, ...args: any): this;
+  /**
+   * Adds a Run Condition which the Scheduler will check before
+   * any Systems within any Phases apart of this Pipeline are ran.
+   */
+  addRunCondition(pipeline: Pipeline, fn: Condition<T>, ...args: any): this;
+
+  /** Runs all Systems tagged with the Phase in order. */
+  run(system: Phase): this;
+  /** Runs all Systems tagged with any Phase within the Pipeline in order. */
+  run(pipeline: Pipeline): this;
+  /** Runs the System, passing in the arguments of the Scheduler, `U...`. */
+  run(system: System<T>): this;
+
+  /**
+   * Runs all Systems within order.
+   *
+   * ### NOTE
+   *
+   * When you add a Pipeline or Phase with an event, it will be grouped
+   * with other Pipelines/Phases on that event. Otherwise, it will be
+   * added to the default group.
+   *
+   * When not running systems on Events, such as with the `runAll` method,
+   * the Default group will be ran first, and then each Event Group in the
+   * order created.
+   *
+   * Pipelines/Phases in these groups are still ordered by their dependencies
+   * and by the order of insertion.
+   */
+  runAll(): this;
+
+  /**
+   * Disconnects all events, closes all threads, and performs
+   * other cleanup work.
+   *
+   * ### Danger
+   * Only use this if you intend to not use the associated
+   * Scheduler anymore. It will not work as intended.
+   *
+   * You should dereference the scheduler object so that
+   * it may be garbage collected.
+   *
+   * ### Warning
+   * If you're creating a "throwaway" scheduler, you should
+   * not add plugins like Jabby or the Matter Debugger to it.
+   * These plugins are unable to properly be cleaned up, use
+   * them with caution.
+   */
+  cleanup(): void;
+}

package/out/Scheduler.luau

@@ -1,11 +1,11 @@
 --!nonstrict
-local DependencyGraph = require("./DependencyGraph")
-local Pipeline = require("./Pipeline")
-local Phase = require("./Phase")
+local DependencyGraph = require(script.Parent.DependencyGraph)
+local Pipeline = require(script.Parent.Pipeline)
+local Phase = require(script.Parent.Phase)
 
-local utils = require("./utils")
-local hooks = require("./hooks")
-local conditions = require("./conditions")
+local utils = require(script.Parent.utils)
+local hooks = require(script.Parent.hooks)
+local conditions = require(script.Parent.conditions)
 
 local getSystem = utils.getSystem
 local getSystemName = utils.getSystemName
@@ -903,4 +903,4 @@ function Scheduler.new(...)
 	return self
 end
 
-return Scheduler
+return Scheduler

package/out/conditions.d.ts

@@ -1,14 +1,63 @@
-import { EventInstance, EventLike } from "./types";
+import { EventInstance, EventLike, ExtractEvents } from "./utils";
 
-type Condition = () => boolean;
+export type Condition<T extends unknown[] = unknown[]> = (
+  ...args: T
+) => boolean;
 
-declare const timePassed: (time: number) => Condition;
+/**
+ * A Throttle condition which checks whether the amount of
+ * time given has passed or not.
+ */
+export const timePassed: (time: number) => Condition;
 
-declare const exported: {
-    timePassed: (time: number) => Condition;
-    runOnce: () => Condition;
-    onEvent: <T extends unknown[]>(instance: EventInstance<T>, event?: string) => LuaTuple<[Condition, () => IterableFunction<LuaTuple<[number, ...T]>>, () => void]>;
-    isNot: (condition: Condition) => Condition;
-    cleanupCondition: (condition: Condition) => void
-}
-export = exported
+/** Checks whether the condition has been called once before. */
+export const runOnce: () => Condition;
+
+type ExtractEventArgs<T> = T extends EventLike<infer U> ? U : never;
+type ExtractEvent<T extends EventInstance> = {
+  [K in keyof T]: T[K] extends EventLike ? ExtractEventArgs<T[K]> : never;
+};
+type CollectEvents<T extends unknown[]> = () => IterableFunction<
+  LuaTuple<[number, ...T]>
+>;
+
+/**
+ * Checks for any new events and allows for the collection of those events.
+ *
+ * Read [OnEvent](https://yetanotherclown.github.io/planck/docs/design/conditions/#on-event) for more information.
+ */
+export function onEvent<T extends EventInstance, E extends ExtractEvents<T>>(
+  instance: T,
+  event: E
+): LuaTuple<
+  [hasNewEvent: Condition, collectEvents: CollectEvents<ExtractEvent<T>[E]>]
+>;
+
+/**
+ * Checks for any new events and allows for the collection of those events.
+ *
+ * Read [OnEvent](https://yetanotherclown.github.io/planck/docs/design/conditions/#on-event) for more information.
+ */
+export function onEvent<T extends EventLike>(
+  instance: EventInstance,
+  event: T
+): LuaTuple<
+  [hasNewEvent: Condition, collectEvents: CollectEvents<ExtractEventArgs<T>>]
+>;
+
+/**
+ * Checks for any new events and allows for the collection of those events.
+ *
+ * Read [OnEvent](https://yetanotherclown.github.io/planck/docs/design/conditions/#on-event) for more information.
+ */
+export function onEvent<T extends EventLike>(
+  instance: T
+): LuaTuple<
+  [hasNewEvent: Condition, collectEvents: CollectEvents<ExtractEventArgs<T>>]
+>;
+
+/** Inverses a given condition. */
+export const isNot: <T extends unknown[]>(
+  fn: Condition<T>,
+  ...any: any[]
+) => Condition<T>;

package/out/conditions.luau

@@ -1,9 +1,11 @@
-local utils = require("./utils")
+local utils = require(script.Parent.utils)
 local getConnectFunction = utils.getConnectFunction
 
-type EventLike = utils.EventLike
-type EventInstance = utils.EventInstance
+type GenericTable = utils.GenericTable
+type SignalLike<U...> = utils.SignalLike<U...>
 type ConnectionLike = utils.ConnectionLike
+type ConnectFn<T, U...> = utils.ConnectFn<T, U...>
+type Callback<U...> = utils.Callback<U...>
 
 type Condition = () -> boolean
 
@@ -59,16 +61,52 @@ local function cleanupCondition(condition: Condition)
 	end
 end
 
+type GetDisconnectFn = () -> () -> ()
+
+type OnEventFn =
+	-- RBXScriptSignal & nil
+	(<U...>(
+		RBXScriptSignal<U...>
+	) -> (Condition, CollectEvents<U...>, GetDisconnectFn))
+	-- Instance & RBXScriptSignal
+	-- Instance & string
+	& (<U...>(
+		Instance,
+		RBXScriptSignal<U...> | string
+	) -> (Condition, CollectEvents<U...>, GetDisconnectFn))
+	-- SignalLike & nil
+	& (<U...>(
+		SignalLike<U...>
+	) -> (Condition, CollectEvents<U...>, GetDisconnectFn))
+	-- table & string
+	& (<U...>(
+		GenericTable,
+		string
+	) -> (Condition, CollectEvents<U...>, GetDisconnectFn))
+	-- table & connectable method
+	& (<T, U...>(
+		GenericTable,
+		(GenericTable, Callback<U...>, ...any) -> T?
+	) -> (Condition, CollectEvents<U...>, GetDisconnectFn))
+	-- connectable function
+	& (<T, U...>(
+		(Callback<U...>, ...any) -> T?
+	) -> (Condition, CollectEvents<U...>, GetDisconnectFn))
+
 --- @within Conditions
+--- @param instance RBXScriptSignal | Instance | SignalLike<...any> | GenericTable | ((Callback<U...>,...any) -> ...any)
+--- @param event (RBXScriptSignal | string | (...any) -> ())?
 --- @return hasNewEvent () -> boolean
 --- @return collectEvents () -> () -> (number, U...)
 --- @return getDisconnectFn () -> () -> ()
 ---
 --- Checks for any new events and allows for the collection of
---- those events.
+--- those events.\
+--- \
+--- Read [OnEvent](../docs/design/conditions#on-event) for more information.
 local function onEvent<U...>(
-	instance: EventInstance | EventLike,
-	event: string | EventLike
+	instance,
+	event
 ): (Condition, CollectEvents<U...>, () -> () -> ())
 	local connect = getConnectFunction(instance, event)
 	assert(connect, "Event passed to .onEvent is not valid")
@@ -144,8 +182,8 @@ end
 return {
 	timePassed = timePassed,
 	runOnce = runOnce,
-	onEvent = onEvent,
+	onEvent = onEvent :: OnEventFn,
 	isNot = isNot,
 
 	cleanupCondition = cleanupCondition,
-}
+}

package/out/hooks.luau

@@ -47,7 +47,7 @@ local function systemReplace(scheduler, oldSystemInfo, newSystemInfo)
 end
 
 local function systemCall(scheduler, hookName, systemInfo, nextFn)
-	local hooks = scheduler._hooks[scheduler.Hooks[hookName] ]
+	local hooks = scheduler._hooks[scheduler.Hooks[hookName]]
 
 	if hooks then
 		for _, hook in hooks do
@@ -70,7 +70,7 @@ local function systemCall(scheduler, hookName, systemInfo, nextFn)
 end
 
 local function systemError(scheduler, systemInfo, err)
-	local hooks = scheduler._hooks[scheduler.Hooks["SystemError"] ]
+	local hooks = scheduler._hooks[scheduler.Hooks["SystemError"]]
 
 	if hooks then
 		for _, hook in hooks do
@@ -85,7 +85,7 @@ end
 
 type PhaseAdd = {
 	scheduler: any,
-	phase: any
+	phase: any,
 }
 
 local function phaseAdd(scheduler, phase)

package/out/index.d.ts

@@ -1,18 +1,12 @@
-import phase from "./Phase";
-import pipeline from "./Pipeline";
-import schedular from "./Scheduler";
-import condition from "./conditions"
+import { Scheduler } from "./Scheduler";
 
-interface Planck {
-    Phase: typeof phase;
-    Pipeline: typeof pipeline; 
-    Scheduler: typeof schedular;
+export * from "./conditions";
+export * from "./Phase";
+export * from "./Pipeline";
+export * from "./Scheduler";
 
-    isNot: typeof condition.isNot;
-    timePassed: typeof condition.timePassed;
-    runOnce: typeof condition.runOnce;
-    onEvent: typeof condition.onEvent;
+export interface Plugin<T extends unknown[]> {
+  build(scheduler: Scheduler<T>): void;
+  cleanup?(): void;
+  [key: string | number | symbol]: any;
 }
-
-declare const planck: Planck;
-export = planck;

package/out/init.luau

@@ -1,12 +1,15 @@
-local Phase = require(script:FindFirstChild("Phase")) :: any
-local Pipeline = require(script:FindFirstChild("Pipeline")) :: any
-local Scheduler = require(script:FindFirstChild("Scheduler")) :: any
+local Phase = require(script.Phase) :: any
+local Pipeline = require(script.Pipeline) :: any
+local Scheduler = require(script.Scheduler) :: any
 
-local conditions = require(script:FindFirstChild("conditions"))
-local utils = require(script:FindFirstChild("utils"))
+local conditions = require(script.conditions)
+local utils = require(script.utils)
 
-type EventLike = utils.EventLike
-type EventInstance = utils.EventInstance
+type GenericTable = utils.GenericTable
+type SignalLike<U...> = utils.SignalLike<U...>
+type ConnectionLike = utils.ConnectionLike
+type ConnectFn<T, U...> = utils.ConnectFn<T, U...>
+type Callback<U...> = utils.Callback<U...>
 
 export type SystemFn<U...> = ((U...) -> any) | ((U...) -> ())
 
@@ -38,7 +41,10 @@ export type Pipeline = {
 
 type Plugin<U...> = {
 	build: (self: Plugin<U...>, scheduler: Scheduler<U...>) -> (),
-	cleanup: ((self: Plugin<U...>) -> ())?,
+	[any]: any,
+} | {
+	build: (self: Plugin<U...>, scheduler: Scheduler<U...>) -> (),
+	cleanup: (self: Plugin<U...>) -> (),
 	[any]: any,
 }
 
@@ -99,29 +105,69 @@ export type Scheduler<U...> = {
 
 	getDeltaTime: (self: Scheduler<U...>) -> number,
 
-	insert: ((self: Scheduler<U...>, phase: Phase) -> Scheduler<U...>) & ((
+	insert: ((
 		self: Scheduler<U...>,
-		pipeline: Pipeline
-	) -> Scheduler<U...>) & ((
+		dependency: Phase | Pipeline
+	) -> Scheduler<U...>)
+		-- RBXScriptSignal & nil
+		& ((
+			self: Scheduler<U...>,
+			dependency: Phase | Pipeline,
+			signal: RBXScriptSignal<U...>
+		) -> Scheduler<U...>)
+		-- Instance & RBXScriptSignal
+		-- Instance & string
+		& ((
+			self: Scheduler<U...>,
+			dependency: Phase | Pipeline,
+			instance: Instance,
+			event: RBXScriptSignal<U...> | string
+		) -> Scheduler<U...>)
+		-- SignalLike & nil
+		& ((
+			self: Scheduler<U...>,
+			dependency: Phase | Pipeline,
+			signal: SignalLike<U...>
+		) -> Scheduler<U...>)
+		-- table & string
+		& ((
+			self: Scheduler<U...>,
+			dependency: Phase | Pipeline,
+			table: GenericTable,
+			event: string
+		) -> Scheduler<U...>)
+		-- table & connectable method
+		& (<T>(
+			self: Scheduler<U...>,
+			dependency: Phase | Pipeline,
+			instance: GenericTable,
+			connectMethod: (GenericTable, Callback<U...>, ...any) -> T
+		) -> Scheduler<U...>)
+		-- connectable function
+		& (<T>(
+			self: Scheduler<U...>,
+			dependency: Phase | Pipeline,
+			connectFn: (Callback<U...>, ...any) -> T
+		) -> Scheduler<U...>),
+
+	insertAfter: ((
 		self: Scheduler<U...>,
 		phase: Phase,
-		instance: EventInstance | EventLike,
-		event: string | EventLike
+		after: Phase | Pipeline
 	) -> Scheduler<U...>) & ((
 		self: Scheduler<U...>,
-		Pipeline: Pipeline,
-		instance: EventInstance | EventLike,
-		event: string | EventLike
+		pipeline: Pipeline,
+		after: Phase | Pipeline
 	) -> Scheduler<U...>),
 
-	insertAfter: ((
+	insertBefore: ((
 		self: Scheduler<U...>,
 		phase: Phase,
-		after: Phase | Pipeline
+		before: Phase | Pipeline
 	) -> Scheduler<U...>) & ((
 		self: Scheduler<U...>,
 		pipeline: Pipeline,
-		after: Phase | Pipeline
+		before: Phase | Pipeline
 	) -> Scheduler<U...>),
 
 	cleanup: (self: Scheduler<U...>) -> (),

package/out/utils.d.ts

@@ -1,4 +1,10 @@
-import { Utils } from "./types";
+export type EventLike<T extends unknown[] = unknown[]> =
+  | RBXScriptSignal<(...args: T) => void>
+  | { connect(...args: T): unknown }
+  | { Connect(...args: T): unknown }
+  | { on(...args: T): unknown };
+export type EventInstance = Instance | { [k: string]: EventLike };
 
-declare const utils : Utils;
-export = utils;
+export type ExtractEvents<T extends EventInstance> = {
+  [K in keyof T]: T[K] extends EventLike ? K : never;
+}[keyof T];

package/out/utils.luau

@@ -53,21 +53,6 @@ end
 
 local EVENT_CONNECT_METHODS = { "Connect", "On", "on", "connect" }
 
-export type EventLike = RBXScriptSignal | {
-	connect: (self: EventLike, ...any) -> any,
-	[any]: any,
-} | {
-	Connect: (self: EventLike, ...any) -> any,
-	[any]: any,
-} | {
-	on: (self: EventLike, ...any) -> any,
-	[any]: any,
-}
-
-export type EventInstance = Instance | {
-	[any]: EventLike,
-}
-
 export type ConnectionLike = RBXScriptConnection | {
 	disconnect: (self: ConnectionLike, ...any) -> any,
 	[any]: any,
@@ -82,8 +67,6 @@ export type ConnectionLike = RBXScriptConnection | {
 	[any]: any,
 } | (...any) -> any
 
-export type ConnectFn<U...> = (callback: (U...) -> ()) -> ConnectionLike
-
 local EVENT_DISCONNECT_METHODS =
 	{ "disconnect", "Disconnect", "destroy", "Destroy" }
 
@@ -107,13 +90,49 @@ local function disconnectEvent(connection: ConnectionLike)
 	end
 end
 
+export type Callback<U...> = (U...) -> ...any
+export type ConnectFn<T, U...> = (callback: (U...) -> ...any) -> T
+export type GenericTable = { [any]: any }
+
+export type SignalLike<U...> = {
+	connect: (self: SignalLike<U...>, Callback<U...>, ...any?) -> any,
+	[any]: any,
+} | {
+	Connect: (self: SignalLike<U...>, Callback<U...>, ...any?) -> any,
+	[any]: any,
+} | {
+	on: (self: SignalLike<U...>, Callback<U...>, ...any?) -> any,
+	[any]: any,
+} | {
+	On: (self: SignalLike<U...>, Callback<U...>, ...any?) -> any,
+	[any]: any,
+}
+
+type GetConnectFn<U...> =
+	-- RBXScriptSignal & nil
+	((RBXScriptSignal<U...>) -> ConnectFn<RBXScriptConnection, U...>)
+	-- Instance & RBXScriptSignal
+	-- Instance & string
+	& ((
+		Instance,
+		RBXScriptSignal<U...> | string
+	) -> ConnectFn<RBXScriptConnection, U...>)
+	-- SignalLike & nil
+	& ((SignalLike<U...>) -> ConnectFn<any, U...>)
+	-- table & string
+	& ((GenericTable, string) -> ConnectFn<any, U...>)
+	-- table & connectable method
+	& (<T>(
+		GenericTable,
+		(GenericTable, Callback<U...>, ...any) -> T
+	) -> ConnectFn<T, U...>)
+	-- connectable function
+	& (<T>((Callback<U...>, ...any) -> T) -> ConnectFn<T, U...>)
+
 -- This function is inspired by useEvent in Matter, a library by evaera (https://github.com/evaera)
 -- License: Copyright (c) 2021 Eryn L. K., MIT License
 -- Source: https://github.com/matter-ecs/matter/blob/main/lib/hooks/useEvent.luau
-local function getConnectFunction<U...>(
-	instance: EventInstance | EventLike,
-	event: string | EventLike
-): ConnectFn<U...>?
+local function getConnectFunction(instance, event)
 	local eventInstance = instance
 
 	if typeof(event) == "RBXScriptSignal" or type(event) == "table" then
@@ -131,6 +150,12 @@ local function getConnectFunction<U...>(
 	end
 
 	if type(eventInstance) == "table" then
+		if type(event) == "function" then
+			return function(callback)
+				return event(eventInstance, callback)
+			end
+		end
+
 		for _, method in EVENT_CONNECT_METHODS do
 			if type(eventInstance[method]) ~= "function" then
 				continue
@@ -156,6 +181,6 @@ return {
 	isPipeline = isPipeline,
 	getEventIdentifier = getEventIdentifier,
 	isValidEvent = isValidEvent,
-	getConnectFunction = getConnectFunction,
+	getConnectFunction = getConnectFunction :: GetConnectFn<...any>,
 	disconnectEvent = disconnectEvent,
 }

package/package.json

@@ -1,51 +1,37 @@
 {
   "name": "@rbxts/planck",
-  "version": "0.2.5",
-  "description": "An agnostic scheduler for ECS",
+  "version": "1.0.0",
+  "description": "An Agnostic Scheduler, inspired by Bevy Schedules and Flecs Pipelines and Phases",
+  "author": "yetanotherclown",
   "main": "out/init.lua",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/yetanotherclown/planck"
+  "scripts": {
+    "install-dependencies": "bun install && (cd tests && bun install)",
+    "build": "rbxtsc",
+    "dev": "bun run build -- -w",
+    "prepublishOnly": "bun test",
+    "test": "bun run build && bun run build -- -p tests && rojo build tests -o tests/test-environment.rbxl && lune run tests tests/test-environment.rbxl"
   },
-  "homepage": "https://yetanotherclown.github.io/planck",
   "keywords": [
-    "ECS",
-    "Entity Component System",
-    "Scheduler",
-    "@rbxts",
-    "Roblox",
-    "Roblox-TS",
-    "roblox ts",
-    "roblox-ts"
+    "roblox",
+    "rbxts"
   ],
-  "author": "YetAnotherClown",
-  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yetanotherclown/planck.git"
+  },
+  "license": "ISC",
   "types": "out/index.d.ts",
   "files": [
     "out",
-    "!**/*.tsbuildinfo",
-    "!out/__tests__",
-    "!out/__tests__/**/*",
-    "!out/jest.config.luau"
+    "!**/*.tsbuildinfo"
   ],
   "publishConfig": {
     "access": "public"
   },
   "devDependencies": {
-    "@rbxts/compiler-types": "3.0.0-types.0",
+    "@rbxts/compiler-types": "^3.0.0-types.0",
     "@rbxts/types": "^1.0.813",
-    "@typescript-eslint/eslint-plugin": "^8.19.0",
-    "@typescript-eslint/parser": "^8.19.0",
-    "eslint": "^9.17.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-plugin-prettier": "^5.2.1",
-    "eslint-plugin-roblox-ts": "^0.0.36",
-    "prettier": "^3.4.2",
-    "roblox-ts": "^3.0.0",
-    "typescript": "^5.7.2"
-  },
-  "scripts": {
-    "build": "rbxtsc",
-    "watch": "rbxtsc -w"
+    "roblox-ts": "npm:@wad4444/roblox-ts@^1.0.2",
+    "typescript": "^5.5.3"
   }
 }

package/out/hooks.d.ts

@@ -1,4 +0,0 @@
-import { Hooks } from "./types";
-
-declare const hooks : Hooks;
-export = hooks;

package/out/types.d.ts

@@ -1,113 +0,0 @@
-import Phase from "./Phase";
-import Pipeline from "./Pipeline";
-import Scheduler from "./Scheduler";
-
-export type SystemInfo<T extends unknown[]> = {
-    readonly system: SystemFn<T>;
-    readonly phase: Phase;
-    readonly name: string;
-    readonly logs: string[];
-}
-
-
-export interface Hooks {
-    readonly Hooks: {
-        readonly SystemAdd: "SystemAdd";
-        readonly SystemRemove: "SystemRemove";
-        readonly SystemReplace: "SystemReplace";
-        readonly SystemError: "SystemError";
-
-        readonly OuterSystemCall: "OuterSystemCall";
-        readonly InnerSystemCall: "InnerSystemCall";
-        readonly SystemCall: "SystemCall";
-
-        readonly PhaseAdd: "PhaseAdd";
-        readonly PhaseBegan: "PhaseBegan";
-    }
-    systemAdd: <T extends unknown[] = unknown[]>(scheduler: Scheduler<T>, systemInfo: SystemInfo<T>) => void;
-    systemRemove: <T extends unknown[] = unknown[]>(scheduler: Scheduler<T>, systemInfo: SystemInfo<T>) => void;
-    systemReplace: <T extends unknown[] = unknown[]>(scheduler: Scheduler<T>, oldSystemInfo: SystemInfo<T>, newSystemInfo: SystemInfo<T>) => void;
-    systemCall: <T extends unknown[] = unknown[]>(scheduler: Scheduler<T>, hookName: "OuterSystemCall" | "InnerSystemCall" | "SystemCall", systemInfo: SystemInfo<T>, nextFn: () => void) => void;
-    systemError: <T extends unknown[] = unknown[]>(scheduler: Scheduler<T>, systemInfo: SystemInfo<T>, error: string) => void;
-    phaseAdd: <T extends unknown[] = unknown[]>(scheduler: Scheduler<T>, phase: Phase) => void;
-    phaseBegan: <T extends unknown[] = unknown[]>(scheduler: Scheduler<T>, phase: Phase) => void;
-}
-type SystemAddHookArgs<T extends unknown[]> = {
-    scheduler: Scheduler<T>,
-    system: SystemInfo<T>
-}
-type SystemRemoveHookArgs<T extends unknown[]> = SystemAddHookArgs<T>;
-type SystemReplaceHookArgs<T extends unknown[]> = {
-    scheduler: Scheduler<T>,
-    old: SystemInfo<T>,
-    new: SystemInfo<T>
-}
-type SystemErrorHookArgs<T extends unknown[]> = SystemAddHookArgs<T> & { error: string };
-type SystemCallHookArgs<T extends unknown[]> = {
-    scheduler: undefined;
-    system: SystemInfo<T>;
-    nextFn: () => void;
-}
-type PhaseAddHookArgs<T extends unknown[]> = {
-    scheduler: Scheduler<T>;
-    phase: Phase;
-}
-type PhaseBeganHookArgs<T extends unknown[]> = PhaseAddHookArgs<T>;
-type HookFunctionMap<T extends unknown[] = unknown[]> = {
-    SystemAdd: SystemAddHookArgs<T>;
-    SystemRemove: SystemRemoveHookArgs<T>;
-    SystemReplace: SystemReplaceHookArgs<T>;
-    SystemError: SystemErrorHookArgs<T>;
-    OuterSystemCall: SystemCallHookArgs<T>;
-    InnerSystemCall: SystemCallHookArgs<T>;
-    SystemCall: SystemCallHookArgs<T>;
-    PhaseAdd: PhaseAddHookArgs<T>;
-    PhaseBegan: PhaseBeganHookArgs<T>;
-}
-// Utility type to get the correct function type based on the hook name
-type HookFunctionArgs<K extends keyof HookFunctionMap, T extends unknown[]> = HookFunctionMap<T>[K];
-
-export type SystemFn<T extends unknown[]> = ((...args: T) => unknown[]) | ((...args: T) => void);
-
-export interface SystemTable<T extends unknown[]> {
-    readonly system: SystemFn<T>;
-    readonly phase?: Phase
-    readonly [key: string]: unknown
-}
-
-export type System<T extends unknown[]> = SystemFn<T> | SystemTable<T>;
-
-export type EventLike<T extends unknown[] = unknown[]> =  {
-    connect(callback: (...args: T) => void): void;
-} | {
-    Connect(callback: (...args: T) => void): void;
-} | {
-    on(callback: (...args: T) => void): void;
-} | {
-    On(callback: (...args: T) => void): void;
-} 
-
-export type EventInstance<T extends unknown[] = unknown[]> = Instance | EventLike<T> | RBXScriptSignal;
-export type Disconnectable = RBXScriptConnection | { Disconnect(): void } | { disconnect(): void } | { Destroy(): void } | { destroy(): void; }
-export type ConnectFn = (callback: (...args: unknown[]) => void) => Disconnectable;
-
-
-export interface Utils {
-    getSystem: <T extends unknown[]>(system: System<T>) => SystemFn<T> | undefined   
-    getSystemName: <T extends unknown[]>(system: SystemFn<T>) => string
-    isPhase: (phase: Phase) => Phase | undefined
-    isPipeline: (pipeline: Pipeline) => Pipeline | undefined
-    getEventIdentifier: <T extends unknown[]>(instance: EventInstance<T>, event?: string) => string
-    isValidEvent: <T extends unknown[]>(instance: EventInstance<T>, event?: string) => boolean
-    getConnectedFunction: <T extends unknown[]>(instance: EventInstance<T>, event?: string) => ConnectFn | undefined
-    disconnectEvent: (disconectable: Disconnectable) => void
-}
-
-export interface Plugin {
-    build(schedular: Scheduler<unknown[]>): void
-}
-
-
-
-
-