diff --git a/.lune/docsgen/init.luau b/.lune/docsgen/init.luau
index 89bafa6..1c2078e 100644
--- a/.lune/docsgen/init.luau
+++ b/.lune/docsgen/init.luau
@@ -8,24 +8,24 @@ local logger = require("./log")
 local writeMarkdown = require("./markdown")
 
 local function extract(input: string): (number, { moonwave.Item }?)
-  local res = process.spawn("moonwave-extractor", { "extract", input }, {
-    stdio = {
-      stderr = "forward"
-    }
-  })
+	local res = process.spawn("moonwave-extractor", { "extract", input }, {
+		stdio = {
+			stderr = "forward",
+		},
+	})
 
-  if not res.ok then
-    print()
-    logger.log("error", "`moonwave-extractor` failed with exit code", res.code)
-    return res.code, nil
-  end
+	if not res.ok then
+		print()
+		logger.log("error", "`moonwave-extractor` failed with exit code", res.code)
+		return res.code, nil
+	end
 
-  local ok, items: { moonwave.Item } = pcall(serde.decode, "json" :: "json", res.stdout)
-  if not ok then 
-    return 1, nil
-  end
+	local ok, items: { moonwave.Item } = pcall(serde.decode, "json" :: "json", res.stdout)
+	if not ok then
+		return 1, nil
+	end
 
-  return 0, items
+	return 0, items
 end
 
 local code, items = extract("lib/init.luau")
diff --git a/.lune/docsgen/log.luau b/.lune/docsgen/log.luau
index 77726d4..c6f6b27 100644
--- a/.lune/docsgen/log.luau
+++ b/.lune/docsgen/log.luau
@@ -8,17 +8,17 @@ local STYLE_ERROR = base .. `{stdio.color("red")}error{stdio.color("reset")}:`
 
 export type LogType = "info" | "warn" | "error"
 local styleMappings: { [LogType]: string } = {
-  info = STYLE_INFO,
-  warn = STYLE_WARN,
-  error = STYLE_ERROR,
+	info = STYLE_INFO,
+	warn = STYLE_WARN,
+	error = STYLE_ERROR,
 }
 
 return {
-  styles = styleMappings,
-  log = function<T...>(type: LogType, ...: T...): ()
-    local writer: (string) -> () = if type == "info" then stdio.write else stdio.ewrite
-    local fmtMsg = stdio.format(styleMappings[type], ...) 
+	styles = styleMappings,
+	log = function<T...>(type: LogType, ...: T...): ()
+		local writer: (string) -> () = if type == "info" then stdio.write else stdio.ewrite
+		local fmtMsg = stdio.format(styleMappings[type], ...)
 
-    return writer(fmtMsg .. "\n")
-  end
+		return writer(fmtMsg .. "\n")
+	end,
 }
