EXTENSIONS

Drive an ESP32-S3 with a screen from swamp. One model type, `s3-panel`, is everything `@vcjdeboer/s3-device` does plus typed methods for the display: `text`, `fill`, `clear`, `backlight` and `logo`, plus touch screens (`screen`, `zonewait`) and a physical `approve` for workflow approvals. The board renders and the host says what to render, so no pixels cross the wire. Built against a Guition JC3248W535 (3.5" 320x480 AXS15231B), but any firmware answering the same commands will do. Firmware 0.12 also runs the panel on its own as a swamp-club profile badge on Wi-Fi, set up from a phone; `wifi`, `configure`, `forget`, `profile` and `idle` drive that from swamp.

Drive an ESP32-S3 from swamp over USB serial. One model type, `s3-device`, speaks a JSON line protocol: one command line in, one JSON object out. It knows nothing about what the board is attached to, so it serves a bare S3 as well as one carrying sensors or a display, and records every exchange as versioned data with an explicit outcome. Screen-specific methods live in `@vcjdeboer/s3-panel`, which builds on the same base.

Headless Apple Podcasts transcript fetcher. Reads the local Apple Podcasts library (MTLibrary.sqlite) to find episodes, and downloads their TTML transcripts via the FetchTranscript binary (Apple's private frameworks) with a Podcasting 2.0 `<podcast:transcript>` RSS fallback. Pure subprocess + HTTP; no GUI. Two methods: `search` — MTLibrary substring lookup returning matching episodes; `fetch` — by store_id, tries FetchTranscript then RSS, writes TTML + plaintext to the output directory and records episode metadata as data.

Is this Jev question safe to build on? A pre-flight check for TypeSafe System One questions. Runs a fully crossed item x framing x repeat grid against the API and reports what you need settled before putting a model's number behind an `if`: repeatability (does an identical request give an identical answer), framing sensitivity (does rewording move the answer, and by how much more than plain noise), resolution (can the question tell your items apart, or does the scale saturate into unrankable ties), threshold stability (does a fixed cut-off flap on identical input), and answerability (is it confidently rating things that have nothing to rate). Works on all three primitives — score for rating, noul for gates, choice for routers. The headline is a decision flip rate: if you reran this, how often would the decision your code acts on come out differently? The report adds a nested variance decomposition that separates repeat noise from framing sensitivity from real differences between items, fitted by a Gibbs/slice sampler in TypeScript so it needs no Stan, R or Python, and it withholds the posterior when the convergence gate fails. It does not take your paraphrases on trust: it hashes every request body and refuses to count a perturbation that produced a byte-identical request.

Multi-dimensional writing voice profiler powered by Jev. Analyze any text across six dimensions — formality, authority, complexity, warmth, pace, conviction — with calibrated probabilities. Compare two texts side by side to see how their voices differ. No training data needed.

Agent + human guidance for the swamp session-* suite: how to record a live session, author a governed analysis (fill a frozen template's typed slots, validated), run it headless, and seal it — and where the R env flake, templates, and recorder clients live. Wire an R project to record its work with the writer init on-ramp.

Never lose how a result was computed. A language-agnostic provenance ledger for interactive data-science sessions: append one immutable, content-checksummed record per executed cell/chunk — its code, value, figures, console output, warnings, packages, and even runtime-declared functions with their internal dependencies — from any client (R/RStudio, Python/Jupyter, targets, …). One append-only ledger, one record per cell, identical shape across languages: the foundation the rest of the session-* suite fills, seals, and replays. Capture the real computation as it happens, so a session can be audited, sealed (session-witness), or re-run later — not reconstructed from memory.

The headless runtime of the session-* suite. Runs a filled analysis template — R/qmd in a pinned nix R env (`run`), a targets pipeline via a harvester (`run-targets`), or Python/ipynb via papermill in the locked conda/Docker env (`run-notebook`) — with the recorder armed or a swamp.returns contract verified. Also faithfully REPLAYS a captured session: `replay` re-runs recorded R against frozen tolerance rules (nix preferred, docker fallback), and the Python host-replay shim serves a captured session's host.* calls offline (or falls through to the live API in hybrid mode). Reproduce a governed run — or a foreign Claude Science session — deterministically.

Drive a UC2-ESP device from swamp over USB serial and record every exchange as versioned data. One model type, `uc2-device`, speaks the UC2-ESP task protocol ({task, qid, ...} with ACK, async events and a final DONE correlated by request id) from Diederich et al., J. Microscopy 2026 (doi:10.1111/jmi.70147).

Drive an ESP32 running MicroPython from swamp over USB serial, with no Arduino IDE: flash the board, run Python or a firmware line-protocol, scan WiFi and Bluetooth, and record every exchange as versioned data with an explicit outcome.

Lift your own Claude Science (operon) sessions out of the local operon-cli.db into open, replayable, sealable swamp records: a typed transcript, a turn->execution->artifact->env provenance graph, an immutable content-addressed byte corpus, the FULL ordered cell script, the CS skills the session used, its replayable host.* calls, a Tier-1 /private/tmp input freeze, a per-source external-data inventory, a presence-only credential manifest, and reproducible Docker + Nix environment locks — then `seal` an order-stable bundle-manifest (witness-digested). With @vcjdeboer/session-execute run-notebook + a host-replay shim, a captured session RE-RUNS outside the app. Reads a disposable scrubbed clone (secret tables dropped and never decrypted; explicit column allow-list; refuses a mid-run session), read-only, deterministic. Anti-lock-in data portability for your own local sessions.

Let an AI fill in an analysis template without letting it touch the science. Governed parameter-fill: the AI fills ONLY the typed parameter slots of a frozen template, and `validate` is the deterministic gate that asserts the frozen structure was untouched and every fill satisfies its slot contract — bounded, validated, reproducible AI authoring, not free-form code generation. `author` builds Quarto (.qmd) or Jupyter (.ipynb) templates from structured cells (the writer owns the document layout and binds each param at its declared type) for R or Python; `init` wires an R project to record its work. The guarantee: what the AI can change is exactly the typed slots and nothing else — the template is the contract.

Prove a recorded data-science session hasn't been altered since you sealed it. The Master member of the session-* suite: a tamper-evident seal + authorship attestation, with no keypairs or infrastructure. `seal` chains the per-version content checksums of a session-record ledger (in sequence) into one sha256 session digest and attests its authors; `verify` recomputes the digest and reports whether a sealed session still matches. `seal_manifest` generalizes the primitive to ANY ordered {name, checksum} list — so a session-ingest bundle-manifest seals exactly the same way. Change one byte of any past record and the digest changes: the seal breaks, loudly. Ultralight integrity for governed, reproducible science — the trust layer under the whole suite.