The mz compiler

mz is the compiler that implements the Mzizi language: toolchain, not the language itself. Today it is the Phase 0 front end: lex → parse → resolve → lower → IR, plus a contract evaluator (“lower” here means into the IR for a component). Two things lower to Rust: a service, which mz build turns into a local Rust + axum package, and a program, which mz build and mz run turn into a Rust package with no dependencies. No component lowers to Rust yet. It is the centre of the toolchain. It is a single Rust binary with no dependencies at all, which is a deliberate house convention rather than an oversight — a compiler whose check loop must stay sub-second on a modest laptop should not start life with a dependency tree to build first, and the small things it needs (JSON emission, SHA-256) are fully specified and therefore hand-rollable with verifiable correctness.

Getting it

There is no release, no published crate, and no installer. The crate is version = "0.0.0" with publish = false.

git clone https://github.com/mzizi-dev/mzizi.git
cd mzizi/compiler
cargo test                                                          # the compiler's tests
cargo run --bin mz -- check    ../primitives/button.mz              # does it compile
cargo run --bin mz -- contract ../primitives/button.mz              # does it do what it says
cargo run --bin mz -- fix      path/to/file.mz                      # apply every exact fix, check again
cargo run --bin mz -- check --agent ../examples/connectivity_bar.mz # NDJSON for an agent
cargo run --bin mz -- outline  ../primitives/alert.mz               # the interface, as valid Mzizi
cargo run --bin mz -- ir       ../primitives/card.mz                # nodes, hashes, structural paths
cargo run --bin mz -- build    ../examples/registry.mz --out out    # a service, lowered to Rust + axum
cargo run --bin mz -- run      ../examples/fib.mz                   # a program: lower, build, run
cargo run --bin mz -- harness  definition                           # the language as an agent reads it

Run cargo test --workspace from the repository root for the whole suite: 765 tests in 29 suites at 2b36c8f, 634 of them in the compiler crate and the rest in the benchmark harness, runner and probe crate. compiler/src is 33,540 lines. All 765 pass there, and the eight example programs run through mz run against their .expected files.

The commands

Command	What it does
`mz check <file.mz>`	Human-readable diagnostics, one per line, plus a summary
`mz check --agent <file.mz>`	The same diagnostics as NDJSON, plus a summary object
`mz fix <file.mz>`	Applies every `exact` fix in place, in one pass, then checks again
`mz contract <file.mz>`	Evaluates the `contract` block; `--agent` gives NDJSON with a tally
`mz outline <file.mz>`	The component’s interface only, emitted as valid Mzizi
`mz hash <file.mz>`	The root hash and the stored node count
`mz ir <file.mz>`	Every node with its hash and structural path
`mz build <file.mz> --out <dir>`	Writes a service as a local Rust + axum package, or a program as a Rust package with no dependencies (below)
`mz run [--release] <file.mz>`	A program only: checks it, lowers it, builds it with Cargo and runs it (below)
`mz harness version`	The protocol version, the language version and the SHA-256 of the definition
`mz harness definition [--agent]`	Every language harness entry, as JSON; `--agent` prints it on one line
`mz harness entry <name>`	One entry, by name (`mz harness entry MZ0905`, `mz harness entry "is not"`)

With no command given, the first positional argument is treated as a file and check is assumed.

Documented elsewhere, not implemented here. RFC-0003 §5 lists mz refs, mz path, mz patch and mz diff under “designed here, next in implementation order”. They are not built, and neither are mz test, mz fmt, mz run --agent or mz harness plugins (what still has to be built). The binary dispatches exactly the commands in the table above: check, fix, contract, outline, build and run, plus hash and ir for the IR and harness. It dispatches on the language harness’s command table, and its usage line is generated from it. Asking for anything else prints the usage line and exits 2. mz outline, mz hash and mz ir refuse a service or a program with exit status 2, because neither has an IR yet.

Exit status is a contract

So the loop can branch on status without parsing output:

Status	Meaning
`0`	No errors. Warnings do not fail.
`1`	Errors present, a contract clause failed, or an IR command had no tree.
`2`	Usage or I/O problem.

mz run is the exception, because 1 belongs to the program it runs: it exits with the program’s own status. See its table.

`mz check --agent`: the protocol