diff --git a/.lune/docsgen/markdown.luau b/.lune/docsgen/markdown.luau
index 673ec5a..2b5ec41 100644
--- a/.lune/docsgen/markdown.luau
+++ b/.lune/docsgen/markdown.luau
@@ -1,177 +1,177 @@
-local fs = require("@lune/fs")
-
-local moonwave = require("./moonwave")
-local logger = require("./log")
-
-local function writeSectionHeader(buf: string, title: string)
-	buf ..= `## {title}\n`
-	return buf
-end
-
-local function writeRef(buf: string, name: string, fragment: string?)
-	buf ..= `\n[{name}]: #{fragment or name}\n`
-	return buf
-end
-
-local function writeClass(buf: string, name: string, desc: string)
-	buf ..= `# \`{name}\`\n`
-	buf ..= desc
-	buf ..= `\n\n`
-	return buf
-end
-
-local function writeDeclaration(buf: string, name: string, fields: { moonwave.Property })
-	buf ..= `\`\`\`luau\n`
-	buf ..= `export type {name} = \{\n`
-	for _, field in fields do
-		buf ..= `\t{field.name}: {field.lua_type},\n`
-	end
-	buf ..= "}\n"
-	buf ..= `\`\`\`\n`
-	return buf
-end
-
-local function writeProperty(buf: string, name: string, desc: string, type: string)
-	-- buf ..= `- **\`{name}: {type}\`** - {desc}\n`
-	buf ..= `- **{name}** - {desc}\n`
-	return buf
-end
-
-local function writeFunction(
-	buf: string,
-	class: string,
-	type: string,
-	name: string,
-	desc: string,
-	params: { moonwave.FunctionParam },
-	returns: { moonwave.FunctionReturn },
-	private: boolean
-)
-	local sep = if type == "method" then ":" else "."
-	local declaredSignature = `{class}{sep}{name}`
-	buf ..= `### \`{name}\`\n`
-
-	if private then
-		buf ..= `> [!IMPORTANT]\n`
-		buf ..= `> This is a private API. It may be exported publicly, but try to avoid\n`
-		buf ..= `> using this API, since it can have breaking changes at any time without\n`
-		buf ..= `> warning.\n\n`
-	end
-
-	buf ..= `{desc}\n`
-	buf ..= `\`\`\`luau\n`
-	buf ..= `{declaredSignature}(`
-	if #params > 0 then
-		buf ..= "\n"
-		for _, param in params do
-			buf ..= `\t{param.name}: {param.lua_type}, -- {param.desc}\n`
-		end
-	end
-	buf ..= `)`
-
-	if #returns > 0 then
-		if #returns == 1 then
-			buf ..= `: {returns[1].lua_type}\n`
-		else
-			for pos, ret in returns do
-				buf ..= `({ret.lua_type}`
-				if pos ~= #returns then
-					buf ..= `, `
-				end
-			end
-			buf ..= `)`
-		end
-	end
-
-	buf ..= `\n\`\`\`\n`
-	buf = writeRef(buf, declaredSignature, name)
-	return buf
-end
-
-local function writeType(buf: string, name: string, desc: string, type: string)
-	buf ..= `\`\`\`luau\n`
-	buf ..= `export type {name} = {type}\n`
-	buf ..= `\`\`\`\n`
-	return buf
-end
-
-local function writeMarkdown(path: string, items: { moonwave.Item })
-	local start = os.clock()
-    local buf = ""
-	for _, item in items do
-        logger.log("info", "Generating docs for", item.name)
-		buf = writeClass(buf, item.name, item.desc)
-
-		local props: { moonwave.Property } = {}
-		for pos, type in item.types do
-			if type.name == item.name then
-				table.remove(item.types, pos)
-				props = type.fields
-			end
-		end
-
-		buf = writeDeclaration(buf, item.name, props)
-		buf = writeSectionHeader(buf, "Properties")
-		for _, prop in props do
-			if prop.ignore then
-				continue
-			end
-
-			buf = writeProperty(buf, prop.name, prop.desc, prop.lua_type)
-		end
-		buf ..= "\n"
-
-		buf = writeSectionHeader(buf, "API")
-		for _, func in item.functions do
-			if func.ignore then
-				continue
-			end
-
-			buf = writeFunction(
-				buf,
-				item.name,
-				func.function_type,
-				func.name,
-				func.desc,
-				func.params,
-				func.returns,
-				func.private
-			)
-		end
-		buf ..= "\n"
-
-		buf = writeSectionHeader(buf, "Types")
-		for _, type in item.types do
-			if type.ignore then
-				continue
-			end
-
-			buf ..= `### \`{type.name}\`\n`
-            if type.private then
-                buf ..= `> [!IMPORTANT]\n`
-                buf ..= `> This is a private type. It may be exported publicly, but try to avoid\n`
-                buf ..= `> using it, since its definition can have a breaking change at any time\n`
-                buf ..= `> without warning.\n\n`
-            end
-			buf ..= `{type.desc}\n`
-			if type.lua_type ~= nil then
-				buf = writeType(buf, type.name, type.desc, type.lua_type)
-			else
-				local fields: { moonwave.Property } = type.fields or {}
-				buf = writeDeclaration(buf, type.name, fields)
-				for _, field in fields do
-					buf = writeProperty(buf, field.name, field.desc, field.lua_type)
-				end
-			end
-			buf = writeRef(buf, type.name)
-		end
-
-		buf = writeRef(buf, item.name)
-	end
-
-    logger.log("info", string.format("Generated docs in %.2fms", (os.clock() - start) * 1000))
-    logger.log("info", "Writing to", path)
-	fs.writeFile(path, buf)
-end
-
-return writeMarkdown
+local fs = require("@lune/fs")
+
+local moonwave = require("./moonwave")
+local logger = require("./log")
+
+local function writeSectionHeader(buf: string, title: string)
+	buf ..= `## {title}\n`
+	return buf
+end
+
+local function writeRef(buf: string, name: string, fragment: string?)
+	buf ..= `\n[{name}]: #{fragment or name}\n`
+	return buf
+end
+
+local function writeClass(buf: string, name: string, desc: string)
+	buf ..= `# \`{name}\`\n`
+	buf ..= desc
+	buf ..= `\n\n`
+	return buf
+end
+
+local function writeDeclaration(buf: string, name: string, fields: { moonwave.Property })
+	buf ..= `\`\`\`luau\n`
+	buf ..= `export type {name} = \{\n`
+	for _, field in fields do
+		buf ..= `\t{field.name}: {field.lua_type},\n`
+	end
+	buf ..= "}\n"
+	buf ..= `\`\`\`\n`
+	return buf
+end
+
+local function writeProperty(buf: string, name: string, desc: string, type: string)
+	-- buf ..= `- **\`{name}: {type}\`** - {desc}\n`
+	buf ..= `- **{name}** - {desc}\n`
+	return buf
+end
+
+local function writeFunction(
+	buf: string,
+	class: string,
+	type: string,
+	name: string,
+	desc: string,
+	params: { moonwave.FunctionParam },
+	returns: { moonwave.FunctionReturn },
+	private: boolean
+)
+	local sep = if type == "method" then ":" else "."
+	local declaredSignature = `{class}{sep}{name}`
+	buf ..= `### \`{name}\`\n`
+
+	if private then
+		buf ..= `> [!IMPORTANT]\n`
+		buf ..= `> This is a private API. It may be exported publicly, but try to avoid\n`
+		buf ..= `> using this API, since it can have breaking changes at any time without\n`
+		buf ..= `> warning.\n\n`
+	end
+
+	buf ..= `{desc}\n`
+	buf ..= `\`\`\`luau\n`
+	buf ..= `{declaredSignature}(`
+	if #params > 0 then
+		buf ..= "\n"
+		for _, param in params do
+			buf ..= `\t{param.name}: {param.lua_type}, -- {param.desc}\n`
+		end
+	end
+	buf ..= `)`
+
+	if #returns > 0 then
+		if #returns == 1 then
+			buf ..= `: {returns[1].lua_type}\n`
+		else
+			for pos, ret in returns do
+				buf ..= `({ret.lua_type}`
+				if pos ~= #returns then
+					buf ..= `, `
+				end
+			end
+			buf ..= `)`
+		end
+	end
+
+	buf ..= `\n\`\`\`\n`
+	buf = writeRef(buf, declaredSignature, name)
+	return buf
+end
+
+local function writeType(buf: string, name: string, desc: string, type: string)
+	buf ..= `\`\`\`luau\n`
+	buf ..= `export type {name} = {type}\n`
+	buf ..= `\`\`\`\n`
+	return buf
+end
+
+local function writeMarkdown(path: string, items: { moonwave.Item })
+	local start = os.clock()
+	local buf = ""
+	for _, item in items do
+		logger.log("info", "Generating docs for", item.name)
+		buf = writeClass(buf, item.name, item.desc)
+
+		local props: { moonwave.Property } = {}
+		for pos, type in item.types do
+			if type.name == item.name then
+				table.remove(item.types, pos)
+				props = type.fields
+			end
+		end
+
+		buf = writeDeclaration(buf, item.name, props)
+		buf = writeSectionHeader(buf, "Properties")
+		for _, prop in props do
+			if prop.ignore then
+				continue
+			end
+
+			buf = writeProperty(buf, prop.name, prop.desc, prop.lua_type)
+		end
+		buf ..= "\n"
+
+		buf = writeSectionHeader(buf, "API")
+		for _, func in item.functions do
+			if func.ignore then
+				continue
+			end
+
+			buf = writeFunction(
+				buf,
+				item.name,
+				func.function_type,
+				func.name,
+				func.desc,
+				func.params,
+				func.returns,
+				func.private
+			)
+		end
+		buf ..= "\n"
+
+		buf = writeSectionHeader(buf, "Types")
+		for _, type in item.types do
+			if type.ignore then
+				continue
+			end
+
+			buf ..= `### \`{type.name}\`\n`
+			if type.private then
+				buf ..= `> [!IMPORTANT]\n`
+				buf ..= `> This is a private type. It may be exported publicly, but try to avoid\n`
+				buf ..= `> using it, since its definition can have a breaking change at any time\n`
+				buf ..= `> without warning.\n\n`
+			end
+			buf ..= `{type.desc}\n`
+			if type.lua_type ~= nil then
+				buf = writeType(buf, type.name, type.desc, type.lua_type)
+			else
+				local fields: { moonwave.Property } = type.fields or {}
+				buf = writeDeclaration(buf, type.name, fields)
+				for _, field in fields do
+					buf = writeProperty(buf, field.name, field.desc, field.lua_type)
+				end
+			end
+			buf = writeRef(buf, type.name)
+		end
+
+		buf = writeRef(buf, item.name)
+	end
+
+	logger.log("info", string.format("Generated docs in %.2fms", (os.clock() - start) * 1000))
+	logger.log("info", "Writing to", path)
+	fs.writeFile(path, buf)
+end
+
+return writeMarkdown
diff --git a/.lune/fmt.luau b/.lune/fmt.luau
index 2f78179..a076809 100644
--- a/.lune/fmt.luau
+++ b/.lune/fmt.luau
@@ -1,13 +1,7 @@
---> Run stylua to check for formatting errors
-
-local process = require("@lune/process")
-
-local CommandBuilder = require("./util/exec")
-
-process.exit(
-	CommandBuilder.new("stylua")
-		:withArg(".")
-		:withArgs(process.args)
-		:withStdioStrategy("forward")
-		:exec().code
-)
\ No newline at end of file
+--> Run stylua to check for formatting errors
+
+local process = require("@lune/process")
+
+local CommandBuilder = require("./util/exec")
+
+process.exit(CommandBuilder.new("stylua"):withArg("."):withArgs(process.args):withStdioStrategy("forward"):exec().code)
diff --git a/.lune/tests/init.luau b/.lune/tests/init.luau
index ac296a4..bcd47f8 100644
--- a/.lune/tests/init.luau
+++ b/.lune/tests/init.luau
@@ -1,79 +1,79 @@
---> Run tests using frktest runner
-
-local fs = require("@lune/fs")
-local process = require("@lune/process")
-
-local frktest = require("../../lune_packages/frktest")
-local reporter = require("./reporter")
-
--- HACK: Cast require to allow for dynamic paths in strict mode
--- A more proper solution would be to use luau.load instead, but
--- frktest requires its global state to be modified by test suites
-local require = require :: (
-	path: string
-) -> (
-	test: typeof(setmetatable(
-		{} :: {
-			case: (name: string, fn: () -> nil) -> (),
-			suite: (name: string, fn: () -> ()) -> (),
-		},
-		{ __index = frktest.test }
-	))
-) -> ()
-
-local function discoverTests(dir: string): { string }
-	local tests = {}
-
-	local entries = fs.readDir(dir)
-	for _, entry in entries do
-		local path = `{dir}/{entry}`
-
-		-- Look for files ending in `.luau` as tests
-		if fs.isFile(path) and string.match(entry, "%.luau$") then
-			table.insert(tests, path)
-			continue
-		end
-
-		-- Recurse for directories
-		if fs.isDir(path) then
-			local dirResults = discoverTests(path)
-			table.move(dirResults, 1, #dirResults, #tests + 1, tests)
-			continue
-		end
-	end
-
-	return tests
-end
-
-local allowedTests = process.args
-for _, test in discoverTests("tests") do
-	-- If we are given any arguments, we only run those tests, otherwise,
-	-- we run all the tests
-
-	-- So, to include only a certain set of test files, you can provide either
-	-- the full path to the test file (with or without the extension) or the test
-	-- file name
-	local basename = string.match(test, "([^/\\]+)$") :: string
-	local basenameWithoutExt = string.gsub(basename, "%.luau$", "")
-	local testPath = string.gsub(test, "%.luau$", "")
-	local isAllowed = #process.args == 0
-		or table.find(allowedTests, test)
-		or table.find(allowedTests, testPath)
-		or table.find(allowedTests, basename)
-		or table.find(allowedTests, basenameWithoutExt)
-
-	local constructors = {
-		case = frktest.test.case,
-		suite = frktest.test.suite,
-	}
-
-	if not isAllowed then
-		constructors.case = frktest.test.skip.case
-		constructors.suite = frktest.test.skip.suite
-	end
-
-	require(`../../{test}`)(setmetatable(constructors, { __index = frktest.test }))
-end
-
-reporter.init()
-process.exit(tonumber(frktest.run()))
+--> Run tests using frktest runner
+
+local fs = require("@lune/fs")
+local process = require("@lune/process")
+
+local frktest = require("../../lune_packages/frktest")
+local reporter = require("./reporter")
+
+-- HACK: Cast require to allow for dynamic paths in strict mode
+-- A more proper solution would be to use luau.load instead, but
+-- frktest requires its global state to be modified by test suites
+local require = require :: (
+	path: string
+) -> (
+	test: typeof(setmetatable(
+		{} :: {
+			case: (name: string, fn: () -> nil) -> (),
+			suite: (name: string, fn: () -> ()) -> (),
+		},
+		{ __index = frktest.test }
+	))
+) -> ()
+
+local function discoverTests(dir: string): { string }
+	local tests = {}
+
+	local entries = fs.readDir(dir)
+	for _, entry in entries do
+		local path = `{dir}/{entry}`
+
+		-- Look for files ending in `.luau` as tests
+		if fs.isFile(path) and string.match(entry, "%.luau$") then
+			table.insert(tests, path)
+			continue
+		end
+
+		-- Recurse for directories
+		if fs.isDir(path) then
+			local dirResults = discoverTests(path)
+			table.move(dirResults, 1, #dirResults, #tests + 1, tests)
+			continue
+		end
+	end
+
+	return tests
+end
+
+local allowedTests = process.args
+for _, test in discoverTests("tests") do
+	-- If we are given any arguments, we only run those tests, otherwise,
+	-- we run all the tests
+
+	-- So, to include only a certain set of test files, you can provide either
+	-- the full path to the test file (with or without the extension) or the test
+	-- file name
+	local basename = string.match(test, "([^/\\]+)$") :: string
+	local basenameWithoutExt = string.gsub(basename, "%.luau$", "")
+	local testPath = string.gsub(test, "%.luau$", "")
+	local isAllowed = #process.args == 0
+		or table.find(allowedTests, test)
+		or table.find(allowedTests, testPath)
+		or table.find(allowedTests, basename)
+		or table.find(allowedTests, basenameWithoutExt)
+
+	local constructors = {
+		case = frktest.test.case,
+		suite = frktest.test.suite,
+	}
+
+	if not isAllowed then
+		constructors.case = frktest.test.skip.case
+		constructors.suite = frktest.test.skip.suite
+	end
+
+	require(`../../{test}`)(setmetatable(constructors, { __index = frktest.test }))
+end
+
+reporter.init()
+process.exit(tonumber(frktest.run()))
diff --git a/.lune/tests/reporter.luau b/.lune/tests/reporter.luau
index 472060f..d864928 100644
--- a/.lune/tests/reporter.luau
+++ b/.lune/tests/reporter.luau
@@ -1,71 +1,61 @@
---> lib: Extension to base frktest reporter for live status reporting
-
-local stdio = require("@lune/stdio")
-
-local frktest = require("../../lune_packages/frktest")
-local Reporter = frktest._reporters.lune_console_reporter
-
-local watch = require("../util/channel")
-
-local STYLE = table.freeze({
-	suite = function(name: string)
-		return `{stdio.style("bold")}{stdio.color("purple")}SUITE{stdio.style(
-			"reset"
-		)} {name}`
-	end,
-
-	report = function(
-		name: string,
-		state: "success" | "error" | "skip",
-		elapsed: number
-	)
-		local state_color: stdio.Color = if state == "success"
-			then "green"
-			elseif state == "error" then "red"
-			elseif state == "skip" then "yellow"
-			else error("Invalid test state")
-		return `    {stdio.style("bold")}{stdio.color(state_color)}{if state
-				== "skip"
-			then "SKIP"
-			else "TEST"}{stdio.style("reset")} {name} [{stdio.style("dim")}{string.format(
-			"%.2fms",
-			elapsed
-		)}{stdio.style("reset")}]`
-	end,
-})
-
-local ReporterExt = {}
-function ReporterExt.init()
-	frktest.test.on_suite_enter(function(suite)
-		print(STYLE.suite(suite.name))
-	end)
-
-	frktest.test.on_suite_leave(function()
-		stdio.write("\n")
-	end)
-
-	local send_ts, recv_ts = watch((nil :: any) :: number)
-
-	frktest.test.on_test_enter(function()
-		-- Send over some high precision timestamp when the test starts
-		return send_ts(os.clock())
-	end)
-
-	frktest.test.on_test_leave(function(test)
-		print(STYLE.report(
-			test.name,
-			if test.failed then "error" else "success",
-
-			-- Await receival of the timestamp and convert the difference to ms
-			(os.clock() - assert(recv_ts())) * 1000
-		))
-	end)
-
-	frktest.test.on_test_skipped(function(test)
-		print(STYLE.report(test.name, "skip", 0))
-	end)
-
-	Reporter.init()
-end
-
-return setmetatable(ReporterExt, { __index = Reporter })
\ No newline at end of file
+--> lib: Extension to base frktest reporter for live status reporting
+
+local stdio = require("@lune/stdio")
+
+local frktest = require("../../lune_packages/frktest")
+local Reporter = frktest._reporters.lune_console_reporter
+
+local watch = require("../util/channel")
+
+local STYLE = table.freeze({
+	suite = function(name: string)
+		return `{stdio.style("bold")}{stdio.color("purple")}SUITE{stdio.style("reset")} {name}`
+	end,
+
+	report = function(name: string, state: "success" | "error" | "skip", elapsed: number)
+		local state_color: stdio.Color = if state == "success"
+			then "green"
+			elseif state == "error" then "red"
+			elseif state == "skip" then "yellow"
+			else error("Invalid test state")
+		return `    {stdio.style("bold")}{stdio.color(state_color)}{if state == "skip" then "SKIP" else "TEST"}{stdio.style(
+			"reset"
+		)} {name} [{stdio.style("dim")}{string.format("%.2fms", elapsed)}{stdio.style("reset")}]`
+	end,
+})
+
+local ReporterExt = {}
+function ReporterExt.init()
+	frktest.test.on_suite_enter(function(suite)
+		print(STYLE.suite(suite.name))
+	end)
+
+	frktest.test.on_suite_leave(function()
+		stdio.write("\n")
+	end)
+
+	local send_ts, recv_ts = watch((nil :: any) :: number)
+
+	frktest.test.on_test_enter(function()
+		-- Send over some high precision timestamp when the test starts
+		return send_ts(os.clock())
+	end)
+
+	frktest.test.on_test_leave(function(test)
+		print(STYLE.report(
+			test.name,
+			if test.failed then "error" else "success",
+
+			-- Await receival of the timestamp and convert the difference to ms
+			(os.clock() - assert(recv_ts())) * 1000
+		))
+	end)
+
+	frktest.test.on_test_skipped(function(test)
+		print(STYLE.report(test.name, "skip", 0))
+	end)
+
+	Reporter.init()
+end
+
+return setmetatable(ReporterExt, { __index = Reporter })
diff --git a/.lune/typecheck.luau b/.lune/typecheck.luau
index db52153..a76bd3f 100644
--- a/.lune/typecheck.luau
+++ b/.lune/typecheck.luau
@@ -1,15 +1,15 @@
---> Run luau-lsp analysis to check for type errors
-
-local process = require("@lune/process")
-
-local CommandBuilder = require("./util/exec")
-
-process.exit(
-	CommandBuilder.new("luau-lsp")
-		:withArg("analyze")
-		:withArgs({ "--settings", ".vscode/settings.json" })
-		:withArgs({ "--ignore", "'**/*_packages/**/*'" })
-		:withArg(".")
-		:withStdioStrategy("forward")
-		:exec().code
-)
\ No newline at end of file
+--> Run luau-lsp analysis to check for type errors
+
+local process = require("@lune/process")
+
+local CommandBuilder = require("./util/exec")
+
+process.exit(
+	CommandBuilder.new("luau-lsp")
+		:withArg("analyze")
+		:withArgs({ "--settings", ".vscode/settings.json" })
+		:withArgs({ "--ignore", "'**/*_packages/**/*'" })
+		:withArg(".")
+		:withStdioStrategy("forward")
+		:exec().code
+)
diff --git a/.lune/util/channel.luau b/.lune/util/channel.luau
index e311988..411d780 100644
--- a/.lune/util/channel.luau
+++ b/.lune/util/channel.luau
@@ -1,48 +1,48 @@
---> util: An MPSC synchronization primitive powered by Lua upvalues which retains only
---> one value at a time.
-
---- ## Usage
---- ```luau
---- local send, recv = watch((nil :: any) :: string)
---- task.delay(5, send, "hello, world!")
---- task.spawn(function()
----     local value = recv()
----     print("received value:", value)
---- end)
---- ```
-type Watch<T> = {
-	value: T?,
-	receivers: { thread },
-}
-
---- Creates a new `Watch` channel, returning its send and receive handles.
-local function chan<T>(_phantom: T): ((T) -> (), () -> T?)
-	local watch: Watch<T> = {
-		value = nil,
-		receivers = {},
-	}
-
-	local function send(value: T)
-		watch.value = value
-
-		for _, receiver in watch.receivers do
-			coroutine.resume(receiver, value)
-		end
-	end
-
-	local function recv(): T
-		local value = watch.value
-		watch.value = nil
-
-		if value == nil then
-			table.insert(watch.receivers, coroutine.running())
-			return coroutine.yield()
-		end
-
-		return value :: T
-	end
-
-	return send, recv
-end
-
-return chan
\ No newline at end of file
+--> util: An MPSC synchronization primitive powered by Lua upvalues which retains only
+--> one value at a time.
+
+--- ## Usage
+--- ```luau
+--- local send, recv = watch((nil :: any) :: string)
+--- task.delay(5, send, "hello, world!")
+--- task.spawn(function()
+---     local value = recv()
+---     print("received value:", value)
+--- end)
+--- ```
+type Watch<T> = {
+	value: T?,
+	receivers: { thread },
+}
+
+--- Creates a new `Watch` channel, returning its send and receive handles.
+local function chan<T>(_phantom: T): ((T) -> (), () -> T?)
+	local watch: Watch<T> = {
+		value = nil,
+		receivers = {},
+	}
+
+	local function send(value: T)
+		watch.value = value
+
+		for _, receiver in watch.receivers do
+			coroutine.resume(receiver, value)
+		end
+	end
+
+	local function recv(): T
+		local value = watch.value
+		watch.value = nil
+
+		if value == nil then
+			table.insert(watch.receivers, coroutine.running())
+			return coroutine.yield()
+		end
+
+		return value :: T
+	end
+
+	return send, recv
+end
+
+return chan
diff --git a/.lune/util/exec.luau b/.lune/util/exec.luau
index aaf1931..4bda6b6 100644
--- a/.lune/util/exec.luau
+++ b/.lune/util/exec.luau
@@ -1,123 +1,103 @@
---> lib: Builder pattern class to spawn child processes
-
-local process = require("@lune/process")
-local stdio = require("@lune/stdio")
-
-local CommandBuilder = {}
-
-export type CommandBuilder = typeof(setmetatable(
-	{} :: CommandBuilderFields,
-	{ __index = CommandBuilder }
-))
-type CommandBuilderFields = {
-	program: string,
-	args: { string },
-	stdioStrategy: IoStrategyMapping?,
-}
-export type StdioStrategy = "pipe" | "forward" | "none"
-export type IoStrategyMapping = {
-	stdout: StdioStrategy?,
-	stderr: StdioStrategy?,
-}
-
-local DEFAULT_STDIO_STRATEGY: IoStrategyMapping = {
-	stdout = "pipe",
-	stderr = "pipe",
-}
-function CommandBuilder.new(program: string)
-	return setmetatable(
-		{
-			program = program,
-			args = {},
-			stdioStrategy = nil,
-		} :: CommandBuilderFields,
-		{
-			__index = CommandBuilder,
-		}
-	)
-end
-
-function CommandBuilder.withArg(
-	self: CommandBuilder,
-	arg: string
-): CommandBuilder
-	table.insert(self.args, arg)
-	return self
-end
-
-function CommandBuilder.withArgs(
-	self: CommandBuilder,
-	args: { string }
-): CommandBuilder
-	for _, arg in args do
-		self:withArg(arg)
-	end
-
-	return self
-end
-
-function CommandBuilder.withStdioStrategy(
-	self: CommandBuilder,
-	strategy: StdioStrategy | IoStrategyMapping
-): CommandBuilder
-	self.stdioStrategy = if typeof(strategy) == "string"
-		then {
-			stdout = strategy,
-			stderr = strategy,
-		}
-		else strategy
-	return self
-end
-
-local function intoSpawnOptionsStdioKind(
-	strategy: StdioStrategy
-): process.SpawnOptionsStdioKind
-	if strategy == "pipe" then
-		return "default"
-	end
-
-	if strategy == "forward" then
-		return "forward"
-	end
-
-	if strategy == "none" then
-		return "none"
-	end
-
-	error(`Non-strategy provided: {strategy}`)
-end
-
-function CommandBuilder.exec(self: CommandBuilder): process.SpawnResult
-	print(
-		"$",
-		stdio.style("dim") .. self.program,
-		table.concat(self.args, " ") .. stdio.style("reset")
-	)
-
-	local function translateIoStrategyMappings(mappings: IoStrategyMapping)
-		local translatedMappings: process.SpawnOptionsStdio = {}
-		for field: string, value in pairs(mappings) do
-			translatedMappings[field] = intoSpawnOptionsStdioKind(value)
-		end
-
-		return translatedMappings
-	end
-
-	local child = process.spawn(self.program, self.args, {
-		shell = true,
-		stdio = translateIoStrategyMappings(
-			self.stdioStrategy or DEFAULT_STDIO_STRATEGY
-		),
-	})
-
-	if not child.ok then
-		print(
-			`\n{stdio.color("red")}[luau-lsp]{stdio.color("reset")} Exited with code`,
-			child.code
-		)
-	end
-
-	return child
-end
-
-return CommandBuilder
\ No newline at end of file
+--> lib: Builder pattern class to spawn child processes
+
+local process = require("@lune/process")
+local stdio = require("@lune/stdio")
+
+local CommandBuilder = {}
+
+export type CommandBuilder = typeof(setmetatable({} :: CommandBuilderFields, { __index = CommandBuilder }))
+type CommandBuilderFields = {
+	program: string,
+	args: { string },
+	stdioStrategy: IoStrategyMapping?,
+}
+export type StdioStrategy = "pipe" | "forward" | "none"
+export type IoStrategyMapping = {
+	stdout: StdioStrategy?,
+	stderr: StdioStrategy?,
+}
+
+local DEFAULT_STDIO_STRATEGY: IoStrategyMapping = {
+	stdout = "pipe",
+	stderr = "pipe",
+}
+function CommandBuilder.new(program: string)
+	return setmetatable(
+		{
+			program = program,
+			args = {},
+			stdioStrategy = nil,
+		} :: CommandBuilderFields,
+		{
+			__index = CommandBuilder,
+		}
+	)
+end
+
+function CommandBuilder.withArg(self: CommandBuilder, arg: string): CommandBuilder
+	table.insert(self.args, arg)
+	return self
+end
+
+function CommandBuilder.withArgs(self: CommandBuilder, args: { string }): CommandBuilder
+	for _, arg in args do
+		self:withArg(arg)
+	end
+
+	return self
+end
+
+function CommandBuilder.withStdioStrategy(
+	self: CommandBuilder,
+	strategy: StdioStrategy | IoStrategyMapping
+): CommandBuilder
+	self.stdioStrategy = if typeof(strategy) == "string"
+		then {
+			stdout = strategy,
+			stderr = strategy,
+		}
+		else strategy
+	return self
+end
+
+local function intoSpawnOptionsStdioKind(strategy: StdioStrategy): process.SpawnOptionsStdioKind
+	if strategy == "pipe" then
+		return "default"
+	end
+
+	if strategy == "forward" then
+		return "forward"
+	end
+
+	if strategy == "none" then
+		return "none"
+	end
+
+	error(`Non-strategy provided: {strategy}`)
+end
+
+function CommandBuilder.exec(self: CommandBuilder): process.SpawnResult
+	print("$", stdio.style("dim") .. self.program, table.concat(self.args, " ") .. stdio.style("reset"))
+
+	local function translateIoStrategyMappings(mappings: IoStrategyMapping)
+		local translatedMappings: process.SpawnOptionsStdio = {}
+		for field: string, value in pairs(mappings) do
+			translatedMappings[field] = intoSpawnOptionsStdioKind(value)
+		end
+
+		return translatedMappings
+	end
+
+	local child = process.spawn(self.program, self.args, {
+		shell = true,
+		stdio = translateIoStrategyMappings(self.stdioStrategy or DEFAULT_STDIO_STRATEGY),
+	})
+
+	if not child.ok then
+		print(`\n{stdio.color("red")}[luau-lsp]{stdio.color("reset")} Exited with code`, child.code)
+	end
+
+	return child
+end
+
+return CommandBuilder