Command reference

Read from the same command tree that parses the arguments.

beck check

Typecheck, infer and verify placement, and slice the signal graph

beck fmt

Print a program in either surface. `beck fmt` on commit normalises to `.beck` (§2.2)

beck iface

Write the module's published signature — the `.becki` of §3.6.

Generated, checked in, and reviewed like an .mli: it is what downstream modules compile against, and the file `beck check --wire-compat` compares releases of.

beck ast

Dump the canonical AST — the notation macro authors work in (§2.7)

beck explain

Interrogate a compiler decision (§4.7)

beck explain place

Where each definition runs, and why (§4.7)

beck explain wire

The command channel's content-derived operation id (§4.3)

beck explain render

Where a component renders, why, and what that puts on the wire (§5.1).

Mode A sends the browser a rendering of the state; Mode B sends it the state and renders locally. This prints which one, what decided it, what crosses, whether the client may apply a command optimistically — and, for a Mode B component, the size of the bundle it would have to download.

beck explain flow

The signal graph, and what the splitter made of it — or, given a type, everywhere that type reaches and everywhere it is refused (§4.7)

beck explain incremental

Which views a dataflow plan could maintain by delta, and why the rest could not (§3.8).

The analysis rather than the plan: it asks whether a *view* is built only from operations with delta rules, and `beck explain query` prints the operators the view actually compiles to. A view this reports as `recompute` may still have its collections maintained around whatever blocked it.

beck explain query

The view as a dataflow plan, and what query fusion made of it (§4.7, §5.3).

Every operator, what it reads, what orders its arrangement and which side of the session cut it is on — then the rewrites that fired, and the ones that matched a rule and were refused, with the condition that refused each.

beck explain cost

What one event costs this program's view, operator by operator (§4.7).

In the engine's own units — applications, entries touched, entries copied, operators recomputed — as a function of the change `δ` and the collection `n`, so the answer is the same on every machine.

beck explain sql

The read model: what an outside SQL client sees, as `create table` (§5.3).

Nothing executes this DDL. There is no table to create — a read model is the collection the fold already holds and the arrangement the view engine already maintains, projected — so this is the shape of the relations `beck run --pgwire` serves rather than a migration.

beck explain deploy

The infrastructure the program's effects imply (§6.5)

beck explain error

What a diagnostic code means — `beck explain error B0341`

beck graph

Every part of the program and the infrastructure it implies, and what depends on what.

The same model the dashboard draws, as text — because a graph is more useful to a tool than to an eye, and the tool is usually the point.

beck impact

What breaks if this changes — transitively, across code *and* infrastructure

beck test

Run the program's own `test` and `property` blocks (§21.2).

A test is a log, a command and an expectation, so this needs no network, no database and no browser: the tiers are co-located and the roles are the ones the runtime drives.

beck run

Run the program in a single process — rung 0 of the parity ladder

beck replay

Fold a recorded log and report the state it produces (§3.7)

beck build

Emit the deployable system: the object graph and the image config (§4.1 stage 11)

beck native

Compile what can be compiled to native code, and say what could not (§5.2).

The LLVM half of §5.2's dual codegen, over the scalar subset of the language: a definition whose parameters and result are `Int`, `Float` or `Bool` and whose body is arithmetic, comparison, `if`, `match` and direct calls. Everything else — anything that needs a heap, and every effect — stays with the evaluator, and this prints which went which way.

Needs `clang` on the path, or `BECK_CLANG` pointing at one.

beck sbom

The bill of materials for what `beck build` emits, as CycloneDX 1.6 JSON.

Derived from the same object graph the image config is, so the two cannot disagree about what is in the image. `beck build` writes one beside the manifests; this prints it.

beck doc

Generate reference documentation — for a module, or for the language itself.

A module's page is derived from the module: signatures come from inference, effects from the row, placement from the solver, and prose from `##` doc comments. The language reference is derived from the compiler's own tables — the diagnostic codes it can emit, the predicate the placement solver evaluates, the schemes inference reads for the prelude, and this command tree.

beck doc module

One module's reference page: every published name, with its signature, effects and tier

beck doc guide

A written guide, rendered for the published site.

The reference is derived from the compiler; a guide is written by a person and *checked* by a harness — every program in `docs/86-getting-started.md` is compiled and run by `beck-cli/tests/getting_started.rs`. This is what puts the checked file on the site instead of a second copy of it that nothing compiles.

beck doc reference

The language reference: the error index, the command reference, the effect and tier matrix, the prelude, and the forms.

Checked in under `docs/reference/` and regenerated by this command, so a change to the compiler that changes the reference shows up in the diff rather than in a stale page.

beck bench

Measure the log against every substrate, so the store is a decision and not a habit

beck bench log

Append, read and encode, against memory, redb and — with a URL — PostgreSQL

beck lsp

Serve the Language Server Protocol on stdin and stdout (§4.6).

The same front end `beck check` runs, so an editor's squiggle and a CI failure are the same diagnostic — §4.6's "there is no separate language server implementation to drift". Not meant to be run by hand: an editor starts it and speaks JSON-RPC to it.

beck up

Bring the program up on a local cluster or host — rung 2 or 3 (§6.6)