Skip to content

Release v0.1.0

Choose a tag to compare

@homer6 homer6 released this 12 Oct 22:32
· 184 commits to main since this release
f669726

Released: 2026-10-12 · Branch: main · Previous: none. This is the first tagged release.

liquid is a version control system, build system, package manager, artifact service and
runtime in one program. It is a C++26 library, libliquid, and a liquid command-line
binary that is a thin client of it. You import a folder, every write is captured as a signed
drip, and a group of drips gets a reviewable name as a change. The same tool caches
build results, explains cache misses, signs provenance, and packages the outputs.

Because this is the first release, this page lists everything in it: every implemented
feature by area, and every one of the 80 commands. The feature list follows
docs/library/status.md, the authoritative implementation record, and
each paragraph names the page that holds the design and verification detail. The command list
was checked against the generated CLI reference, so none is missing.

This tag is the source that Lake v0.1.0 is built from: the development deployment's image
was compiled against liquid 88c5ef4, the commit this release is cut from apart from the
version string and the release documents.

Measured Value
Commits, pull requests 248 commits across 167 pull requests, from 2026-09-01
Commands in the generated CLI reference 80
Tree-sitter grammars bundled 49
Feature specifications, research topics 25 and 27
Tests 745 run, 733 passed, 12 skipped (see Verification)

Implemented is not the same as specified. docs/features/ holds 25
specifications of what liquid is meant to do, including the hosted service and the IDE. This
page lists only what the library and binary implement today. What is still owed is under
What v0.1.0 does not include.

Contents

  1. Library and binary
  2. The store
  3. Repositories: drips, changes and history
  4. Identity, signing and encryption
  5. Capture, secret scanning and attestations
  6. Sync, review, drive and Git
  7. Working trees: mounts and materialisation
  8. Transparency, TUF and admission
  9. Search
  10. The build engine
  11. Remote execution and distribution
  12. The incremental engine
  13. Formats, projection, resolution and configuration
  14. Deployment
  15. Every command
  16. Guides and documentation

1. Library and binary

  • libliquid (liquid::liquid): static by default, shared with BUILD_SHARED_LIBS. Other
    programs consume it through its exported CMake target; find_package(liquid CONFIG REQUIRED)
    works from an installed and relocated prefix, with the complete static dependency closure
    (libliquid.md).
  • The liquid binary: a thin client of the library. It validates every option from one
    typed command table, and the Markdown, JSON and man-page reference are generated from that
    table.
  • Git's command names: init, clone, status, log, diff, blame, mv, rm,
    push, pull, gc and repack mean what they mean in Git. The path-move command was
    move before this release; move is still accepted.
  • Coroutine API: the public waiting operations are lazy Boost.Capy tasks backed by a private
    Corosio runtime (runtime.md).
  • Public API: errors, digests (BLAKE3, SHA-256 and keyed BLAKE3 identifiers), the identity
    document codec, the signature decoder and release approval
    (api-map.md, hash-agility.md).
  • Platforms: macOS and Linux. Windows builds, and returns a documented unsupported result
    for the daemon and for wrap, verify and replay.

2. The store

One content-addressed chunk store holds source, binaries, packages, images, search indexes and
encrypted data (store.md, gc.md,
simulation.md).

  • Persistence backends: an injected, coroutine-native backend interface with disk and
    in-memory implementations. Disk is the default.
  • Reads and writes: open, put, get, range read, contains, and bounded-memory put_file and
    get_to_file for files of any size.
  • Garbage collection: leased roots, epoch collection and pack compaction. A collection
    publishes its object map before it commits tombstones, so a crash between them never leaves an
    object naming a tombstoned chunk. liquid gc --explain says why a chunk is live.
  • Near-duplicate compression: digest-addressed chunk deltas with resemblance-selected bases;
    repacking rebases delta chains and collection keeps their transitive bases.
  • Crash simulator: a deterministic, seeded simulator that runs the same invariants against
    the disk and memory backends.
  • Shared stores: several repositories in one caller-owned store, with repository-scoped
    checkpoints, journals and retention leases. A shared-store repository's own state is backend
    keys, so a backend with no local root holds the whole repository.
  • Write-through and eviction: a store owner can await a whole-content write-through callback
    before the first local pack write, and evict local copies that are registered remotely.
  • Process ownership and hand-off: one handle owns a disk root across processes, and a
    successor waits for a draining or killed predecessor to release it.
  • Injected owners and fencing: on a backend without a local root, ownership comes from an
    injected owner whose grant carries a fence sent with every mutation, so the remote refuses a
    stale holder.
  • Whole-repository transfer: repository::transfer copies one repository between two open
    shared stores, resumably, with a verify mode that reports every difference.
  • Append-only writes: no store write rewrites bytes already written, which object storage
    that only appends or replaces whole objects requires.

