commit f06242ebb53fc4aa0b0ab0663d689c05ff558cbc
Author: marked <iczerwony98@gmail.com>
Date:   Sun Mar 2 05:07:57 2025 +0100

    Initial commit

diff --git a/.forgejo/workflows/release.yml b/.forgejo/workflows/release.yml
new file mode 100644
index 0000000..ca999c4
--- /dev/null
+++ b/.forgejo/workflows/release.yml
@@ -0,0 +1,55 @@
+name: Release
+
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: "10 0 * * *" # Runs at 00:10 UTC every day
+
+jobs:
+  sync:
+    name: Sync
+    runs-on: docker
+    container:
+      image: ghcr.io/catthehacker/ubuntu:act-22.04
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+
+      - name: Install Rokit
+        uses: https://github.com/CompeyDev/setup-rokit@v0.1.2
+        with:
+          token: ${{ secrets.githubtoken }}
+
+      - name: Install fj
+        run: |
+          wget https://codeberg.org/Cyborus/forgejo-cli/releases/download/v0.2.0/forgejo-cli-linux.gz -O fj.tar.gz
+          gunzip fj.tar.gz
+          mv fj /usr/local/bin/fj
+          chmod +x /usr/local/bin/fj
+
+      - name: Sync & Release
+        run: lune run src/init
+
+      - name: Read Jecs Version
+        id: read_jecs_version
+        run: |
+          version=$(lune run src/read_version | tr '\n' ' ')
+          echo "JECS_VERSION=$version" >> $GITHUB_OUTPUT
+
+      - name: Create Pull Request
+        id: create_pull_request
+        uses: https://git.devmarked.win/actions/create-pull-request@7174d368c2e4450dea17b297819eb28ae93ee645
+        with:
+          title: Sync to upstream Jecs ${{ steps.read_jecs_version.outputs.JECS_VERSION }}
+          body: |
+            Sync to upstream Jecs ${{ steps.read_jecs_version.outputs.JECS_VERSION }}
+            - This pull request is **auto-generated**
+          branch: auto/synchronize
+          commit-message: Sync to upstream Jecs ${{ steps.read_jecs_version.outputs.JECS_VERSION }}
+          base: main
+          token: ${{ secrets.privileged_forgejo_token }}
+
+      - name: Merge Pull Request
+        run: |
+          fj --host git.devmarked.win auth add-key marked ${{ secrets.privileged_forgejo_token }}
+          fj --host git.devmarked.win pr merge --method squash "${{ steps.create_pull_request.outputs.pull-request-number }}"
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..d54104d
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+**/*.tar.gz
diff --git a/.luaurc b/.luaurc
new file mode 100644
index 0000000..e81bde4
--- /dev/null
+++ b/.luaurc
@@ -0,0 +1,6 @@
+{
+    "languageMode": "strict",
+    "aliases": {
+        "lune": ".lune/.lune-defs"
+    }
+}
diff --git a/.lune/.lune-defs/datetime.luau b/.lune/.lune-defs/datetime.luau
new file mode 100644
index 0000000..8992dab
--- /dev/null
+++ b/.lune/.lune-defs/datetime.luau
@@ -0,0 +1,408 @@
+--[[
+	NOTE: We export a couple different DateTimeValues types below to ensure
+	that types are completely accurate, for method args milliseconds will
+	always be optional, but for return values millis are always included
+
+	If we figure out some better strategy here where we can
+	export just a single type while maintaining accuracy we
+	can change to that in a future breaking semver release
+]]
+
+type OptionalMillisecond = {
+	millisecond: number?,
+}
+
+type Millisecond = {
+	millisecond: number,
+}
+
+--[=[
+	@interface Locale
+	@within DateTime
+
+	Enum type representing supported DateTime locales.
+
+	Currently supported locales are:
+
+	- `en` - English
+	- `de` - German
+	- `es` - Spanish
+	- `fr` - French
+	- `it` - Italian
+	- `ja` - Japanese
+	- `pl` - Polish
+	- `pt-br` - Brazilian Portuguese
+	- `pt` - Portuguese
+	- `tr` - Turkish
+]=]
+export type Locale = "en" | "de" | "es" | "fr" | "it" | "ja" | "pl" | "pt-br" | "pt" | "tr"
+
+--[=[
+	@interface DateTimeValues
+	@within DateTime
+
+	Individual date & time values, representing the primitives that make up a `DateTime`.
+
+	This is a dictionary that will contain the following values:
+
+	- `year` - Year(s), in the range 1400 -> 9999
+	- `month` - Month(s), in the range 1 -> 12
+	- `day` - Day(s), in the range 1 -> 31
+	- `hour` - Hour(s), in the range 0 -> 23
+	- `minute` - Minute(s), in the range 0 -> 59
+	- `second` - Second(s), in the range 0 -> 60, where 60 is a leap second
+
+	An additional `millisecond` value may also be included,
+	and should be within the range `0 -> 999`, but is optional.
+
+	However, any method returning this type should be guaranteed
+	to include milliseconds - see individual methods to verify.
+]=]
+export type DateTimeValues = {
+	year: number,
+	month: number,
+	day: number,
+	hour: number,
+	minute: number,
+	second: number,
+}
+
+--[=[
+	@interface DateTimeValueArguments
+	@within DateTime
+
+	Alias for `DateTimeValues` with an optional `millisecond` value.
+
+	Refer to the `DateTimeValues` documentation for additional information.
+]=]
+export type DateTimeValueArguments = DateTimeValues & OptionalMillisecond
+
+--[=[
+	@interface DateTimeValueReturns
+	@within DateTime
+
+	Alias for `DateTimeValues` with a mandatory `millisecond` value.
+
+	Refer to the `DateTimeValues` documentation for additional information.
+]=]
+export type DateTimeValueReturns = DateTimeValues & Millisecond
+
+local DateTime = {
+	--- Number of seconds passed since the UNIX epoch.
+	unixTimestamp = (nil :: any) :: number,
+	--- Number of milliseconds passed since the UNIX epoch.
+	unixTimestampMillis = (nil :: any) :: number,
+}
+
+--[=[
+	@within DateTime
+	@tag Method
+
+	Formats this `DateTime` using the given `formatString` and `locale`, as local time.
+
+	The given `formatString` is parsed using a `strftime`/`strptime`-inspired
+	date and time formatting syntax, allowing tokens such as the following:
+
+	| Token | Example  | Description   |
+	|-------|----------|---------------|
+	| `%Y`  | `1998`   | Year number   |
+	| `%m`  | `04`     | Month number  |
+	| `%d`  | `29`     | Day number    |
+	| `%A`  | `Monday` | Weekday name  |
+	| `%M`  | `59`     | Minute number |
+	| `%S`  | `10`     | Second number |
+
+	For a full reference of all available tokens, see the
+	[chrono documentation](https://docs.rs/chrono/latest/chrono/format/strftime/index.html).
+
+	If not provided, `formatString` and `locale` will default
+	to `"%Y-%m-%d %H:%M:%S"` and `"en"` (english) respectively.
+
+	@param formatString -- A string containing formatting tokens
+	@param locale -- The locale the time should be formatted in
+	@return string -- The formatting string
+]=]
+function DateTime.formatLocalTime(self: DateTime, formatString: string?, locale: Locale?): string
+	return nil :: any
+end
+
+--[=[
+	@within DateTime
+	@tag Method
+
+	Formats this `DateTime` using the given `formatString` and `locale`, as UTC (universal) time.
+
+	The given `formatString` is parsed using a `strftime`/`strptime`-inspired
+	date and time formatting syntax, allowing tokens such as the following:
+
+	| Token | Example  | Description   |
+	|-------|----------|---------------|
+	| `%Y`  | `1998`   | Year number   |
+	| `%m`  | `04`     | Month number  |
+	| `%d`  | `29`     | Day number    |
+	| `%A`  | `Monday` | Weekday name  |
+	| `%M`  | `59`     | Minute number |
+	| `%S`  | `10`     | Second number |
+
+	For a full reference of all available tokens, see the
+	[chrono documentation](https://docs.rs/chrono/latest/chrono/format/strftime/index.html).
+
+	If not provided, `formatString` and `locale` will default
+	to `"%Y-%m-%d %H:%M:%S"` and `"en"` (english) respectively.
+
+	@param formatString -- A string containing formatting tokens
+	@param locale -- The locale the time should be formatted in
+	@return string -- The formatting string
+]=]
+function DateTime.formatUniversalTime(
+	self: DateTime,
+	formatString: string?,
+	locale: Locale?
+): string
+	return nil :: any
+end
+
+--[=[
+	@within DateTime
+	@tag Method
+
+	Formats this `DateTime` as an ISO 8601 date-time string.
+
+	Some examples of ISO 8601 date-time strings are:
+
+	- `2020-02-22T18:12:08Z`
+	- `2000-01-31T12:34:56+05:00`
+	- `1970-01-01T00:00:00.055Z`
+
+	@return string -- The ISO 8601 formatted string
+]=]
+function DateTime.toIsoDate(self: DateTime): string
+	return nil :: any
+end
+
+--[=[
+	@within DateTime
+	@tag Method
+
+	Extracts separated local date & time values from this `DateTime`.
+
+	The returned table contains the following values:
+
+	| Key           | Type     | Range          |
+	|---------------|----------|----------------|
+	| `year`        | `number` | `1400 -> 9999` |
+	| `month`       | `number` | `1 -> 12`      |
+	| `day`         | `number` | `1 -> 31`      |
+	| `hour`        | `number` | `0 -> 23`      |
+	| `minute`      | `number` | `0 -> 59`      |
+	| `second`      | `number` | `0 -> 60`      |
+	| `millisecond` | `number` | `0 -> 999`     |
+
+	@return DateTimeValueReturns -- A table of DateTime values
+]=]
+function DateTime.toLocalTime(self: DateTime): DateTimeValueReturns
+	return nil :: any
+end
+
+--[=[
+	@within DateTime
+	@tag Method
+
+	Extracts separated UTC (universal) date & time values from this `DateTime`.
+
+	The returned table contains the following values:
+
+	| Key           | Type     | Range          |
+	|---------------|----------|----------------|
+	| `year`        | `number` | `1400 -> 9999` |
+	| `month`       | `number` | `1 -> 12`      |
+	| `day`         | `number` | `1 -> 31`      |
+	| `hour`        | `number` | `0 -> 23`      |
+	| `minute`      | `number` | `0 -> 59`      |
+	| `second`      | `number` | `0 -> 60`      |
+	| `millisecond` | `number` | `0 -> 999`     |
+
+	@return DateTimeValueReturns -- A table of DateTime values
+]=]
+function DateTime.toUniversalTime(self: DateTime): DateTimeValueReturns
+	return nil :: any
+end
+
+export type DateTime = typeof(DateTime)
+
+--[=[
+	@class DateTime
+
+	Built-in library for date & time
+
+	### Example usage
+
+	```lua
+	local DateTime = require("@lune/datetime")
+
+	-- Creates a DateTime for the current exact moment in time
+	local now = DateTime.now()
+
+	-- Formats the current moment in time as an ISO 8601 string
+	print(now:toIsoDate())
+
+	-- Formats the current moment in time, using the local
+	-- time, the French locale, and the specified time string
+	print(now:formatLocalTime("%A, %d %B %Y", "fr"))
+
+	-- Returns a specific moment in time as a DateTime instance
+	local someDayInTheFuture = DateTime.fromLocalTime({
+		year = 3033,
+		month = 8,
+		day = 26,
+		hour = 16,
+		minute = 56,
+		second = 28,
+		millisecond = 892,
+	})
+
+	-- Extracts the current local date & time as separate values (same values as above table)
+	print(now:toLocalTime())
+
+	-- Returns a DateTime instance from a given float, where the whole
+	-- denotes the seconds and the fraction denotes the milliseconds
+	-- Note that the fraction for millis here is completely optional
+	DateTime.fromUnixTimestamp(871978212313.321)
+
+	-- Extracts the current universal (UTC) date & time as separate values
+	print(now:toUniversalTime())
+	```
+]=]
+local dateTime = {}
+
+--[=[
+	@within DateTime
+	@tag Constructor
+
+	Returns a `DateTime` representing the current moment in time.
+
+	@return DateTime -- The new DateTime object
+]=]
+function dateTime.now(): DateTime
+	return nil :: any
+end
+
+--[=[
+	@within DateTime
+	@tag Constructor
+
+	Creates a new `DateTime` from the given UNIX timestamp.
+
+	This timestamp may contain both a whole and fractional part -
+	where the fractional part denotes milliseconds / nanoseconds.
+
+	Example usage of fractions:
+
+	- `DateTime.fromUnixTimestamp(123456789.001)` - one millisecond
+	- `DateTime.fromUnixTimestamp(123456789.000000001)` - one nanosecond
+
+	Note that the fractional part has limited precision down to exactly
+	one nanosecond, any fraction that is more precise will get truncated.
+
+	@param unixTimestamp -- Seconds passed since the UNIX epoch
+	@return DateTime -- The new DateTime object
+]=]
+function dateTime.fromUnixTimestamp(unixTimestamp: number): DateTime
+	return nil :: any
+end
+
+--[=[
+	@within DateTime
+	@tag Constructor
+
+	Creates a new `DateTime` from the given date & time values table, in universal (UTC) time.
+
+	The given table must contain the following values:
+
+	| Key      | Type     | Range          |
+	|----------|----------|----------------|
+	| `year`   | `number` | `1400 -> 9999` |
+	| `month`  | `number` | `1 -> 12`      |
+	| `day`    | `number` | `1 -> 31`      |
+	| `hour`   | `number` | `0 -> 23`      |
+	| `minute` | `number` | `0 -> 59`      |
+	| `second` | `number` | `0 -> 60`      |
+
+	An additional `millisecond` value may also be included,
+	and should be within the range `0 -> 999`, but is optional.
+
+	Any non-integer values in the given table will be rounded down.
+
+	### Errors
+
+	This constructor is fallible and may throw an error in the following situations:
+
+	- Date units (year, month, day) were given that produce an invalid date. For example, January 32nd or February 29th on a non-leap year.
+
+	@param values -- Table containing date & time values
+	@return DateTime -- The new DateTime object
+]=]
+function dateTime.fromUniversalTime(values: DateTimeValueArguments): DateTime
+	return nil :: any
+end
+
+--[=[
+	@within DateTime
+	@tag Constructor
+
+	Creates a new `DateTime` from the given date & time values table, in local time.
+
+	The given table must contain the following values:
+
+	| Key      | Type     | Range          |
+	|----------|----------|----------------|
+	| `year`   | `number` | `1400 -> 9999` |
+	| `month`  | `number` | `1 -> 12`      |
+	| `day`    | `number` | `1 -> 31`      |
+	| `hour`   | `number` | `0 -> 23`      |
+	| `minute` | `number` | `0 -> 59`      |
+	| `second` | `number` | `0 -> 60`      |
+
+	An additional `millisecond` value may also be included,
+	and should be within the range `0 -> 999`, but is optional.
+
+	Any non-integer values in the given table will be rounded down.
+
+	### Errors
+
+	This constructor is fallible and may throw an error in the following situations:
+
+	- Date units (year, month, day) were given that produce an invalid date. For example, January 32nd or February 29th on a non-leap year.
+
+	@param values -- Table containing date & time values
+	@return DateTime -- The new DateTime object
+]=]
+function dateTime.fromLocalTime(values: DateTimeValueArguments): DateTime
+	return nil :: any
+end
+
+--[=[
+	@within DateTime
+	@tag Constructor
+
+	Creates a new `DateTime` from an ISO 8601 date-time string.
+
+	### Errors
+
+	This constructor is fallible and may throw an error if the given
+	string does not strictly follow the ISO 8601 date-time string format.
+
+	Some examples of valid ISO 8601 date-time strings are:
+
+	- `2020-02-22T18:12:08Z`
+	- `2000-01-31T12:34:56+05:00`
+	- `1970-01-01T00:00:00.055Z`
+
+	@param isoDate -- An ISO 8601 formatted string
+	@return DateTime -- The new DateTime object
+]=]
+function dateTime.fromIsoDate(isoDate: string): DateTime
+	return nil :: any
+end
+
+return dateTime
diff --git a/.lune/.lune-defs/fs.luau b/.lune/.lune-defs/fs.luau
new file mode 100644
index 0000000..823f6f7
--- /dev/null
+++ b/.lune/.lune-defs/fs.luau
@@ -0,0 +1,289 @@
+local DateTime = require("./datetime")
+type DateTime = DateTime.DateTime
+
+export type MetadataKind = "file" | "dir" | "symlink"
+
+--[=[
+	@interface MetadataPermissions
+	@within FS
+
+	Permissions for the given file or directory.
+
+	This is a dictionary that will contain the following values:
+
+	* `readOnly` - If the target path is read-only or not
+]=]
+export type MetadataPermissions = {
+	readOnly: boolean,
+}
+
+-- FIXME: We lose doc comments here below in Metadata because of the union type
+
+--[=[
+	@interface Metadata
+	@within FS
+
+	Metadata for the given file or directory.
+
+	This is a dictionary that will contain the following values:
+
+	* `kind` - If the target path is a `file`, `dir` or `symlink`
+	* `exists` - If the target path exists
+	* `createdAt` - The timestamp represented as a `DateTime` object at which the file or directory was created
+	* `modifiedAt` - The timestamp represented as a `DateTime` object at which the file or directory was last modified
+	* `accessedAt` - The timestamp represented as a `DateTime` object at which the file or directory was last accessed
+	* `permissions` - Current permissions for the file or directory
+
+	Note that timestamps are relative to the unix epoch, and
+	may not be accurate if the system clock is not accurate.
+]=]
+export type Metadata = {
+	kind: MetadataKind,
+	exists: true,
+	createdAt: DateTime,
+	modifiedAt: DateTime,
+	accessedAt: DateTime,
+	permissions: MetadataPermissions,
+} | {
+	kind: nil,
+	exists: false,
+	createdAt: nil,
+	modifiedAt: nil,
+	accessedAt: nil,
+	permissions: nil,
+}
+
+--[=[
+	@interface WriteOptions
+	@within FS
+
+	Options for filesystem APIs what write to files and/or directories.
+
+	This is a dictionary that may contain one or more of the following values:
+
+	* `overwrite` - If the target path should be overwritten or not, in the case that it already exists
+]=]
+export type WriteOptions = {
+	overwrite: boolean?,
+}
+
+--[=[
+	@class FS
+
+	Built-in library for filesystem access
+
+	### Example usage
+
+	```lua
+	local fs = require("@lune/fs")
+
+	-- Reading a file
+	local myTextFile: string = fs.readFile("myFileName.txt")
+
+	-- Reading entries (files & dirs) in a directory
+	for _, entryName in fs.readDir("myDirName") do
+		if fs.isFile("myDirName/" .. entryName) then
+			print("Found file " .. entryName)
+		elseif fs.isDir("myDirName/" .. entryName) then
+			print("Found subdirectory " .. entryName)
+		end
+	end
+	```
+]=]
+local fs = {}
+
+--[=[
+	@within FS
+	@tag must_use
+
+	Reads a file at `path`.
+
+	An error will be thrown in the following situations:
+
+	* `path` does not point to an existing file.
+	* The current process lacks permissions to read the file.
+	* Some other I/O error occurred.
+
+	@param path The path to the file to read
+	@return The contents of the file
+]=]
+function fs.readFile(path: string): string
+	return nil :: any
+end
+
+--[=[
+	@within FS
+	@tag must_use
+
+	Reads entries in a directory at `path`.
+
+	An error will be thrown in the following situations:
+
+	* `path` does not point to an existing directory.
+	* The current process lacks permissions to read the contents of the directory.
+	* Some other I/O error occurred.
+
+	@param path The directory path to search in
+	@return A list of files & directories found
+]=]
+function fs.readDir(path: string): { string }
+	return {}
+end
+
+--[=[
+	@within FS
+
+	Writes to a file at `path`.
+
+	An error will be thrown in the following situations:
+
+	* The file's parent directory does not exist.
+	* The current process lacks permissions to write to the file.
+	* Some other I/O error occurred.
+
+	@param path The path of the file
+	@param contents The contents of the file
+]=]
+function fs.writeFile(path: string, contents: buffer | string) end
+
+--[=[
+	@within FS
+
+	Creates a directory and its parent directories if they are missing.
+
+	An error will be thrown in the following situations:
+
+	* `path` already points to an existing file or directory.
+	* The current process lacks permissions to create the directory or its missing parents.
+	* Some other I/O error occurred.
+
+	@param path The directory to create
+]=]
+function fs.writeDir(path: string) end
+
+--[=[
+	@within FS
+
+	Removes a file.
+
+	An error will be thrown in the following situations:
+
+	* `path` does not point to an existing file.
+	* The current process lacks permissions to remove the file.
+	* Some other I/O error occurred.
+
+	@param path The file to remove
+]=]
+function fs.removeFile(path: string) end
+
+--[=[
+	@within FS
+
+	Removes a directory and all of its contents.
+
+	An error will be thrown in the following situations:
+
+	* `path` is not an existing and empty directory.
+	* The current process lacks permissions to remove the directory.
+	* Some other I/O error occurred.
+
+	@param path The directory to remove
+]=]
+function fs.removeDir(path: string) end
+
+--[=[
+	@within FS
+	@tag must_use
+
+	Gets metadata for the given path.
+
+	An error will be thrown in the following situations:
+
+	* The current process lacks permissions to read at `path`.
+	* Some other I/O error occurred.
+
+	@param path The path to get metadata for
+	@return Metadata for the path
+]=]
+function fs.metadata(path: string): Metadata
+	return nil :: any
+end
+
+--[=[
+	@within FS
+	@tag must_use
+
+	Checks if a given path is a file.
+
+	An error will be thrown in the following situations:
+
+	* The current process lacks permissions to read at `path`.
+	* Some other I/O error occurred.
+
+	@param path The file path to check
+	@return If the path is a file or not
+]=]
+function fs.isFile(path: string): boolean
+	return nil :: any
+end
+
+--[=[
+	@within FS
+	@tag must_use
+
+	Checks if a given path is a directory.
+
+	An error will be thrown in the following situations:
+
+	* The current process lacks permissions to read at `path`.
+	* Some other I/O error occurred.
+
+	@param path The directory path to check
+	@return If the path is a directory or not
+]=]
+function fs.isDir(path: string): boolean
+	return nil :: any
+end
+
+--[=[
+	@within FS
+
+	Moves a file or directory to a new path.
+
+	Throws an error if a file or directory already exists at the target path.
+	This can be bypassed by passing `true` as the third argument, or a dictionary of options.
+	Refer to the documentation for `WriteOptions` for specific option keys and their values.
+
+	An error will be thrown in the following situations:
+
+	* The current process lacks permissions to read at `from` or write at `to`.
+	* The new path exists on a different mount point.
+	* Some other I/O error occurred.
+
+	@param from The path to move from
+	@param to The path to move to
+	@param overwriteOrOptions Options for the target path, such as if should be overwritten if it already exists
+]=]
+function fs.move(from: string, to: string, overwriteOrOptions: (boolean | WriteOptions)?) end
+
+--[=[
+	@within FS
+
+	Copies a file or directory recursively to a new path.
+
+	Throws an error if a file or directory already exists at the target path.
+	This can be bypassed by passing `true` as the third argument, or a dictionary of options.
+	Refer to the documentation for `WriteOptions` for specific option keys and their values.
+
+	An error will be thrown in the following situations:
+
+	* The current process lacks permissions to read at `from` or write at `to`.
+	* Some other I/O error occurred.
+
+	@param from The path to copy from
+	@param to The path to copy to
+	@param overwriteOrOptions Options for the target path, such as if should be overwritten if it already exists
+]=]
+function fs.copy(from: string, to: string, overwriteOrOptions: (boolean | WriteOptions)?) end
+
+return fs
diff --git a/.lune/.lune-defs/luau.luau b/.lune/.lune-defs/luau.luau
new file mode 100644
index 0000000..ab40c4f
--- /dev/null
+++ b/.lune/.lune-defs/luau.luau
@@ -0,0 +1,123 @@
+--[=[
+	@interface CompileOptions
+	@within Luau
+
+	The options passed to the luau compiler while compiling bytecode.
+
+	This is a dictionary that may contain one or more of the following values:
+
+	* `optimizationLevel` - Sets the compiler option "optimizationLevel". Defaults to `1`.
+	* `coverageLevel` - Sets the compiler option "coverageLevel". Defaults to `0`.
+	* `debugLevel` - Sets the compiler option "debugLevel". Defaults to `1`.
+
+	Documentation regarding what these values represent can be found [here](https://github.com/Roblox/luau/blob/bd229816c0a82a8590395416c81c333087f541fd/Compiler/include/luacode.h#L13-L39).
+]=]
+export type CompileOptions = {
+	optimizationLevel: number?,
+	coverageLevel: number?,
+	debugLevel: number?,
+}
+
+--[=[
+	@interface LoadOptions
+	@within Luau
+
+	The options passed while loading a luau chunk from an arbitrary string, or bytecode.
+
+	This is a dictionary that may contain one or more of the following values:
+
+	* `debugName` - The debug name of the closure. Defaults to `luau.load(...)`.
+	* `environment` - A custom environment to load the chunk in. Setting a custom environment will deoptimize the chunk and forcefully disable codegen. Defaults to the global environment.
+	* `injectGlobals` - Whether or not to inject globals in the custom environment. Has no effect if no custom environment is provided. Defaults to `true`.
+	* `codegenEnabled` - Whether or not to enable codegen. Defaults to `false`.
+]=]
+export type LoadOptions = {
+	debugName: string?,
+	environment: { [string]: any }?,
+	injectGlobals: boolean?,
+	codegenEnabled: boolean?,
+}
+
+--[=[
+	@class Luau
+
+	Built-in library for generating luau bytecode & functions.
+
+	### Example usage
+
+	```lua
+	local luau = require("@lune/luau")
+
+	local bytecode = luau.compile("print('Hello, World!')")
+	local callableFn = luau.load(bytecode)
+
+	-- Additionally, we can skip the bytecode generation and load a callable function directly from the code itself.
+	-- local callableFn = luau.load("print('Hello, World!')")
+
+	callableFn()
+	```
+
+	Since luau bytecode is highly compressible, it may also make sense to compress it using the `serde` library
+	while transmitting large amounts of it.
+]=]
+local luau = {}
+
+--[=[
+	@within Luau
+
+	Compiles sourcecode into Luau bytecode
+
+	An error will be thrown if the sourcecode given isn't valid Luau code.
+
+	### Example usage
+
+	```lua
+	local luau = require("@lune/luau")
+
+	-- Compile the source to some highly optimized bytecode
+	local bytecode = luau.compile("print('Hello, World!')", {
+		optimizationLevel = 2,
+		coverageLevel = 0,
+		debugLevel = 1,
+	})
+	```
+
+	@param source The string that will be compiled into bytecode
+	@param compileOptions The options passed to the luau compiler that will output the bytecode
+
+	@return luau bytecode
+]=]
+function luau.compile(source: string, compileOptions: CompileOptions?): string
+	return nil :: any
+end
+
+--[=[
+	@within Luau
+
+	Generates a function from either bytecode or sourcecode
+
+	An error will be thrown if the sourcecode given isn't valid luau code.
+
+	### Example usage
+
+	```lua
+	local luau = require("@lune/luau")
+
+	local bytecode = luau.compile("print('Hello, World!')")
+	local callableFn = luau.load(bytecode, {
+		debugName = "'Hello, World'"
+	})
+
+	callableFn()
+	```
+
+	@param source Either luau bytecode or string source code
+	@param loadOptions The options passed to luau for loading the chunk
+
+	@return luau chunk
+]=]
+function luau.load(source: string, loadOptions: LoadOptions?): (...any) -> ...any
+	return nil :: any
+end
+
+return luau
diff --git a/.lune/.lune-defs/net.luau b/.lune/.lune-defs/net.luau
new file mode 100644
index 0000000..e9b793e
--- /dev/null
+++ b/.lune/.lune-defs/net.luau
@@ -0,0 +1,321 @@
+export type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "HEAD" | "OPTIONS" | "PATCH"
+
+type HttpQueryOrHeaderMap = { [string]: string | { string } }
+export type HttpQueryMap = HttpQueryOrHeaderMap
+export type HttpHeaderMap = HttpQueryOrHeaderMap
+
+--[=[
+	@interface FetchParamsOptions
+	@within Net
+
+	Extra options for `FetchParams`.
+
+	This is a dictionary that may contain one or more of the following values:
+
+	* `decompress` - If the request body should be automatically decompressed when possible. Defaults to `true`
+]=]
+export type FetchParamsOptions = {
+	decompress: boolean?,
+}
+
+--[=[
+	@interface FetchParams
+	@within Net
+
+	Parameters for sending network requests with `net.request`.
+
+	This is a dictionary that may contain one or more of the following values:
+
+	* `url` - The URL to send a request to. This is always required
+	* `method` - The HTTP method verb, such as `"GET"`, `"POST"`, `"PATCH"`, `"PUT"`, or `"DELETE"`. Defaults to `"GET"`
+	* `body` - The request body
+	* `query` - A table of key-value pairs representing query parameters in the request path
+	* `headers` - A table of key-value pairs representing headers
+	* `options` - Extra options for things such as automatic decompression of response bodies
+]=]
+export type FetchParams = {
+	url: string,
+	method: HttpMethod?,
+	body: (string | buffer)?,
+	query: HttpQueryMap?,
+	headers: HttpHeaderMap?,
+	options: FetchParamsOptions?,
+}
+
+--[=[
+	@interface FetchResponse
+	@within Net
+
+	Response type for sending network requests with `net.request`.
+
+	This is a dictionary containing the following values:
+
+	* `ok` - If the status code is a canonical success status code, meaning within the range 200 -> 299
+	* `statusCode` - The status code returned for the request
+	* `statusMessage` - The canonical status message for the returned status code, such as `"Not Found"` for status code 404
+	* `headers` - A table of key-value pairs representing headers
+	* `body` - The request body, or an empty string if one was not given
+]=]
+export type FetchResponse = {
+	ok: boolean,
+	statusCode: number,
+	statusMessage: string,
+	headers: HttpHeaderMap,
+	body: string,
+}
+
+--[=[
+	@interface ServeRequest
+	@within Net
+
+	Data type for requests in `net.serve`.
+
+	This is a dictionary containing the following values:
+
+	* `path` - The path being requested, relative to the root. Will be `/` if not specified
+	* `query` - A table of key-value pairs representing query parameters in the request path
+	* `method` - The HTTP method verb, such as `"GET"`, `"POST"`, `"PATCH"`, `"PUT"`, or `"DELETE"`. Will always be uppercase
+	* `headers` - A table of key-value pairs representing headers
+	* `body` - The request body, or an empty string if one was not given
+]=]
+export type ServeRequest = {
+	path: string,
+	query: { [string]: string? },
+	method: HttpMethod,
+	headers: { [string]: string },
+	body: string,
+}
+
+--[=[
+	@interface ServeResponse
+	@within Net
+
+	Response type for requests in `net.serve`.
+
+	This is a dictionary that may contain one or more of the following values:
+
+	* `status` - The status code for the request, in the range `100` -> `599`
+	* `headers` - A table of key-value pairs representing headers
+	* `body` - The response body
+]=]
+export type ServeResponse = {
+	status: number?,
+	headers: { [string]: string }?,
+	body: (string | buffer)?,
+}
+
+type ServeHttpHandler = (request: ServeRequest) -> string | ServeResponse
+type ServeWebSocketHandler = (socket: WebSocket) -> ()
+
+--[=[
+	@interface ServeConfig
+	@within Net
+
+	Configuration for `net.serve`.
+
+	This may contain one of or more of the following values:
+
+	* `address` for setting the IP address to serve from. Defaults to the loopback interface (`http://localhost`).
+	* `handleRequest` for handling normal http requests, equivalent to just passing a function to `net.serve`
+	* `handleWebSocket` for handling web socket requests, which will receive a `WebSocket` object as its first and only parameter
+
+	When setting `address`, the `handleRequest` callback must also be defined.
+
+	```lua
+		net.serve(8080, {
+			address = "http://0.0.0.0",
+			handleRequest = function(request)
+				return {
+					status = 200,
+					body = "Echo:\n" .. request.body,
+				}
+			end
+		})
+	```
+]=]
+export type ServeConfig = {
+	address: string?,
+	handleRequest: ServeHttpHandler?,
+	handleWebSocket: ServeWebSocketHandler?,
+}
+
+--[=[
+	@interface ServeHandle
+	@within Net
+
+	A handle to a currently running web server, containing a single `stop` function to gracefully shut down the web server.
+]=]
+export type ServeHandle = {
+	stop: () -> (),
+}
+
+--[=[
+	@interface WebSocket
+	@within Net
+
+	A reference to a web socket connection.
+
+	The web socket may be in either an "open" or a "closed" state, changing its current behavior.
+
+	When open:
+
+	* Any function on the socket such as `send`, `next` or `close` can be called without erroring
+	* `next` can be called to yield until the next message is received or the socket becomes closed
+
+	When closed:
+
+	* `next` will no longer return any message(s) and instead instantly return nil
+	* `send` will throw an error stating that the socket has been closed
+
+	Once the websocket has been closed, `closeCode` will no longer be nil, and will be populated with a close
+	code according to the [WebSocket specification](https://www.iana.org/assignments/websocket/websocket.xhtml).
+	This will be an integer between 1000 and 4999, where 1000 is the canonical code for normal, error-free closure.
+]=]
+export type WebSocket = {
+	closeCode: number?,
+	close: (code: number?) -> (),
+	send: (message: (string | buffer)?, asBinaryMessage: boolean?) -> (),
+	next: () -> string?,
+}
+
+--[=[
+	@class Net
+
+
+	Built-in library for network access
+
+	### Example usage
+
+	```lua
+	local net = require("@lune/net")
+
+	-- Sending a web request
+	local response = net.request("https://www.google.com")
+	print(response.ok)
+	print(response.statusCode, response.statusMessage)
+	print(response.headers)
+
+	-- Using a JSON web API
+	local response = net.request({
+		url = "https://dummyjson.com/products/add",
+		method = "POST",
+		headers = { ["Content-Type"] = "application/json" },
+		body = net.jsonEncode({
+			title = "Cool Pencil",
+		})
+	})
+	local product = net.jsonDecode(response.body)
+	print(product.id, "-", product.title)
+
+	-- Starting up a webserver
+	net.serve(8080, function(request)
+		return {
+			status = 200,
+			body = "Echo:\n" .. request.body,
+		}
+	end)
+	```
+]=]
+local net = {}
+
+--[=[
+	@within Net
+
+	Sends an HTTP request using the given url and / or parameters, and returns a dictionary that describes the response received.
+
+	Only throws an error if a miscellaneous network or I/O error occurs, never for unsuccessful status codes.
+
+	@param config The URL or request config to use
+	@return A dictionary representing the response for the request
+]=]
+function net.request(config: string | FetchParams): FetchResponse
+	return nil :: any
+end
+
+--[=[
+	@within Net
+	@tag must_use
+
+	Connects to a web socket at the given URL.
+
+	Throws an error if the server at the given URL does not support
+	web sockets, or if a miscellaneous network or I/O error occurs.
+
+	@param url The URL to connect to
+	@return A web socket handle
+]=]
+function net.socket(url: string): WebSocket
+	return nil :: any
+end
+
+--[=[
+	@within Net
+
+	Creates an HTTP server that listens on the given `port`.
+
+	This will ***not*** block and will keep listening for requests on the given `port`
+	until the `stop` function on the returned `ServeHandle` has been called.
+
+	@param port The port to use for the server
+	@param handlerOrConfig The handler function or config to use for the server
+]=]
+function net.serve(port: number, handlerOrConfig: ServeHttpHandler | ServeConfig): ServeHandle
+	return nil :: any
+end
+
+--[=[
+	@within Net
+	@tag must_use
+
+	Encodes the given value as JSON.
+
+	@param value The value to encode as JSON
+	@param pretty If the encoded JSON string should include newlines and spaces. Defaults to false
+	@return The encoded JSON string
+]=]
+function net.jsonEncode(value: any, pretty: boolean?): string
+	return nil :: any
+end
+
+--[=[
+	@within Net
+	@tag must_use
+
+	Decodes the given JSON string into a lua value.
+
+	@param encoded The JSON string to decode
+	@return The decoded lua value
+]=]
+function net.jsonDecode(encoded: string): any
+	return nil :: any
+end
+
+--[=[
+	@within Net
+	@tag must_use
+
+	Encodes the given string using URL encoding.
+
+	@param s The string to encode
+	@param binary If the string should be treated as binary data and/or is not valid utf-8. Defaults to false
+	@return The encoded string
+]=]
+function net.urlEncode(s: string, binary: boolean?): string
+	return nil :: any
+end
+
+--[=[
+	@within Net
+	@tag must_use
+
+	Decodes the given string using URL decoding.
+
+	@param s The string to decode
+	@param binary If the string should be treated as binary data and/or is not valid utf-8. Defaults to false
+	@return The decoded string
+]=]
+function net.urlDecode(s: string, binary: boolean?): string
+	return nil :: any
+end
+
+return net
diff --git a/.lune/.lune-defs/process.luau b/.lune/.lune-defs/process.luau
new file mode 100644
index 0000000..7b82052
--- /dev/null
+++ b/.lune/.lune-defs/process.luau
@@ -0,0 +1,182 @@
+export type OS = "linux" | "macos" | "windows"
+export type Arch = "x86_64" | "aarch64"
+
+export type SpawnOptionsStdioKind = "default" | "inherit" | "forward" | "none"
+export type SpawnOptionsStdio = {
+	stdout: SpawnOptionsStdioKind?,
+	stderr: SpawnOptionsStdioKind?,
+	stdin: string?,
+}
+
+--[=[
+	@interface SpawnOptions
+	@within Process
+
+	A dictionary of options for `process.spawn`, with the following available values:
+
+	* `cwd` - The current working directory for the process
+	* `env` - Extra environment variables to give to the process
+	* `shell` - Whether to run in a shell or not - set to `true` to run using the default shell, or a string to run using a specific shell
+	* `stdio` - How to treat output and error streams from the child process - see `SpawnOptionsStdioKind` and `SpawnOptionsStdio` for more info
+	* `stdin` - Optional standard input to pass to spawned child process
+]=]
+export type SpawnOptions = {
+	cwd: string?,
+	env: { [string]: string }?,
+	shell: (boolean | string)?,
+	stdio: (SpawnOptionsStdioKind | SpawnOptionsStdio)?,
+	stdin: string?, -- TODO: Remove this since it is now available in stdio above, breaking change
+}
+
+--[=[
+	@interface SpawnResult
+	@within Process
+
+	Result type for child processes in `process.spawn`.
+
+	This is a dictionary containing the following values:
+
+	* `ok` - If the child process exited successfully or not, meaning the exit code was zero or not set
+	* `code` - The exit code set by the child process, or 0 if one was not set
+	* `stdout` - The full contents written to stdout by the child process, or an empty string if nothing was written
+	* `stderr` - The full contents written to stderr by the child process, or an empty string if nothing was written
+]=]
+export type SpawnResult = {
+	ok: boolean,
+	code: number,
+	stdout: string,
+	stderr: string,
+}
+
+--[=[
+	@class Process
+
+	Built-in functions for the current process & child processes
+
+	### Example usage
+
+	```lua
+	local process = require("@lune/process")
+
+	-- Getting the arguments passed to the Lune script
+	for index, arg in process.args do
+		print("Process argument #" .. tostring(index) .. ": " .. arg)
+	end
+
+	-- Getting the currently available environment variables
+	local PORT: string? = process.env.PORT
+	local HOME: string? = process.env.HOME
+	for name, value in process.env do
+		print("Environment variable " .. name .. " is set to " .. value)
+	end
+
+	-- Getting the current os and processor architecture
+	print("Running " .. process.os .. " on " .. process.arch .. "!")
+
+	-- Spawning a child process
+	local result = process.spawn("program", {
+		"cli argument",
+		"other cli argument"
+	})
+	if result.ok then
+		print(result.stdout)
+	else
+		print(result.stderr)
+	end
+	```
+]=]
+local process = {}
+
+--[=[
+	@within Process
+	@prop os OS
+	@tag read_only
+
+	The current operating system being used.
+
+	Possible values:
+
+	* `"linux"`
+	* `"macos"`
+	* `"windows"`
+]=]
+process.os = (nil :: any) :: OS
+
+--[=[
+	@within Process
+	@prop arch Arch
+	@tag read_only
+
+	The architecture of the processor currently being used.
+
+	Possible values:
+
+	* `"x86_64"`
+	* `"aarch64"`
+]=]
+process.arch = (nil :: any) :: Arch
+
+--[=[
+	@within Process
+	@prop args { string }
+	@tag read_only
+
+	The arguments given when running the Lune script.
+]=]
+process.args = (nil :: any) :: { string }
+
+--[=[
+	@within Process
+	@prop cwd string
+	@tag read_only
+
+	The current working directory in which the Lune script is running.
+]=]
+process.cwd = (nil :: any) :: string
+
+--[=[
+	@within Process
+	@prop env { [string]: string? }
+	@tag read_write
+
+	Current environment variables for this process.
+
+	Setting a value on this table will set the corresponding environment variable.
+]=]
+process.env = (nil :: any) :: { [string]: string? }
+
+--[=[
+	@within Process
+
+	Exits the currently running script as soon as possible with the given exit code.
+
+	Exit code 0 is treated as a successful exit, any other value is treated as an error.
+
+	Setting the exit code using this function will override any otherwise automatic exit code.
+
+	@param code The exit code to set
+]=]
+function process.exit(code: number?): never
+	return nil :: any
+end
+
+--[=[
+	@within Process
+
+	Spawns a child process that will run the program `program`, and returns a dictionary that describes the final status and ouput of the child process.
+
+	The second argument, `params`, can be passed as a list of string parameters to give to the program.
+
+	The third argument, `options`, can be passed as a dictionary of options to give to the child process.
+	Refer to the documentation for `SpawnOptions` for specific option keys and their values.
+
+	@param program The program to spawn as a child process
+	@param params Additional parameters to pass to the program
+	@param options A dictionary of options for the child process
+	@return A dictionary representing the result of the child process
+]=]
+function process.spawn(program: string, params: { string }?, options: SpawnOptions?): SpawnResult
+	return nil :: any
+end
+
+return process
diff --git a/.lune/.lune-defs/regex.luau b/.lune/.lune-defs/regex.luau
new file mode 100644
index 0000000..59756f3
--- /dev/null
+++ b/.lune/.lune-defs/regex.luau
@@ -0,0 +1,218 @@
+--[=[
+	@class RegexMatch
+
+	A match from a regular expression.
+
+	Contains the following values:
+
+	- `start` -- The start index of the match in the original string.
+	- `finish` -- The end index of the match in the original string.
+	- `text` -- The text that was matched.
+	- `len` -- The length of the text that was matched.
+]=]
+local RegexMatch = {
+	start = 0,
+	finish = 0,
+	text = "",
+	len = 0,
+}
+
+type RegexMatch = typeof(RegexMatch)
+
+--[=[
+	@class RegexCaptures
+
+	Captures from a regular expression.
+]=]
+local RegexCaptures = {}
+
+--[=[
+	@within RegexCaptures
+	@tag Method
+
+	Returns the match at the given index, if one exists.
+
+	@param index -- The index of the match to get
+	@return RegexMatch -- The match, if one exists
+]=]
+function RegexCaptures.get(self: RegexCaptures, index: number): RegexMatch?
+	return nil :: any
+end
+
+--[=[
+	@within RegexCaptures
+	@tag Method
+
+	Returns the match for the given named match group, if one exists.
+
+	@param group -- The name of the group to get
+	@return RegexMatch -- The match, if one exists
+]=]
+function RegexCaptures.group(self: RegexCaptures, group: string): RegexMatch?
+	return nil :: any
+end
+
+--[=[
+	@within RegexCaptures
+	@tag Method
+
+	Formats the captures using the given format string.
+
+	### Example usage
+
+	```lua
+	local regex = require("@lune/regex")
+
+	local re = regex.new("(?<day>[0-9]{2})-(?<month>[0-9]{2})-(?<year>[0-9]{4})")
+
+	local caps = re:captures("On 14-03-2010, I became a Tenneessee lamb.");
+	assert(caps ~= nil, "Example pattern should match example text")
+
+	local formatted = caps:format("year=$year, month=$month, day=$day")
+	print(formatted) -- "year=2010, month=03, day=14"
+	```
+
+	@param format -- The format string to use
+	@return string -- The formatted string
+]=]
+function RegexCaptures.format(self: RegexCaptures, format: string): string
+	return nil :: any
+end
+
+export type RegexCaptures = typeof(RegexCaptures)
+
+local Regex = {}
+
+--[=[
+	@within Regex
+	@tag Method
+
+	Check if the given text matches the regular expression.
+
+	This method may be slightly more efficient than calling `find`
+	if you only need to know if the text matches the pattern.
+
+	@param text -- The text to search
+	@return boolean -- Whether the text matches the pattern
+]=]
+function Regex.isMatch(self: Regex, text: string): boolean
+	return nil :: any
+end
+
+--[=[
+	@within Regex
+	@tag Method
+
+	Finds the first match in the given text.
+
+	Returns `nil` if no match was found.
+
+	@param text -- The text to search
+	@return RegexMatch? -- The match object
+]=]
+function Regex.find(self: Regex, text: string): RegexMatch?
+	return nil :: any
+end
+
+--[=[
+	@within Regex
+	@tag Method
+
+	Finds all matches in the given text as a `RegexCaptures` object.
+
+	Returns `nil` if no matches are found.
+
+	@param text -- The text to search
+	@return RegexCaptures? -- The captures object
+]=]
+function Regex.captures(self: Regex, text: string): RegexCaptures?
+	return nil :: any
+end
+
+--[=[
+	@within Regex
+	@tag Method
+
+	Splits the given text using the regular expression.
+
+	@param text -- The text to split
+	@return { string } -- The split text
+]=]
+function Regex.split(self: Regex, text: string): { string }
+	return nil :: any
+end
+
+--[=[
+	@within Regex
+	@tag Method
+
+	Replaces the first match in the given text with the given replacer string.
+
+	@param haystack -- The text to search
+	@param replacer -- The string to replace matches with
+	@return string -- The text with the first match replaced
+]=]
+function Regex.replace(self: Regex, haystack: string, replacer: string): string
+	return nil :: any
+end
+
+--[=[
+	@within Regex
+	@tag Method
+
+	Replaces all matches in the given text with the given replacer string.
+
+	@param haystack -- The text to search
+	@param replacer -- The string to replace matches with
+	@return string -- The text with all matches replaced
+]=]
+function Regex.replaceAll(self: Regex, haystack: string, replacer: string): string
+	return nil :: any
+end
+
+export type Regex = typeof(Regex)
+
+--[=[
+	@class Regex
+
+	Built-in library for regular expressions
+
+	### Example usage
+
+	```lua
+	local Regex = require("@lune/regex")
+
+	local re = Regex.new("hello")
+
+	if re:isMatch("hello, world!") then
+		print("Matched!")
+	end
+
+	local caps = re:captures("hello, world! hello, again!")
+
+	print(#caps) -- 2
+	print(caps:get(1)) -- "hello"
+	print(caps:get(2)) -- "hello"
+	print(caps:get(3)) -- nil
+	```
+]=]
+local regex = {}
+
+--[=[
+	@within Regex
+	@tag Constructor
+
+	Creates a new `Regex` from a given string pattern.
+
+	### Errors
+
+	This constructor throws an error if the given pattern is invalid.
+
+	@param pattern -- The string pattern to use
+	@return Regex -- The new Regex object
+]=]
+function regex.new(pattern: string): Regex
+	return nil :: any
+end
+
+return regex
diff --git a/.lune/.lune-defs/roblox.luau b/.lune/.lune-defs/roblox.luau
new file mode 100644
index 0000000..b79ad60
--- /dev/null
+++ b/.lune/.lune-defs/roblox.luau
@@ -0,0 +1,507 @@
+export type DatabaseScriptability = "None" | "Custom" | "Read" | "ReadWrite" | "Write"
+
+export type DatabasePropertyTag =
+	"Deprecated"
+	| "Hidden"
+	| "NotBrowsable"
+	| "NotReplicated"
+	| "NotScriptable"
+	| "ReadOnly"
+	| "WriteOnly"
+
+export type DatabaseClassTag =
+	"Deprecated"
+	| "NotBrowsable"
+	| "NotCreatable"
+	| "NotReplicated"
+	| "PlayerReplicated"
+	| "Service"
+	| "Settings"
+	| "UserSettings"
+
+export type DatabaseProperty = {
+	--[=[
+		The name of the property.
+	]=]
+	Name: string,
+	--[=[
+		The datatype of the property.
+
+		For normal datatypes this will be a string such as `string`, `Color3`, ...
+
+		For enums this will be a string formatted as `Enum.EnumName`.
+	]=]
+	Datatype: string,
+	--[=[
+		The scriptability of this property, meaning if it can be written / read at runtime.
+
+		All properties are writable and readable in Lune even if scriptability is not.
+	]=]
+	Scriptability: DatabaseScriptability,
+	--[=[
+		Tags describing the property.
+
+		These include information such as if the property can be replicated to players
+		at runtime, if the property should be hidden in Roblox Studio, and more.
+	]=]
+	Tags: { DatabasePropertyTag },
+}
+
+export type DatabaseClass = {
+	--[=[
+		The name of the class.
+	]=]
+	Name: string,
+	--[=[
+		The superclass (parent class) of this class.
+
+		May be nil if no parent class exists.
+	]=]
+	Superclass: string?,
+	--[=[
+		Known properties for this class.
+	]=]
+	Properties: { [string]: DatabaseProperty },
+	--[=[
+		Default values for properties of this class.
+
+		Note that these default properties use Lune's built-in datatype
+		userdatas, and that if there is a new datatype that Lune does
+		not yet know about, it may be missing from this table.
+	]=]
+	DefaultProperties: { [string]: any },
+	--[=[
+		Tags describing the class.
+
+		These include information such as if the class can be replicated
+		to players at runtime, and top-level class categories.
+	]=]
+	Tags: { DatabaseClassTag },
+}
+
+export type DatabaseEnum = {
+	--[=[
+		The name of this enum, for example `PartType` or `UserInputState`.
+	]=]
+	Name: string,
+	--[=[
+		Members of this enum.
+
+		Note that this is a direct map of name -> enum values,
+		and does not actually use the EnumItem datatype itself.
+	]=]
+	Items: { [string]: number },
+}
+
+export type Database = {
+	--[=[
+		The current version of the reflection database.
+
+		This will follow the format `x.y.z.w`, which most commonly looks something like `0.567.0.123456789`
+	]=]
+	Version: string,
+	--[=[
+		Retrieves a list of all currently known class names.
+	]=]
+	GetClassNames: (self: Database) -> { string },
+	--[=[
+		Retrieves a list of all currently known enum names.
+	]=]
+	GetEnumNames: (self: Database) -> { string },
+	--[=[
+		Gets a class with the exact given name, if one exists.
+	]=]
+	GetClass: (self: Database, name: string) -> DatabaseClass?,
+	--[=[
+		Gets an enum with the exact given name, if one exists.
+	]=]
+	GetEnum: (self: Database, name: string) -> DatabaseEnum?,
+	--[=[
+		Finds a class with the given name.
+
+		This will use case-insensitive matching and ignore leading and trailing whitespace.
+	]=]
+	FindClass: (self: Database, name: string) -> DatabaseClass?,
+	--[=[
+		Finds an enum with the given name.
+
+		This will use case-insensitive matching and ignore leading and trailing whitespace.
+	]=]
+	FindEnum: (self: Database, name: string) -> DatabaseEnum?,
+}
+
+type InstanceProperties = {
+	Parent: Instance?,
+	ClassName: string,
+	Name: string,
+	-- FIXME: This breaks intellisense, but we need some way to access
+	-- instance properties without casting the entire instance to any...
+	-- [string]: any,
+}
+
+type InstanceMetatable = {
+	Clone: (self: Instance) -> Instance,
+	Destroy: (self: Instance) -> (),
+	ClearAllChildren: (self: Instance) -> (),
+
+	GetChildren: (self: Instance) -> { Instance },
+	GetDebugId: (self: Instance) -> string,
+	GetDescendants: (self: Instance) -> { Instance },
+	GetFullName: (self: Instance) -> string,
+
+	FindFirstAncestor: (self: Instance, name: string) -> Instance?,
+	FindFirstAncestorOfClass: (self: Instance, className: string) -> Instance?,
+	FindFirstAncestorWhichIsA: (self: Instance, className: string) -> Instance?,
+	FindFirstChild: (self: Instance, name: string, recursive: boolean?) -> Instance?,
+	FindFirstChildOfClass: (self: Instance, className: string, recursive: boolean?) -> Instance?,
+	FindFirstChildWhichIsA: (self: Instance, className: string, recursive: boolean?) -> Instance?,
+
+	IsA: (self: Instance, className: string) -> boolean,
+	IsAncestorOf: (self: Instance, descendant: Instance) -> boolean,
+	IsDescendantOf: (self: Instance, ancestor: Instance) -> boolean,
+
+	GetAttribute: (self: Instance, name: string) -> any,
+	GetAttributes: (self: Instance) -> { [string]: any },
+	SetAttribute: (self: Instance, name: string, value: any) -> (),
+
+	GetTags: (self: Instance) -> { string },
+	HasTag: (self: Instance, name: string) -> boolean,
+	AddTag: (self: Instance, name: string) -> (),
+	RemoveTag: (self: Instance, name: string) -> (),
+}
+
+export type Instance = typeof(setmetatable(
+	(nil :: any) :: InstanceProperties,
+	(nil :: any) :: { __index: InstanceMetatable }
+))
+
+export type DataModelProperties = {}
+export type DataModelMetatable = {
+	GetService: (self: DataModel, name: string) -> Instance,
+	FindService: (self: DataModel, name: string) -> Instance?,
+}
+
+export type DataModel =
+	Instance
+	& typeof(setmetatable(
+		(nil :: any) :: DataModelProperties,
+		(nil :: any) :: { __index: DataModelMetatable }
+	))
+
+--[=[
+	@class Roblox
+
+	Built-in library for manipulating Roblox place & model files
+
+	### Example usage
+
+	```lua
+	local fs = require("@lune/fs")
+	local roblox = require("@lune/roblox")
+
+	-- Reading a place file
+	local placeFile = fs.readFile("myPlaceFile.rbxl")
+	local game = roblox.deserializePlace(placeFile)
+
+	-- Manipulating and reading instances - just like in Roblox!
+	local workspace = game:GetService("Workspace")
+	for _, child in workspace:GetChildren() do
+		print("Found child " .. child.Name .. " of class " .. child.ClassName)
+	end
+
+	-- Writing a place file
+	local newPlaceFile = roblox.serializePlace(game)
+	fs.writeFile("myPlaceFile.rbxl", newPlaceFile)
+	```
+]=]
+local roblox = {}
+
+--[=[
+	@within Roblox
+	@tag must_use
+
+	Deserializes a place into a DataModel instance.
+
+	This function accepts a string of contents, *not* a file path.
+	If reading a place file from a file path is desired, `fs.readFile`
+	can be used and the resulting string may be passed to this function.
+
+	### Example usage
+
+	```lua
+	local fs = require("@lune/fs")
+	local roblox = require("@lune/roblox")
+
+	local placeFile = fs.readFile("filePath.rbxl")
+	local game = roblox.deserializePlace(placeFile)
+	```
+
+	@param contents The contents of the place to read
+]=]
+function roblox.deserializePlace(contents: string): DataModel
+	return nil :: any
+end
+
+--[=[
+	@within Roblox
+	@tag must_use
+
+	Deserializes a model into an array of instances.
+
+	This function accepts a string of contents, *not* a file path.
+	If reading a model file from a file path is desired, `fs.readFile`
+	can be used and the resulting string may be passed to this function.
+
+	### Example usage
+
+	```lua
+	local fs = require("@lune/fs")
+	local roblox = require("@lune/roblox")
+
+	local modelFile = fs.readFile("filePath.rbxm")
+	local instances = roblox.deserializeModel(modelFile)
+	```
+
+	@param contents The contents of the model to read
+]=]
+function roblox.deserializeModel(contents: string): { Instance }
+	return nil :: any
+end
+
+--[=[
+	@within Roblox
+	@tag must_use
+
+	Serializes a place from a DataModel instance.
+
+	This string can then be written to a file, or sent over the network.
+
+	### Example usage
+
+	```lua
+	local fs = require("@lune/fs")
+	local roblox = require("@lune/roblox")
+
+	local placeFile = roblox.serializePlace(game)
+	fs.writeFile("filePath.rbxl", placeFile)
+	```
+
+	@param dataModel The DataModel for the place to serialize
+	@param xml If the place should be serialized as xml or not. Defaults to `false`, meaning the place gets serialized using the binary format and not xml.
+]=]
+function roblox.serializePlace(dataModel: DataModel, xml: boolean?): string
+	return nil :: any
+end
+
+--[=[
+	@within Roblox
+	@tag must_use
+
+	Serializes one or more instances as a model.
+
+	This string can then be written to a file, or sent over the network.
+
+	### Example usage
+
+	```lua
+	local fs = require("@lune/fs")
+	local roblox = require("@lune/roblox")
+
+	local modelFile = roblox.serializeModel({ instance1, instance2, ... })
+	fs.writeFile("filePath.rbxm", modelFile)
+	```
+
+	@param instances The array of instances to serialize
+	@param xml If the model should be serialized as xml or not. Defaults to `false`, meaning the model gets serialized using the binary format and not xml.
+]=]
+function roblox.serializeModel(instances: { Instance }, xml: boolean?): string
+	return nil :: any
+end
+
+--[=[
+	@within Roblox
+	@tag must_use
+
+	Gets the current auth cookie, for usage with Roblox web APIs.
+
+	Note that this auth cookie is formatted for use as a "Cookie" header,
+	and that it contains restrictions so that it may only be used for
+	official Roblox endpoints. To get the raw cookie value without any
+	additional formatting, you can pass `true` as the first and only parameter.
+
+	### Example usage
+
+	```lua
+	local roblox = require("@lune/roblox")
+	local net = require("@lune/net")
+
+	local cookie = roblox.getAuthCookie()
+	assert(cookie ~= nil, "Failed to get roblox auth cookie")
+
+	local myPrivatePlaceId = 1234567890
+
+	local response = net.request({
+		url = "https://assetdelivery.roblox.com/v2/assetId/" .. tostring(myPrivatePlaceId),
+		headers = {
+			Cookie = cookie,
+		},
+	})
+
+	local responseTable = net.jsonDecode(response.body)
+	local responseLocation = responseTable.locations[1].location
+	print("Download link to place: " .. responseLocation)
+	```
+
+	@param raw If the cookie should be returned as a pure value or not. Defaults to false
+]=]
+function roblox.getAuthCookie(raw: boolean?): string?
+	return nil :: any
+end
+
+--[=[
+	@within Roblox
+	@tag must_use
+
+	Gets the bundled reflection database.
+
+	This database contains information about Roblox enums, classes, and their properties.
+
+	### Example usage
+
+	```lua
+	local roblox = require("@lune/roblox")
+
+	local db = roblox.getReflectionDatabase()
+
+	print("There are", #db:GetClassNames(), "classes in the reflection database")
+
+	print("All base instance properties:")
+
+	local class = db:GetClass("Instance")
+	for name, prop in class.Properties do
+		print(string.format(
+			"- %s with datatype %s and default value %s",
+			prop.Name,
+			prop.Datatype,
+			tostring(class.DefaultProperties[prop.Name])
+		))
+	end
+	```
+]=]
+function roblox.getReflectionDatabase(): Database
+	return nil :: any
+end
+
+--[=[
+	@within Roblox
+
+	Implements a property for all instances of the given `className`.
+
+	This takes into account class hierarchies, so implementing a property
+	for the `BasePart` class will also implement it for `Part` and others,
+	unless a more specific implementation is added to the `Part` class directly.
+
+	### Behavior
+
+	The given `getter` callback will be called each time the property is
+	indexed, with the instance as its one and only argument. The `setter`
+	callback, if given, will be called each time the property should be set,
+	with the instance as the first argument and the property value as second.
+
+	### Example usage
+
+	```lua
+	local roblox = require("@lune/roblox")
+
+	local part = roblox.Instance.new("Part")
+
+	local propertyValues = {}
+	roblox.implementProperty(
+		"BasePart",
+		"CoolProp",
+		function(instance)
+			if propertyValues[instance] == nil then
+				propertyValues[instance] = 0
+			end
+			propertyValues[instance] += 1
+			return propertyValues[instance]
+		end,
+		function(instance, value)
+			propertyValues[instance] = value
+		end
+	)
+
+	print(part.CoolProp) --> 1
+	print(part.CoolProp) --> 2
+	print(part.CoolProp) --> 3
+
+	part.CoolProp = 10
+
+	print(part.CoolProp) --> 11
+	print(part.CoolProp) --> 12
+	print(part.CoolProp) --> 13
+	```
+
+	@param className The class to implement the property for.
+	@param propertyName The name of the property to implement.
+	@param getter The function which will be called to get the property value when indexed.
+	@param setter The function which will be called to set the property value when indexed. Defaults to a function that will error with a message saying the property is read-only.
+]=]
+function roblox.implementProperty<T>(
+	className: string,
+	propertyName: string,
+	getter: (instance: Instance) -> T,
+	setter: ((instance: Instance, value: T) -> ())?
+)
+	return nil :: any
+end
+
+--[=[
+	@within Roblox
+
+	Implements a method for all instances of the given `className`.
+
+	This takes into account class hierarchies, so implementing a method
+	for the `BasePart` class will also implement it for `Part` and others,
+	unless a more specific implementation is added to the `Part` class directly.
+
+	### Behavior
+
+	The given `callback` will be called every time the method is called,
+	and will receive the instance it was called on as its first argument.
+	The remaining arguments will be what the caller passed to the method, and
+	all values returned from the callback will then be returned to the caller.
+
+	### Example usage
+
+	```lua
+	local roblox = require("@lune/roblox")
+
+	local part = roblox.Instance.new("Part")
+
+	roblox.implementMethod("BasePart", "TestMethod", function(instance, ...)
+	    print("Called TestMethod on instance", instance, "with", ...)
+	end)
+
+	part:TestMethod("Hello", "world!")
+	--> Called TestMethod on instance Part with Hello, world!
+	```
+
+	@param className The class to implement the method for.
+	@param methodName The name of the method to implement.
+	@param callback The function which will be called when the method is called.
+]=]
+function roblox.implementMethod(
+	className: string,
+	methodName: string,
+	callback: (instance: Instance, ...any) -> ...any
+)
+	return nil :: any
+end
+
+-- TODO: Make typedefs for all of the datatypes as well...
+roblox.Instance = (nil :: any) :: {
+	new: ((className: "DataModel") -> DataModel) & ((className: string) -> Instance),
+}
+
+return roblox
diff --git a/.lune/.lune-defs/serde.luau b/.lune/.lune-defs/serde.luau
new file mode 100644
index 0000000..cd2658d
--- /dev/null
+++ b/.lune/.lune-defs/serde.luau
@@ -0,0 +1,200 @@
+--[=[
+	@within Serde
+	@interface EncodeDecodeFormat
+
+	A serialization/deserialization format supported by the Serde library.
+
+	Currently supported formats:
+
+	| Name   | Learn More           |
+	|:-------|:---------------------|
+	| `json` | https://www.json.org |
+	| `yaml` | https://yaml.org     |
+	| `toml` | https://toml.io      |
+]=]
+export type EncodeDecodeFormat = "json" | "yaml" | "toml"
+
+--[=[
+	@within Serde
+	@interface CompressDecompressFormat
+
+	A compression/decompression format supported by the Serde library.
+
+	Currently supported formats:
+
+	| Name     | Learn More                        |
+	|:---------|:----------------------------------|
+	| `brotli` | https://github.com/google/brotli  |
+	| `gzip`   | https://www.gnu.org/software/gzip |
+	| `lz4`    | https://github.com/lz4/lz4        |
+	| `zlib`   | https://www.zlib.net              |
+]=]
+export type CompressDecompressFormat = "brotli" | "gzip" | "lz4" | "zlib"
+
+--[=[
+	@within Serde
+	@interface HashAlgorithm
+
+	A hash algorithm supported by the Serde library.
+
+	Currently supported algorithms:
+
+	| Name       | Learn More                           |
+	|:-----------|:-------------------------------------|
+	| `md5`      | https://en.wikipedia.org/wiki/MD5    |
+	| `sha1`     | https://en.wikipedia.org/wiki/SHA-1  |
+	| `sha224`   | https://en.wikipedia.org/wiki/SHA-2  |
+	| `sha256`   | https://en.wikipedia.org/wiki/SHA-2  |
+	| `sha384`   | https://en.wikipedia.org/wiki/SHA-2  |
+	| `sha512`   | https://en.wikipedia.org/wiki/SHA-2  |
+	| `sha3-224` | https://en.wikipedia.org/wiki/SHA-3  |
+	| `sha3-256` | https://en.wikipedia.org/wiki/SHA-3  |
+	| `sha3-384` | https://en.wikipedia.org/wiki/SHA-3  |
+	| `sha3-512` | https://en.wikipedia.org/wiki/SHA-3  |
+	| `blake3`   | https://en.wikipedia.org/wiki/BLAKE3 |
+]=]
+export type HashAlgorithm =
+	"md5"
+	| "sha1"
+	| "sha224"
+	| "sha256"
+	| "sha384"
+	| "sha512"
+	| "sha3-224"
+	| "sha3-256"
+	| "sha3-384"
+	| "sha3-512"
+	| "blake3"
+
+--[=[
+	@class Serde
+
+	Built-in library for:
+	- serialization & deserialization
+	- encoding & decoding
+	- compression
+
+	### Example usage
+
+	```lua
+	local fs = require("@lune/fs")
+	local serde = require("@lune/serde")
+
+	-- Parse different file formats into lua tables
+	local someJson = serde.decode("json", fs.readFile("myFile.json"))
+	local someToml = serde.decode("toml", fs.readFile("myFile.toml"))
+	local someYaml = serde.decode("yaml", fs.readFile("myFile.yaml"))
+
+	-- Write lua tables to files in different formats
+	fs.writeFile("myFile.json", serde.encode("json", someJson))
+	fs.writeFile("myFile.toml", serde.encode("toml", someToml))
+	fs.writeFile("myFile.yaml", serde.encode("yaml", someYaml))
+	```
+]=]
+local serde = {}
+
+--[=[
+	@within Serde
+	@tag must_use
+
+	Encodes the given value using the given format.
+
+	See [`EncodeDecodeFormat`] for a list of supported formats.
+
+	@param format The format to use
+	@param value The value to encode
+	@param pretty If the encoded string should be human-readable, including things such as newlines and spaces. Only supported for json and toml formats, and defaults to false
+	@return The encoded string
+]=]
+function serde.encode(format: EncodeDecodeFormat, value: any, pretty: boolean?): string
+	return nil :: any
+end
+
+--[=[
+	@within Serde
+	@tag must_use
+
+	Decodes the given string using the given format into a lua value.
+
+	See [`EncodeDecodeFormat`] for a list of supported formats.
+
+	@param format The format to use
+	@param encoded The string to decode
+	@return The decoded lua value
+]=]
+function serde.decode(format: EncodeDecodeFormat, encoded: buffer | string): any
+	return nil :: any
+end
+
+--[=[
+	@within Serde
+	@tag must_use
+
+	Compresses the given string using the given format.
+
+	See [`CompressDecompressFormat`] for a list of supported formats.
+
+	@param format The format to use
+	@param s The string to compress
+	@param level The compression level to use, clamped to the format's limits. The best compression level is used by default
+	@return The compressed string
+]=]
+function serde.compress(format: CompressDecompressFormat, s: buffer | string, level: number?): string
+	return nil :: any
+end
+
+--[=[
+	@within Serde
+	@tag must_use
+
+	Decompresses the given string using the given format.
+
+	See [`CompressDecompressFormat`] for a list of supported formats.
+
+	@param format The format to use
+	@param s The string to decompress
+	@return The decompressed string
+]=]
+function serde.decompress(format: CompressDecompressFormat, s: buffer | string): string
+	return nil :: any
+end
+
+--[=[
+	@within Serde
+	@tag must_use
+
+	Hashes the given message using the given algorithm
+	and returns the hash as a hex string.
+
+	See [`HashAlgorithm`] for a list of supported algorithms.
+
+	@param algorithm The algorithm to use
+	@param message The message to hash
+	@return The hash as a hex string
+]=]
+function serde.hash(algorithm: HashAlgorithm, message: string | buffer): string
+	return nil :: any
+end
+
+--[=[
+	@within Serde
+	@tag must_use
+
+	Hashes the given message using HMAC with the given secret
+	and algorithm, returning the hash as a base64 string.
+
+	See [`HashAlgorithm`] for a list of supported algorithms.
+
+	@param algorithm The algorithm to use
+	@param message The message to hash
+	@return The hash as a base64 string
+]=]
+function serde.hmac(
+	algorithm: HashAlgorithm,
+	message: string | buffer,
+	secret: string | buffer
+): string
+	return nil :: any
+end
+
+return serde
diff --git a/.lune/.lune-defs/stdio.luau b/.lune/.lune-defs/stdio.luau
new file mode 100644
index 0000000..e6e88a4
--- /dev/null
+++ b/.lune/.lune-defs/stdio.luau
@@ -0,0 +1,161 @@
+export type Color =
+	"reset"
+	| "black"
+	| "red"
+	| "green"
+	| "yellow"
+	| "blue"
+	| "purple"
+	| "cyan"
+	| "white"
+export type Style = "reset" | "bold" | "dim"
+
+type PromptFn = (
+	(() -> string)
+	& ((kind: "text", message: string?, defaultOrOptions: string?) -> string)
+	& ((kind: "confirm", message: string, defaultOrOptions: boolean?) -> boolean)
+	& ((kind: "select", message: string?, defaultOrOptions: { string }) -> number?)
+	& ((kind: "multiselect", message: string?, defaultOrOptions: { string }) -> { number }?)
+)
+
+--[=[
+	@within Stdio
+	@function prompt
+	@tag must_use
+
+	Prompts for user input using the wanted kind of prompt:
+
+	* `"text"` - Prompts for a plain text string from the user
+	* `"confirm"` - Prompts the user to confirm with y / n (yes / no)
+	* `"select"` - Prompts the user to select *one* value from a list
+	* `"multiselect"` - Prompts the user to select *one or more* values from a list
+	* `nil` - Equivalent to `"text"` with no extra arguments
+
+	@param kind The kind of prompt to use
+	@param message The message to show the user
+	@param defaultOrOptions The default value for the prompt, or options to choose from for selection prompts
+]=]
+local prompt: PromptFn = function(kind: any, message: any, defaultOrOptions: any)
+	return nil :: any
+end
+
+--[=[
+	@class Stdio
+
+	Built-in standard input / output & utility functions
+
+	### Example usage
+
+	```lua
+	local stdio = require("@lune/stdio")
+
+	-- Prompting the user for basic input
+	local text: string = stdio.prompt("text", "Please write some text")
+	local confirmed: boolean = stdio.prompt("confirm", "Please confirm this action")
+
+	-- Writing directly to stdout or stderr, without the auto-formatting of print/warn/error
+	stdio.write("Hello, ")
+	stdio.write("World! ")
+	stdio.write("All on the same line")
+	stdio.ewrite("\nAnd some error text, too")
+
+	-- Reading the entire input from stdin
+	local input = stdio.readToEnd()
+	```
+]=]
+local stdio = {}
+
+stdio.prompt = prompt
+
+--[=[
+	@within Stdio
+	@tag must_use
+
+	Return an ANSI string that can be used to modify the persistent output color.
+
+	Pass `"reset"` to get a string that can reset the persistent output color.
+
+	### Example usage
+
+	```lua
+	stdio.write(stdio.color("red"))
+	print("This text will be red")
+	stdio.write(stdio.color("reset"))
+	print("This text will be normal")
+	```
+
+	@param color The color to use
+	@return A printable ANSI string
+]=]
+function stdio.color(color: Color): string
+	return nil :: any
+end
+
+--[=[
+	@within Stdio
+	@tag must_use
+
+	Return an ANSI string that can be used to modify the persistent output style.
+
+	Pass `"reset"` to get a string that can reset the persistent output style.
+
+	### Example usage
+
+	```lua
+	stdio.write(stdio.style("bold"))
+	print("This text will be bold")
+	stdio.write(stdio.style("reset"))
+	print("This text will be normal")
+	```
+
+	@param style The style to use
+	@return A printable ANSI string
+]=]
+function stdio.style(style: Style): string
+	return nil :: any
+end
+
+--[=[
+	@within Stdio
+	@tag must_use
+
+	Formats arguments into a human-readable string with syntax highlighting for tables.
+
+	@param ... The values to format
+	@return The formatted string
+]=]
+function stdio.format(...: any): string
+	return nil :: any
+end
+
+--[=[
+	@within Stdio
+
+	Writes a string directly to stdout, without any newline.
+
+	@param s The string to write to stdout
+]=]
+function stdio.write(s: string) end
+
+--[=[
+	@within Stdio
+
+	Writes a string directly to stderr, without any newline.
+
+	@param s The string to write to stderr
+]=]
+function stdio.ewrite(s: string) end
+
+--[=[
+    @within Stdio
+    @tag must_use
+
+    Reads the entire input from stdin.
+
+    @return The input from stdin
+]=]
+function stdio.readToEnd(): string
+	return nil :: any
+end
+
+return stdio
diff --git a/.lune/.lune-defs/task.luau b/.lune/.lune-defs/task.luau
new file mode 100644
index 0000000..81bdc2f
--- /dev/null
+++ b/.lune/.lune-defs/task.luau
@@ -0,0 +1,99 @@
+--[=[
+	@class Task
+
+	Built-in task scheduler & thread spawning
+
+	### Example usage
+
+	```lua
+	local task = require("@lune/task")
+
+	-- Waiting for a certain amount of time
+	task.wait(1)
+	print("Waited for one second")
+
+	-- Running a task after a given amount of time
+	task.delay(2, function()
+		print("Ran after two seconds")
+	end)
+
+	-- Spawning a new task that runs concurrently
+	task.spawn(function()
+		print("Running instantly")
+		task.wait(1)
+		print("One second passed inside the task")
+	end)
+
+	print("Running after task.spawn yields")
+	```
+]=]
+local task = {}
+
+--[=[
+	@within Task
+
+	Stops a currently scheduled thread from resuming.
+
+	@param thread The thread to cancel
+]=]
+function task.cancel(thread: thread) end
+
+--[=[
+	@within Task
+
+	Defers a thread or function to run at the end of the current task queue.
+
+	@param functionOrThread The function or thread to defer
+	@return The thread that will be deferred
+]=]
+function task.defer<T...>(functionOrThread: thread | (T...) -> ...any, ...: T...): thread
+	return nil :: any
+end
+
+--[=[
+	@within Task
+
+	Delays a thread or function to run after `duration` seconds.
+
+	@param functionOrThread The function or thread to delay
+	@return The thread that will be delayed
+]=]
+function task.delay<T...>(
+	duration: number,
+	functionOrThread: thread | (T...) -> ...any,
+	...: T...
+): thread
+	return nil :: any
+end
+
+--[=[
+	@within Task
+
+	Instantly runs a thread or function.
+
+	If the spawned task yields, the thread that spawned the task
+	will resume, letting the spawned task run in the background.
+
+	@param functionOrThread The function or thread to spawn
+	@return The thread that was spawned
+]=]
+function task.spawn<T...>(functionOrThread: thread | (T...) -> ...any, ...: T...): thread
+	return nil :: any
+end
+
+--[=[
+	@within Task
+
+	Waits for *at least* the given amount of time.
+
+	The minimum wait time possible when using `task.wait` is limited by the underlying OS sleep implementation.
+	For most systems this means `task.wait` is accurate down to about 5 milliseconds or less.
+
+	@param duration The amount of time to wait
+	@return The exact amount of time waited
+]=]
+function task.wait(duration: number?): number
+	return nil :: any
+end
+
+return task
diff --git a/.zed/settings.json b/.zed/settings.json
new file mode 100644
index 0000000..4b4a979
--- /dev/null
+++ b/.zed/settings.json
@@ -0,0 +1,39 @@
+// Folder-specific settings
+//
+// For a full list of overridable settings, and general information on folder-specific settings,
+// see the documentation: https://zed.dev/docs/configuring-zed#folder-specific-settings
+{
+	"lsp": {
+		"luau-lsp": {
+			"settings": {
+				"luau-lsp": {
+					"completion": {
+						"imports": {
+							"enabled": true,
+							"suggestServices": true,
+							"suggestRequires": false
+						}
+					},
+					"require": {
+						"mode": "relativeToFile"
+					}
+				},
+				"ext": {
+					"roblox": {
+						"enabled": false
+					},
+					"fflags": {
+						"override": {},
+						"sync": true,
+						"enable_by_default": false
+					}
+				}
+			}
+		}
+	},
+	"file_types": {
+		"Luau": [
+			"lua"
+		]
+	}
+}
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..ca73154
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 marked
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..d9abee7
--- /dev/null
+++ b/README.md
@@ -0,0 +1,24 @@
+# jecs-nightly
+
+Nightly releases of jecs.
+
+All versions are in the format of `<latest-jecs-version>-nightly.timestamp`.</br>
+Timestamps are in the ISO 8601 format (`YYYYmmddThhmmssZ`).
+
+## Warning
+
+Don't let it auto update. If you're gonna use it, lock it to a specific version (`scope/name@=VERSION`), otherwise it'll ruin your day in the future.
+
+## Installation (pesde)
+
+1. `pesde add marked/jecs_nightly`
+2. `pesde install`
+
+## Installation (wally)
+
+1. Add `jecs-nightly` to your manifest:
+    ```toml
+    [dependencies]
+    jecs = "mark-marks/jecs-nightly@LATEST" # Replace LATEST with the latest version
+    ```
+2. `wally install`
diff --git a/jecs/.luaurc b/jecs/.luaurc
new file mode 100644
index 0000000..07221f7
--- /dev/null
+++ b/jecs/.luaurc
@@ -0,0 +1,8 @@
+{
+    "aliases": {
+        "jecs": "jecs",
+        "testkit": "test/testkit",
+        "mirror": "mirror"
+    },
+    "languageMode": "strict"
+}
diff --git a/jecs/CHANGELOG.md b/jecs/CHANGELOG.md
new file mode 100644
index 0000000..52f87cc
--- /dev/null
+++ b/jecs/CHANGELOG.md
@@ -0,0 +1,205 @@
+# Jecs Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog][kac], and this project adheres to
+[Semantic Versioning][semver].
+
+[kac]: https://keepachangelog.com/en/1.1.0/
+[semver]: https://semver.org/spec/v2.0.0.html
+
+## [Unreleased]
+
+-   `[world]`:
+    -   16% faster `world:get`
+    -   `world:has` no longer typechecks components after the 8th one.
+-   `[typescript]`
+
+    -   Fixed Entity type to default to `undefined | unknown` instead of just `undefined`
+
+-   `[query]`:
+    -   Fixed bug where `world:clear` did not invoke `jecs.OnRemove` hooks
+    -   Changed `query.__iter` to drain on iteration
+        -   It will initialize once wherever you left iteration off at last time
+    -   Changed `query:iter` to restart the iterator
+    -   Removed `query:drain` and `query:next`
+        -   If you want to get individual results outside of a for-loop, you need to call `query:iter` to initialize the iterator and then call the iterator function manually
+        ```lua
+        local it = world:query(A, B, C):iter()
+        local entity, a, b, c = it()
+        entity, a, b, c = it() -- get next results
+        ```
+-   `[world`
+    -   Fixed a bug with `world:clear` not invoking `jecs.OnRemove` hooks
+-   `[typescript]`:
+    -   Changed pair to accept generics
+    -   Improved handling of Tags
+
+## [0.3.2] - 2024-10-01
+
+-   `[world]`:
+    -   Changed `world:cleanup` to traverse a header type for graph edges. (Edit)
+    -   Fixed a regression that occurred when you call `world:set` following a `world:remove` using the same component
+    -   Remove explicit error in JECS_DEBUG for `world:target` when not applying an index parameter
+-   `[typescript]` :
+    -   Fixed `world.set` with NoInfer<T>
+
+## [0.3.1] - 2024-10-01
+
+-   `[world]`:
+    -   Added an index parameter to `world:target`
+    -   Added a way to change the components limit via `_G.JECS_HI_COMPONENT_ID`
+        -   Set it to whatever number you want but try to make it as close to the number of components you will use as possible
+        -   Make sure to set this before importing jecs or else it will not work
+    -   Added debug mode, enable via setting `_G.JECS_DEBUG` to true
+        -   Make sure to set this before importing jecs or else it will not work
+    -   Added `world:cleanup` which is called to cleanup empty archetypes manually
+    -   Changed `world:delete` to delete archetypes that are dependent on the passed entity
+    -   Changed `world:delete` to delete entity's children before the entity to prevent cycles
+-   `[query]`:
+    -   Fixed the iterator to not drain by default
+-   `[typescript]`
+    -   Fixed entry point of the package.json file to be `src` rather than `src/init`
+    -   Fixed `query.next` returning a query object whereas it would be expected to return a tuple containing the entity and the corresponding component values
+    -   Exported `query.archetypes`
+    -   Changed `pair` to return a number instead of an entity
+        -   Preventing direct usage of a pair as an entity while still allowing it to be used as a component
+    -   Exported built-in components `ChildOf` and `Name`
+    -   Exported `world.parent`
+
+## [0.2.10] - 2024-09-07
+
+-   `[world]`:
+    -   Improved performance for hooks
+    -   Changed `world:set` to be idempotent when setting tags
+-   `[traits]`:
+    -   Added cleanup condition `jecs.OnDelete` for when the entity or component is deleted
+    -   Added cleanup action `jecs.Remove` which removes instances of the specified (component) id from all entities
+        -   This is the default cleanup action
+    -   Added component trait `jecs.Tag` which allows for zero-cost components used as tags
+        -   Setting data to a component with this trait will do nothing
+-   `[luau]`:
+    -   Exported `world:contains()`
+    -   Exported `query:drain()`
+    -   Exported `Query`
+    -   Improved types for the hook `OnAdd`, `OnSet`, `OnRemove`
+    -   Changed functions to accept any ID including pairs in type parameters
+        -   Applies to `world:add()`, `world:set()`, `world:remove()`, `world:get()`, `world:has()` and `world:query()`
+        -   New exported type `Id<T = nil> = Entity<T> | Pair`
+    -   Changed `world:contains()` to return a `boolean` instead of an entity which may or may not exist
+    -   Fixed `world:has()` to take the correct parameters
+
+## [0.2.2] - 2024-07-07
+
+### Added
+
+-   Added `query:replace(function(...T) return ...U end)` for replacing components in place
+    -   Method is fast pathed to replace the data to the components for each corresponding entity
+
+### Changed
+
+-   Iterator now goes backwards instead to prevent common cases of iterator invalidation
+
+## [0.2.1] - 2024-07-06
+
+### Added
+
+-   Added `jecs.Component` built-in component which will be added to ids created with `world:component()`.
+    -   Used to find every component id with `query(jecs.Component)
+
+## [0.2.0] - 2024-07-03
+
+### Added
+
+-   Added `world:parent(entity)` and `jecs.ChildOf` respectively as first class citizen for building parent-child relationships.
+    -   Give a parent to an entity with `world:add($source, pair(ChildOf, $target))`
+    -   Use `world:parent(entity)` to find the target of the relationship
+-   Added user-facing Luau types
+
+### Changed
+
+-   Improved iteration speeds 20-40% by manually indexing rather than using `next()` :scream:
+
+## [0.1.1] - 2024-05-19
+
+### Added
+
+-   Added `world:clear(entity)` for removing the components to the corresponding entity
+-   Added Typescript Types
+
+## [0.1.0] - 2024-05-13
+
+### Changed
+
+-   Optimized iterator
+
+## [0.1.0-rc.6] - 2024-05-13
+
+### Added
+
+-   Added a `jecs.Wildcard` term
+    -   it lets you query any partially matched pairs
+
+## [0.1.0-rc.5] - 2024-05-10
+
+### Added
+
+-   Added Entity relationships for creating logical connections between entities
+-   Added `world:__iter method` which allows for iteration over the whole world to get every entity
+    -   used for reconciling whole worlds such as via replication, saving/loading, etc
+-   Added `world:add(entity, component)` which adds a component to the entity
+    -   it is an idempotent function, so calling it twice and in any order should be fine
+
+### Fixed
+
+-   Fixed component overriding when in disorder
+    -   Previously setting the components in different order results in it overriding component data because it incorrectly mapped the index of the column. So it took the index from the source archetype rather than the destination archetype
+
+## [0.0.0-prototype.rc.3] - 2024-05-01
+
+### Added
+
+-   Added observers
+-   Added an arm to query `query:without()` for chaining invariants.
+
+### Changed
+
+-   Separates ranges for components and entity IDs.
+
+    -   IDs created with `world:component()` will promote array lookups rather than map lookups in the `component_index` which is a significant boost
+
+-   No longer caches the column pointers directly and instead the column indices which stay persistent even when data is reallocated during swap-removals
+    -   This was an issue with the iterator being invalidated when you move an entity to a different archetype.
+
+### Fixedhttps://github.com/Ukendio/jecs/releases/tag/v0.0.0-prototype.rc.3
+
+-   Fixed a bug where changing an existing component would be slow because it was always appending changing the row of the entity record
+    -   The fix dramatically improves times where it is basically down to just the speed of setting a field in a table
+
+## [0.0.0-prototype.rc.2] - 2024-04-26
+
+### Changed
+
+-   Optimized the creation of the query
+    -   It will now finds the smallest archetype map to iterate over
+-   Optimized the query iterator
+
+    -   It will now populates iterator with columns for faster indexing
+
+-   Renamed the insertion method from world:add to world:set to better reflect what it does.
+
+## [0.0.0-prototype.rc.2] - 2024-04-23
+
+-   Initial release
+
+[unreleased]: https://github.com/ukendio/jecs/compare/v0.0.0.0-prototype.rc.2...HEAD
+[0.2.2]: https://github.com/ukendio/jecs/releases/tag/v0.2.2
+[0.2.1]: https://github.com/ukendio/jecs/releases/tag/v0.2.1
+[0.2.0]: https://github.com/ukendio/jecs/releases/tag/v0.2.0
+[0.1.1]: https://github.com/ukendio/jecs/releases/tag/v0.1.1
+[0.1.0]: https://github.com/ukendio/jecs/releases/tag/v0.1.0
+[0.1.0-rc.6]: https://github.com/ukendio/jecs/releases/tag/v0.1.0-rc.6
+[0.1.0-rc.5]: https://github.com/ukendio/jecs/releases/tag/v0.1.0-rc.5
+[0.0.0-prototype-rc.3]: https://github.com/ukendio/jecs/releases/tag/v0.0.0-prototype.rc.3
+[0.0.0-prototype.rc.2]: https://github.com/ukendio/jecs/releases/tag/v0.0.0-prototype.rc.2
+[0.0.0-prototype-rc.1]: https://github.com/ukendio/jecs/releases/tag/v0.0.0-prototype.rc.1
diff --git a/jecs/LICENSE b/jecs/LICENSE
new file mode 100644
index 0000000..605eef8
--- /dev/null
+++ b/jecs/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 jecs authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/jecs/README.md b/jecs/README.md
new file mode 100644
index 0000000..d44797c
--- /dev/null
+++ b/jecs/README.md
@@ -0,0 +1,64 @@
+<p align="center">
+  <img src="assets/image-5.png" width=35%/>
+</p>
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg?style=for-the-badge)](LICENSE) [![Wally](https://img.shields.io/github/v/tag/ukendio/jecs?&style=for-the-badge)](https://wally.run/package/ukendio/jecs)
+
+Just a stupidly fast Entity Component System
+
+-   [Entity Relationships](https://ajmmertens.medium.com/building-games-in-ecs-with-entity-relationships-657275ba2c6c) as first class citizens
+-   Iterate 800,000 entities at 60 frames per second
+-   Type-safe [Luau](https://luau-lang.org/) API
+-   Zero-dependency package
+-   Optimized for column-major operations
+-   Cache friendly [archetype/SoA](https://ajmmertens.medium.com/building-an-ecs-2-archetypes-and-vectorization-fe21690805f9) storage
+-   Rigorously [unit tested](https://github.com/Ukendio/jecs/actions/workflows/ci.yaml) for stability
+
+### Example
+
+```lua
+local world = jecs.World.new()
+local pair = jecs.pair
+
+-- These components and functions are actually already builtin
+-- but have been illustrated for demonstration purposes
+local ChildOf = world:component()
+local Name = world:component()
+
+local function parent(entity)
+    return world:target(entity, ChildOf)
+end
+local function getName(entity)
+    return world:get(entity, Name)
+end
+
+local alice = world:entity()
+world:set(alice, Name, "alice")
+
+local bob = world:entity()
+world:add(bob, pair(ChildOf, alice))
+world:set(bob, Name, "bob")
+
+local sara = world:entity()
+world:add(sara, pair(ChildOf, alice))
+world:set(sara, Name, "sara")
+
+print(getName(parent(sara)))
+
+for e in world:query(pair(ChildOf, alice)) do
+    print(getName(e), "is the child of alice")
+end
+
+-- Output
+-- "alice"
+-- bob is the child of alice
+-- sara is the child of alice
+```
+
+21,000 entities 125 archetypes 4 random components queried.
+![Queries](assets/image-3.png)
+Can be found under /benches/visual/query.luau
+
+Inserting 8 components to an entity and updating them over 50 times.
+![Insertions](assets/image-4.png)
+Can be found under /benches/visual/insertions.luau
diff --git a/jecs/default.project.json b/jecs/default.project.json
new file mode 100644
index 0000000..d4531a0
--- /dev/null
+++ b/jecs/default.project.json
@@ -0,0 +1,6 @@
+{
+	"name": "jecs",
+	"tree": {
+		"$path": "jecs.luau"
+	}
+}
diff --git a/jecs/jecs.luau b/jecs/jecs.luau
new file mode 100644
index 0000000..e53d366
--- /dev/null
+++ b/jecs/jecs.luau
@@ -0,0 +1,2564 @@
+--!optimize 2
+--!native
+--!strict
+--draft 4
+
+type i53 = number
+type i24 = number
+
+type Ty = { i53 }
+type ArchetypeId = number
+
+type Column = { any }
+
+type Map<K, V> = { [K]: V }
+
+type GraphEdge = {
+	from: Archetype,
+	to: Archetype?,
+	id: number,
+	prev: GraphEdge?,
+	next: GraphEdge?,
+}
+
+type GraphEdges = Map<i53, GraphEdge>
+
+type GraphNode = {
+	add: GraphEdges,
+	remove: GraphEdges,
+	refs: GraphEdge,
+}
+
+export type Archetype = {
+	id: number,
+	types: Ty,
+	type: string,
+	entities: { number },
+	columns: { Column },
+	records: { number },
+	counts: { number },
+} & GraphNode
+
+export type Record = {
+	archetype: Archetype,
+	row: number,
+	dense: i24,
+}
+
+type IdRecord = {
+	columns: { number },
+	counts: { number },
+	flags: number,
+	size: number,
+	hooks: {
+		on_add: ((entity: i53) -> ())?,
+		on_set: ((entity: i53, data: any) -> ())?,
+		on_remove: ((entity: i53) -> ())?,
+	},
+}
+
+type ComponentIndex = Map<i53, IdRecord>
+
+type Archetypes = { [ArchetypeId]: Archetype }
+
+type ArchetypeDiff = {
+	added: Ty,
+	removed: Ty,
+}
+
+type EntityIndex = {
+	dense_array: Map<i24, i53>,
+	sparse_array: Map<i53, Record>,
+	alive_count: number,
+	max_id: number,
+}
+
+local HI_COMPONENT_ID = _G.__JECS_HI_COMPONENT_ID or 256
+-- stylua: ignore start
+local EcsOnAdd =                    HI_COMPONENT_ID +  1
+local EcsOnRemove =                 HI_COMPONENT_ID +  2
+local EcsOnSet =                    HI_COMPONENT_ID +  3
+local EcsWildcard =                 HI_COMPONENT_ID +  4
+local EcsChildOf =                  HI_COMPONENT_ID +  5
+local EcsComponent =                HI_COMPONENT_ID +  6
+local EcsOnDelete =                 HI_COMPONENT_ID +  7
+local EcsOnDeleteTarget =           HI_COMPONENT_ID +  8
+local EcsDelete =                   HI_COMPONENT_ID +  9
+local EcsRemove =                   HI_COMPONENT_ID + 10
+local EcsName =                     HI_COMPONENT_ID + 11
+local EcsOnArchetypeCreate =        HI_COMPONENT_ID + 12
+local EcsOnArchetypeDelete =        HI_COMPONENT_ID + 13
+local EcsRest =                     HI_COMPONENT_ID + 14
+
+local ECS_PAIR_FLAG =                                0x8
+local ECS_ID_FLAGS_MASK =                           0x10
+local ECS_ENTITY_MASK =              bit32.lshift(1, 24)
+local ECS_GENERATION_MASK =          bit32.lshift(1, 16)
+
+local ECS_ID_DELETE =                        0b0000_0001
+local ECS_ID_IS_TAG =                        0b0000_0010
+local ECS_ID_HAS_ON_ADD =                    0b0000_0100
+local ECS_ID_HAS_ON_SET =                    0b0000_1000
+local ECS_ID_HAS_ON_REMOVE =                 0b0001_0000
+local ECS_ID_MASK =                          0b0000_0000
+-- stylua: ignore end
+local NULL_ARRAY = table.freeze({}) :: Column
+
+local function FLAGS_ADD(is_pair: boolean): number
+	local flags = 0x0
+
+	if is_pair then
+		flags = bit32.bor(flags, ECS_PAIR_FLAG) -- HIGHEST bit in the ID.
+	end
+	if false then
+		flags = bit32.bor(flags, 0x4) -- Set the second flag to true
+	end
+	if false then
+		flags = bit32.bor(flags, 0x2) -- Set the third flag to true
+	end
+	if false then
+		flags = bit32.bor(flags, 0x1) -- LAST BIT in the ID.
+	end
+
+	return flags
+end
+
+local function ECS_COMBINE(source: number, target: number): i53
+	return (source * 268435456) + (target * ECS_ID_FLAGS_MASK)
+end
+
+local function ECS_IS_PAIR(e: number): boolean
+	return if e > ECS_ENTITY_MASK then (e % ECS_ID_FLAGS_MASK) // ECS_PAIR_FLAG ~= 0 else false
+end
+
+-- HIGH 24 bits LOW 24 bits
+local function ECS_GENERATION(e: i53): i24
+	return if e > ECS_ENTITY_MASK then (e // ECS_ID_FLAGS_MASK) % ECS_GENERATION_MASK else 0
+end
+
+local function ECS_GENERATION_INC(e: i53)
+	if e > ECS_ENTITY_MASK then
+		local flags = e // ECS_ID_FLAGS_MASK
+		local id = flags // ECS_ENTITY_MASK
+		local generation = flags % ECS_GENERATION_MASK
+
+		local next_gen = generation + 1
+		if next_gen > ECS_GENERATION_MASK then
+			return id
+		end
+
+		return ECS_COMBINE(id, next_gen)
+	end
+	return ECS_COMBINE(e, 1)
+end
+
+-- FIRST gets the high ID
+local function ECS_ENTITY_T_HI(e: i53): i24
+	return if e > ECS_ENTITY_MASK then (e // ECS_ID_FLAGS_MASK) % ECS_ENTITY_MASK else e
+end
+
+-- SECOND
+local function ECS_ENTITY_T_LO(e: i53): i24
+	return if e > ECS_ENTITY_MASK then (e // ECS_ID_FLAGS_MASK) // ECS_ENTITY_MASK else e
+end
+
+local function _STRIP_GENERATION(e: i53): i24
+	return ECS_ENTITY_T_LO(e)
+end
+
+local function ECS_PAIR(pred: i53, obj: i53): i53
+	return ECS_COMBINE(ECS_ENTITY_T_LO(pred), ECS_ENTITY_T_LO(obj)) + FLAGS_ADD(--[[isPair]] true) :: i53
+end
+
+local function entity_index_try_get_any(entity_index: EntityIndex, entity: number): Record?
+	local r = entity_index.sparse_array[ECS_ENTITY_T_LO(entity)]
+	if not r then
+		return nil
+	end
+
+	if not r or r.dense == 0 then
+		return nil
+	end
+
+	return r
+end
+
+local function entity_index_try_get(entity_index: EntityIndex, entity: number): Record?
+	local r = entity_index_try_get_any(entity_index, entity)
+	if r then
+		local r_dense = r.dense
+		if r_dense > entity_index.alive_count then
+			return nil
+		end
+		if entity_index.dense_array[r_dense] ~= entity then
+			return nil
+		end
+	end
+	return r
+end
+
+local function entity_index_try_get_fast(entity_index: EntityIndex, entity: number): Record?
+	local r = entity_index.sparse_array[ECS_ENTITY_T_LO(entity)]
+	if r then
+		if entity_index.dense_array[r.dense] ~= entity then
+			return nil
+		end
+	end
+	return r
+end
+
+local function entity_index_get_alive(index: EntityIndex, e: i24): i53
+	local r = entity_index_try_get_any(index, e)
+	if r then
+		return index.dense_array[r.dense]
+	end
+	return 0
+end
+
+local function entity_index_is_alive(entity_index: EntityIndex, entity: number)
+	return entity_index_try_get(entity_index, entity) ~= nil
+end
+
+local function entity_index_new_id(entity_index: EntityIndex): i53
+	local dense_array = entity_index.dense_array
+	local alive_count = entity_index.alive_count
+	if alive_count ~= #dense_array then
+		alive_count += 1
+		entity_index.alive_count = alive_count
+		local id = dense_array[alive_count]
+		return id
+	end
+
+	local id = entity_index.max_id + 1
+	entity_index.max_id = id
+	alive_count += 1
+	entity_index.alive_count = alive_count
+	dense_array[alive_count] = id
+	entity_index.sparse_array[id] = { dense = alive_count } :: Record
+
+	return id
+end
+
+-- ECS_PAIR_FIRST, gets the relationship target / obj / HIGH bits
+local function ecs_pair_first(world, e)
+	return entity_index_get_alive(world.entity_index, ECS_ENTITY_T_LO(e))
+end
+
+-- ECS_PAIR_SECOND gets the relationship / pred / LOW bits
+local function ecs_pair_second(world, e)
+	return entity_index_get_alive(world.entity_index, ECS_ENTITY_T_HI(e))
+end
+
+local function query_match(query, archetype: Archetype)
+	local records = archetype.records
+	local with = query.filter_with
+
+	for _, id in with do
+		if not records[id] then
+			return false
+		end
+	end
+
+	local without = query.filter_without
+	if without then
+		for _, id in without do
+			if records[id] then
+				return false
+			end
+		end
+	end
+
+	return true
+end
+
+local function find_observers(world: World, event, component): { Observer }?
+	local cache = world.observable[event]
+	if not cache then
+		return nil
+	end
+	return cache[component] :: any
+end
+
+local function archetype_move(entity_index: EntityIndex, to: Archetype, dst_row: i24, from: Archetype, src_row: i24)
+	local src_columns = from.columns
+	local dst_columns = to.columns
+	local dst_entities = to.entities
+	local src_entities = from.entities
+
+	local last = #src_entities
+	local id_types = from.types
+	local records = to.records
+
+	for i, column in src_columns do
+		if column == NULL_ARRAY then
+			continue
+		end
+		-- Retrieves the new column index from the source archetype's record from each component
+		-- We have to do this because the columns are tightly packed and indexes may not correspond to each other.
+		local tr = records[id_types[i]]
+
+		-- Sometimes target column may not exist, e.g. when you remove a component.
+		if tr then
+			dst_columns[tr][dst_row] = column[src_row]
+		end
+
+		-- If the entity is the last row in the archetype then swapping it would be meaningless.
+		if src_row ~= last then
+			-- Swap rempves columns to ensure there are no holes in the archetype.
+			column[src_row] = column[last]
+		end
+		column[last] = nil
+	end
+
+	local moved = #src_entities
+
+	-- Move the entity from the source to the destination archetype.
+	-- Because we have swapped columns we now have to update the records
+	-- corresponding to the entities' rows that were swapped.
+	local e1 = src_entities[src_row]
+	local e2 = src_entities[moved]
+
+	if src_row ~= moved then
+		src_entities[src_row] = e2
+	end
+
+	src_entities[moved] = nil :: any
+	dst_entities[dst_row] = e1
+
+	local sparse_array = entity_index.sparse_array
+
+	local record1 = sparse_array[ECS_ENTITY_T_LO(e1)]
+	local record2 = sparse_array[ECS_ENTITY_T_LO(e2)]
+	record1.row = dst_row
+	record2.row = src_row
+end
+
+local function archetype_append(entity: number, archetype: Archetype): number
+	local entities = archetype.entities
+	local length = #entities + 1
+	entities[length] = entity
+	return length
+end
+
+local function new_entity(entity: i53, record: Record, archetype: Archetype): Record
+	local row = archetype_append(entity, archetype)
+	record.archetype = archetype
+	record.row = row
+	return record
+end
+
+local function entity_move(entity_index: EntityIndex, entity: i53, record: Record, to: Archetype)
+	local sourceRow = record.row
+	local from = record.archetype
+	local dst_row = archetype_append(entity, to)
+	archetype_move(entity_index, to, dst_row, from, sourceRow)
+	record.archetype = to
+	record.row = dst_row
+end
+
+local function hash(arr: { number }): string
+	return table.concat(arr, "_")
+end
+
+local function fetch(id, records: { number }, columns: { Column }, row: number): any
+	local tr = records[id]
+
+	if not tr then
+		return nil
+	end
+
+	return columns[tr][row]
+end
+
+local function world_get(world: World, entity: i53, a: i53, b: i53?, c: i53?, d: i53?, e: i53?): ...any
+	local record = entity_index_try_get_fast(world.entity_index, entity)
+	if not record then
+		return nil
+	end
+
+	local archetype = record.archetype
+	if not archetype then
+		return nil
+	end
+
+	local records = archetype.records
+	local columns = archetype.columns
+	local row = record.row
+
+	local va = fetch(a, records, columns, row)
+
+	if not b then
+		return va
+	elseif not c then
+		return va, fetch(b, records, columns, row)
+	elseif not d then
+		return va, fetch(b, records, columns, row), fetch(c, records, columns, row)
+	elseif not e then
+		return va, fetch(b, records, columns, row), fetch(c, records, columns, row), fetch(d, records, columns, row)
+	else
+		error("args exceeded")
+	end
+end
+
+local function world_get_one_inline(world: World, entity: i53, id: i53): any
+	local record = entity_index_try_get_fast(world.entity_index, entity)
+	if not record then
+		return nil
+	end
+
+	local archetype = record.archetype
+	if not archetype then
+		return nil
+	end
+
+	local tr = archetype.records[id]
+	if not tr then
+		return nil
+	end
+	return archetype.columns[tr][record.row]
+end
+
+local function world_has_one_inline(world: World, entity: number, id: i53): boolean
+	local record = entity_index_try_get_fast(world.entity_index, entity)
+	if not record then
+		return false
+	end
+
+	local archetype = record.archetype
+	if not archetype then
+		return false
+	end
+
+	local records = archetype.records
+
+	return records[id] ~= nil
+end
+
+local function world_has(world: World, entity: number, ...: i53): boolean
+	local record = entity_index_try_get_fast(world.entity_index, entity)
+	if not record then
+		return false
+	end
+
+	local archetype = record.archetype
+	if not archetype then
+		return false
+	end
+
+	local records = archetype.records
+
+	for i = 1, select("#", ...) do
+		if not records[select(i, ...)] then
+			return false
+		end
+	end
+
+	return true
+end
+
+local function world_target(world: World, entity: i53, relation: i24, index: number?): i24?
+	local nth = index or 0
+	local record = entity_index_try_get_fast(world.entity_index, entity)
+	if not record then
+		return nil
+	end
+
+	local archetype = record.archetype
+	if not archetype then
+		return nil
+	end
+
+	local idr = world.component_index[ECS_PAIR(relation, EcsWildcard)]
+	if not idr then
+		return nil
+	end
+
+	local archetype_id = archetype.id
+	local count = idr.counts[archetype.id]
+	if not count then
+		return nil
+	end
+
+	if nth >= count then
+		nth = nth + count + 1
+	end
+
+	local tr = idr.columns[archetype_id]
+
+	nth = archetype.types[nth + tr]
+
+	if not nth then
+		return nil
+	end
+
+	return ecs_pair_second(world, nth)
+end
+
+local function ECS_ID_IS_WILDCARD(e: i53): boolean
+	local first = ECS_ENTITY_T_HI(e)
+	local second = ECS_ENTITY_T_LO(e)
+	return first == EcsWildcard or second == EcsWildcard
+end
+
+local function id_record_ensure(world: World, id: number): IdRecord
+	local component_index = world.component_index
+	local idr: IdRecord = component_index[id]
+
+	if not idr then
+		local flags = ECS_ID_MASK
+		local relation = id
+		local is_pair = ECS_IS_PAIR(id)
+		if is_pair then
+			relation = ecs_pair_first(world, id)
+		end
+
+		local cleanup_policy = world_target(world, relation, EcsOnDelete, 0)
+		local cleanup_policy_target = world_target(world, relation, EcsOnDeleteTarget, 0)
+
+		local has_delete = false
+
+		if cleanup_policy == EcsDelete or cleanup_policy_target == EcsDelete then
+			has_delete = true
+		end
+
+		local on_add, on_set, on_remove = world_get(world, relation, EcsOnAdd, EcsOnSet, EcsOnRemove)
+
+		local is_tag = not world_has_one_inline(world, relation, EcsComponent)
+
+		if is_tag and is_pair then
+			is_tag = not world_has_one_inline(world, ecs_pair_second(world, id), EcsComponent)
+		end
+
+		flags = bit32.bor(
+			flags,
+			if on_add then ECS_ID_HAS_ON_ADD else 0,
+			if on_remove then ECS_ID_HAS_ON_REMOVE else 0,
+			if on_set then ECS_ID_HAS_ON_SET else 0,
+			if has_delete then ECS_ID_DELETE else 0,
+			if is_tag then ECS_ID_IS_TAG else 0
+		)
+
+		idr = {
+			size = 0,
+			columns = {},
+			counts = {},
+			flags = flags,
+			hooks = {
+				on_add = on_add,
+				on_set = on_set,
+				on_remove = on_remove,
+			},
+		}
+
+		component_index[id] = idr
+	end
+
+	return idr
+end
+
+local function archetype_append_to_records(
+	idr: IdRecord,
+	archetype: Archetype,
+	id: number,
+	index: number
+)
+	local archetype_id = archetype.id
+	local archetype_records = archetype.records
+	local archetype_counts = archetype.counts
+	local idr_columns = idr.columns
+	local idr_counts = idr.counts
+	local tr = idr_columns[archetype_id]
+	if not tr then
+		idr_columns[archetype_id] = index
+		idr_counts[archetype_id] = 1
+
+		archetype_records[id] = index
+		archetype_counts[id] = 1
+	else
+		local max_count = idr_counts[archetype_id] + 1
+		idr_counts[archetype_id] = max_count
+		archetype_counts[id] = max_count
+	end
+end
+
+local function archetype_create(world: World, id_types: { i24 }, ty, prev: i53?): Archetype
+	local archetype_id = (world.max_archetype_id :: number) + 1
+	world.max_archetype_id = archetype_id
+
+	local length = #id_types
+	local columns = (table.create(length) :: any) :: { Column }
+
+	local records: { number } = {}
+	local counts: {number} = {}
+
+	local archetype: Archetype = {
+		columns = columns,
+		entities = {},
+		id = archetype_id,
+		records = records,
+		counts = counts,
+		type = ty,
+		types = id_types,
+
+		add = {},
+		remove = {},
+		refs = {} :: GraphEdge,
+	}
+
+	for i, componentId in id_types do
+		local idr = id_record_ensure(world, componentId)
+		archetype_append_to_records(idr, archetype, componentId, i)
+
+		if ECS_IS_PAIR(componentId) then
+			local relation = ecs_pair_first(world, componentId)
+			local object = ecs_pair_second(world, componentId)
+
+			local r = ECS_PAIR(relation, EcsWildcard)
+			local idr_r = id_record_ensure(world, r)
+			archetype_append_to_records(idr_r, archetype, r, i)
+
+			local t = ECS_PAIR(EcsWildcard, object)
+			local idr_t = id_record_ensure(world, t)
+			archetype_append_to_records(idr_t, archetype, t, i)
+		end
+
+		if bit32.band(idr.flags, ECS_ID_IS_TAG) == 0 then
+			columns[i] = {}
+		else
+			columns[i] = NULL_ARRAY
+		end
+	end
+
+	for id in records do
+		local observer_list = find_observers(world, EcsOnArchetypeCreate, id)
+		if not observer_list then
+			continue
+		end
+		for _, observer in observer_list do
+			if query_match(observer.query, archetype) then
+				observer.callback(archetype)
+			end
+		end
+	end
+
+	world.archetype_index[ty] = archetype
+	world.archetypes[archetype_id] = archetype
+
+	return archetype
+end
+
+local function world_entity(world: World): i53
+	return entity_index_new_id(world.entity_index)
+end
+
+local function world_parent(world: World, entity: i53)
+	return world_target(world, entity, EcsChildOf, 0)
+end
+
+local function archetype_ensure(world: World, id_types): Archetype
+	if #id_types < 1 then
+		return world.ROOT_ARCHETYPE
+	end
+
+	local ty = hash(id_types)
+	local archetype = world.archetype_index[ty]
+	if archetype then
+		return archetype
+	end
+
+	return archetype_create(world, id_types, ty)
+end
+
+local function find_insert(id_types: { i53 }, toAdd: i53): number
+	for i, id in id_types do
+		if id == toAdd then
+			return -1
+		end
+		if id > toAdd then
+			return i
+		end
+	end
+	return #id_types + 1
+end
+
+local function find_archetype_with(world: World, node: Archetype, id: i53): Archetype
+	local id_types = node.types
+	-- Component IDs are added incrementally, so inserting and sorting
+	-- them each time would be expensive. Instead this insertion sort can find the insertion
+	-- point in the types array.
+
+	local dst = table.clone(node.types) :: { i53 }
+	local at = find_insert(id_types, id)
+	if at == -1 then
+		-- If it finds a duplicate, it just means it is the same archetype so it can return it
+		-- directly instead of needing to hash types for a lookup to the archetype.
+		return node
+	end
+	table.insert(dst, at, id)
+
+	return archetype_ensure(world, dst)
+end
+
+local function find_archetype_without(world: World, node: Archetype, id: i53): Archetype
+	local id_types = node.types
+	local at = table.find(id_types, id)
+	if at == nil then
+		return node
+	end
+
+	local dst = table.clone(id_types)
+	table.remove(dst, at)
+
+	return archetype_ensure(world, dst)
+end
+
+local function archetype_init_edge(archetype: Archetype, edge: GraphEdge, id: i53, to: Archetype)
+	edge.from = archetype
+	edge.to = to
+	edge.id = id
+end
+
+local function archetype_ensure_edge(world, edges: GraphEdges, id): GraphEdge
+	local edge = edges[id]
+	if not edge then
+		edge = {} :: GraphEdge
+		edges[id] = edge
+	end
+
+	return edge
+end
+
+local function init_edge_for_add(world, archetype: Archetype, edge: GraphEdge, id, to: Archetype)
+	archetype_init_edge(archetype, edge, id, to)
+	archetype_ensure_edge(world, archetype.add, id)
+	if archetype ~= to then
+		local to_refs = to.refs
+		local next_edge = to_refs.next
+
+		to_refs.next = edge
+		edge.prev = to_refs
+		edge.next = next_edge
+
+		if next_edge then
+			next_edge.prev = edge
+		end
+	end
+end
+
+local function init_edge_for_remove(world: World, archetype: Archetype, edge: GraphEdge, id: number, to: Archetype)
+	archetype_init_edge(archetype, edge, id, to)
+	archetype_ensure_edge(world, archetype.remove, id)
+	if archetype ~= to then
+		local to_refs = to.refs
+		local prev_edge = to_refs.prev
+
+		to_refs.prev = edge
+		edge.next = to_refs
+		edge.prev = prev_edge
+
+		if prev_edge then
+			prev_edge.next = edge
+		end
+	end
+end
+
+local function create_edge_for_add(world: World, node: Archetype, edge: GraphEdge, id: i53): Archetype
+	local to = find_archetype_with(world, node, id)
+	init_edge_for_add(world, node, edge, id, to)
+	return to
+end
+
+local function create_edge_for_remove(world: World, node: Archetype, edge: GraphEdge, id: i53): Archetype
+	local to = find_archetype_without(world, node, id)
+	init_edge_for_remove(world, node, edge, id, to)
+	return to
+end
+
+local function archetype_traverse_add(world: World, id: i53, from: Archetype): Archetype
+	from = from or world.ROOT_ARCHETYPE
+	local edge = archetype_ensure_edge(world, from.add, id)
+
+	local to = edge.to
+	if not to then
+		to = create_edge_for_add(world, from, edge, id)
+	end
+
+	return to :: Archetype
+end
+
+local function archetype_traverse_remove(world: World, id: i53, from: Archetype): Archetype
+	from = from or world.ROOT_ARCHETYPE
+
+	local edge = archetype_ensure_edge(world, from.remove, id)
+
+	local to = edge.to
+	if not to then
+		to = create_edge_for_remove(world, from, edge, id)
+	end
+
+	return to :: Archetype
+end
+
+local function world_add(world: World, entity: i53, id: i53): ()
+	local entity_index = world.entity_index
+	local record = entity_index_try_get_fast(entity_index, entity)
+	if not record then
+		return
+	end
+
+	local from = record.archetype
+	local to = archetype_traverse_add(world, id, from)
+	if from == to then
+		return
+	end
+	if from then
+		entity_move(entity_index, entity, record, to)
+	else
+		if #to.types > 0 then
+			new_entity(entity, record, to)
+		end
+	end
+
+	local idr = world.component_index[id]
+	local on_add = idr.hooks.on_add
+
+	if on_add then
+		on_add(entity)
+	end
+end
+
+local function world_set(world: World, entity: i53, id: i53, data: unknown): ()
+	local entity_index = world.entity_index
+	local record = entity_index_try_get_fast(entity_index, entity)
+	if not record then
+		return
+	end
+
+	local from: Archetype = record.archetype
+	local to: Archetype = archetype_traverse_add(world, id, from)
+	local idr = world.component_index[id]
+	local idr_hooks = idr.hooks
+
+	if from == to then
+		-- If the archetypes are the same it can avoid moving the entity
+		-- and just set the data directly.
+		local tr = to.records[id]
+		local column = from.columns[tr]
+		column[record.row] = data
+		local on_set = idr_hooks.on_set
+		if on_set then
+			on_set(entity, data)
+		end
+
+		return
+	end
+
+	if from then
+		-- If there was a previous archetype, then the entity needs to move the archetype
+		entity_move(entity_index, entity, record, to)
+	else
+		if #to.types > 0 then
+			-- When there is no previous archetype it should create the archetype
+			new_entity(entity, record, to)
+		end
+	end
+
+	local on_add = idr_hooks.on_add
+	if on_add then
+		on_add(entity)
+	end
+
+	local tr = to.records[id]
+	local column = to.columns[tr]
+
+	column[record.row] = data
+
+	local on_set = idr_hooks.on_set
+	if on_set then
+		on_set(entity, data)
+	end
+end
+
+local function world_component(world: World): i53
+	local id = (world.max_component_id :: number) + 1
+	if id > HI_COMPONENT_ID then
+		-- IDs are partitioned into ranges because component IDs are not nominal,
+		-- so it needs to error when IDs intersect into the entity range.
+		error("Too many components, consider using world:entity() instead to create components.")
+	end
+	world.max_component_id = id
+
+	return id
+end
+
+local function world_remove(world: World, entity: i53, id: i53)
+	local entity_index = world.entity_index
+	local record = entity_index_try_get_fast(entity_index, entity)
+	if not record then
+		return
+	end
+	local from = record.archetype
+
+	if not from then
+		return
+	end
+	local to = archetype_traverse_remove(world, id, from)
+
+	if from ~= to then
+		local idr = world.component_index[id]
+		local on_remove = idr.hooks.on_remove
+		if on_remove then
+			on_remove(entity)
+		end
+
+		entity_move(entity_index, entity, record, to)
+	end
+end
+
+local function archetype_fast_delete_last(columns: { Column }, column_count: number, types: { i53 }, entity: i53)
+	for i, column in columns do
+		if column ~= NULL_ARRAY then
+			column[column_count] = nil
+		end
+	end
+end
+
+local function archetype_fast_delete(columns: { Column }, column_count: number, row, types, entity)
+	for i, column in columns do
+		if column ~= NULL_ARRAY then
+			column[row] = column[column_count]
+			column[column_count] = nil
+		end
+	end
+end
+
+local function archetype_delete(world: World, archetype: Archetype, row: number, destruct: boolean?)
+	local entity_index = world.entity_index
+	local component_index = world.component_index
+	local columns = archetype.columns
+	local id_types = archetype.types
+	local entities = archetype.entities
+	local column_count = #entities
+	local last = #entities
+	local move = entities[last]
+	-- We assume first that the entity is the last in the archetype
+	local delete = move
+
+	if row ~= last then
+		local record_to_move = entity_index_try_get_any(entity_index, move)
+		if record_to_move then
+			record_to_move.row = row
+		end
+
+		delete = entities[row]
+		entities[row] = move
+	end
+
+	for _, id in id_types do
+		local idr = component_index[id]
+		local on_remove = idr.hooks.on_remove
+		if on_remove then
+			on_remove(delete)
+		end
+	end
+
+	entities[last] = nil :: any
+
+	if row == last then
+		archetype_fast_delete_last(columns, column_count, id_types, delete)
+	else
+		archetype_fast_delete(columns, column_count, row, id_types, delete)
+	end
+end
+
+local function world_clear(world: World, entity: i53)
+	--TODO: use sparse_get (stashed)
+	local record = entity_index_try_get(world.entity_index, entity)
+	if not record then
+		return
+	end
+
+	local archetype = record.archetype
+	local row = record.row
+
+	if archetype then
+		-- In the future should have a destruct mode for
+		-- deleting archetypes themselves. Maybe requires recycling
+		archetype_delete(world, archetype, row)
+	end
+
+	record.archetype = nil :: any
+	record.row = nil :: any
+end
+
+local function archetype_disconnect_edge(edge: GraphEdge)
+	local edge_next = edge.next
+	local edge_prev = edge.prev
+	if edge_next then
+		edge_next.prev = edge_prev
+	end
+	if edge_prev then
+		edge_prev.next = edge_next
+	end
+end
+
+local function archetype_remove_edge(edges: Map<i53, GraphEdge>, id: i53, edge: GraphEdge)
+	archetype_disconnect_edge(edge)
+	edges[id] = nil :: any
+end
+
+local function archetype_clear_edges(archetype: Archetype)
+	local add: GraphEdges = archetype.add
+	local remove: GraphEdges = archetype.remove
+	local node_refs = archetype.refs
+	for id, edge in add do
+		archetype_disconnect_edge(edge)
+		add[id] = nil :: any
+	end
+	for id, edge in remove do
+		archetype_disconnect_edge(edge)
+		remove[id] = nil :: any
+	end
+
+	local cur = node_refs.next
+	while cur do
+		local edge = cur :: GraphEdge
+		local next_edge = edge.next
+		archetype_remove_edge(edge.from.add, edge.id, edge)
+		cur = next_edge
+	end
+
+	cur = node_refs.prev
+	while cur do
+		local edge: GraphEdge = cur
+		local next_edge = edge.prev
+		archetype_remove_edge(edge.from.remove, edge.id, edge)
+		cur = next_edge
+	end
+
+	node_refs.next = nil
+	node_refs.prev = nil
+end
+
+local function archetype_destroy(world: World, archetype: Archetype)
+	if archetype == world.ROOT_ARCHETYPE then
+		return
+	end
+
+	local component_index = world.component_index
+	archetype_clear_edges(archetype)
+	local archetype_id = archetype.id
+	world.archetypes[archetype_id] = nil :: any
+	world.archetype_index[archetype.type] = nil :: any
+	local records = archetype.records
+
+	for id in records do
+		local observer_list = find_observers(world, EcsOnArchetypeDelete, id)
+		if not observer_list then
+			continue
+		end
+		for _, observer in observer_list do
+			if query_match(observer.query, archetype) then
+				observer.callback(archetype)
+			end
+		end
+	end
+
+	for id in records do
+		local idr = component_index[id]
+		idr.columns[archetype_id] = nil :: any
+		idr.counts[archetype_id] = nil
+		idr.size -= 1
+		records[id] = nil :: any
+		if idr.size == 0 then
+			component_index[id] = nil :: any
+		end
+	end
+end
+
+local function world_cleanup(world: World)
+	local archetypes = world.archetypes
+
+	for _, archetype in archetypes do
+		if #archetype.entities == 0 then
+			archetype_destroy(world, archetype)
+		end
+	end
+
+	local new_archetypes = table.create(#archetypes) :: { Archetype }
+	local new_archetype_map = {}
+
+	for index, archetype in archetypes do
+		new_archetypes[index] = archetype
+		new_archetype_map[archetype.type] = archetype
+	end
+
+	world.archetypes = new_archetypes
+	world.archetype_index = new_archetype_map
+end
+
+local world_delete: (world: World, entity: i53, destruct: boolean?) -> ()
+do
+	function world_delete(world: World, entity: i53, destruct: boolean?)
+		local entity_index = world.entity_index
+		local record = entity_index_try_get(entity_index, entity)
+		if not record then
+			return
+		end
+
+		local archetype = record.archetype
+		local row = record.row
+
+		if archetype then
+			-- In the future should have a destruct mode for
+			-- deleting archetypes themselves. Maybe requires recycling
+			archetype_delete(world, archetype, row, destruct)
+		end
+
+		local delete = entity
+		local component_index = world.component_index
+		local archetypes: Archetypes = world.archetypes
+		local tgt = ECS_PAIR(EcsWildcard, delete)
+		local idr_t = component_index[tgt]
+		local idr = component_index[delete]
+
+		if idr then
+			local flags = idr.flags
+			if bit32.band(flags, ECS_ID_DELETE) ~= 0 then
+				for archetype_id in idr.columns do
+					local idr_archetype = archetypes[archetype_id]
+
+					local entities = idr_archetype.entities
+					local n = #entities
+					for i = n, 1, -1 do
+						world_delete(world, entities[i])
+					end
+
+					archetype_destroy(world, idr_archetype)
+				end
+			else
+				for archetype_id in idr.columns do
+					local idr_archetype = archetypes[archetype_id]
+					local entities = idr_archetype.entities
+					local n = #entities
+					for i = n, 1, -1 do
+						world_remove(world, entities[i], delete)
+					end
+
+					archetype_destroy(world, idr_archetype)
+				end
+			end
+		end
+
+		local sparse_array = entity_index.sparse_array
+		local dense_array = entity_index.dense_array
+
+		if idr_t then
+			for archetype_id in idr_t.columns do
+				local children = {}
+				local idr_t_archetype = archetypes[archetype_id]
+
+				local idr_t_types = idr_t_archetype.types
+
+				for _, child in idr_t_archetype.entities do
+					table.insert(children, child)
+				end
+
+				local n = #children
+
+				for _, id in idr_t_types do
+					if not ECS_IS_PAIR(id) then
+						continue
+					end
+					local object = ecs_pair_second(world, id)
+					if object == delete then
+						local id_record = component_index[id]
+						local flags = id_record.flags
+						local flags_delete_mask: number = bit32.band(flags, ECS_ID_DELETE)
+						if flags_delete_mask ~= 0 then
+							for i = n, 1, -1 do
+								world_delete(world, children[i])
+							end
+							break
+						else
+							local on_remove = id_record.hooks.on_remove
+							local to = archetype_traverse_remove(world, id, idr_t_archetype)
+							local empty = #to.types == 0
+							for i = n, 1, -1 do
+								local child = children[i]
+								if on_remove then
+									on_remove(child)
+								end
+								local r = sparse_array[ECS_ENTITY_T_LO(child)]
+								if not empty then
+									entity_move(entity_index, child, r, to)
+								end
+							end
+						end
+					end
+				end
+
+				archetype_destroy(world, idr_t_archetype)
+			end
+		end
+
+		local index_of_deleted_entity = record.dense
+		local index_of_last_alive_entity = entity_index.alive_count
+		entity_index.alive_count = index_of_last_alive_entity - 1
+
+		local last_alive_entity = dense_array[index_of_last_alive_entity]
+		local r_swap = entity_index_try_get_any(entity_index, last_alive_entity) :: Record
+		r_swap.dense = index_of_deleted_entity
+		record.archetype = nil :: any
+		record.row = nil :: any
+		record.dense = index_of_last_alive_entity
+
+		dense_array[index_of_deleted_entity] = last_alive_entity
+		dense_array[index_of_last_alive_entity] = ECS_GENERATION_INC(entity)
+	end
+end
+
+local function world_contains(world: World, entity): boolean
+	return entity_index_is_alive(world.entity_index, entity)
+end
+
+local function NOOP() end
+
+local function ARM(query, ...)
+	return query
+end
+
+local EMPTY_LIST = {}
+local EMPTY_QUERY = {
+	__iter = function()
+		return NOOP
+	end,
+	iter = function()
+		return NOOP
+	end,
+	with = ARM,
+	without = ARM,
+	archetypes = function()
+		return EMPTY_LIST
+	end,
+}
+
+setmetatable(EMPTY_QUERY, EMPTY_QUERY)
+
+type QueryInner = {
+	compatible_archetypes: { Archetype },
+	ids: { i53 },
+	filter_with: { i53 },
+	filter_without: { i53 },
+	next: () -> (number, ...any),
+	world: World,
+}
+
+local function query_iter_init(query: QueryInner): () -> (number, ...any)
+	local world_query_iter_next
+
+	local compatible_archetypes = query.compatible_archetypes
+	local lastArchetype = 1
+	local archetype = compatible_archetypes[1]
+	if not archetype then
+		return NOOP :: () -> (number, ...any)
+	end
+	local columns = archetype.columns
+	local entities = archetype.entities
+	local i = #entities
+	local records = archetype.records
+
+	local ids = query.ids
+	local A, B, C, D, E, F, G, H, I = unpack(ids)
+	local a: Column, b: Column, c: Column, d: Column
+	local e: Column, f: Column, g: Column, h: Column
+
+	if not B then
+		a = columns[records[A]]
+	elseif not C then
+		a = columns[records[A]]
+		b = columns[records[B]]
+	elseif not D then
+		a = columns[records[A]]
+		b = columns[records[B]]
+		c = columns[records[C]]
+	elseif not E then
+		a = columns[records[A]]
+		b = columns[records[B]]
+		c = columns[records[C]]
+		d = columns[records[D]]
+	elseif not F then
+		a = columns[records[A]]
+		b = columns[records[B]]
+		c = columns[records[C]]
+		d = columns[records[D]]
+		e = columns[records[E]]
+	elseif not G then
+		a = columns[records[A]]
+		b = columns[records[B]]
+		c = columns[records[C]]
+		d = columns[records[D]]
+		e = columns[records[E]]
+		f = columns[records[F]]
+	elseif not H then
+		a = columns[records[A]]
+		b = columns[records[B]]
+		c = columns[records[C]]
+		d = columns[records[D]]
+		e = columns[records[E]]
+		f = columns[records[F]]
+		g = columns[records[G]]
+	elseif not I then
+		a = columns[records[A]]
+		b = columns[records[B]]
+		c = columns[records[C]]
+		d = columns[records[D]]
+		e = columns[records[E]]
+		f = columns[records[F]]
+		g = columns[records[G]]
+		h = columns[records[H]]
+	end
+
+	if not B then
+		function world_query_iter_next(): any
+			local entity = entities[i]
+			while entity == nil do
+				lastArchetype += 1
+				archetype = compatible_archetypes[lastArchetype]
+				if not archetype then
+					return nil
+				end
+
+				entities = archetype.entities
+				i = #entities
+				if i == 0 then
+					continue
+				end
+				entity = entities[i]
+				columns = archetype.columns
+				records = archetype.records
+				a = columns[records[A]]
+			end
+
+			local row = i
+			i -= 1
+
+			return entity, a[row]
+		end
+	elseif not C then
+		function world_query_iter_next(): any
+			local entity = entities[i]
+			while entity == nil do
+				lastArchetype += 1
+				archetype = compatible_archetypes[lastArchetype]
+				if not archetype then
+					return nil
+				end
+
+				entities = archetype.entities
+				i = #entities
+				if i == 0 then
+					continue
+				end
+				entity = entities[i]
+				columns = archetype.columns
+				records = archetype.records
+				a = columns[records[A]]
+				b = columns[records[B]]
+			end
+
+			local row = i
+			i -= 1
+
+			return entity, a[row], b[row]
+		end
+	elseif not D then
+		function world_query_iter_next(): any
+			local entity = entities[i]
+			while entity == nil do
+				lastArchetype += 1
+				archetype = compatible_archetypes[lastArchetype]
+				if not archetype then
+					return nil
+				end
+
+				entities = archetype.entities
+				i = #entities
+				if i == 0 then
+					continue
+				end
+				entity = entities[i]
+				columns = archetype.columns
+				records = archetype.records
+				a = columns[records[A]]
+				b = columns[records[B]]
+				c = columns[records[C]]
+			end
+
+			local row = i
+			i -= 1
+
+			return entity, a[row], b[row], c[row]
+		end
+	elseif not E then
+		function world_query_iter_next(): any
+			local entity = entities[i]
+			while entity == nil do
+				lastArchetype += 1
+				archetype = compatible_archetypes[lastArchetype]
+				if not archetype then
+					return nil
+				end
+
+				entities = archetype.entities
+				i = #entities
+				if i == 0 then
+					continue
+				end
+				entity = entities[i]
+				columns = archetype.columns
+				records = archetype.records
+				a = columns[records[A]]
+				b = columns[records[B]]
+				c = columns[records[C]]
+				d = columns[records[D]]
+			end
+
+			local row = i
+			i -= 1
+
+			return entity, a[row], b[row], c[row], d[row]
+		end
+	elseif not F then
+		function world_query_iter_next(): any
+			local entity = entities[i]
+			while entity == nil do
+				lastArchetype += 1
+				archetype = compatible_archetypes[lastArchetype]
+				if not archetype then
+					return nil
+				end
+
+				entities = archetype.entities
+				i = #entities
+				if i == 0 then
+					continue
+				end
+				entity = entities[i]
+				columns = archetype.columns
+				records = archetype.records
+				a = columns[records[A]]
+				b = columns[records[B]]
+				c = columns[records[C]]
+				d = columns[records[D]]
+				e = columns[records[E]]
+			end
+
+			local row = i
+			i -= 1
+
+			return entity, a[row], b[row], c[row], d[row], e[row]
+		end
+	elseif not G then
+		function world_query_iter_next(): any
+			local entity = entities[i]
+			while entity == nil do
+				lastArchetype += 1
+				archetype = compatible_archetypes[lastArchetype]
+				if not archetype then
+					return nil
+				end
+
+				entities = archetype.entities
+				i = #entities
+				if i == 0 then
+					continue
+				end
+				entity = entities[i]
+				columns = archetype.columns
+				records = archetype.records
+				a = columns[records[A]]
+				b = columns[records[B]]
+				c = columns[records[C]]
+				d = columns[records[D]]
+				e = columns[records[E]]
+				f = columns[records[F]]
+			end
+
+			local row = i
+			i -= 1
+
+			return entity, a[row], b[row], c[row], d[row], e[row], f[row]
+		end
+	elseif not H then
+		function world_query_iter_next(): any
+			local entity = entities[i]
+			while entity == nil do
+				lastArchetype += 1
+				archetype = compatible_archetypes[lastArchetype]
+				if not archetype then
+					return nil
+				end
+
+				entities = archetype.entities
+				i = #entities
+				if i == 0 then
+					continue
+				end
+				entity = entities[i]
+				columns = archetype.columns
+				records = archetype.records
+				a = columns[records[A]]
+				b = columns[records[B]]
+				c = columns[records[C]]
+				d = columns[records[D]]
+				e = columns[records[E]]
+				f = columns[records[F]]
+				g = columns[records[G]]
+			end
+
+			local row = i
+			i -= 1
+
+			return entity, a[row], b[row], c[row], d[row], e[row], f[row], g[row]
+		end
+	elseif not I then
+		function world_query_iter_next(): any
+			local entity = entities[i]
+			while entity == nil do
+				lastArchetype += 1
+				archetype = compatible_archetypes[lastArchetype]
+				if not archetype then
+					return nil
+				end
+
+				entities = archetype.entities
+				i = #entities
+				if i == 0 then
+					continue
+				end
+				entity = entities[i]
+				columns = archetype.columns
+				records = archetype.records
+				a = columns[records[A]]
+				b = columns[records[B]]
+				c = columns[records[C]]
+				d = columns[records[D]]
+				e = columns[records[E]]
+				f = columns[records[F]]
+				g = columns[records[G]]
+				h = columns[records[H]]
+			end
+
+			local row = i
+			i -= 1
+
+			return entity, a[row], b[row], c[row], d[row], e[row], f[row], g[row], h[row]
+		end
+	else
+		local output = {}
+		function world_query_iter_next(): any
+			local entity = entities[i]
+			while entity == nil do
+				lastArchetype += 1
+				archetype = compatible_archetypes[lastArchetype]
+				if not archetype then
+					return nil
+				end
+
+				entities = archetype.entities
+				i = #entities
+				if i == 0 then
+					continue
+				end
+				entity = entities[i]
+				columns = archetype.columns
+				records = archetype.records
+			end
+
+			local row = i
+			i -= 1
+
+			for j, id in ids do
+				output[j] = columns[records[id]][row]
+			end
+
+			return entity, unpack(output)
+		end
+	end
+
+	query.next = world_query_iter_next
+	return world_query_iter_next
+end
+
+local function query_iter(query): () -> (number, ...any)
+	local query_next = query.next
+	if not query_next then
+		query_next = query_iter_init(query)
+	end
+	return query_next
+end
+
+local function query_without(query: QueryInner, ...: i53)
+	local without = { ... }
+	query.filter_without = without
+	local compatible_archetypes = query.compatible_archetypes
+	for i = #compatible_archetypes, 1, -1 do
+		local archetype = compatible_archetypes[i]
+		local records = archetype.records
+		local matches = true
+
+		for _, id in without do
+			if records[id] then
+				matches = false
+				break
+			end
+		end
+
+		if matches then
+			continue
+		end
+
+		local last = #compatible_archetypes
+		if last ~= i then
+			compatible_archetypes[i] = compatible_archetypes[last]
+		end
+		compatible_archetypes[last] = nil :: any
+	end
+
+	return query :: any
+end
+
+local function query_with(query: QueryInner, ...: i53)
+	local compatible_archetypes = query.compatible_archetypes
+	local with = { ... }
+	query.filter_with = with
+
+	for i = #compatible_archetypes, 1, -1 do
+		local archetype = compatible_archetypes[i]
+		local records = archetype.records
+		local matches = true
+
+		for _, id in with do
+			if not records[id] then
+				matches = false
+				break
+			end
+		end
+
+		if matches then
+			continue
+		end
+
+		local last = #compatible_archetypes
+		if last ~= i then
+			compatible_archetypes[i] = compatible_archetypes[last]
+		end
+		compatible_archetypes[last] = nil :: any
+	end
+
+	return query :: any
+end
+
+-- Meant for directly iterating over archetypes to minimize
+-- function call overhead. Should not be used unless iterating over
+-- hundreds of thousands of entities in bulk.
+local function query_archetypes(query)
+	return query.compatible_archetypes
+end
+
+local function query_cached(query: QueryInner)
+	local with = query.filter_with
+	local ids = query.ids
+	if with then
+		table.move(ids, 1, #ids, #with + 1, with)
+	else
+		query.filter_with = ids
+	end
+
+	local compatible_archetypes = query.compatible_archetypes
+	local lastArchetype = 1
+
+	local A, B, C, D, E, F, G, H, I = unpack(ids)
+	local a: Column, b: Column, c: Column, d: Column
+	local e: Column, f: Column, g: Column, h: Column
+
+	local world_query_iter_next
+	local columns: { Column }
+	local entities: { number }
+	local i: number
+	local archetype: Archetype
+	local records: { number }
+	local archetypes = query.compatible_archetypes
+
+	local world = query.world :: { observable: Observable }
+	-- Only need one observer for EcsArchetypeCreate and EcsArchetypeDelete respectively
+	-- because the event will be emitted for all components of that Archetype.
+	local observable = world.observable :: Observable
+	local on_create_action = observable[EcsOnArchetypeCreate]
+	if not on_create_action then
+		on_create_action = {}
+		observable[EcsOnArchetypeCreate] = on_create_action
+	end
+	local query_cache_on_create = on_create_action[A]
+	if not query_cache_on_create then
+		query_cache_on_create = {}
+		on_create_action[A] = query_cache_on_create
+	end
+
+	local on_delete_action = observable[EcsOnArchetypeDelete]
+	if not on_delete_action then
+		on_delete_action = {}
+		observable[EcsOnArchetypeDelete] = on_delete_action
+	end
+	local query_cache_on_delete = on_delete_action[A]
+	if not query_cache_on_delete then
+		query_cache_on_delete = {}
+		on_delete_action[A] = query_cache_on_delete
+	end
+
+	local function on_create_callback(archetype)
+		table.insert(archetypes, archetype)
+	end
+
+	local function on_delete_callback(archetype)
+		local i = table.find(archetypes, archetype)  :: number
+		local n = #archetypes
+		archetypes[i] = archetypes[n]
+		archetypes[n] = nil
+	end
+
+	local observer_for_create = { query = query, callback = on_create_callback }
+	local observer_for_delete = { query = query, callback = on_delete_callback }
+
+	table.insert(query_cache_on_create, observer_for_create)
+	table.insert(query_cache_on_delete, observer_for_delete)
+
+	local function cached_query_iter()
+		lastArchetype = 1
+		archetype = compatible_archetypes[lastArchetype]
+		if not archetype then
+			return NOOP
+		end
+		entities = archetype.entities
+		i = #entities
+		records = archetype.records
+		columns = archetype.columns
+		if not B then
+			a = columns[records[A]]
+		elseif not C then
+			a = columns[records[A]]
+			b = columns[records[B]]
+		elseif not D then
+			a = columns[records[A]]
+			b = columns[records[B]]
+			c = columns[records[C]]
+		elseif not E then
+			a = columns[records[A]]
+			b = columns[records[B]]
+			c = columns[records[C]]
+			d = columns[records[D]]
+		elseif not F then
+			a = columns[records[A]]
+			b = columns[records[B]]
+			c = columns[records[C]]
+			d = columns[records[D]]
+			e = columns[records[E]]
+		elseif not G then
+			a = columns[records[A]]
+			b = columns[records[B]]
+			c = columns[records[C]]
+			d = columns[records[D]]
+			e = columns[records[E]]
+			f = columns[records[F]]
+		elseif not H then
+			a = columns[records[A]]
+			b = columns[records[B]]
+			c = columns[records[C]]
+			d = columns[records[D]]
+			e = columns[records[E]]
+			f = columns[records[F]]
+			g = columns[records[G]]
+		elseif not I then
+			a = columns[records[A]]
+			b = columns[records[B]]
+			c = columns[records[C]]
+			d = columns[records[D]]
+			e = columns[records[E]]
+			f = columns[records[F]]
+			g = columns[records[G]]
+			h = columns[records[H]]
+		end
+
+		return world_query_iter_next
+	end
+
+	if not B then
+		function world_query_iter_next(): any
+			local entity = entities[i]
+			while entity == nil do
+				lastArchetype += 1
+				archetype = compatible_archetypes[lastArchetype]
+				if not archetype then
+					return nil
+				end
+
+				entities = archetype.entities
+				i = #entities
+				if i == 0 then
+					continue
+				end
+				entity = entities[i]
+				columns = archetype.columns
+				records = archetype.records
+				a = columns[records[A]]
+			end
+
+			local row = i
+			i -= 1
+
+			return entity, a[row]
+		end
+	elseif not C then
+		function world_query_iter_next(): any
+			local entity = entities[i]
+			while entity == nil do
+				lastArchetype += 1
+				archetype = compatible_archetypes[lastArchetype]
+				if not archetype then
+					return nil
+				end
+
+				entities = archetype.entities
+				i = #entities
+				if i == 0 then
+					continue
+				end
+				entity = entities[i]
+				columns = archetype.columns
+				records = archetype.records
+				a = columns[records[A]]
+				b = columns[records[B]]
+			end
+
+			local row = i
+			i -= 1
+
+			return entity, a[row], b[row]
+		end
+	elseif not D then
+		function world_query_iter_next(): any
+			local entity = entities[i]
+			while entity == nil do
+				lastArchetype += 1
+				archetype = compatible_archetypes[lastArchetype]
+				if not archetype then
+					return nil
+				end
+
+				entities = archetype.entities
+				i = #entities
+				if i == 0 then
+					continue
+				end
+				entity = entities[i]
+				columns = archetype.columns
+				records = archetype.records
+				a = columns[records[A]]
+				b = columns[records[B]]
+				c = columns[records[C]]
+			end
+
+			local row = i
+			i -= 1
+
+			return entity, a[row], b[row], c[row]
+		end
+	elseif not E then
+		function world_query_iter_next(): any
+			local entity = entities[i]
+			while entity == nil do
+				lastArchetype += 1
+				archetype = compatible_archetypes[lastArchetype]
+				if not archetype then
+					return nil
+				end
+
+				entities = archetype.entities
+				i = #entities
+				if i == 0 then
+					continue
+				end
+				entity = entities[i]
+				columns = archetype.columns
+				records = archetype.records
+				a = columns[records[A]]
+				b = columns[records[B]]
+				c = columns[records[C]]
+				d = columns[records[D]]
+			end
+
+			local row = i
+			i -= 1
+
+			return entity, a[row], b[row], c[row], d[row]
+		end
+	elseif not F then
+		function world_query_iter_next(): any
+			local entity = entities[i]
+			while entity == nil do
+				lastArchetype += 1
+				archetype = compatible_archetypes[lastArchetype]
+				if not archetype then
+					return nil
+				end
+
+				entities = archetype.entities
+				i = #entities
+				if i == 0 then
+					continue
+				end
+				entity = entities[i]
+				columns = archetype.columns
+				records = archetype.records
+				a = columns[records[A]]
+				b = columns[records[B]]
+				c = columns[records[C]]
+				d = columns[records[D]]
+				e = columns[records[E]]
+			end
+
+			local row = i
+			i -= 1
+
+			return entity, a[row], b[row], c[row], d[row], e[row]
+		end
+	elseif not G then
+		function world_query_iter_next(): any
+			local entity = entities[i]
+			while entity == nil do
+				lastArchetype += 1
+				archetype = compatible_archetypes[lastArchetype]
+				if not archetype then
+					return nil
+				end
+
+				entities = archetype.entities
+				i = #entities
+				if i == 0 then
+					continue
+				end
+				entity = entities[i]
+				columns = archetype.columns
+				records = archetype.records
+				a = columns[records[A]]
+				b = columns[records[B]]
+				c = columns[records[C]]
+				d = columns[records[D]]
+				e = columns[records[E]]
+				f = columns[records[F]]
+			end
+
+			local row = i
+			i -= 1
+
+			return entity, a[row], b[row], c[row], d[row], e[row], f[row]
+		end
+	elseif not H then
+		function world_query_iter_next(): any
+			local entity = entities[i]
+			while entity == nil do
+				lastArchetype += 1
+				archetype = compatible_archetypes[lastArchetype]
+				if not archetype then
+					return nil
+				end
+
+				entities = archetype.entities
+				i = #entities
+				if i == 0 then
+					continue
+				end
+				entity = entities[i]
+				columns = archetype.columns
+				records = archetype.records
+				a = columns[records[A]]
+				b = columns[records[B]]
+				c = columns[records[C]]
+				d = columns[records[D]]
+				e = columns[records[E]]
+				f = columns[records[F]]
+				g = columns[records[G]]
+			end
+
+			local row = i
+			i -= 1
+
+			return entity, a[row], b[row], c[row], d[row], e[row], f[row], g[row]
+		end
+	elseif not I then
+		function world_query_iter_next(): any
+			local entity = entities[i]
+			while entity == nil do
+				lastArchetype += 1
+				archetype = compatible_archetypes[lastArchetype]
+				if not archetype then
+					return nil
+				end
+
+				entities = archetype.entities
+				i = #entities
+				if i == 0 then
+					continue
+				end
+				entity = entities[i]
+				columns = archetype.columns
+				records = archetype.records
+				a = columns[records[A]]
+				b = columns[records[B]]
+				c = columns[records[C]]
+				d = columns[records[D]]
+				e = columns[records[E]]
+				f = columns[records[F]]
+				g = columns[records[G]]
+				h = columns[records[H]]
+			end
+
+			local row = i
+			i -= 1
+
+			return entity, a[row], b[row], c[row], d[row], e[row], f[row], g[row], h[row]
+		end
+	else
+		local queryOutput = {}
+		function world_query_iter_next(): any
+			local entity = entities[i]
+			while entity == nil do
+				lastArchetype += 1
+				archetype = compatible_archetypes[lastArchetype]
+				if not archetype then
+					return nil
+				end
+
+				entities = archetype.entities
+				i = #entities
+				if i == 0 then
+					continue
+				end
+				entity = entities[i]
+				columns = archetype.columns
+				records = archetype.records
+			end
+
+			local row = i
+			i -= 1
+
+			if not F then
+				return entity, a[row], b[row], c[row], d[row], e[row]
+			elseif not G then
+				return entity, a[row], b[row], c[row], d[row], e[row], f[row]
+			elseif not H then
+				return entity, a[row], b[row], c[row], d[row], e[row], f[row], g[row]
+			elseif not I then
+				return entity, a[row], b[row], c[row], d[row], e[row], f[row], g[row], h[row]
+			end
+
+			for j, id in ids do
+				queryOutput[j] = columns[records[id]][row]
+			end
+
+			return entity, unpack(queryOutput)
+		end
+	end
+
+	local cached_query = query :: any
+	cached_query.archetypes = query_archetypes
+	cached_query.__iter = cached_query_iter
+	cached_query.iter = cached_query_iter
+	setmetatable(cached_query, cached_query)
+	return cached_query
+end
+
+local Query = {}
+Query.__index = Query
+Query.__iter = query_iter
+Query.iter = query_iter_init
+Query.without = query_without
+Query.with = query_with
+Query.archetypes = query_archetypes
+Query.cached = query_cached
+
+local function world_query(world: World, ...)
+	local compatible_archetypes = {}
+	local length = 0
+
+	local ids = { ... }
+
+	local archetypes = world.archetypes
+
+	local idr: IdRecord?
+	local component_index = world.component_index
+
+	local q = setmetatable({
+		ids = ids,
+		compatible_archetypes = compatible_archetypes,
+		world = world,
+	}, Query)
+
+	for _, id in ids do
+		local map = component_index[id]
+		if not map then
+			return q
+		end
+
+		if idr == nil or map.size < idr.size then
+			idr = map
+		end
+	end
+
+	if not idr then
+		return q
+	end
+
+	for archetype_id in idr.columns do
+		local compatibleArchetype = archetypes[archetype_id]
+		if #compatibleArchetype.entities == 0 then
+			continue
+		end
+		local records = compatibleArchetype.records
+
+		local skip = false
+
+		for i, id in ids do
+			local tr = records[id]
+			if not tr then
+				skip = true
+				break
+			end
+		end
+
+		if skip then
+			continue
+		end
+
+		length += 1
+		compatible_archetypes[length] = compatibleArchetype
+	end
+
+	return q
+end
+
+local function world_each(world: World, id): () -> ()
+	local idr = world.component_index[id]
+	if not idr then
+		return NOOP
+	end
+
+	local idr_columns = idr.columns
+	local archetypes = world.archetypes
+	local archetype_id = next(idr_columns, nil) :: number
+	local archetype = archetypes[archetype_id]
+	if not archetype then
+		return NOOP
+	end
+
+	local entities = archetype.entities
+	local row = #entities
+
+	return function(): any
+		local entity = entities[row]
+		while not entity do
+			archetype_id = next(idr_columns, archetype_id) :: number
+			if not archetype_id then
+				return
+			end
+			archetype = archetypes[archetype_id]
+			entities = archetype.entities
+			row = #entities
+			entity = entities[row]
+		end
+		row -= 1
+		return entity
+	end
+end
+
+local function world_children(world, parent)
+	return world_each(world, ECS_PAIR(EcsChildOf, parent))
+end
+
+local World = {}
+World.__index = World
+
+World.entity = world_entity
+World.query = world_query
+World.remove = world_remove
+World.clear = world_clear
+World.delete = world_delete
+World.component = world_component
+World.add = world_add
+World.set = world_set
+World.get = world_get
+World.has = world_has
+World.target = world_target
+World.parent = world_parent
+World.contains = world_contains
+World.cleanup = world_cleanup
+World.each = world_each
+World.children = world_children
+
+if _G.__JECS_DEBUG then
+	local function dbg_info(n: number): any
+		return debug.info(n, "s")
+	end
+	local function throw(msg: string)
+		local s = 1
+		local root = dbg_info(1)
+		repeat
+			s += 1
+		until dbg_info(s) ~= root
+		if warn then
+			error(msg, s)
+		else
+			print(`[jecs] error: {msg}\n`)
+		end
+	end
+
+	local function ASSERT<T>(v: T, msg: string)
+		if v then
+			return
+		end
+		throw(msg)
+	end
+
+	local function get_name(world, id)
+		return world_get_one_inline(world, id, EcsName)
+	end
+
+	local function bname(world: World, id): string
+		local name: string
+		if ECS_IS_PAIR(id) then
+			local first = get_name(world, ecs_pair_first(world, id))
+			local second = get_name(world, ecs_pair_second(world, id))
+			name = `pair({first}, {second})`
+		else
+			return get_name(world, id)
+		end
+		if name then
+			return name
+		else
+			return `${id}`
+		end
+	end
+
+	local function ID_IS_TAG(world: World, id)
+		if ECS_IS_PAIR(id) then
+			id = ecs_pair_first(world, id)
+		end
+		return not world_has_one_inline(world, id, EcsComponent)
+	end
+
+	World.query = function(world: World, ...)
+		ASSERT((...), "Requires at least a single component")
+		return world_query(world, ...)
+	end
+
+	World.set = function(world: World, entity: i53, id: i53, value: any): ()
+		local is_tag = ID_IS_TAG(world, id)
+		if is_tag and value == nil then
+			local _1 = bname(world, entity)
+			local _2 = bname(world, id)
+			local why = "cannot set component value to nil"
+			throw(why)
+			return
+		elseif value ~= nil and is_tag then
+			local _1 = bname(world, entity)
+			local _2 = bname(world, id)
+			local why = `cannot set a component value because {_2} is a tag`
+			why ..= `\n[jecs] note: consider using "world:add({_1}, {_2})" instead`
+			throw(why)
+			return
+		end
+
+		world_set(world, entity, id, value)
+	end
+
+	World.add = function(world: World, entity: i53, id: i53, value: any)
+		if value ~= nil then
+			local _1 = bname(world, entity)
+			local _2 = bname(world, id)
+			throw("You provided a value when none was expected. " .. `Did you mean to use "world:add({_1}, {_2})"`)
+		end
+
+		world_add(world, entity, id)
+	end
+
+	World.get = function(world: World, entity: i53, ...)
+		local length = select("#", ...)
+		ASSERT(length < 5, "world:get does not support more than 4 components")
+		local _1
+		for i = 1, length do
+			local id = select(i, ...)
+			local id_is_tag = not world_has(world, id, EcsComponent)
+			if id_is_tag then
+				local name = get_name(world, id)
+				if not _1 then
+					_1 = get_name(world, entity)
+				end
+				throw(
+					`cannot get (#{i}) component {name} value because it is a tag.`
+						.. `\n[jecs] note: If this was intentional, use "world:has({_1}, {name}) instead"`
+				)
+			end
+		end
+
+		return world_get(world, entity, ...)
+	end
+end
+
+function World.new()
+	local entity_index: EntityIndex = {
+		dense_array = {} :: { [i24]: i53 },
+		sparse_array = {} :: { [i53]: Record },
+		alive_count = 0,
+		max_id = 0,
+	}
+	local self = setmetatable({
+		archetype_index = {} :: { [string]: Archetype },
+		archetypes = {} :: Archetypes,
+		component_index = {} :: ComponentIndex,
+		entity_index = entity_index,
+		ROOT_ARCHETYPE = (nil :: any) :: Archetype,
+
+		max_archetype_id = 0,
+		max_component_id = 0,
+
+		observable = {} :: Observable,
+	}, World) :: any
+
+	self.ROOT_ARCHETYPE = archetype_create(self, {}, "")
+
+	for i = 1, HI_COMPONENT_ID do
+		local e = entity_index_new_id(entity_index)
+		world_add(self, e, EcsComponent)
+	end
+
+	for i = HI_COMPONENT_ID + 1, EcsRest do
+		-- Initialize built-in components
+		entity_index_new_id(entity_index)
+	end
+
+	world_add(self, EcsName, EcsComponent)
+	world_add(self, EcsOnSet, EcsComponent)
+	world_add(self, EcsOnAdd, EcsComponent)
+	world_add(self, EcsOnRemove, EcsComponent)
+	world_add(self, EcsWildcard, EcsComponent)
+	world_add(self, EcsRest, EcsComponent)
+
+	world_set(self, EcsOnAdd, EcsName, "jecs.OnAdd")
+	world_set(self, EcsOnRemove, EcsName, "jecs.OnRemove")
+	world_set(self, EcsOnSet, EcsName, "jecs.OnSet")
+	world_set(self, EcsWildcard, EcsName, "jecs.Wildcard")
+	world_set(self, EcsChildOf, EcsName, "jecs.ChildOf")
+	world_set(self, EcsComponent, EcsName, "jecs.Component")
+	world_set(self, EcsOnDelete, EcsName, "jecs.OnDelete")
+	world_set(self, EcsOnDeleteTarget, EcsName, "jecs.OnDeleteTarget")
+	world_set(self, EcsDelete, EcsName, "jecs.Delete")
+	world_set(self, EcsRemove, EcsName, "jecs.Remove")
+	world_set(self, EcsName, EcsName, "jecs.Name")
+	world_set(self, EcsRest, EcsRest, "jecs.Rest")
+
+	world_add(self, EcsChildOf, ECS_PAIR(EcsOnDeleteTarget, EcsDelete))
+
+	return self
+end
+
+export type Entity<T = unknown> = {__T: T}
+
+export type Id<T = unknown> =
+    | Entity<T>
+    | Pair<Entity<T>, Entity>
+    | Pair<Entity, Entity<T>>
+    | Pair<Entity<T>, Entity<unknown>>
+
+export type Pair<P, O> = number & {
+    __P: P,
+    __O: O,
+}
+
+type Item<T...> = (self: Query<T...>) -> (Entity, T...)
+
+type Iter<T...> = (query: Query<T...>) -> () -> (Entity, T...)
+
+
+export type Query<T...> = typeof(setmetatable({}, {
+	__iter = (nil :: any) :: Iter<T...>,
+})) & {
+	iter: Iter<T...>,
+	with: (self: Query<T...>, ...Id) -> Query<T...>,
+	without: (self: Query<T...>, ...Id) -> Query<T...>,
+	archetypes: (self: Query<T...>) -> { Archetype },
+	cached: (self: Query<T...>) -> Query<T...>,
+}
+
+export type Observer = {
+ 	callback: (archetype: Archetype) -> (),
+   	query: QueryInner,
+}
+
+type Observable = {
+	[i53]: {
+		[i53]: {
+			{ Observer }
+		}
+	}
+}
+
+export type World = {
+	archetype_index: { [string]: Archetype },
+	archetypes: Archetypes,
+	component_index: ComponentIndex,
+	entity_index: EntityIndex,
+	ROOT_ARCHETYPE: Archetype,
+
+	max_component_id: number,
+	max_archetype_id: number,
+
+	observable: any,
+
+	--- Creates a new entity
+	entity: (self: World) -> Entity,
+	--- Creates a new entity located in the first 256 ids.
+	--- These should be used for static components for fast access.
+	component: <T>(self: World) -> Entity<T>,
+	--- Gets the target of an relationship. For example, when a user calls
+	--- `world:target(id, ChildOf(parent), 0)`, you will obtain the parent entity.
+	target: <T, U>(self: World, id: Entity<T>, relation: Entity<U>, index: number?) -> Entity?,
+	--- Deletes an entity and all it's related components and relationships.
+	delete: <T>(self: World, id: Entity<T>) -> (),
+
+	--- Adds a component to the entity with no value
+	add: <T, U>(self: World, id: Entity<T>, component: Id<U>) -> (),
+	--- Assigns a value to a component on the given entity
+	set: <T, U>(self: World, id: Entity<T>, component: Id<U>, data: U) -> (),
+
+	cleanup: (self: World) -> (),
+	-- Clears an entity from the world
+	clear: <T>(self: World, id: Entity<T>) -> (),
+	--- Removes a component from the given entity
+	remove: <T, U>(self: World, id: Entity<T>, component: Id<U>) -> (),
+	--- Retrieves the value of up to 4 components. These values may be nil.
+	get: (<T, A>(self: World, id: Entity<T>, Id<A>) -> A?)
+		& (<T, A, B>(self: World, id: Entity<T>, Id<A>, Id<B>) -> (A?, B?))
+		& (<T, A, B, C>(self: World, id: Entity<T>, Id<A>, Id<B>, Id<C>) -> (A?, B?, C?))
+		& <T, A, B, C, D>(self: World, id: Entity<T>, Id<A>, Id<B>, Id<C>, Id<D>) -> (A?, B?, C?, D?),
+
+	--- Returns whether the entity has the ID.
+	has: (<T, U>(self: World, entity: Entity<T>, ...Id<U>) -> boolean)
+		& (<T, U, V>(self: World, entity: Entity<T>, Id<U>, Id<V>) -> boolean)
+		& (<T, U, V, W>(self: World, entity: Entity<T>, Id<U>, Id<V>, Id<W>) -> boolean)
+		& (<T, U, V, W, X>(self: World, entity: Entity<T>, Id<U>, Id<V>, Id<W>, Id<X>) -> boolean)
+		& (<T, U, V, W, X, Y>(self: World, entity: Entity<T>, Id<U>, Id<V>, Id<W>, Id<X>, Id<Y>) -> boolean)
+		& (<T, U, V, W, X, Y, Z>(self: World, entity: Entity<T>, Id<U>, Id<V>, Id<W>, Id<X>, Id<Y>, Id<Z>) -> boolean)
+		& (<T, U, V, W, X, Y, Z, A>(self: World, entity: Entity<T>, Id<U>, Id<V>, Id<W>, Id<X>, Id<Y>, Id<Z>, Id<A>) -> boolean)
+		& (<T, U, V, W, X, Y, Z, A>(self: World, entity: Entity<T>, Id<U>, Id<V>, Id<W>, Id<X>, Id<Y>, Id<Z>, Id<A>, ...unknown) -> boolean),
+
+	--- Get parent (target of ChildOf relationship) for entity. If there is no ChildOf relationship pair, it will return nil.
+	parent: <T>(self: World, entity: Entity<T>) -> Entity,
+
+	--- Checks if the world contains the given entity
+	contains: <T>(self: World, entity: Entity<T>) -> boolean,
+
+	each: <T>(self: World, id: Id<T>) -> () -> Entity,
+
+	children: <T>(self: World, id: Id<T>) -> () -> Entity,
+
+	--- Searches the world for entities that match a given query
+	query: (<A>(World, Id<A>) -> Query<A>)
+		& (<A, B>(World, Id<A>, Id<B>) -> Query<A, B>)
+		& (<A, B, C>(World, Id<A>, Id<B>, Id<C>) -> Query<A, B, C>)
+		& (<A, B, C, D>(World, Id<A>, Id<B>, Id<C>, Id<D>) -> Query<A, B, C, D>)
+		& (<A, B, C, D, E>(World, Id<A>, Id<B>, Id<C>, Id<D>, Id<E>) -> Query<A, B, C, D, E>)
+		& (<A, B, C, D, E, F>(World, Id<A>, Id<B>, Id<C>, Id<D>, Id<E>, Id<F>) -> Query<A, B, C, D, E, F>)
+		& (<A, B, C, D, E, F, G>(World, Id<A>, Id<B>, Id<C>, Id<D>, Id<E>, Id<F>, Id<G>) -> Query<A, B, C, D, E, F, G>)
+		& (<A, B, C, D, E, F, G, H>(World, Id<A>, Id<B>, Id<C>, Id<D>, Id<E>, Id<F>, Id<G>, Id<H>, ...Id<any>) -> Query<A, B, C, D, E, F, G, H>)
+}
+-- type function ecs_id_t(entity)
+-- 	local ty = entity:components()[2]
+-- 	local __T = ty:readproperty(types.singleton("__T"))
+-- 	if not __T then
+-- 		return ty:readproperty(types.singleton("__jecs_pair_value"))
+-- 	end
+-- 	return __T
+-- end
+
+-- type function ecs_pair_t(first, second)
+-- 	if ecs_id_t(first):is("nil") then
+-- 		return second
+-- 	else
+-- 		return first
+-- 	end
+-- end
+
+return {
+	World = World :: { new: () -> World },
+
+	OnAdd = EcsOnAdd :: Entity<(entity: Entity) -> ()>,
+	OnRemove = EcsOnRemove :: Entity<(entity: Entity) -> ()>,
+	OnSet = EcsOnSet :: Entity<(entity: Entity, data: any) -> ()>,
+	ChildOf = EcsChildOf :: Entity,
+	Component = EcsComponent :: Entity,
+	Wildcard = EcsWildcard :: Entity,
+	w = EcsWildcard :: Entity,
+	OnDelete = EcsOnDelete :: Entity,
+	OnDeleteTarget = EcsOnDeleteTarget :: Entity,
+	Delete = EcsDelete :: Entity,
+	Remove = EcsRemove :: Entity,
+	Name = EcsName :: Entity<string>,
+	Rest = EcsRest :: Entity,
+
+	pair = ECS_PAIR :: <P, O>(first: P, second: O) -> Pair<P, O>,
+
+	-- Inwards facing API for testing
+	ECS_ID = ECS_ENTITY_T_LO,
+	ECS_GENERATION_INC = ECS_GENERATION_INC,
+	ECS_GENERATION = ECS_GENERATION,
+	ECS_ID_IS_WILDCARD = ECS_ID_IS_WILDCARD,
+
+	IS_PAIR = ECS_IS_PAIR,
+	pair_first = ecs_pair_first,
+	pair_second = ecs_pair_second,
+	entity_index_get_alive = entity_index_get_alive,
+
+	archetype_append_to_records = archetype_append_to_records,
+	id_record_ensure = id_record_ensure,
+	archetype_create = archetype_create,
+	archetype_ensure = archetype_ensure,
+	find_insert = find_insert,
+	find_archetype_with = find_archetype_with,
+	find_archetype_without = find_archetype_without,
+	archetype_init_edge = archetype_init_edge,
+	archetype_ensure_edge = archetype_ensure_edge,
+	init_edge_for_add = init_edge_for_add,
+	init_edge_for_remove = init_edge_for_remove,
+	create_edge_for_add = create_edge_for_add,
+	create_edge_for_remove = create_edge_for_remove,
+	archetype_traverse_add = archetype_traverse_add,
+	archetype_traverse_remove = archetype_traverse_remove,
+
+	entity_move = entity_move,
+
+	entity_index_try_get = entity_index_try_get,
+	entity_index_try_get_any = entity_index_try_get_any,
+	entity_index_try_get_fast = entity_index_try_get_fast,
+	entity_index_is_alive = entity_index_is_alive,
+	entity_index_new_id = entity_index_new_id,
+
+	query_iter = query_iter,
+	query_iter_init = query_iter_init,
+	query_with = query_with,
+	query_without = query_without,
+	query_archetypes = query_archetypes,
+	query_match = query_match,
+
+	find_observers = find_observers,
+}
diff --git a/jecs/pesde.toml b/jecs/pesde.toml
new file mode 100644
index 0000000..0b544b1
--- /dev/null
+++ b/jecs/pesde.toml
@@ -0,0 +1,13 @@
+authors = ["jecs authors"]
+includes = ["init.luau", "pesde.toml", "README.md", "CHANGELOG.md", "LICENSE", ".luaurc"]
+license = "MIT"
+name = "marked/jecs_nightly"
+repository = "https://git.devmarked.win/jecs-nightly"
+version = "0.5.5-nightly.20250302T040332Z"
+
+[indices]
+default = "https://github.com/daimond113/pesde-index"
+
+[target]
+environment = "luau"
+lib = "jecs.luau"
diff --git a/jecs/wally.toml b/jecs/wally.toml
new file mode 100644
index 0000000..af8dbd6
--- /dev/null
+++ b/jecs/wally.toml
@@ -0,0 +1,8 @@
+[package]
+exclude = ["**"]
+include = ["default.project.json", "jecs.luau", "wally.toml", "README.md", "CHANGELOG.md", "LICENSE"]
+license = "MIT"
+name = "mark-marks/jecs-nightly"
+realm = "shared"
+registry = "https://github.com/UpliftGames/wally-index"
+version = "0.5.5-nightly.20250302T040332Z"
diff --git a/rokit.toml b/rokit.toml
new file mode 100644
index 0000000..1cc79c6
--- /dev/null
+++ b/rokit.toml
@@ -0,0 +1,11 @@
+# This file lists tools managed by Rokit, a toolchain manager for Roblox projects.
+# For more information, see https://github.com/rojo-rbx/rokit
+
+# New tools can be added by running `rokit add <tool>` in a terminal.
+
+[tools]
+lune = "lune-org/lune@0.8.9"
+luau-lsp = "johnnymorganz/luau-lsp@1.37.0" # https://discord.com/channels/385151591524597761/1259775232533856327/1326154624335347732
+stylua = "johnnymorganz/stylua@2.0.2"
+wally = "upliftgames/wally@0.3.2"
+pesde = "pesde-pkg/pesde@0.6.0+registry.0.2.0"
diff --git a/src/init.luau b/src/init.luau
new file mode 100644
index 0000000..32a8084
--- /dev/null
+++ b/src/init.luau
@@ -0,0 +1,16 @@
+--!strict
+local release = require("./release")
+local sync = require("./sync")
+
+local res = sync("jecs")
+if not res.ok then
+    print(`Can't continue: {res.err}`)
+    return
+end
+
+if res.val == false then
+    print(`No changes made. Aborting.`)
+    return
+end
+
+release("jecs", { pesde = "marked/jecs_nightly", wally = "mark-marks/jecs-nightly" })
diff --git a/src/read_version.luau b/src/read_version.luau
new file mode 100644
index 0000000..b9b8388
--- /dev/null
+++ b/src/read_version.luau
@@ -0,0 +1,10 @@
+--!strict
+local fs = require("@lune/fs")
+local serde = require("@lune/serde")
+local types = require("./types")
+
+local manifest_contents = fs.readFile("jecs/pesde.toml")
+local manifest: types.PesdeManifest = serde.decode("toml", manifest_contents) or error("Couldn't decode manifest.")
+local jecs_version = manifest.version
+
+print(jecs_version)
diff --git a/src/release.luau b/src/release.luau
new file mode 100644
index 0000000..08048be
--- /dev/null
+++ b/src/release.luau
@@ -0,0 +1,161 @@
+--!strict
+local datetime = require("@lune/datetime")
+local fs = require("@lune/fs")
+local net = require("@lune/net")
+local process = require("@lune/process")
+local serde = require("@lune/serde")
+local stdio = require("@lune/stdio")
+
+local progress_bar = require("./util/progress")
+local result = require("./util/result")
+local types = require("./types")
+
+-- Returns an ISO 8601 date (YYYYmmddThhmmssZ)
+local function iso_date_light(now: datetime.DateTime): string
+    return now:formatUniversalTime("%Y%m%dT%H%M%SZ")
+end
+
+local function make_pesde_manifest(version: string, scope: string): types.PesdeManifest
+    return {
+        name = scope,
+        version = version,
+        authors = { "jecs authors" },
+        repository = "https://git.devmarked.win/jecs-nightly",
+        license = "MIT",
+        includes = {
+            "init.luau",
+            "pesde.toml",
+            "README.md",
+            "CHANGELOG.md",
+            "LICENSE",
+            ".luaurc",
+        },
+
+        target = {
+            environment = "luau",
+            lib = "jecs.luau",
+        },
+
+        indices = {
+            default = "https://github.com/daimond113/pesde-index",
+        },
+    }
+end
+
+local function make_wally_manifest(version: string, scope: string): types.WallyManifest
+    return {
+        package = {
+            name = scope,
+            version = version,
+            registry = "https://github.com/UpliftGames/wally-index",
+            realm = "shared",
+            license = "MIT",
+            include = {
+                "default.project.json",
+                "jecs.luau",
+                "wally.toml",
+                "README.md",
+                "CHANGELOG.md",
+                "LICENSE",
+            },
+            exclude = { "**" },
+        },
+    }
+end
+
+local function round_to(n: number, places: number)
+    local x = 10 ^ (places or 0)
+    return math.round(n * x) / x
+end
+
+--- Fetches the given file raw from the jecs github
+local function fetch_raw(file: string): result.Identity<string>
+    local res = net.request(`https://raw.githubusercontent.com/Ukendio/jecs/refs/heads/main/{file}`)
+    if not res.ok then
+        return result(false, `Not ok: {res.statusMessage} @ {res.statusCode}`)
+    end
+    return result(true, res.body)
+end
+
+local function release(origin: string, scopes: { wally: string, pesde: string }, dry: boolean?): result.Identity<nil>
+    local begin = os.clock()
+    local now = datetime.now()
+
+    local progress = progress_bar
+        .new()
+        :withStage("init", "Initializing")
+        :withStage("pull", "Pull latest version")
+        :withStage("prepare", "Preparing manifests")
+        :withStage("release (pesde)", "Releasing on pesde")
+        :withStage("release (wally)", "Releasing on wally")
+    progress:start()
+
+    dry = dry or true
+
+    if not fs.metadata(origin).exists then
+        progress:stop()
+        stdio.ewrite(`🔥 {origin} is not a valid directory which exists.\n`)
+        return result(false, `{origin} is not a valid directory which exists.`)
+    end
+
+    progress:nextStage()
+
+    local wally_contents = fetch_raw("wally.toml")
+    if not wally_contents.ok then
+        progress:stop()
+        stdio.ewrite(`🔥 Couldn't get the jecs wally manifest:\n{wally_contents.err}\n`)
+        return result(false, `Couldn't get the jecs wally manifest:\n{wally_contents.err}`)
+    end
+
+    local parsed: types.WallyManifest = serde.decode("toml", wally_contents.val)
+    local version = `{parsed.package.version}-nightly.{iso_date_light(now)}`
+
+    progress:nextStage()
+
+    do
+        local manifest = make_pesde_manifest(version, scopes.pesde)
+        local encoded = serde.encode("toml", manifest)
+        fs.writeFile(`{origin}/pesde.toml`, encoded)
+    end
+
+    do
+        local manifest = make_wally_manifest(version, scopes.wally)
+        local encoded = serde.encode("toml", manifest)
+        fs.writeFile(`{origin}/wally.toml`, encoded)
+    end
+
+    progress:nextStage()
+
+    local cwd = process.cwd .. origin
+
+    if not dry then
+        process.spawn("pesde", { "publish", "-y" }, { cwd = cwd })
+    else
+        process.spawn("pesde", { "publish", "-d", "-y" }, { cwd = cwd })
+    end
+
+    progress:nextStage()
+
+    if not dry then
+        process.spawn("wally", { "publish" }, { cwd = cwd })
+    else
+        process.spawn("wally", { "package", "--output", "wally.tar.gz" }, { cwd = cwd })
+    end
+
+    progress:stop()
+
+    local took = round_to((os.clock() - begin) * 1_000, 2)
+    if not dry then
+        print(`🚀 Published packages {stdio.style("dim")}(took {took}ms){stdio.style("reset")}`)
+    else
+        print(`📦 Packaged packages {stdio.style("dim")}(took {took}ms){stdio.style("reset")}`)
+    end
+    print({
+        pesde = `{scopes.pesde}@{version}`,
+        wally = `{scopes.wally}@{version}`,
+    })
+
+    return result(true, nil)
+end
+
+return release
diff --git a/src/sync.luau b/src/sync.luau
new file mode 100644
index 0000000..1fd4252
--- /dev/null
+++ b/src/sync.luau
@@ -0,0 +1,110 @@
+--!strict
+local fs = require("@lune/fs")
+local net = require("@lune/net")
+local stdio = require("@lune/stdio")
+
+local progress_bar = require("./util/progress")
+local result = require("./util/result")
+
+--- Fetches the given file raw from the jecs github
+local function fetch_raw(file: string): result.Identity<string>
+    local res = net.request(`https://raw.githubusercontent.com/Ukendio/jecs/refs/heads/main/{file}`)
+    if not res.ok then
+        return result(false, `Not ok: {res.statusMessage} @ {res.statusCode}`)
+    end
+    return result(true, res.body)
+end
+
+local function save_if_diff(filepath: string, contents: string): result.Identity<nil>
+    if not fs.metadata(filepath).exists then
+        fs.writeFile(filepath, contents)
+        return result(true, nil)
+    end
+
+    local existing = fs.readFile(filepath)
+    if existing == contents then
+        return result(false, "Contents are the same.")
+    end
+
+    fs.writeFile(filepath, contents)
+    return result(true, nil)
+end
+
+local function round_to(n: number, places: number)
+    local x = 10 ^ (places or 0)
+    return math.round(n * x) / x
+end
+
+--- Synchronizes the required files from the jecs main branch.
+local function sync(to: string): result.Identity<boolean>
+    local begin = os.clock()
+
+    local progress = progress_bar
+        .new()
+        :withStage("init", "Initializing")
+        :withStage("fetch", "Fetching latest files")
+        :withStage("save", "Saving files")
+    progress:start()
+
+    if not fs.metadata(to).exists then
+        fs.writeDir(to)
+    end
+
+    progress:nextStage()
+
+    local includes = {
+        "jecs.luau",
+        "README.md",
+        "CHANGELOG.md",
+        "LICENSE",
+        ".luaurc",
+        "default.project.json",
+    }
+
+    local sources = {}
+
+    for _, file in includes do
+        local contents = fetch_raw(file)
+        if not contents.ok then
+            progress:stop()
+            stdio.ewrite(`🔥 Couldn't get the latest source for {file}:\n{contents.err}\n`)
+            return result(false, `Couldn't get the latest source for {file}.`)
+        end
+
+        sources[file] = contents.val
+    end
+
+    progress:nextStage()
+
+    local sources_modified = {}
+    local any_changed = false
+    for file, contents in sources do
+        local res = save_if_diff(`{to}/{file}`, contents)
+        if res.ok then
+            any_changed = true
+            table.insert(sources_modified, file)
+        end
+    end
+
+    if not any_changed then
+        progress:stop()
+        local took = round_to((os.clock() - begin) * 1_000, 2)
+        print(
+            `🕛 Finished synchronizing, no changes since latest source {stdio.style("dim")}(took {took}ms){stdio.style(
+                "reset"
+            )}`
+        )
+        return result(true, false)
+    end
+
+    progress:stop()
+
+    local took = round_to((os.clock() - begin) * 1_000, 2)
+    print(`🪨 Finished synchronizing {stdio.style("dim")}(took {took}ms){stdio.style("reset")}`)
+    print(`Changed files:`)
+    print(sources_modified)
+
+    return result(true, true)
+end
+
+return sync
diff --git a/src/types.luau b/src/types.luau
new file mode 100644
index 0000000..8773354
--- /dev/null
+++ b/src/types.luau
@@ -0,0 +1,78 @@
+--!strict
+export type SPDXLicense =
+    "MIT"
+    | "Apache-2.0"
+    | "BSD-2-Clause"
+    | "BSD-3-Clause"
+    | "GPL-2.0"
+    | "GPL-3.0"
+    | "LGPL-2.1"
+    | "LGPL-3.0"
+    | "MPL-2.0"
+    | "ISC"
+    | "Unlicense"
+    | "WTFPL"
+    | "Zlib"
+    | "CC0-1.0"
+    | "CC-BY-4.0"
+    | "CC-BY-SA-4.0"
+    | "BSL-1.0"
+    | "EPL-2.0"
+    | "AGPL-3.0"
+
+export type DependencySpecifier = ((
+    { name: string, version: string, index: string? }
+    | { workspace: string, version: string }
+    | { repo: string, rev: string, path: string? }
+) & {
+    target: string?,
+}) | { wally: string, version: string, index: string? }
+
+export type PackageTarget = {
+    environment: "luau" | "lune" | "roblox" | "roblox_server",
+    lib: string,
+} | {
+    environment: "luau" | "lune",
+    bin: string,
+}
+
+export type PesdeManifest = {
+    name: string,
+    version: string,
+    description: string?,
+    license: SPDXLicense?,
+    authors: { string }?,
+    repository: string?,
+    private: boolean?,
+    includes: { string }?,
+    pesde_version: string?,
+    workspace_members: { string }?,
+    target: PackageTarget,
+    build_files: { string }?,
+    scripts: { [string]: string }?,
+    indices: { [string]: string },
+    wally_indices: { [string]: string }?,
+    overrides: { [string]: DependencySpecifier }?,
+    patches: { [string]: { [string]: string } }?,
+    place: { [string]: string }?,
+    dependencies: { [string]: DependencySpecifier }?,
+    peer_dependencies: { [string]: DependencySpecifier }?,
+    dev_dependencies: { [string]: DependencySpecifier }?,
+}
+
+export type WallyManifest = {
+    package: {
+        name: string,
+        version: string,
+        registry: string,
+        realm: string,
+        license: string?,
+        exclude: { string }?,
+        include: { string }?,
+    },
+    dependencies: {
+        [string]: string,
+    }?,
+}
+
+return "<types>"
diff --git a/src/util/progress.luau b/src/util/progress.luau
new file mode 100644
index 0000000..2c9d234
--- /dev/null
+++ b/src/util/progress.luau
@@ -0,0 +1,97 @@
+--!strict
+--> Inspired by Rokit's progress bar: https://github.com/rojo-rbx/rokit/blob/a303faf/src/util/progress.rs
+-- Original: https://github.com/pesde-pkg/tooling/blob/main/toolchainlib/src/utils/progress.luau
+local task = require("@lune/task")
+local stdio = require("@lune/stdio")
+
+local result = require("./result")
+
+-- FORMAT: {SPINNER} {MESSAGE} {BAR} {STAGE}
+local SPINNERS = { "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏" }
+local BAR_COMPONENT = "▇"
+local MAX_BAR_LENGTH = 30
+
+local ProgressBar = {}
+type ProgressBar = {
+	stages: { { tag: string, message: string } },
+	currentStageIndex: number,
+	finished: boolean,
+	thread: thread?,
+}
+export type ProgressBarImpl = typeof(setmetatable({} :: ProgressBar, { __index = ProgressBar }))
+
+function ProgressBar.new(): ProgressBarImpl
+	return setmetatable(
+		{
+			stages = {},
+			currentStageIndex = 1,
+			finished = false,
+		} :: ProgressBar,
+		{
+			__index = ProgressBar,
+		}
+	)
+end
+
+function ProgressBar.withStage(self: ProgressBarImpl, tag: string, msg: string): ProgressBarImpl
+	table.insert(self.stages, { tag = tag, message = msg })
+	return self
+end
+
+function ProgressBar.start(self: ProgressBarImpl)
+	local BAR_LENGTH = MAX_BAR_LENGTH // #self.stages
+	local TOTAL_BAR_LENGTH = BAR_LENGTH * #self.stages
+	local BAR = string.rep(BAR_COMPONENT, BAR_LENGTH)
+	local MAX_MESSAGE_LENGTH = 0
+	for _, stage in self.stages do
+		local len = #stage.message
+		if len > MAX_MESSAGE_LENGTH then
+			MAX_MESSAGE_LENGTH = len
+		end
+	end
+
+	self.thread = task.spawn(function()
+		while true do
+			for _, spinner in SPINNERS do
+				if self.finished then
+					return
+				end
+
+				local stage = self.stages[self.currentStageIndex]
+				stdio.ewrite(
+					`\x1b[2K\x1b[0G{stdio.color("cyan")}{spinner} {stage.message}{stdio.color("reset")}{string.rep(
+						" ",
+						MAX_MESSAGE_LENGTH - #stage.message
+					)} [{stdio.style("dim")}{string.rep(BAR, self.currentStageIndex)}{string.rep(
+						" ",
+						TOTAL_BAR_LENGTH - (BAR_LENGTH * self.currentStageIndex)
+					)}{stdio.style("reset")}] {stdio.style("bold")}{self.currentStageIndex} / {#self.stages}{stdio.style(
+						"reset"
+					)}`
+				)
+
+				task.wait(0.1)
+			end
+		end
+	end)
+end
+
+function ProgressBar.stop(self: ProgressBarImpl)
+	-- Trigger upvalue, kill thread and clean progress bar remnant
+	self.finished = true
+	stdio.ewrite("\x1b[2K\x1b[0G")
+end
+
+function ProgressBar.nextStage(self: ProgressBarImpl): result.Identity<nil>
+	local inc = self.currentStageIndex + 1
+	if inc > #self.stages then
+		-- TODO: Make this a result
+		self.finished = true
+		return result(false, "OutOfBounds - Attempted to advance past last stage")
+	end
+
+	self.currentStageIndex = inc
+	return result(true, nil)
+end
+
+return ProgressBar
diff --git a/src/util/result.luau b/src/util/result.luau
new file mode 100644
index 0000000..5f21015
--- /dev/null
+++ b/src/util/result.luau
@@ -0,0 +1,24 @@
+--!strict
+export type Identity<T> = {
+	ok: true,
+	val: T,
+} | {
+	ok: false,
+	err: string,
+}
+
+local function construct<T>(ok: boolean, value: T & string): Identity<T>
+	if ok then
+		return {
+			ok = true,
+			val = value,
+		}
+	else
+		return {
+			ok = false,
+			err = value,
+		}
+	end
+end
+
+return (construct :: any) :: (<T>(ok: true, value: T) -> Identity<T>) & (<T>(ok: false, value: string) -> Identity<T>)
diff --git a/stylua.toml b/stylua.toml
new file mode 100644
index 0000000..920827f
--- /dev/null
+++ b/stylua.toml
@@ -0,0 +1,10 @@
+column_width = 120
+line_endings = "Unix"
+indent_type = "Spaces"
+indent_width = 4
+quote_style = "AutoPreferDouble"
+call_parentheses = "Input"
+collapse_simple_statement = "Never"
+
+[sort_requires]
+enabled = true