This is the surface an agent should use. RFC-0001 §4 states it as a versioned contract, and four properties define it.

Whole-program, all at once, deterministic order

Statement-per-line plus end-anchored blocks let the parser resynchronise at every line. The recovery target is at most one diagnostic per true author error — never a cascade, and never “fix one to see the next”. That is the direct answer to FM-5: a compiler that stops at the first parse error turns one mistake into five agent turns.

NDJSON, one diagnostic per line

Each line is a complete JSON object carrying code, severity, file, span as [start_line, start_col, end_line, end_col], say, and an optional fix.

say is written for a reader with zero file context

It quotes the offending source inline, so the agent needn’t re-read the file to understand the error. The stated target is ≤ 200 characters — density is the budget.

Fixes are data

Every diagnostic carries a machine-applicable fix when one is unambiguous, tagged exact, guess or none. mz fix applies every exact fix in one pass, which takes a whole class of mechanical error out of the loop.

The shape RFC-0001 specifies:

{"code":"MZ0412","file":"connectivity_bar.mz","span":[38,10,38,17],
 "say":"`emit on_state_change(sync)` — `sync` is not a variant of `connection_state`; nearest is `syncing`",
 "fix":{"span":[38,10,38,17],"replace":"syncing"},"confidence":"exact"}

The emitter in compiler/src/diagnostic.rs writes the same fields with severity added and confidence nested inside the fix object:

{"code":…,"severity":…,"file":…,"span":[…],"say":…,"fix":{"span":[…],"replace":…,"confidence":…}}

Every run ends with a summary line, so a consumer always has a terminator:

{"summary":true,"errors":3,"warnings":1,"exact_fixable":2,"ms":480}

The human-readable mode ends with the same information as prose: mz: 3 errors (2 exact-fixable), 480ms.

Diagnostic codes

Codes are grouped by phase, and the ranges are stable:

Range	Phase
`MZ01xx`	Lexical
`MZ02xx`	The component header, `use`, and block closing — including every `end` echo mismatch
`MZ03xx`	Enum variants and `prop` declarations
`MZ04xx`	Lines that cannot start where they appear, and the view grammar
`MZ05xx`	The contract block’s presence and shape
`MZ06xx`	Contract clauses, from `mz contract` (RFC-0006)
`MZ07xx`	Names and types, from the resolver (RFC-0008)
`MZ09xx`	Programs (RFC-0013), from `mz check` and `mz run`: every code below

Two are worth quoting because they show what the messages are trying to be. MZ0402, when something that cannot start a view line does:

… cannot start a view line — expected an element, `name = value`, `nothing`, or `end`

It names the whole set of valid continuations rather than only what was wrong — the Elm-derived expected-vs-found discipline RFC-0002 §3 names as the most valuable borrow in compiler-error UX, on the grounds that a small model cannot infer from an indirect hint. And MZ0501, which is a warning rather than an error, and is how RFC-0001 §1.6’s rule (“a component without a contract block compiles with a warning”) is actually enforced:

`component button` has no `contract` block — behaviour is unverified (RFC-0001 §1.6)

The end-echo diagnostics (MZ0206–MZ0208) are the payoff for the name echo: they can say which block on which line an end actually closes, and hand back the exact text to write instead. Each fix rewrites the whole closer, not only the end word.

Codes added after pilot 2

Pilot 2’s 7B model brought React habits the compiler did not name, and several view mistakes gave a cascade instead of one error on the right line. These codes are the fixes, audited in benchmarks/READINESS.md. Each message below is quoted from compiler/src/lex.rs or compiler/src/parse.rs.

Code	Severity	What it catches	Fix
`MZ0106`	error	A spread, `...props` or `{...props}`. Mzizi has none: a component names each prop it reads	`exact`: delete the spread, or its whole line when it stands alone
`MZ0312`	warning	A prop named `as_child`, React’s `asChild`. Mzizi elements are not polymorphic	`exact` (delete the prop) when nothing reads it; otherwise names the branch
`MZ0313`	error	A variant row whose `height` disagrees with the `h-N` or `size-N` class that renders it	`exact`: the rendered number
`MZ0406`	error	An attribute written without its `=`, such as `class "flex"`	Insert `=`: `exact` for a known attribute word, `guess` otherwise
`MZ0407`	error	`if` in a view. The one conditional is `when`	`exact`: `when`
`MZ0408`	error	Attributes directly under `view`, which holds one element tree	None
`MZ0409`	error	Anything after an element word on its line, such as `span class="x"`. Before, the tail was silently kept	None
`MZ0410`	error	`match` in a view. A view has no `match` (a program does): write one `when <subject> is x … end` block per variant, with `else` for the rest. Before, `match size` read as an element named `match`	None: one `match` becomes several `when` blocks

