Command reference

Read from the same command tree that parses the arguments.

Exit status

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 style

Every class the program's pages can carry, and every place one is built rather than named (`docs/104` §104.4).

The compiler resolved the program, so it knows the strings that can reach a `class=` — across a module boundary, and without a scanner or a safelist. What it prints is that set, and the sites where a class is assembled at run time instead, which are the ones a stylesheet emitted from this could not cover.

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).

§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.

`--backend llvm` (the default) needs `clang` on the path, or `BECK_CLANG` pointing at one. `--backend cranelift` needs only a linker, because Cranelift is a crate. `--backend wasm` needs nothing at all and produces nothing this command can run: a WebAssembly module is loaded by whoever is going to call it, which for Mode B is a browser, so it writes the module and its listing and stops.

beck bundle

Write a Mode B component's bundle — the slice a browser downloads (§5.1, `docs/94` §94.6).

This is not how a deployment gets one. `beck run` derives the bundle from the program it is executing, so a served slice cannot be of a different program than the running one, and `beck build` deliberately writes no bundle for the same reason. This is how a *measurement* gets one: §5.1 budgets "< 150 KB brotli for a typical Mode-B component bundle", and a budget nothing can weigh is not a budget.

A Mode A component has no bundle, and asking for one is an error rather than an empty file.

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 changelog

The changelog, assembled from `changelog/` — one file per change.

A change records itself by adding a file there and editing nothing else, so two branches never write the same line and their merge has nothing to resolve. This assembles those files into the flat newest-first list under `CHANGELOG.md`'s hand-written head.

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 image

Build the container image, in this process — no apko, no melange, no daemon (§6.2).

Resolves the packages `beck build`'s apko config names, fetches them from the Wolfi repository, unpacks them, adds the toolchain and the program, and writes an OCI image layout. The result is reproducible: the same inputs produce the same digest, which is the property §6.2 chose this image format for and which `beck image` run twice will show.

beck sign

Sign the image in an OCI layout, in the form `cosign verify` reads (§6.2)

beck verify

Check a layout's signature against a public key — and that it is over *this* image

beck key

A signing key, and the public half a consumer verifies with

beck key generate

Write a new P-256 key pair: `<name>.key` and `<name>.pub`

beck init

Write the files a repository needs around a Beck program

beck init ci

The continuous-integration workflow for this program (§28.3).

Check, test, wire-compat, build — then, from the default branch, an image and a signature. Written to `.github/workflows/beck.yml`, reviewed and committed like any other file.

beck play

Serve the playground: the compiler and a running application, in a browser tab (§17).

Rung A is the compiler compiled to WebAssembly — diagnostics, the two surfaces, inferred placement, the dataflow plan, the read model, the generated Kubernetes objects — with no server involved at all. Rung B runs the program *in the tab*: a log, a fold and two client subscriptions in one page, speaking the patch protocol over a `MessageChannel`.

Needs the module: `cargo build -p beck-play --release --target wasm32-unknown-unknown`, or `BECK_PLAYGROUND` pointing at one.

beck up

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