Expressions and pipes

This is the reference for the expression dialect inside {{ }}: how a source is classified, the operator grammar as the evaluator actually splits it, bracket indexing, scope frames, protocol reads, and every built-in pipe. Every example on this page was run through the real engine (lzr render-page, the same entry the site recipes use) and shows the output it actually produced. The single authority is the compatibility evaluator in internal/lzr/render/compat_expr.go — there is no separate spec.

How an expression is classified

Before evaluation, expr.ParseProgram (internal/lzr/expr/expr.go) sorts each {{ }} source into one of four kinds:

Operator grammar and precedence

The evaluator has no token tree; it repeatedly splits the source at the top level (quote- and bracket-aware) in a fixed order. Whatever splits first binds loosest. The order, loosest to tightest:

Truthiness

One rule, from truthy in internal/lzr/render/shape.go, used by <if>, ternary, ||/&&, ! and the empty pipe: null, "" and numeric 0 are false; everything else is true — including empty lists and maps. Test emptiness of a collection with | empty or | jq:'length', not with bare truthiness.

Paths, bracket indexing, suffix chains

Paths resolve against the scope chain (next section). After any resolved base you can chain .field and [expr] segments freely. The bracket expression is a full expression itself. All verified against this corpus' data:

{{ campaign.title }}             -> Corpus Campaign
{{ items[0].title }}             -> Alpha        (list index)
{{ items[-1].title }}            -> Gamma        (negative index counts from the end)
{{ items[1 + 1].title }}         -> Gamma        (computed index)
{{ labels.statuses['live'] }}    -> Live now     (quoted map key)
{{ labels['site']['meta']['lang'] }} -> en       (chained brackets)
{{ labels.statuses[item.status] }}            (loop-variable key)
		

Out-of-range list indices are hard errors (index 3 out of range); missing map keys are missing-value errors. Inside a foreach body, missing item subpaths render as an empty string instead (verified: {{ item.nope }} → "") — loop rows tolerate ragged data, page-level names do not.

Scope frames and name resolution

A name resolves through nested frames, innermost first. This is the same chain hypermake lzr scope-map reports (see Expressions and scope for the worked tour):

Unresolvable names are build-failing diagnostics, not silent blanks: missing_value for plain paths, compat_expr_failed inside compound expressions. The sanctioned probes are the missing-tolerant pipes | isset and | empty — the only pipes that accept a missing input instead of propagating the error.

Protocol reads in expressions

An expression whose source starts with a known scheme is a protocol read. The compat evaluator recognizes src://, data://, cache://, public://, rendered://, projection://, client://, inspector://, project://, request-projection:// (hasProtocolPrefix, internal/lzr/render/core_helpers.go). Resolution asks the graph authority first; in page renders the file-backed schemes then resolve from the project root:

Pipes

A pipe chain applies left to right: value | name:arg1:arg2. Arguments follow : and are full expressions themselves (quoted strings, numbers, paths — {{ labels | get:key }} works); :// inside an argument is protected from the split, so protocol addresses pass through intact. Pipe evaluation binds looser than &&/==/arithmetic and tighter than || and the ternary — {{ item.href | empty? 'unreleased': item.href }} is a verified working idiom from this corpus.

The complete built-in registry — every applyPipe case in compat_expr.go. Each output below is what the engine actually produced:

Unknown pipe names are hard errors: unsupported pipe "name". There is no machine-readable pipe registry today — this table is transcribed from applyPipe and verified case by case.

Extension registry: prefix helpers and pack pipes

Component packs can extend the dialect through rendercompat.Registry (internal/lzr/rendercompat/helpers.go): named pipes, prefix helpers (helperName:rest-of-expression, matched before everything else), and per-pipe missing-tolerance. The stock packs register: seoDetails (prefix + missing-tolerant pipe) and mkJsonLD from the SEO pack, mkImageDetails (prefix + pipe) and imageSources from the image pack (internal/lzr/componentpack/{seo,img}/helpers.go). They attach only when the pack's component directory is on the render's component path (attachBundledComponentPackHelpers, internal/lzr/client/component_registry.go) — this site does not load them, so they are cited here, not demonstrated.

Output and escaping contract

Verify this page

Every example above was run through the standalone renderer against a scratch project (probe templates p1…p17), and this page itself performs live reads of this corpus' data — the campaign title and jq count shown above are rendered, not typed. Reproduce any row with:

lzr render-page --root . --in src/probe.html --template probe.html --out out.html --sidecars skip
hypermake lzr scope-map src/docs/expressions-pipes.html
hypermake explain rendered/public/docs/expressions-pipes.html
		

Source authorities, in reading order: internal/lzr/render/compat_expr.go (eval, applyPipe, resolveProtocol), internal/lzr/render/content.go (output contract), internal/lzr/render/shape.go (truthy), internal/lzr/render/foreach.go (loop frames), internal/lzr/expr/expr.go (classification, dependencies), internal/lzr/richtext/validate.go (rich-text trust boundary).