MZ0313 quotes both numbers, so the agent needn’t work out the scale itself:

`icon` declares `height 48` but its class `size-14` renders 56px (N × 4) — write `height 56`, or drop the column and let the class say it once

Program codes (MZ09xx)

A program is checked with the codes RFC-0013 §16 reserves, MZ09xx (53 of them), and reuses 27 shared codes (MZ0101–MZ0106, MZ0204–MZ0208, MZ0301–MZ0303, MZ0306, MZ0310, MZ0407, MZ0411, MZ0701, MZ0704, MZ0707, MZ0708, MZ0710, MZ0711, MZ0712, MZ0714 and MZ0808). MZ0301, MZ0302, MZ0303 and MZ0704 were registered in the language harness in the second release of 8 October 2026 (mzizi#96), which moved them off the pending list. MZ0960, MZ0961, MZ0963 and MZ0964 are new in the third release of 8 October 2026 (mzizi#99, collections). No component or service diagnostic changed when programs landed. The fourth release, tagged v0.8.0, adds no code: MZ0915 also reports a literal empty split separator, MZ0919 no longer lists text’s methods, which are built, and MZ0962 reports int(s) and float(s) on text with a guess to parse_int and parse_float. This table is generated from the language harness, not written by hand: it is mz harness definition at language main 2b36c8f (tagged v0.12.0), each MZ09xx entry’s severity, the tool that reports it, its say text and the fix kinds it is recorded as raising. “Or none” means some reports of that code carry no fix. The say text is the entry’s own, which the harness writes by hand and does not compare with the checker; mz harness entry <code> prints an entry with the source that triggers it. MZ0990–MZ0992 come from mz run, and MZ0991 and MZ0992 are printed by the running program on standard error.

Code	Severity	From	What it reports (`say`)	Fix kinds
`MZ0901`	error	`mz check`	a `program` line without a name, statements outside every `fn`, a block a program cannot hold (`view`, `prop`, `route`, …), or anything after `end program`	None
`MZ0902`	error	`mz check`	no `fn main`, a second one, or `main` with parameters or with a return type other than `result(none, E)`	None
`MZ0903`	error	`mz check`	a malformed signature: `def` / `function` / `func` (exact `fn`), `->` (exact `:`), `()` on no parameters (exact delete), `: none` / `: void` (exact delete), an untyped parameter, a default value, a keyword as a name	`exact`, or none
`MZ0904`	error	`mz check`	two `fn`s with one name, a `fn` and an `enum` with one name, a `fn` named like a built-in function, or a parameter named twice	None
`MZ0905`	error	`mz check`	a call or method with the wrong number of arguments or an argument of the wrong type, or a named argument; the say quotes the signature. A `float` exponent to `pow` gets a guess (`2.0` to `2`, `0.5` to `x.sqrt()`)	`guess`, or none
`MZ0906`	error	`mz check`	a path through a function with a return type that reaches `end fn` without `return`; exact fix when the last line is a value of that type	`exact`, or none
`MZ0907`	error	`mz check`	a statement after a `return`, `break` or `continue` that every path takes, which can never run; the exact fix deletes it	`exact`
`MZ0908`	error	`mz check`	a `return` that does not fit its function: a value where none is returned, none where one is, or the wrong type	None
`MZ0909`	error	`mz check`	a `fn` used as a value outside `map`, `filter` and the folds (exact fix `()` when it takes no parameters), a function argument that is not a named `fn` or whose signature does not fit (the say quotes both), or a lambda	`exact`, or none
`MZ0910`	error	`mz check`	an operator spelt from another language: `==` `===` `!=` `!==` `&&` `\|\|` `!` (exact), `not a is b` without parentheses (exact), Python’s `x not in xs` (exact `not x in xs`), a contract predicate in an expression (exact), or `**` (guess `x.pow(n)`; no fix when an operand could not be read)	`exact`, `guess`, or none
`MZ0911`	error	`mz check`	a comment Mzizi lacks: a line starting with `//` or `#` (exact `##`; a guess when code follows the marker with no space), `/* … /`, or a comment after code (guess: move it to its own line above); `/ … /` on a line of its own, or an unclosed `/`, has no fix	`exact`, `guess`, or none
`MZ0912`	error	`mz check`	operands of the wrong type: `int` with `float` (exact on an `int` literal), `+` on text (fix to interpolation), unlike types compared, `not` or `-` on the wrong type, `in` on another type than the collection holds, `otherwise` on a non-option, `is none` on a non-collection	`exact`, `guess`, or none
`MZ0913`	error	`mz check`	`and` mixed with `or` without parentheses (the exact fix writes the parentheses the precedence implies), or a chained comparison `a < b < c` (guess: split it with `and`)	`exact`, `guess`
`MZ0914`	error	`mz check`	a malformed number: `1.` or `.5` (exact: add the `0`), `1_000` (exact `1000`), `0x10`, `1e3`, or a float literal too large for a `float`	`exact`, or none
`MZ0915`	error	`mz check`	a fault visible in constants: division by a literal `0`, a literal negative `int` exponent or `repeat` count, a constant `int` overflow, a literal negative index (guess `xs[xs.length() - 1]`), or a literal empty `split` separator (guess `s.chars()`)	`guess`, or none
`MZ0916`	error	`mz check`	an expression statement whose value nothing reads	None
`MZ0917`	error	`mz check`	a line a function body cannot read: a value expected and something else found, a missing `)`, an unknown escape, a second `else`, a Rust macro, or tokens left over	None
`MZ0918`	error	`mz check`	`+=`, `-=`, `*=`, `/=`, `++` or `--`; the exact fix writes `x = x + 1`. On `xs[i]`, an option, the fix is a guess, `xs[i] = (xs[i] otherwise 0) + 1`, and there is none when no default can be guessed	`exact`, `guess`, or none
`MZ0919`	error	`mz check`	not built yet (RFC-0013), reported once: `option(T)` as a type, `none` as a value, narrowing an option; a method that changes `self`; a record that holds itself; a `use` line; a `test` block; a `contract` block	None
`MZ0920`	error	`mz check`	a name used before its binding, or after its block ended; the guess declares a `var` before the block	`guess`, or none
`MZ0921`	error	`mz check`	a name a program reserves: a word of the language, a built-in name, a name starting with `mz_`, a binding named like a function, an enum or a variant, a `fn` named like a variant, or a name already bound in the function (no shadowing)	`guess`, or none
`MZ0922`	error	`mz check`	assignment to a `let` (exact fix `var`), to a parameter, to a method’s `self` (a method cannot reassign its receiver: it returns `self with (…)`), or to a `for each` binding	`exact`, or none
`MZ0923`	error	`mz check`	assignment to an unbound name; the fix inserts `let` or `var`	`exact`, `guess`
`MZ0924`	warning	`mz check`	a warning: a `var` never assigned again; the exact fix writes `let`	`exact`
`MZ0925`	error	`mz check`	a binding form from another language: `const` `val` `auto` (exact `let`), `let mut` `mut` (exact `var`), `x := e`, or a type on an assignment	`exact`
`MZ0926`	error	`mz check`	a binding with no value	None
`MZ0927`	error	`mz check`	a call’s label written another way: `range(a, to: b)` (exact `to = b`), or `s.replace(a, b)`, `s.replace(a, by: b)` or `s.replace(a, with = b)` (exact `by = b`); §6.5’s other labels are not built	`exact`
`MZ0930`	error	`mz check`	a `match` that misses a case: the enum variants it misses, named, or `else` on an `int` or a `text`	None
`MZ0931`	error	`mz check`	a case that can never run: a value listed twice, a case after `else`, or an `else` when every value has a case; the exact fix deletes it	`exact`
`MZ0932`	error	`mz check`	a `when` or `match` used as a value where it cannot be (inside a larger expression or an argument), without `else` or a case for every value, with a branch that is not one value line, or with branches of different types	None
`MZ0933`	error	`mz check`	a conditional spelt from another language: `elif`, `else if` (exact `else when`), `switch` (exact `match`), `default:`, `case _`, `_ =>` (exact `else`)	`exact`
`MZ0934`	error	`mz check`	a loop spelt from another language: `for x in xs`, `for (const x of xs)`, `loop`, `range(n)` (exact), TypeScript’s `for (… in …)` (a guess: it iterates keys), a C-style `for` and `do … while` (no fix)	`exact`, `guess`, or none
`MZ0935`	error	`mz check`	`break` or `continue` outside a loop	None
`MZ0936`	error	`mz check`	an `else when` chain whose every condition is `<name> is <variant>` of one enum, as statements or as a value: a `match`, which checks every variant has a case; the guess rewrites it as one	`guess`
`MZ0937`	error	`mz check`	a trailing `:` on a block line; the exact fix deletes it	`exact`
`MZ0950`	error	`mz check`	a result nothing matches or propagates: discarded, used as its success value, printed, compared, passed, assigned, held by a `var`, returned where the type differs, a parameter, or inside a result; the guess inserts `try`, and `try f(x).y` gets the exact `(try f(x)).y`	`exact`, `guess`, or none
`MZ0951`	error	`mz check`	a `try` that cannot propagate: on a value that is not a result, in a function that does not return a result, or with another error type	None
`MZ0952`	error	`mz check`	an error idiom from another language: `Ok(v)` (exact `v`), `Err(e)` (exact `error(e)`), postfix `?` (exact prefix `try`), `throw e` or `raise e` (`return error(e)`, exact when `e` visibly has the error type); a `try` block, `.unwrap()` and `.expect()` have no fix	`exact`, `guess`, or none
`MZ0953`	error	`mz check`	`error(e)` outside a function that returns a result, or with an `e` of another type; a bare `ok` or `error` variant in a function that returns a result (exact: name its enum)	`exact`, or none
`MZ0954`	error	`mz check`	`return try r` with `r` of the function’s own result type, which unwraps only to wrap again; the exact fix deletes `try`	`exact`
`MZ0960`	error	`mz check`	a mutation (`push`, `insert`, `remove`, `xs[i] = v`) of something that is not a `var`: a `let` (exact fix `var`), a parameter, a loop binding, or a value no name holds	`exact`, or none
`MZ0961`	error	`mz check`	a bracket literal that cannot be typed: `[]` with nothing to say what it holds, elements of different types, `key: value` entries mixed with elements, or a map key written twice	None
`MZ0962`	error	`mz check`	an operation spelt another way: `str(x)`, `len(x)`, `s.strip()`, a method without `()`; `int(s)` and `float(s)` on text (guess `s.parse_int()`); on a list `.size()`, `.append`, `.get(i)`, `is []`, `find`, `sorted`; `t in s` on text (`exact` `s.contains(t)`); a guess where meanings differ	`exact`, `guess`, or none
`MZ0963`	error	`mz check`	a tuple, `(a, b)`: Mzizi has none, and two values that travel together are a record with named fields, which only the author can name	None
`MZ0964`	error	`mz check`	a map key, set element or `sort_by` / `group_by` key whose type has no order: a `float`, a collection, an option	None
`MZ0970`	error	`mz check`	`self` where it is not a method’s receiver: as a parameter (`fn norm(self)`, delete it), or read outside a method. A method’s receiver is written `self` and never declared, and a method’s name cannot be a field’s	None
`MZ0971`	error	`mz check`	a method assigns to `self` or one of its fields. A method reads its receiver: it returns a changed copy with `with`. A method that changes `self` (`changes self`) is designed but not built (MZ0919)	None
`MZ0974`	error	`mz check`	a `with` that cannot copy a record: on a value that is not a record, with no fields, a field the record does not have (the nearest name is its guess), a field replaced twice, fields out of declaration order, or a value of the wrong type	`guess`, or none
`MZ0975`	error	`mz check`	an `always` clause that cannot hold or cannot be checked: a literal record that breaks it (it traps every time it runs), or a clause that calls a `fn` or a method, builds or copies a record, or uses `try`	None
`MZ0980`	error	`mz check`	a print spelt from another language: `print(a, b)` (exact, to one interpolated text), `console.log`, `println!`, `fmt.Println`, `puts`, `print x`	`exact`, or none
`MZ0990`	error	`mz run`	the Rust lowered from a program did not compile: a bug in mz, not in the program. It names the program and quotes rustc’s first message; exit 3	None
`MZ0991`	error	`mz run`	a trap while the program ran: integer overflow (including `pow` and `abs`), `int` division or remainder by zero, a negative `int` exponent or `repeat` count, a `repeat` or a `range` list too long to hold, or `to_int()` on a float out of range. The line names the `.mz` position and the expression; exit 101	None
`MZ0992`	error	`mz run`	`fn main` returned an error: the program writes `mz: error MZ0992: main returned an error: <its text form>` to standard error and exits 1	None

Deep nesting is one diagnostic

Blocks nest at most 64 deep. The first block past that depth is the error MZ0411, reported once per file, and the compiler skips every such block without recursing into it. Before the cap, 5,000 nested view elements or handler blocks made mz abort with a stack overflow. compiler/tests/robustness.rs runs check, contract, fix, outline, the IR and service lowering over seeded random edits, random tokens, random bytes, nesting up to 10,000 deep and 1 MiB lines, and fails on a panic or a hang. The deepest .mz file in the repository nests 9 levels. A program has a tighter budget: its blocks and expressions nest at most 32 deep together, and an expression’s tree of binary operators at most 64, because a level of a program cost 12 to 16 KiB of stack in a debug build. Past that is the same single MZ0411.

`mz fix`: apply every exact fix

mz fix <file.mz> checks the file, applies every exact fix to it in place, then checks the result again. The output and the exit status describe the file as it now is.

$ mz fix button.mz
mz: applied 1 exact fixes; 0 errors (0 exact-fixable) remain, 0ms

One pass. It applies the exact fixes the first check reported, once. It does not loop until nothing changes. The second check says what is left.
guess fixes are never applied. Where two exact fixes would overlap, the checker keeps one as exact and demotes the other to guess, so the edits never collide. A demoted fix may come back as exact on the next run.
--agent works here too. mz fix --agent <file.mz> prints the second check as NDJSON, exactly as mz check --agent would.
The exit status is the second check’s: 0 with no errors left, 1 with errors left, 2 if the file could not be read or written.

RFC-0001 §4.3 described this command before it existed. It landed after pilot 2, whose 7B model resubmitted a byte-identical file in 15 of 16 Mzizi repair attempts. READINESS.md records that applying mz fix to any Mzizi candidate from either pilot never raised its error count. Whether it helps an agent converge is for the benchmark to measure, and it has not been measured.

`mz contract`: does it do what it says

check and contract are separate on purpose. The charter measures two different things: “a syntax/compile error is not itself a defect for this metric… the defect rate measures what gets past the compiler wrong.” One exit code covering both would make the Phase 0 defect metric unreadable. mz contract <file> evaluates the component’s own contract block against its own declarations: enum variants and their data columns, defaults, slots and the view. A failed clause exits 1, exactly as a compile error does, so a harness can branch on status alone. Across the nine primitives there are 29 clauses, and CI evaluates every one.

mz: 0 errors (0 exact-fixable), 5 contract clauses, 0 failed, 0ms

What it does not do: it checks nothing rendered, and it does not compare a component with a reference implementation. That comparison is the benchmark harness’s job (benchmarks/harness). For a service, mz contract runs it in process (RFC-0011 §6–§7). Each example clause is one request, and each ensure clause is tested over a generated set of requests: tested, not proven. Over the example service:

$ mz contract examples/registry.mz
mz: 0 errors (0 exact-fixable), 22 contract clauses, 0 failed, tested over 61 generated requests, 1ms

A size’s height is now read from its class. Pilot 2’s 7B buttons wrote icon class "size-14" height 48: the class renders 56px, the contract read the 48, and mz contract passed. Now a variant row may leave height out, and the evaluator takes the height its first plain h-N or size-N class token renders (N × 4 pixels). A row that writes a height which disagrees with its class fails mz check with MZ0313. The rule is the one the benchmark harness scores with, and both test suites check it on the same examples. Tokens with a prefix or an arbitrary value, such as md:h-10 or h-[56px], are not read. See the pilot results.

`mz build`: lower a service or a program

mz build <file.mz> --out <dir> lowers a service to Rust (RFC-0011 §8), or a program to a Rust package with no dependencies (RFC-0013 §14), the package mz run builds. It refuses a component (exit 2) and a file with errors (exit 1).

$ mz build examples/registry.mz --out out/registry
mz: built `service registry` into out/registry (3 routes, 1 fixtures); run it with `cargo run --release --manifest-path out/registry/Cargo.toml`

The output is an ordinary local Cargo package: the runtime (RFC-0011 §6 as one Rust function), the generated route table and handlers, and one #[tokio::test] per example. It pins axum =0.8.9 and tokio =1.53.1. CI’s lowering job builds the example service, runs its 18 generated tests, starts the server and sends a request over a socket. What it is not: there is no Workers, Containers or WebAssembly target, and no component lowering. A generated service package runs locally as a native server. See what still has to be built.

`mz run`: run a program

mz run [--release] <file.mz> checks a program, lowers it to a Cargo package with no dependencies in a per-user cache directory, builds it with cargo build --offline --quiet, and runs it with the terminal’s standard input, output and error. Standard output belongs to the program; everything mz run writes of its own goes to standard error.

$ mz run examples/fib.mz
fib(9) is 34
fib(20) is 6765
fib(10) + fib(11) is 144, and that is fib(12): true
6765 is odd, or not positive

It exits with the program’s own status, so 1 does not mean “errors” here:

Status	Meaning
`0`	The program ran and `main` ended
`1`	The program ran and `main` returned an error (`MZ0992`)
`2`	A usage, environment or I/O problem, such as no `cargo` or no cache directory
`3`	The program did not compile: `mz check` errors, or `rustc` rejected the lowered code (`MZ0990`)
`101`	The program trapped: integer overflow, division by zero, or a `to_int` out of range (`MZ0991`)
`141`	The program’s standard output was closed
`128+n`	A signal `n` killed the program

CI’s lowering job runs every example program, examples/hello.mz, fib.mz, numbers.mz, control.mz and errors.mz, through mz run and compares its output with the committed .expected file. mz run --agent is not built and exits 2. See Programs.

`mz outline`: the representation for dependencies

When editing component A that uses B, an agent needs B’s interface, not B’s body. Reading the file gets both, plus comments and unrelated functions — RFC-0003’s barrier RB-2. The outline carries: the first doc line, the component name, declared capabilities, every prop with its type and default, every enum with its variant names only, the names of fn declarations, and a marker for whether a contract exists. It drops variant column data, view bodies and function bodies — which is where the bulk of a component’s bytes are. It is emitted as valid Mzizi, deliberately: a reader who can read the language can already read this, so there is no second format to learn and no second parser to keep in step. Measured over the nine primitives and the two component examples, the worst case is 38% of source (spinner.mz); the test in compiler/tests/ir_measured.rs fails above 75%.

Compile speed is a protocol property

RFC-0001 §4.6 makes this explicit: “A slow compiler fails Phase 0 no matter how good its errors are.” The stated budget is sub-second incremental for a single-component change, and the benchmark is specified to record it per iteration. What has been measured so far is much narrower: parse and lower of all eleven component .mz files in the repository takes about 10 ms in a debug build, against a 400 ms test budget. That is a floor on a tiny corpus, not the incremental-compile figure the charter asks for. See Status.

Paths in the agent output

mz check --agent prints each diagnostic’s file exactly as it was given. In pilot 2 the benchmark runner passed absolute paths, so the 7B model read about 13,500 tokens of path strings. That was the first fix pilot 2 listed, and it is fixed in the runner rather than the compiler: the runner’s default file-name normaliser replaces the candidate’s path with its bare file name before the model sees it, for every arm. If you drive mz from your own loop, pass a relative path.

​Getting it

​The commands

​Exit status is a contract

​mz check --agent: the protocol

​Diagnostic codes

​Codes added after pilot 2

​Program codes (MZ09xx)

​Deep nesting is one diagnostic

​mz fix: apply every exact fix

​mz contract: does it do what it says

​mz build: lower a service or a program

​mz run: run a program

​mz outline: the representation for dependencies

​Compile speed is a protocol property

​Paths in the agent output