How-to guides

Evaluate a file, read from stdin, or question a document interactively with the `aontu` command.

Embed the engine in Node with the `Aontu` class: parse, unify and generate from your own code.

Embed the engine with the Go port: the same three calls, with errors returned instead of thrown.

Print what a document means (defaults, disjunctions and all) instead of what it resolves to.

Fill `$name` variables from the calling program to parameterise a model from code.

Generate a ground-truth stanza with `aontu agentsmd` and serve the verbs over MCP with `aontu mcp`.

Gather every problem in one pass with `collect: true` (TypeScript) or `Check` (Go) instead of stopping at the first.

What a conflict message names, in what order, and how to tell a conflict from an unresolved path.

Connect `aontu lsp` to VS Code, Neovim, or any LSP client for diagnostics as you type.

Write a default in a disjunction with the type an override must satisfy, and layer defaults by rank.

Use a `&:` spread entry to unify one template into every key of a map or every element of a list.

Close both the set of `pack`-generated children and each child's shape, or seal from the side with a hidden guard.

Pull other parts of the document in by reference, extend them, and relocate them with `move` and `copy`.

Mark schema and helper fields with `type()` or `hide()` so they constrain and compute without being generated.

Type every element of a list with a `&:` spread, and know why a bare `[string]` does not.

Seal a map with `close` so a typo'd or invented key is refused instead of absorbed.

Suffix a key with `?` so a field that never receives a value is dropped instead of erroring.

Build a `uint8`/`port` vocabulary as a `type()`-marked block of ordinary fields.

Reference a definition inside itself to get a schema that applies at every depth of the data.

Keep money exact inside aontu and cross JSON as a fixed-scale decimal string with a conversion mark.

Export a model as JSON Schema 2020-12 with `aontu jsonschema`, and read the loss report it owes you.

Generate target-language source from a model: a rule set over the records, a component tree of files and lines, and `aontu render` to write the bytes and hold them against their goldens.

Print one node of the evaluated document by path, or a keys, types, or depth-limited view of it.

List every contribution that met at a path (which file, which line, which layer) with aontu model why.

Append a change to an overlay file with aontu model set, so the original document keeps its bytes and a bad change is refused before it lands.

Ask aontu allow whether a role may change a subtree before aontu model set writes it, with the answer read from a role model that is itself an aontu document.

Rewrite a pinned literal where the author wrote it with aontu model set --in-place, and know the cases where the verb appends instead.

Report map entries whose removal changes nothing, so layered files do not silt up with lines a template already implies.

Draw a model as a dependency tree, matrix or architecture layers with aontu view, and gate the committed figures in CI.

Run aontu vet in a pipeline so a document that does not hold fails the build, with the reason attached.

Gate schema edits with aontu breaking, so a change that would refuse previously valid documents fails the review.

Declare a relation once at the field with rel(), acyclic() and inverse(), and have the whole model's edge set checked.

Ask whether one entity reaches another over the declared edges with aontu reaches, and get the path as the answer.

Pin a document's meaning to one string with aontu hash, and detect when the meaning moves.

Put a document in the agreed form with `aontu fmt`, gate a repository on it in CI, read what the formatter will and will not change, and point `--lint` at the style it never touches.

Load other source files with @"path" so a base model and its overrides unify into one document.

Lock a dependency closure with aontu sync and commit aontu_meta/vendor/ so a build resolves every import with no network at all.

Bootstrap a module dependency with no repository to fetch from by copying its source tree into aontu_meta/vendor/ and letting aontu sync pin what it means.

Publish a package with aontu publish, gated on compatibility with the version before it, into a local repository that aontu pkg serve serves and aontu sync reads.