New in ShotScript
module Result makes the type ResultModule, so a type called Result can sit beside it.
Renaming or moving a class, module or type rewrites every use, from imports to doc links, in one undo step.
Write define public type X beside the code using it: check copies it into Types.shot, with errors at that line.
shot map shows a linked project as a link to its file, and check no longer reads it as yours.
In a Roblox or Generic project, use Inventory and import Item from Inventory reach a linked project's root, typed as it.
shot check asks for one top-level module in a Roblox or Generic project, named after the project.
An error about a name one typo away from a real one ends with "did you mean" and that name.
Every script is checked in Luau's strict mode, no --!strict line needed; a .luau file may opt out.
A disabled script doesn't run, and shot run says so; map, outline and api mark it, and check still reads it.
A script starting with @api is the interface of the scripts under it: only types its export lines name leave it.
A Types.shot can import QuickSignal from QuickSignal, and a class can extend Mop or QuickSignal.
shot map and overview count every file, api and outline show members as declared, and a silent run says what ran.
shot check notes an instance that can't work where it sits, such as UI with no Window above it.
RobloxFileService reads the tags and whole-number attributes of places saved by current Studio.
A function's return type may now sit on the line after its closing ), as in Luau.
A stray }, code after a closing } or a nameless class = { gets an error naming the fix.
A malformed use line now suggests forms that reach one of your project's own modules, like use script.Parent.Bank.
Parameter lists spanning several lines no longer shift later errors: shot check names their right line and column.
shot refs Wallet.Pay no longer lists lines that only store a Wallet as an interface, and names that interface instead.
shot build removes files an earlier build wrote that the project no longer has, and leaves every other file alone.
A doc comment above an event line is that event's doc, and shot outline and shot show print it.
table.insert, remove, clear, sort and move on an owned field from outside its system are errors, like a direct write.
shot doc Wallet prints a page: members in groups with their docs, and links to the types it names.
shot run lists and plays only your project's own scenarios; with none, it says how to write the first one.
The client and server checks and remote signature checks now follow modules and remotes reached through use lines.
A run or shot check right after you edit a project you use reads that edit, with no save first.
Older code that sets Button's HoverLift or PressLift still runs: each sets the matching colour; completion offers only HoverColor and PressColor.
A use external path changed to a same-named file moves its header line, keeping alias and interface; unused lines go.
shot run stops at any @shot path check refuses, with its words; check flags .luau string requires a run refuses.
Errors name the fix for your own line: a dot call becomes ProcessService:StartAsync(...), an @shot path use root.Data.Greeter.
A wrong service name (Process, ProcesService, Files) now names the nearest service and the use line to write.
New pages: how a script uses its project's modules, and a System project's own scenarios. Guides now use .ssp.
New pages walk through FileService, every service, how instances behave, and using another project with use external.
A System project's check holds each Generic project it uses to Generic's rules, with one error at the use line.
A file whose declaration has another name now says how to fix it: rename the declaration, or rename the file.
shot move to a new .shot name renames the declaration that matched the old name, and says how to find what still uses it.
A project is one .ssp file for every kind; older .shotsystem projects still open and can be saved as .ssp.
shot new takes --kind system, roblox or generic and writes a project of that kind; System is the default.
pcall, xpcall and debug.traceback in a program now give the .shot file and line of an error, like an uncaught one.
shot trace now follows functions handed to later calls, like a timer's After, a page's Handle and BindToClose.
A use line that shot check refuses now stops shot run at that line with the same message.
A require that names nothing now lists the project's services and built-in modules, and how its own modules are reached.
Instance.new with a misspelled class now says which class to write, then lists what it can make.
ProcessService:AttachAsync gets a running program by its pid, and GetChildProcessesAsync lists the programs a program started.
ProcessService:StartAsync gets the first program of a run going much sooner, even with several programs starting at once.
Destroying a page server ends every open page's live channel at once, and each page hears that it closed.
A Handle route ending in /* answers every path below it that no other route, page or file answers.
Instance.BulkSet sets one property on many instances and SetProperties sets many on one instance, all or nothing.
ProgramService reads environment variables and known folders, BindToClose runs cleanup before the program ends, and ExitAsync ends it.
HttpService:ServeAsync starts a local server that other programs call by method and path; requests from browser pages are refused.
shot check on a System project now knows the standard library's services and datatypes and checks every call into them.
A .shot script is a Script at run time, IntValue holds whole numbers, and printing an instance prints its name.
Started programs are ProcessHandler objects named after the program, and KillAsync ends a whole process tree and says how many ended.
CreateTimer makes a timer to start, stop and reset, CreateAlarm fires at a clock time, and every timer counts its fires.
FollowAsync gives a FileFollower that hands over each new line and can pause; WatchAsync reports files added, changed or removed.
ProgramService gives a program its arguments, project path, working folder and a data folder of its own for settings and logs.
A decoded file encodes back with its key order, empty arrays and nulls kept, so files other tools write stay tidy.
NumberSequence and ColorSequence work in programs with Roblox's keypoint rules, and collectgarbage("count") gives memory in KB.
Vector3, Color3, CFrame, UDim2 and the other datatypes now work in programs, with Transition, Font, Icon and Curve values beside them.
The editor's local server now needs its own key and refuses other sites, and a change to many items at once is one undo step.
Run plays the editor's copy, with a Run menu for the program or each scenario, and leaves the file and its history untouched.
Services, files and the handles they give out are instances with events, Destroy, Clone and Instance.new, called with a colon as in Roblox.
New projects start with a Main.shot program, and the insert menu's Script makes one, so a program no longer needs plain Luau.
shot help, shot map and shot overview work on a System project and describe its own tree, export and services.
In a System project shot check names the Roblox forms that don't run there, like game:GetService, workspace and Enum, and says what to write instead.
In a System project shot check reports a write to a bare global, like Counter = 1, as an error. Use a local instead.
Writes and appends to one file started at once now take turns, so every line lands, in the order it was written.
shot show, shot edit and shot write work on a project's .shotsystem header, so you can change its export line.
A project records the interfaces it uses; when one changes, shot check shows the difference and shot external accept takes it.
use external "Bank.shotsystem" brings in another project's export, root names your own project's root, and shot check types both.
Code using a service is checked against it, by shot check and as you type: a misspelt member is an error at its line.
shot new makes a project that runs at once; the insert menu starts each module, class and program from a template that checks clean.
Write use ProcessService, use FileService or another service by name; shot check types every call.
HttpService sends GET and POST requests and gives back the status, headers and body.
PageService serves a project's own web page with a live channel both ways, for tools with a window of their own.
JsonService encodes and decodes JSON; TimeService gives the time, formats it and runs code after a delay or on a timer.
FileService reads, writes, appends, lists, copies and moves files and folders, and follows a growing log file.
ProcessService starts programs with no window, streams their output line by line and stops them with their children.
shot check types every object path from the project's tree, so a misspelt child or game is an error.
shot run runs a project's program, or plays a library's scenarios, outside Roblox.
Folders, scripts and value objects with attributes and tags, changed with shot create, set, attr and tag, each one undo step.
A whole project lives in one readable text file: shot new makes one, shot import turns a folder into one.
shot edit and shot write on an adopted game now report whether the changed script still parses, with the line of any new error.
shot adopt <folder> runs the shot tools on a Roblox game mirrored to disk as plain Luau, converting nothing.
event ItemSold(...) on ShopBus puts an event on a bus module of your own instead of EventBus.
event CoinsGiven(...) published by Wallet, Shop names the systems that publish it; shot check flags any other publish.
invariant WalletServer.CoinsInRange names a function that checks a rule, and shot run checks it after every frame of every scenario.
shot savelock records each saved section's shape; shot check flags a change that no Version bump and Migrate step covers.
function Start() after Wallet.Start says which start runs first, and shot check checks the order of the start calls.
owns Purse.Coins via WalletServer.Grant: a write to the field from another system is an error naming that function.
RemoteEvent (board : Board) in a .instance file: shot check flags payloads Roblox can't send and sends that don't match.
id ProductId declares a kind of string id, and shot check catches a misspelt one and names the id you meant.
Declare an event once in a system's Types.shot, and shot check checks every publish and every listener against it.
shot needs Bank.Give lists the state it reads and who writes it, and shot show lists what a member connects to.
Some one-file projects could not be opened, from the terminal or in Studio. Now every one can.
shot brief takes what you are about to do and prints one page: the systems it touches, their rules and members.
Keep .luau files beside your .shot files: they build as they are, are type checked, and use reaches them.
In a class that extends another, super.new(...) and super:Name(...) call the parent's constructor and methods.
With the plugin in Studio, each change is one Studio undo step, Studio edits come back, and playtests reload changed code.
A whole project in one place file that Studio opens and plays, with undo and history for every change.
shot graph writes one page of every system, what it uses and its events, and marks events nobody sends or hears.
List a system's uses in its Types.shot, and shot check flags every link you didn't plan and every pair that would use each other.
implements and required are promises shot check keeps: every member an interface lists, every function the game must call.
Branch on a string union's value with match, and shot check names every value a match doesn't handle yet.
shot trace Bank.Give shows what runs after it, through calls, events and remotes. --up shows what leads to it.
shot rename Wallet.Add Deposit renames a member and every real use of it, then checks the project.
use Bank requires the nearest module named Bank, looking up through the folders.
doc and rootdoc take Rules and Extend sections, and shot check flags a backticked name that no longer exists.
shot map, outline, show, find, refs and wiring answer with the file and line of what you asked for.
shot check reports parse errors, ShotScript's rules and Luau type errors at the .shot line and column.
Declare one class, module or func per .shot file, and the build writes the metatables, types and Types module.
shot run plays your scenarios in a mock Roblox, with a server, player clients, remotes and virtual time.
The build writes a Rojo layout, and a .instance file holding a RemoteEvent becomes a real remote that use reaches.
@server or @client on a file's first line makes it a script that runs when the game starts.
Mark code server or client and shot check keeps each side out of the other's. A split module has one version per side.