built template

.editorconfig

@@ -0,0 +1,13 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.{lua,luau}]
+indent_style = tab
+indent_size = 4
+tab_width = 4
+max_line_length = 120

.gitignore

@@ -0,0 +1,5 @@
+/sourcemap.json
+/.cache/
+/output/
+*.rbxl
+*.rbxlx

.luaurc

@@ -0,0 +1 @@
+{ "languageMode": "strict" }

.styluaignore

@@ -0,0 +1 @@
+**/Modules/Libraries/External/**

.vscode/extensions.json

@@ -0,0 +1,7 @@
+{
+  "recommendations": [
+    "JohnnyMorganz.luau-lsp",
+    "JohnnyMorganz.stylua",
+    "EditorConfig.EditorConfig"
+  ]
+}

.vscode/settings.json

@@ -0,0 +1,13 @@
+{
+  "files.associations": { "*.lua": "luau", "*.luau": "luau" },
+  "[luau]": {
+    "editor.defaultFormatter": "JohnnyMorganz.stylua",
+    "editor.formatOnSave": true,
+    "editor.insertSpaces": false,
+    "editor.tabSize": 4,
+    "editor.detectIndentation": false
+  },
+  "luau-lsp.platform.type": "roblox",
+  "luau-lsp.sourcemap.enabled": true,
+  "luau-lsp.sourcemap.autogenerate": false
+}

CODE_STYLE.md

@@ -0,0 +1,173 @@
+# Code style
+
+Code should have clear indentation and generous spacing between logical steps, so a reader can follow it without unpacking a dense block.
+
+## Tabs and layout
+
+- Use real tabs for Luau/Lua indentation, displayed at four columns.
+- Use spaces around operators and after commas. Let StyLua handle continuation indentation; do not align columns by hand.
+- Keep lines within 120 columns where practical. Wrap long signatures and calls with one argument per line.
+- Prefer double-quoted strings, LF line endings, a final newline, and no trailing whitespace.
+- Keep one statement per line. Do not compress guards, loops, or functions onto a single line.
+
+`stylua.toml` defines formatter settings. `.editorconfig` gives editors the same tab and newline conventions.
+
+## Vertical spacing
+
+Use one blank line to separate meaningful groups:
+
+- Module comments, services, dependencies, types/constants, and the module implementation.
+- Local declarations from the work that uses them.
+- Guard clauses from the main path.
+- Loops and conditionals from the next independent step.
+- A side effect or calculation from the final return.
+- Function definitions, including methods inside a returned API table.
+
+Keep related assignments together, such as updating a position's X/Y values or configuring a UI object. Do not put blank lines between every table field or every assignment. Avoid several consecutive blank lines, decorative dividers, and empty lines immediately inside a block.
+
+```luau
+local function join(player: Player, token: number): ()
+	local entry = players[player]
+
+	if not entry or entry.token ~= token then
+		return
+	end
+
+	local room = rooms[entry.roomId]
+
+	if not room then
+		publish(player, "This lobby is no longer available.")
+
+		return
+	end
+
+	room.guest = player
+	entry.ready = true
+
+	startMatch(room)
+end
+```
+
+StyLua preserves intentional blank lines; grouping statements remains the author's responsibility.
+
+### Block endings
+
+After the final `end` in a guard, loop, conditional branch, callback, or function, leave one blank line before the next independent statement. This makes the end of one piece of logic visible before the next piece begins. Keep `else`, `elseif`, `until`, closing parentheses, commas, and table braces adjacent to the `end` they continue.
+
+```luau
+if not player then
+	return
+end
+
+local profile = profiles[player]
+
+for _, item in ipairs(items) do
+	process(item)
+end
+
+publish(profile)
+```
+
+Do not add blank lines between an `end` and the `end` of its containing block. Do not use several blank lines or put an empty line immediately after an opening block. One blank line is the standard separator.
+
+### Local declarations
+
+Keep consecutive local declarations together. After the final local variable declaration, leave one blank line before the statement that uses those values. This separates setup from work while keeping related variables easy to scan.
+
+```luau
+local bounceProgress = 1 - bounceTime / BOUNCE_DURATION
+local compression = math.exp(-progress * 4) * math.cos(progress * 8)
+local normal = 1 - compression * 0.42 * bounceStrength
+local tangent = 1 + compression * 0.5 * bounceStrength
+
+setBallSize(
+	BALL_WIDTH * (if bounceHorizontal then normal else tangent),
+	BALL_HEIGHT * (if bounceHorizontal then tangent else normal)
+)
+```
+
+Do not put blank lines between variables that belong to the same setup group. Keep multiline declarations together until their closing expression.
+
+### Assignment groups
+
+Treat assignments that update state the same way as local declarations. Consecutive assignments to related variables may stay together, but separate that group from calls, conditionals, loops, and other work with one blank line on each side. This keeps a state change visually distinct from the operation that follows it.
+
+```luau
+setBallSize(width, height)
+
+bounceTime = math.max(0, bounceTime - dt)
+
+setBallSize(BALL_WIDTH, BALL_HEIGHT)
+```
+
+Keep assignments that belong to one transition together:
+
+```luau
+bounceTime = BOUNCE_DURATION
+bounceHorizontal = false
+bounceStrength = 1
+
+touchingWall = atWall
+```
+
+### String composition and property edits
+
+When a string is built across several lines with `..`, keep the complete assignment together, then leave one blank line before the next condition, call, or assignment. Treat property edits the same way: an assignment such as `label.TextColor3 = color` gets its own space before the next operation. A related run of property assignments may stay together when they form one transition.
+
+```luau
+rewards.Text = "<font color=\""
+	.. color
+	.. "\">"
+	.. xp
+	.. " XP</font>"
+
+if result.xpRequired then
+	xpLabel.TextColor3 = gold
+
+	animateXP(result)
+end
+```
+
+## Modules and names
+
+Start runtime Luau modules with `--!strict`. Keep services and shared dependencies near the top, followed by types, constants, module state, helpers, and public functions. End with the module return.
+
+Use PascalCase for module names and exported types, camelCase for functions, variables, and record fields, and UPPER_SNAKE_CASE for local constants. Configuration files keep their established PascalCase keys. Prefer descriptive names; short coordinate names such as `x`, `y`, and `dt` are appropriate in simulation/rendering code.
+
+Use one name for one concept throughout a module. Choose names that describe the value's role (`player`, `profile`, `room`, `entry`, `settings`) and keep related names parallel (`host`/`guest`, `up`/`down`, `left`/`right`). Avoid switching between abbreviations and full names for the same value. Use `value` only for a genuinely generic value and prefer a domain name when its meaning is known.
+
+Keep each module responsible for one concern. Managers own state and rules; handlers connect those rules to Roblox services or presentation; libraries contain reusable behavior. Put first-party libraries in `Modules/Libraries/Internal` and third-party libraries in `Modules/Libraries/External`, under ReplicatedStorage for shared code or ServerStorage for private code. Preserve third-party licenses and formatting; `.styluaignore` excludes external libraries. Use shared types from `src/ReplicatedStorage/Modules/Types` instead of copying contracts.
+
+Use consistent public APIs for related behavior, with explicit parameters and shared implementations.
+
+## Functions, types, and tables
+
+Prefer guard clauses over deeply nested branches. Keep simple value choices as short `if` expressions; use ordinary `if/elseif/else` statements when a choice becomes hard to read.
+
+Annotate public function parameters and return values where useful, and use shared domain types. Infer obvious local types. Avoid `any`; validate unknown remote or saved data at its boundary.
+
+Small records may stay inline if they are easy to scan. Larger records and nested configuration should use one field per line with trailing commas. Group related fields with a blank line only when it clarifies the structure.
+
+Use multiple assignment for values that belong to the same operation, such as coordinates or a coordinated state transition. Declare unrelated values separately.
+
+## Comments and rendering
+
+Comments explain intent, constraints, or surprising behavior. Avoid narrating obvious assignments or repeating a function's name.
+
+Keep work in frame callbacks bounded and avoid unnecessary allocations. Disconnect event connections and release owned instances when their owner is destroyed. Verify rendering and input in Studio. Formatting changes must not alter runtime behavior.
+
+## Before finishing a change
+
+Format first-party source and checks:
+
+```sh
+nix-shell --run 'stylua src tests tools'
+```
+
+For behavior changes, run the existing checks:
+
+```sh
+nix-shell --run 'bash tools/check.sh'
+```
+
+Use focused regression tests for bugs and real Studio checks for rendering changes. Do not reformat vendored packages or backup archives. Keep formatting-only changes separate from behavior changes when reviewing the diff.

README.md

@@ -0,0 +1,88 @@
+# Roblox Luau environment
+
+A reusable starting point extracted from the parent project's development environment. Copy the **contents** of this folder, including dotfiles, into a new repository. It has its own project mapping, source examples, tools, and documentation; commands below run from that new root (or from `luaenv` while trying it here).
+
+## Requirements and first run
+
+Install [Nix](https://nixos.org/download/) with a configured `nixpkgs` channel, and install Roblox Studio on a supported operating system. Nix supplies the command-line tools; it does not install or run Studio. On Linux, use a separate Studio setup or machine. Studio must be able to reach the machine running Argon.
+
+```sh
+nix-shell
+argon --version
+stylua --version
+bash tools/check.sh
+argon serve default.project.json --sourcemap
+```
+
+Or run tools without entering an interactive shell:
+
+```sh
+nix-shell --run 'bash tools/check.sh'
+nix-shell --run 'argon serve default.project.json --sourcemap'
+```
+
+Rename `MyGame` in `default.project.json`. Follow [the Argon guide](docs/argon.md) to connect Studio. Press Play: the starter prints `Server ready` on the server and `Client ready` on the client. Replace these examples with your game's startup code.
+
+## Included tools
+
+| Tool | Purpose |
+| --- | --- |
+| Argon | Sync source into Studio; generate the instance sourcemap; build place files. |
+| StyLua | Format Lua/Luau using `stylua.toml`. |
+| luau-lsp | Editor language service and command-line Roblox type checking. |
+| Luau | Run tests for pure Luau modules outside Studio. |
+| Darklua | Optional source transformations for tests or builds. |
+| Lua 5.4 | Optional execution of transformed code with game-specific Roblox mocks. |
+| curl | Download Roblox type definitions for command-line analysis. |
+
+`shell.nix` uses the same tool list as the source project. It imports `<nixpkgs>` from your local configuration, so versions are **not pinned**. Pin nixpkgs in your project if developers and CI need identical versions. No Wally, Selene, Rojo, or Aftman setup is required or bundled.
+
+## Source structure
+
+```text
+src/
+├── ReplicatedFirst/                   # Optional early loading scripts
+├── ReplicatedStorage/Modules/         # Shared code visible to clients
+│   ├── Config/
+│   ├── Handlers/
+│   ├── Libraries/
+│   │   ├── External/                 # Third-party libraries
+│   │   └── Internal/Numbers.lua      # First-party example module
+│   ├── Managers/
+│   └── Types/
+├── ServerScriptService/
+│   └── InitServer.server.lua          # Server entry point
+├── ServerStorage/Modules/             # Private server code
+│   ├── Config/
+│   ├── Handlers/
+│   ├── Libraries/
+│   │   ├── External/                 # Server-only third-party libraries
+│   │   └── Internal/                 # Server-only first-party libraries
+│   └── Managers/GameManager.lua
+└── StarterPlayer/StarterPlayerScripts/
+    └── InitClient.client.lua          # Client entry point
+tests/                                # Native Luau tests
+tools/                                # Check script and Darklua config
+docs/                                 # Setup and tooling notes
+```
+
+`default.project.json` maps these paths into Roblox services and creates `ReplicatedStorage.Remotes` and `StarterGui`. UI can be created in code or explicitly mapped later. Empty directories contain `.gitkeep` placeholders for Git. Add files under mapped directories without adding each script to the project file. Libraries go in `Modules/Libraries/Internal` for first-party code and `Modules/Libraries/External` for third-party code. Both sync automatically; `.styluaignore` excludes external libraries from formatting. Folders outside the mapped tree are not synced automatically.
+
+Managers own state and rules, handlers connect behavior to events or presentation, libraries provide reusable operations, and Types holds shared contracts. This organization is a convention, not a runtime framework. Startup order remains explicit in the entry scripts. Code and configuration placed in ReplicatedStorage are visible to clients; keep server-only logic and secrets out of it.
+
+## Formatting, editing, and checks
+
+Read [CODE_STYLE.md](CODE_STYLE.md). Use tabs displayed at four columns, a 120-column target, double-quoted strings, LF endings, strict runtime modules, and blank lines between logical steps. StyLua formats syntax; authors still choose meaningful grouping and names.
+
+```sh
+nix-shell --run 'stylua src tests tools'
+nix-shell --run 'bash tools/check.sh'
+```
+
+The check script checks formatting, regenerates `sourcemap.json`, checks `src` against Roblox types, then runs each `tests/*.luau` file in its own native Luau process. It exits on the first failure. Add regression tests as behavior grows. See [tooling notes](docs/tooling.md) for cached type definitions, editor setup, dependencies, and optional Lua 5.4 tests.
+
+CLI tests do not provide the Roblox engine. Use Studio's Play and Server & Clients tests for services, networking, rendering, physics, input, and platform behavior. Test with multiple clients and the Device Emulator when those features matter to your game.
+
+## What was generalized
+
+The Nix shell, StyLua configuration, EditorConfig, strict `.luaurc`, service-based layout, and style conventions come from the source project. The project mapping and startup scripts are new generic examples. Checks now regenerate the sourcemap and use the project-neutral `ROBLOX_TYPES` variable. Game code, assets, third-party packages, dependency stubs, and game-specific mock tests are omitted. Add those only as your new game needs them.

default.project.json

@@ -0,0 +1,17 @@
+{
+  "name": "MyGame",
+  "tree": {
+    "$className": "DataModel",
+    "ReplicatedFirst": { "$path": "src/ReplicatedFirst" },
+    "ReplicatedStorage": {
+      "Remotes": { "$className": "Folder" },
+      "Modules": { "$path": "src/ReplicatedStorage/Modules" }
+    },
+    "ServerScriptService": { "$path": "src/ServerScriptService" },
+    "ServerStorage": { "$path": "src/ServerStorage" },
+    "StarterPlayer": {
+      "StarterPlayerScripts": { "$path": "src/StarterPlayer/StarterPlayerScripts" }
+    },
+    "StarterGui": { "$className": "StarterGui" }
+  }
+}

docs/argon.md

@@ -0,0 +1,48 @@
+# Argon setup
+
+1. Install the Argon Studio plugin using the official [Argon documentation](https://argon.wiki/docs/intro). Enable it in Studio's Plugins tab. The Nix shell supplies the CLI; the Studio plugin is installed separately.
+2. Open a new or backed-up place in Studio. Set `name` in `default.project.json` to your game's name. The project tree defines which filesystem paths sync to which services.
+3. From the project root, start the server:
+
+   ```sh
+   nix-shell --run 'argon serve default.project.json --sourcemap'
+   ```
+
+4. In the Studio plugin, connect to the address and port printed by the CLI. Review the proposed changes before syncing. Allow any plugin permissions Studio requests for the connection. The starter owns its mapped instances; importing an existing place requires reconciling its instance tree with the filesystem first.
+5. Keep the command running while editing, and press Play in Studio to run the game. Stop play and restart clients/server after startup or protocol changes. Stop Argon with Ctrl+C when done.
+
+For different machines or a VM, configure a reachable host and port with `argon serve --host <address> --port <port>`. Use `argon serve --help` for your installed version's options. Use a trusted network and the printed port; a remote Studio instance cannot connect through its own `localhost` to another machine.
+
+## File conventions
+
+- `Name.server.lua` or `.server.luau` becomes a Script.
+- `Name.client.lua` or `.client.luau` becomes a LocalScript.
+- `Name.lua` or `.luau` becomes a ModuleScript.
+- A directory containing `init.lua` or `init.luau` becomes a ModuleScript with children. Otherwise it becomes a Folder. Script variants such as `init.server.lua` set the corresponding script class.
+
+For example, require the shared example as `require(ReplicatedStorage.Modules.Libraries.Internal.Numbers)`. Require a third-party module as `require(ReplicatedStorage.Modules.Libraries.External.Vendor)`. Filesystem-relative requires in native Luau tests are separate from Roblox instance-based requires in runtime code.
+
+## Sourcemaps and builds
+
+The sourcemap connects filesystem source to Roblox instance paths for luau-lsp; it is not runtime code. `--sourcemap` updates it while serving. Generate it without Studio with:
+
+```sh
+nix-shell --run 'argon sourcemap default.project.json --output sourcemap.json'
+```
+
+The check script runs this automatically. Generated maps are ignored by Git. Rebuild the map when adding, moving, or deleting modules; stale maps can cause incorrect require diagnostics.
+
+To build a local place artifact:
+
+```sh
+mkdir -p output
+nix-shell --run 'argon build default.project.json --output output/MyGame.rbxlx'
+```
+
+Building is separate from publishing to Roblox. Use Studio to inspect, playtest, and publish the resulting place.
+
+## Adding packages or services
+
+Put third-party runtime code in `src/ReplicatedStorage/Modules/Libraries/External/<Vendor>/`, retaining its license. Put your own reusable modules in `src/ReplicatedStorage/Modules/Libraries/Internal/`. For server-only libraries, use the equivalent directories under `src/ServerStorage/Modules/Libraries/`. These directories are already mapped, so no additional project entries are needed. A vendor's `init.lua` or `init.luau` becomes its module entry point. Import the runtime source rather than an entire vendor repository with tooling and examples. Do not run two sync sessions that own the same instances. `.styluaignore` excludes external libraries from first-party formatting commands.
+
+To add file-based UI or other services, add the corresponding directory and `$path` mapping. Avoid copying game-specific device orientation, mouse lock, assets, or package mounts into every new game; choose those per project.

docs/tooling.md

@@ -0,0 +1,45 @@
+# Tooling details
+
+## Editor setup
+
+Open the new project root in your editor. `.editorconfig` defines UTF-8, LF, final newlines, no trailing whitespace, and four-column tabs for Lua/Luau. `stylua.toml` defines formatting; `.luaurc` sets strict analysis by default.
+
+The optional `.vscode` files recommend Luau Language Server, StyLua, and EditorConfig, associate both source extensions with Luau, and enable format-on-save. Install these extensions yourself. Ensure the editor and extensions can locate tools from `nix-shell`, for example by launching the editor from that shell. An already-running editor may retain its old environment.
+
+The editor configuration disables Rojo-based sourcemap autogeneration because Argon generates `sourcemap.json`. Run Argon with `--sourcemap` or run `tools/check.sh` before expecting instance-aware requires to resolve. Editor Roblox definitions are managed by the language-server extension; the CLI check supplies its own definitions explicitly.
+
+## Roblox definitions and analysis
+
+On first use, `tools/check.sh` downloads `globalTypes.d.luau` from luau-lsp into `.cache/`. This requires internet access. Later checks reuse the cached file. To use your own downloaded or pinned definitions, pass an absolute path:
+
+```sh
+ROBLOX_TYPES=/absolute/path/globalTypes.d.luau nix-shell --run 'bash tools/check.sh'
+```
+
+For reproducible CI, pin compatible tooling and the definitions revision together. The default download follows upstream `main`; refresh `.cache/globalTypes.d.luau` deliberately when upgrading tools. A nonempty cache is reused, so delete that file to fetch an updated copy. `ROBLOX_TYPES` replaces the source project's game-specific `PONG_ROBLOX_TYPES` name.
+
+The check command analyzes runtime source, then executes native tests. Runtime modules use Roblox instance requires, whereas standalone tests use relative file requires. Roblox services and globals such as `game`, `Instance`, and `Vector3` do not exist in the standalone runtime merely because the analyzer knows their types.
+
+## Test strategy
+
+Prefer pure modules for algorithms that can be tested directly with `luau`. `tests/numbers.luau` demonstrates this using the starter module. Add test files directly under `tests/` with a `.luau` extension for automatic execution by the check script. Organize more elaborate suites behind their own entry points when needed.
+
+Use Studio for engine behavior. If you need external integration tests, design explicit mocks and a loader for your own game's Roblox dependencies. The parent project's Lua mocks, Jolt integration harness, and declaration stubs are tied to its game and are intentionally not included here.
+
+## Optional Darklua / Lua 5.4 path
+
+The shell includes Darklua and Lua 5.4 to support the parent project's testing approach. `tools/darklua.json` removes types, if-expressions, compound assignments, and `continue`, producing readable output. This step is optional and is not part of the starter check script:
+
+```sh
+mkdir -p output
+nix-shell --run 'darklua process src output/lua -c tools/darklua.json'
+nix-shell --run 'lua -e '\''assert(_VERSION == "Lua 5.4")'\'''
+```
+
+Always transform into a separate generated directory. Studio runs the original strict Luau source. These transformations do not emulate Roblox, rewrite all instance-based requires, or guarantee compatibility for every Luau feature. Lua 5.4 tests need appropriate mocks, module loading, and compatibility helpers; native Luau is preferable when those adaptations are unnecessary.
+
+## Dependencies and future tools
+
+Place runtime dependencies in `Modules/Libraries/External` under the appropriate shared or server-only source tree; Argon already maps these directories. First-party libraries belong in `Modules/Libraries/Internal`. `.styluaignore` keeps third-party formatting intact. The type checker still analyzes source under `src`, including external libraries. If luau-lsp cannot analyze a dependency, add narrowly scoped declarations or an analysis strategy for that dependency; analysis stubs never replace its runtime implementation. Document versions and licenses. Wally or other package managers can be added later, but this template uses no dependency installer or generated package tree.
+
+This shell does not install Selene. StyLua checks formatting and luau-lsp checks types; add a linter and its Roblox configuration explicitly if desired. Keep builds, downloaded types, and sourcemaps out of source control. Commit the project mapping, source, tests, shell, and formatter settings.

shell.nix

@@ -0,0 +1,4 @@
+{ pkgs ? import <nixpkgs> {} }:
+pkgs.mkShell {
+  packages = with pkgs; [ luau luau-lsp darklua lua5_4 stylua curl argon ];
+}

src/ReplicatedStorage/Modules/Libraries/Internal/Numbers.lua

@@ -0,0 +1,9 @@
+--!strict
+
+local Numbers = {}
+
+function Numbers.clamp01(value: number): number
+	return math.clamp(value, 0, 1)
+end
+
+return Numbers

src/ServerScriptService/InitServer.server.lua

@@ -0,0 +1,6 @@
+--!strict
+
+local ServerStorage = game:GetService("ServerStorage")
+local GameManager = require(ServerStorage.Modules.Managers.GameManager)
+
+GameManager.start()

src/ServerStorage/Modules/Managers/GameManager.lua

@@ -0,0 +1,9 @@
+--!strict
+
+local GameManager = {}
+
+function GameManager.start(): ()
+	print("Server ready")
+end
+
+return GameManager

src/StarterPlayer/StarterPlayerScripts/InitClient.client.lua

@@ -0,0 +1,6 @@
+--!strict
+
+local ReplicatedStorage = game:GetService("ReplicatedStorage")
+local Numbers = require(ReplicatedStorage.Modules.Libraries.Internal.Numbers)
+
+print("Client ready", Numbers.clamp01(0.5))

stylua.toml

@@ -0,0 +1,7 @@
+column_width = 120
+line_endings = "Unix"
+indent_type = "Tabs"
+indent_width = 4
+quote_style = "AutoPreferDouble"
+call_parentheses = "Always"
+collapse_simple_statement = "Never"

tests/numbers.luau

@@ -0,0 +1,9 @@
+--!strict
+
+local Numbers = require("../src/ReplicatedStorage/Modules/Libraries/Internal/Numbers")
+
+assert(Numbers.clamp01(-2) == 0, "Negative values should clamp to zero")
+assert(Numbers.clamp01(0.5) == 0.5, "Values within the range should be preserved")
+assert(Numbers.clamp01(3) == 1, "Values above one should clamp to one")
+
+print("Numbers checks passed")

tools/check.sh

@@ -0,0 +1,34 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+project_dir="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "$project_dir"
+
+stylua --check src tests tools
+argon sourcemap default.project.json --output sourcemap.json
+
+definitions="${ROBLOX_TYPES:-$project_dir/.cache/globalTypes.d.luau}"
+
+if [[ -n "${ROBLOX_TYPES:-}" ]]; then
+    if [[ ! -s "$definitions" ]]; then
+        printf 'ROBLOX_TYPES must point to a nonempty Roblox definitions file: %s\n' "$definitions" >&2
+        exit 1
+    fi
+elif [[ ! -s "$definitions" ]]; then
+    mkdir -p .cache
+    temporary_definitions="$(mktemp "$project_dir/.cache/globalTypes.XXXXXX")"
+    trap 'rm -f -- "$temporary_definitions"' EXIT
+    curl -fL --retry 2 --max-time 60 -sS \
+        https://raw.githubusercontent.com/JohnnyMorganz/luau-lsp/main/scripts/globalTypes.d.luau \
+        -o "$temporary_definitions"
+    mv -- "$temporary_definitions" "$definitions"
+fi
+
+luau-lsp analyze --platform=roblox --definitions="$definitions" --sourcemap=sourcemap.json src
+
+for test_file in tests/*.luau; do
+    [[ -f "$test_file" ]] || continue
+    luau "$test_file"
+done
+
+printf 'Checks passed.\n'

tools/darklua.json

@@ -0,0 +1 @@
+{ "rules": ["remove_types", "remove_if_expression", "remove_compound_assignment", "remove_continue"], "generator": "readable" }