WARD/EN6000

A directive is one entry file plus the modules it includes. The entry file starts with language 2; and holds exactly one on start block, which runs when the drone leaves the airlock. Everything else, in any file, is a function or an enum declaration.

• includeinclude "path.warden"; links another file at that point. Paths are relative to the file that includes them, without .. or a leading slash. A file is linked once however many times it is included, and a circular include is refused.
• ModulesA module contains functions, enums and includes. It may not declare language or on start. The shipped modules live under lib/; yours can too.
• Comments// to the end of the line or /* across lines */. A docblock above a function is what the editor shows on hover.
• NamesLetters, digits and underscores, not starting with a digit. One namespace for functions, enums, parameters and locals; a directive's own enum names are reserved.

Parentheses group. Conditions treat false, null, 0 and "" as false and everything else as true. Expressions may nest 64 deep.

• letDeclares a local with an initial value. A local lives to the end of its block and may be reassigned.
• AssignmentThe target is a name, a field (r.x) or an index (a[i]). Records and arrays are shared by reference, so the change is seen everywhere the value is held.
• if / elseBraces are always required. else if is an else whose block holds an if.
• whileThe only loop. break leaves it, continue goes back to the condition. There is no for; count with a local.
• returnLeaves the function with a value, or null when none is given. Inside on start it ends the directive. A directive that ends without extract() strands the drone.
• ExpressionAny call or expression followed by ;. Hardware calls are usually written this way and their Result ignored; the library checks them.

Blocks nest 64 deep and a directive holds at most 4,000 statements. Semicolons end every simple statement.

• fnfn name(params) { ... } at the top level of any file. Parameters are positional; a call must supply every one.
• AnnotationsOptional on parameters and the return: x: number, : MoveResult. Types are number, string, boolean, site, array, record, function, any or an enum name. The editor checks literals against them before dispatch; the controller checks the value when it arrives.
• CallbacksA function is a value. move_to takes a response callback, calls it response(seen, style) before every step and acts on its Response. Write your own instead of defend.
• pure fnMay read observe() and cell() and compute, but any hardware action inside it, or inside anything it calls, halts the directive. Route planning is pure; the shipped planner is one.
• RecursionAllowed, 32 calls deep including the callbacks the library makes into your code.

enumsenum Order { core_first, recorder_first }

fn plan(order: Order) {
    if (order == Order.core_first) { ... }
}

// A member's value is its own name as a string.
log(Style.quick == "quick"); // true

enum Name { member, ... } declares a set of values at the top level of any file. Use them as Name.member; a bare name or an undeclared member is a compile error. Passing a string literal where an enum is expected is refused unless it is a member, and the Workbench then shows the member to write instead.

The hardware's own enums are always in scope:

The library adds Style, MoveResult, Response and Search, listed with it below.

• objectivesIn the ship's order. kind is a Task, priority a Priority, status a Progress evaluated as the drone goes.
• candidatesThe site names that may house a recovery's item, in the ship's order. A suggestion, never the item's true position; housings(item) turns them into positions.
• site, methodFor a survey objective: the site to confirm and whether Method.observe (be there) or Method.scan (scan there) satisfies it.
• extractionThe airlocks the contract accepts. home_site() is the first.

A plan that reads the briefing instead of naming sites flies on any wreck. The shipped recover and survey do exactly that.

VALIDATE compiles the directive against the drone's actual fit and the wreck's chart before dispatch. TEST BENCH runs it on a prebuilt scenario with breakpoints, stepping and a live schematic; the debugger is never available on a real salvage. The same checks run in VS Code through the WARD/EN extension and its language server.

See the test bench The course