3. Repositories: drips, changes and history

(object-model.md, multiplayer.md)

  • Create a repository from a folder, and read and write its working tree.
  • Drips and changes: every captured write is a signed drip; cut names the working change.
  • History: references, snapshots, the state of a document at any point, the change log, path
    history and restore, and per-line attribution to the session and change that last wrote it.
  • Diff: between trees and changes, with text anchors that survive edits.
  • Moves and removals recorded as such.
  • Composition: nest another repository, split a subtree into a standalone repository that
    owns its chunks and keeps its original signed history, and combine two repositories
    (split.md).
  • Conflicts as values: a conflict is a recorded value that can be listed, inspected and
    resolved, not a broken working tree (conflicts.md).
  • Undo: of the newest operation, a named one, or a whole session's.
  • Exclusive checkout locks: configured path patterns need a lock to write. A lock record
    carries holder, time and reason, and offline reconciliation produces conflict values
    (locks.md).
  • Agent sessions: private speculative replicas; semantic leases on a file, symbol or range;
    transient presence; delegation attribution.
  • Writes from a stated base: a write names what it was based on, and a stale base is
    refused, re-validated when the edits are disjoint, or recorded as a forced re-plan.
  • Compaction epochs that checkpoint a repository.
  • Streaming: one-drip streaming file writes and tree imports, in bounded memory.
  • Paged enumeration of results, attestations, traces and SBOMs.

4. Identity, signing and encryption

(identity.md, encryption.md,
release-approval.md)

  • TAAP/1 identities for people, devices and agents, with signed drips and changes.
  • Identity backends: software keys, FIDO2 and PIV hardware tokens, with rotation across
    backends and chain verification.
  • Public identity export: liquid identity show --document prints only the signed public
    document; private keys stay local.
  • Encrypted objects by trust domain, with key custody by passphrase, raw key file,
    age/X25519 recipient, cloud KMS, Lake transit, Shamir shares, or a TPM sealed to PCR values.
  • Data-key rotation and revocation, versioned, with reports of which revisions a repository
    can still read.
  • Encryption of structured values: path rules encrypt selected JSON and .env leaf values
    and leave the structure visible, with explicit plaintext reads and a key-only historical diff
    (leaf-encryption.md).
  • Lake sealed secrets: the sealed-secret envelope and its commands
    (sealed-secrets.md).
  • Threshold release approval: signed release policies evaluated against a threshold of
    approvers.

5. Capture, secret scanning and attestations

(capture.md, secret-scanning.md,
attestations.md)

  • Change capture from the file system, with subscriptions, pause and resume.
  • Flow control: persisted write budgets per actor, directory document and repository. An
    over-budget write is rejected before a transaction opens, and the same limits apply to pushes.
  • Secret scanning, blocking by default, with repository exceptions and signed scan
    attestations.
  • Verified redaction of a secret from repository history.
  • An attestation registry of 17 profiles: org_membership/1, delegation/1,
    authorship/1, review_approval/1, slsa_provenance/1, sbom/1, delta/1,
    hot_update/1, model_provenance/1, abi_compatibility/1, scan_result/1,
    reproducibility/1, image_provenance/1, projection/1, platform_signature/1,
    release_policy/1 and release_approval/1, with profile-keyed verification, freshness
    and selective disclosure.

6. Sync, review, drive and Git

  • Push and pull with signed metadata exchange and missing-object negotiation
    (sync.md).
  • A sync server (liquid serve sync) with per-reference authorization, and mixed or atomic
    push outcomes.
  • Review: a client for Lake's change review, with a polling event stream and an installable
    test double (forge-client.md).
  • Drive: a folder kept in sync, with named conflict values, resume of an interrupted
    transfer, path history and restore; per-path online-only, available-offline and excluded
    state; pin and unpin; hydration policy; and file-manager badges for GNOME Files and Dolphin
    (drive.md).
  • Clone, including adoption of the identity on first pull.
  • Git import and export: liquid import git preserves reachable local Git history and maps
    identities; liquid export git writes a standalone Git repository and reports what could not
    be carried over (git-interop.md).

