Pipelines, first-class
Every stage produces a stream — Pipeline<T>. Compose with
| at the shell line or .pipe() in TypeScript.
v0.3 · the whole test stack
Mock it, test it, load it, tail it —
Mock it, test it, load it, tail it —
the whole test stack, baked into one binary.
Spec-driven mocks, fixture suites generated from your OpenAPI spec, load gates CI can
fail on, and every process log in one stream — all composing on the same
| / .pipe(), from the REPL, a crust -c one-liner,
or a .crust script. Zero dependencies, one compiled binary — and it never
reports a false pass.
curl -fsSL https://raw.githubusercontent.com/lariocpt/crust/main/install.sh | bash
or from npm —
npm i -g @lariocpt/crust
·
npm package page
$ range(0, 10000) | parallel 100 | GET :3000/health | expect 200 | stats
# { count: 10001, durationMs: 814, p50: 5, p95: 17, p99: 41 }
$ read fixtures/*.json | POST :3000/users | expect 201
$ lines **/*.log | grep ERROR | filter (l => !l.includes('healthcheck')) | wc -l
$ sql "select email from users limit 5" | (r => r.email) Why crust
Bash and TypeScript, one pipeline.
Shell stages and TS lambdas are equal citizens — both sit on the same pipeline. Pipe anything into anything: globs into HTTP, ranges into parallel workers, SQL rows into lambdas.
HTTP verbs as stages
GET, POST, PUT, PATCH,
DELETE ship as pipeline stages — auto JSON encoding, headers via
-H, status matchers like expect 201 and
expect 2xx.
Request chaining — capture
POST … | (r => r.json()) | capture ID (b => b.id) — later
lines expand $ID. Whole CRUD flows as .pipes suites,
no framework.
Load scenarios & CI gates
load 30s 100/s | parallel 50 | GET :3000/health | stats | assert (s =>
s.p95 < 200) — paced ramps, honest drop accounting, thresholds as
chained asserts.
Fixture testing & stress mode
test-fixture 'fixtures/*.crust.ts' -n1000 -j32 runs your
.crust.ts fixtures with p50/p95/p99 reports.
OpenAPI mock, validator & proxy
mock-server ./openapi.yaml — spec-driven mock with
envelope-aware --stateful CRUD — persistent via --state
sqlite/postgres, seedable via --seed — --validate 422s,
and a --proxy mode that audits a real backend's conformance.
Agent skills, embedded
crust skills install writes ten agent skills into
.agents/skills/ — linked into .claude/skills/ for
Claude Code, chosen in a terminal menu — and they are grammar-lint-tested
against the live parser, so examples can't rot.
Verify web links + SEO
verify-web-links https://example.com — crawl your
sitemap, catch broken links and dead anchors, diff Open Graph tags against
fixtures.
One-liner mode
Stay in your shell — call crust -c '…' from bash/zsh/fish for the
lines where pipeline syntax wins, and the tools as commands:
crust mock-server openapi.json, crust skills install.
Recipes
From smoke tests to stress runs.
Hand-picked workflows you can lift into your own pipelines today.
Stress testing
Paced load scenarios with ramps and drop accounting — plus
--count + --threads fixture runs at volume.
CI load gates
stats | assert (s => s.p95 < 200) — thresholds, baselines
via stats --out, and honest exit codes for CI.
OpenAPI mock server
Boot a Bun.serve mock from any Swagger / OpenAPI 3.x spec — stateful CRUD that persists to sqlite/postgres, seeds itself on first boot, and round-trips enveloped entities.
Read recipe →API smoke tests
read fixtures/*.json | POST :3000/users | expect 201 in one
line — or whole .pipes suites with SQL asserts.
Log mining
Forensic queries over log trees, live streams from any command via
stdin, and an interactive logs session that
holds the stream while you iterate on filters.
Heap snapshots during testing
A Bun [test].preload that writes a
.heapsnapshot and prints rss / heap / top-classes after every
bun test.
Bake it in.
Install in one curl. Script it with .crust files, drive it from your
shell with crust -c, or live in the REPL.