7. Working trees: mounts and materialisation

  • Full materialisation writes a plain directory.
  • Lazy mounts hydrate a file's chunks when it is read, through libfuse3 on Linux and
    optional macFUSE on macOS (vfs.md).
  • Conformance: nine common cases pass against liquid's own core backend. The libfuse
    baseline on Linux is still owed
    (#299).

8. Transparency, TUF and admission

  • Transparency-log client: verifies signed checkpoints with a witness quorum, every entry
    and parent hash tile, exact inclusion, consistency, and scans by identity, before a caller
    trusts a log response (transparency.md).
  • Trusted timestamps: RFC 3161 checkpoint timestamps and RFC 4998 renewal chains, checked
    against explicitly pinned trust anchors at each token's own generation time.
  • TUF client: verifies root rotation, timestamp, snapshot, targets and the complete target
    bytes before a registry or drive client accepts them. liquid registry trust pins or shows
    the root (tuf.md).
  • Kubernetes admission (liquid serve admission): a fail-closed webhook with named policy
    sets that reload atomically, structured decisions, evidence lookup, transparency
    verification pinned by policy, and a bound on checkpoint age. Metrics, REST, OpenAPI and MCP
    expose the same record (admission.md,
    ../api/admission.md).

9. Search

Repository-local search over the working tree or a named reference
(search.md).

  • Three executors: BM25F ranking, verified positional trigrams for substrings and regular
    expressions, and a parallel mapped scan.
  • Measured cost planning picks one, and liquid search --explain reports the inputs, the
    estimate, the actual cost and the alternatives it rejected.
  • A content-addressed index published atomically after each drip. Identical blobs are
    indexed once.
  • Inside archives: entries of supported containers are searchable at !/ paths.

10. The build engine

(build-engine.md)

  • liquid wrap runs an unchanged CMake, Autotools, Make or compilation-database project in
    one observed mount and turns each output-producing tool process into a cached action. Inputs
    are observed, not declared.
  • Sandboxed execution in Linux namespaces or a macOS sandbox, with a fixed environment
    (../build/sandboxed-executor.md).
  • A persistent disk cache of signed results, looked up by candidate key and validated
    against the current input tree. A miss reports the first differing input.
  • Verification: liquid verify re-executes cached actions in fresh sandboxes, compares the
    exit status and every output digest, signs a reproducibility attestation, and permanently
    quarantines a result that diverges. wrap samples one action in twenty by default.
  • Content-addressed outputs: an upstream tree that is byte-identical after normalisation
    stops the downstream cascade. Directory modes, ar headers and Python bytecode are
    normalised before storage.
  • Named inputs: wrap --input <name>=<result|tree> mounts upstream bytes read-only under
    deps/<name>/.
  • Relocatable installs: wrap --install-prefix stages an install tree with relative ELF or
    Mach-O lookup paths, and publication refuses embedded sandbox or install prefixes
    (relocation.md).
  • Provenance: signed SLSA provenance for every result, and --dsse projects it as an
    in-toto Statement (provenance.md).
  • SBOMs: SPDX 2.3 or CycloneDX 1.5 derived from the build graph for every output, with
    separately marked inference for foreign binaries (sbom.md).
  • ABI: stored ABI descriptors and signed compatibility comparisons for every built shared
    library (abi.md).
  • Explanations: liquid why explains a miss by digest, arguments, environment, toolchain,
    sandbox, line range and drip. cache stats and wrap --explain report hit rates and bytes
    avoided.
  • Observability: each result records queued, sandbox, exec, hash and store phases; every
    wrap keeps a dependency trace and prints wall time, critical path and achieved parallelism;
    liquid build trace --chrome exports it and liquid why-slow <target> names the critical
    path.
  • Build-input policy: rules can require attestations from approved builders for source and
    toolchain inputs before anything executes; liquid policy check evaluates a target without
    building (policy.md).
  • Configure facts: Autotools cache variables and common CMake check results are facts keyed
    by compiler, sysroot and target; wrap --target refuses to execute an uncached probe for a
    foreign target.
  • Retention: typed rules keep matching references and cost-weighted results; a size cap
    evicts the results with the lowest execution cost per byte, and liquid retain explain names
    the rule responsible.
  • liquid builds liquid: the static library and CLI build under liquid wrap twice, the
    second run with a 100% disk hit rate, and both outputs compare byte for byte with the CMake
    bootstrap (self-host.md).

11. Remote execution and distribution

(distribution.md, reapi.md,
workers.md)

  • Remote execution: a transport-independent executor that ships source and toolchain trees
    from the store and chooses local, remote or racing execution from recorded timing, absent
    bytes, queue depth and cache locality. Short actions are batched; a race cancels its loser.
  • REAPI: a dependency-free protobuf codec for REAPI v2.3, a client for CAS, ByteStream,
    ActionCache and Execution, a validated remote cache tier for wrap and build --profile,
    and liquid serve reapi, which exposes liquid's CAS and ActionCache. Stock Bazel reads and
    writes it (reapi-codec.md).
  • Scheduler and workers: liquid's own scheduler and signed worker fleet, with one bounded
    requeue after a worker is lost, placement by size class, and health, metrics, REST, OpenAPI
    and MCP surfaces.
  • Node store: a per-node runtime chunk store with metadata-only image receipt,
    reference-counted read-only mounts, reuse counters, eviction to a byte budget, and its own
    control surface (node-store.md).
  • Build without bytes: remote results keep their locations without fetching outputs, and
    reads fetch verified chunks only on demand. liquid status reports the bytes still remote.
  • Replay: liquid replay reconstructs a recorded action and compares exit status, output
    streams and declared outputs byte for byte.
  • Delta delivery: liquid delta creates, applies and fetches a signed patch between two
    artifacts, verifying source, patch and target digests.

12. The incremental engine

(incremental-engine.md)

  • A persisted, demand-driven query graph: red-green validation, early cut-off on unchanged
    fingerprints, durability, cooperative cancellation, and continuous clean validation that
    recomputes one query in twenty and evicts a value that diverges.
  • Language frontends: a versioned C ABI loads replaceable language modules. The bundled
    tree-sitter fallback fetches 49 grammars at exact commits under SHA-256 checks
    (frontends.md, grammars.md).
  • Per-definition C++ builds: the Clang module emits one action per definition, so an edit
    to a function body re-executes only that definition.
  • Structural diff: reports moves, semantic edits, formatting and comments, and labels its
    fallback to text or binary (structural-diff.md).
  • Support tiers: liquid tiers prints the declared support for each language, format and
    platform (support-tiers.md).
  • Symbols: content-addressed symbol records per translation unit, with a labelled
    tree-sitter fallback (symbols.md).
  • Hot update: evidence-based classification into tiers 0 to 4, signed patch and restart
    records, and a cooperative C runtime for macOS arm64 and Linux x86_64
    (hot-update.md).
  • Build streams, tests and plans: build handles stream events through the library and the
    daemon; CMake test registrations become cached actions that liquid test runs; and
    liquid build --plan prints the complete action plan
    (../cli/build-events.md, ../cli/test.md).
  • Structural edits for C and C++: rename, extract, move and concrete-tree edits, previewed
    as minimal text changes, applied as one drip per file and undone as one operation
    (edit.md).
  • The checkout daemon, on macOS and Linux: one process per checkout that owns capture, maps
    each drip to the graph inputs it changed, feeds build, search, collaborator and Lake targets
    in order with durable cursors, reports lag, and exits when idle.
  • Database branches for agents: one isolated PostgreSQL branch per session from a template
    copy, guarded promotion that refuses a changed base, and discard
    (data-branching.md).

13. Formats, projection, resolution and configuration

  • Structural merge of concurrently changed source: disjoint definition edits combine, and
    suspicious proposals stay conflict values (structural-merge.md).
  • Format registry: codecs for ZIP, tar, HDF5, Parquet, SQLite, linked binaries, PDF,
    notebooks, office documents, packages, wheels, JARs, safetensors and (without executing it)
    pickle. They drive diffs inside containers and search inside archives
    (formats.md).
  • Projection: one checked install tree projects to deterministic .deb, .rpm, .apk,
    Homebrew bottles, Arch recipes, OCI image layouts, digest-pinned Helm charts, AppImages,
    Flatpak build directories and Snaps, each with signed projection, provenance and SBOM
    statements (projection.md).
  • Source projection: a change or result projects to an unsigned Debian .dsc with
    deterministic source archives.
  • Platform packages and signing: reproducible unsigned macOS packages, disk images, MSIX and
    winget manifests, with signing records that bind the unsigned and shipped digests.
  • Install intent: canonical records generate Debian, RPM and Alpine lifecycle scripts, and
    install, list and rollback use atomic generations with interruption recovery.
  • Image-based OS projection: OSTree commits and bootc OCI layouts.
  • Dependency resolution: liquid's own CDCL solver over Spack-style specs, with virtual
    providers, compilers as dependencies, target-family fallback, reuse preferred over freshness,
    and minimal attributed conflict explanations (resolution.md).
  • The .liquid configuration language: typed, declarative records for packages, sources,
    targets, install intents and exclusive-checkout rules, with includes, exact diagnostics,
    canonical formatting and generators that run with signed provenance
    (configuration-language.md).
  • Spack import: a pinned Spack export becomes .liquid documents and package records, with
    a report of what was translated and what was lost. A committed 500-package fixture checks
    resolution (import-spack.md).

14. Deployment

A client for the operator's control plane: digest-pinned OCI images, named environments, status
readback and rollback (deploy.md).


15. Every command

All 80 commands of the generated reference (docs/reference/cli/),
with the reference's own one-line summary.

Where Git has a command for the same thing, liquid uses Git's name. liquid --help lists
the commands in the groups below, Git's own first. A Git command that liquid deliberately does
not have says what to use instead: liquid commit answers with liquid cut, and add, grep,
reflog, submodule, mergetool, restore and branch have hints too. The rule and the
reason for every difference are in docs/cli/git-commands.md.

Repositories and history

Command What it does
init create a repository and import its regular files
clone clone and materialize a repository
status show repository status
cut cut the working change
log show changes and drips, or verify timestamps and the transparency log
refs list repository references
diff compare changes, containers, and source syntax
history show or restore path history
blame show the session and change that last wrote each line
tree print the recorded root tree digest
write write a file from a stated base
mv record a path move
rm record a path removal
anchor map a text position between changes
ops list recorded operations
undo undo the newest, named, or session operations
edit preview or apply a structural edit
symbols show compiler or syntactic symbols for a source path
search search paths and contents

Composition, conflicts, locks and sessions

Command What it does
nest nest another repository
split split a subtree into a repository
combine combine another repository
conflicts list unresolved conflicts
conflict inspect or resolve an unresolved conflict
resolve concretise packages or resolve a conflict
lock exclusively lock a configured path
unlock release an exclusive lock
session manage a private speculative replica
data manage session database branches

Capture, working trees and the store

Command What it does
daemon start or stop the checkout daemon
watch capture changes until Ctrl-C
pause pause working-tree capture
resume resume working-tree capture
mount mount a lazy working tree
materialise write a full working tree
compact checkpoint a repository epoch
gc checkpoint and collect a repository
repack rebase stored chunk deltas
retain explain retention for an object

Sync, review, drive and interchange

Command What it does
push push repository changes and objects
pull pull repository changes and objects
review review a lake change in place
drive synchronize a drive folder
import import a local tree, Git repository, or Spack package universe
export export as a Git repository
serve serve repository sync, REAPI, or image admission

Identity, keys, signing and trust

Command What it does
identity show or rotate the device identity
keys inspect and manage data-key custody
secret fetch, seal, or unseal a Lake environment secret
sign sign a digest or projected platform installer
release manage threshold release approval
attest show, verify, or mint an image attestation
registry manage artifact-registry trust
policy check or explain build-input policy

Building

Command What it does
wrap run an existing build as cached actions
build plan, start, profile, or trace a configured repository build
test run discovered tests as cached actions
verify re-execute and compare cached actions or the query graph
replay reproduce and compare a recorded action
why explain the latest cache lookup
why-slow show the critical path to a build target
cache show build-cache statistics
facts inspect or export configure facts
provenance print and verify build provenance
sbom print a derived or explicitly inferred SBOM
abi show or compare library ABIs
inspect explain a recognised artifact
hot-update classify, apply, or inspect runtime updates
scheduler run the remote-execution scheduler and CAS
worker run a remote-execution worker
node-store run or control the runtime node chunk store

Packaging, installing and deploying

Command What it does
config check, lower, or format .liquid configuration
project project content into packages, commits, images, or charts
delta create, apply, or fetch an artifact delta
install install or list atomic generations
rollback select the previous installed generation
deploy create, inspect, or roll back an environment deployment

About the tool

Command What it does
version print the version
tiers print declared language, format, and platform support
docs generate the CLI reference

16. Guides and documentation

Five executable guides, whose shell blocks run as tests (docs/guides/):

  • Your first repository: automatic drips, named changes, diff, search, and push to a local
    sync peer.
  • Wrap an existing build: real CMake and Autotools projects, cache reuse, miss explanation
    and provenance.
  • Keys and encryption: public identity export, encrypted paths, key providers and rotation.
  • Resolve packages from declarations: a two-package dependency graph and canonical records.
  • Package ordinary repository files: a change packaged as Debian and OCI artifacts, with
    deterministic Debian bytes.

Also in the tree: the generated CLI reference, 25 feature specifications
(docs/features/), 27 research topics
(docs/research/), the library notes
(docs/library/), and the vendored TAAP/1 draft
(docs/standards/).


What v0.1.0 does not include

The known limits, from docs/library/status.md:

  • Lazy mounts, wrap, verify and replay need libfuse3 on Linux and macFUSE on macOS.
    Without macFUSE those commands report their documented unsupported or skipped result.
  • Windows returns a documented unsupported result for the daemon, and for wrap, verify
    and replay.
  • Phase exits not yet demonstrated: the Phase 2 exit
    (#299) and the Phase 4 exit
    (#300). No machine reachable from the
    development Mac has a FUSE mount; the
    lane audit records what was checked.
  • The action-result memory cache tier is separate work.
  • Measured transfer timing remains Phase 3 work.
  • The containerd proxy snapshotter remains in k0s.
  • The executable-aware delta algorithm id is reserved and unused.
  • Encrypted objects are not transferred by repository::transfer.
  • The data-branch reflink fast path needs local cluster control metadata.
  • Apple notarisation has no recorded credentialed proof, and booting a projected image is
    outside the projection implementation.
  • Tier B source projection is Debian-only.
  • Filesystem projection without FUSE on Linux, macOS and Windows
    (#302,
    #303,
    #304).
  • The hosted service and the IDE are their own projects (Lake and liquify), not part of
    this release.
  • A licence. None has been chosen
    (liquid-bridge#2).

Known issues

  • #349 — creating the local identity
    races: concurrent first uses can leave it unreadable (cannot unwrap local identity).
  • #346 — SIGBUS inside liquid's runtime
    under heavy parallel test load.
  • #325 — block_on's runner threads use
    the platform default stack, which is 512 KiB on macOS.
  • #319 — the shared-library build fails
    to link the CLI on macOS, with undefined Boost symbols.
  • #310 — the public constructors of
    forge_client and sync_endpoint throw across the library boundary.
  • #341 — a one-file commit issues 57
    store barriers, which bounds a remote store by round trips.
  • #340 — the sync client does not retry
    a 503 that carries Retry-After.
  • #291 — the wrap, cache and provenance
    promises cannot be proven on the development Mac, because macFUSE is absent.
  • #281 — the real-world import gate is
    stale: main takes 1,773 s against a 900 s ceiling.
  • The suite on Linux: #356 (the full
    suite fails about 300 tests under a parallel run on the Linux lane) and
    #348 (326 of 693 fail in a container on
    environment, not code).
  • Intermittent tests: #354 and
    #336 (admission server),
    #353 (daemon under load),
    #264 (node store) and
    #225 (drip overflow on Linux).

Verification

Full suite, run serially (ctest --test-dir build, no -j) on the release branch. macOS
arm64, Homebrew Clang 22.1.8, without macFUSE, 367 seconds, after the last code change on the
branch (the grouped help and mv):

745 tests · 733 passed · 0 failed · 12 skipped

The 12 skipped tests need something this host lacks: a FUSE mount (lazy mount, wrapped
build and libfuse conformance cases), a configured REAPI or NativeLink peer, a node content
store, native packaging peers, or a restart hook. So this run does not exercise wrap,
verify, replay or lazy mounts end to end; see
#291.

A first run on this branch failed one test, and the cause is fixed in this release.
Version.StringMatchesStruct showed that the version lives in a third place,
current_version() in include/liquid/version.hpp, which still said 0.0.1. The header now
says 0.1.0, and the test compares the string with the struct instead of repeating a literal.
Every run since, including the one above, is the whole suite after that fix.

The build has no compiler warnings. ./build/liquid version prints liquid 0.1.0.

Checks on this page and the tree: the command tables match
docs/reference/cli/cli.json (80 commands, none missing, none extra); the link check over
docs/, README.md and CLAUDE.md reports 0 broken links.

Not done for this release: the suite on Linux (the cluster BuildKit lane; see
#356 and
#348), the shared-library build
(#319), and Windows.


Building it

git clone --recurse-submodules git@github.com:oramasearch/liquid.git
cd liquid
cmake -S . -B build -G Ninja
cmake --build build
ctest --test-dir build

Prerequisites, options and the install layout are in
docs/build/local.md. Consuming the library from another CMake project is
in docs/library/libliquid.md.