lgwks_std

Everyday Rust primitives with no async runtime required: hex, base64, timestamps, UUIDs, hashing, glob matching, regex, JSON, HTTP, and structured logging, as single-import calls, each behind one audited dependency stack.

Pick exactly what you need. The default build is core plus trace; every other capability is one feature with one vetted stack beneath it.

trace is default-on. Structured logging is the replacement for terminal output in library code, so it has to be reachable without selecting a feature first. It includes the tracing facade and the default subscriber bootstrap: LGWKS_LOG/RUST_LOG filtering, compact local output, pretty local output, and JSON lines for machine ingestion. It still keeps tracing-attributes off, so the foundation crate does not pull the syn instrumentation macro stack.

Want a zero-dependency build?

cargo add lgwks_std --no-default-features --features core

That is the only configuration in which this crate pulls nothing at all, and it is verified by command rather than asserted. cargo tree -p lgwks_std --no-default-features --features core -e normal prints one line: lgwks_std itself.

Package lgwks_std (underscore) lives in directory crates/lgwks-std (hyphen): cargo add lgwks_std then use lgwks_std::....

Install

cargo add lgwks_std                                    # core + trace
cargo add lgwks_std --features json,http               # pick what you need
cargo add lgwks_std --no-default-features --features core   # zero deps
cargo run -p lgwks_std --example quickstart            # 10-line tour (this repo)

Usage

// Core — zero external deps, always available
use lgwks_std::{hex, time, encoding, glob};

let digest = hex::encode(b"hello");
let now = time::now_rfc3339();
let encoded = encoding::base64::encode(b"payload");
let matches = glob::matches("src/**/*.rs", "src/lib.rs");

// Debugging — default-on with the crate defaults
use lgwks_std::trace::{info, install_default};

install_default("my-service")?;
info!(tenant = "demo", "service started");

// Opt-in features — each adds exactly one vetted dependency
use lgwks_std::id::Uuid;       // feature = "random"
use lgwks_std::hash;            // feature = "hash"
use lgwks_std::pattern::Regex;  // feature = "pattern"
use lgwks_std::json;            // feature = "json"

let id = Uuid::new_v4().expect("OS entropy");
let blake3 = hash::blake3(b"content-addressable");
let re = Regex::new(r"\d+").expect("valid regex");

#[derive(json::Serialize, json::Deserialize)]
#[serde(crate = "lgwks_std::json::serde")]
struct Point { x: i32, y: i32 }

let point: Point = json::from_str(r#"{"x":1,"y":2}"#).expect("valid JSON");

The #[serde(crate = ...)] line is required. The derive macro resolves a crate named serde, and the dependency policy forbids consumers from declaring serde directly, because lgwks_std owns that edge. The attribute points the expansion at the re-export instead. If the compiler reports cannot find serde in this scope, add the attribute rather than running cargo add serde; lgwks-deps check refuses that edge.

Feature map

One manifest key, three alternative lines. Use exactly one of them:

[dependencies]
# Zero external deps: defaults off, core selected. The default build is core
# plus trace, so a bare `lgwks_std = "0.7"` is NOT zero-dependency.
lgwks_std = { version = "0.7", default-features = false, features = ["core"] }

# Pick what you need, on top of the default core + trace.
# lgwks_std = { version = "0.7", features = ["hash", "json"] }

# Everything.
# lgwks_std = { version = "0.7", features = ["full"] }

Module reference

Dependency philosophy

Every direct dependency is a vetted leaf or single-purpose stack registered by semantic capability and owner. lgwks-deps check audits authored edges from Cargo metadata; Cargo.lock preserves the exact transitive provenance.

• blake3 — 3 zero-dep leaves (arrayvec, cfg-if, constant_time_eq)
• regex — 4 BurntSushi-internal crates, zero external deps
• serde — derive stack (proc-macro2, quote, syn)
• serde_json — 2 leaves beyond serde (itoa, ryu)
• ron — 1 leaf beyond serde (bitflags)
• rkyv — 5 djkoloski crates, zero external deps
• getrandom — zero deps in std-only mode
• ureq — blocking HTTP client, rustls-only TLS stack plus small leaves
• iri-string — zero-dep URI validation leaf at default features
• rustix — safe POSIX syscall surface for the fs-raw primitive; Unix-only, optional
• tracing — default-on structured event facade for library diagnostics.
• tracing-subscriber — default debugger bootstrap. install_default("service") installs env-filtered compact output, and LGWKS_LOG_FORMAT=json switches the same stream to JSON lines. attributes stays off, so #[instrument] and its proc-macro stack do not enter this crate.

core alone carries zero external dependencies; the default build is core plus trace. You choose what you pull in; every other feature flag is one capability, one stack, no surprises.

Minimum supported Rust version

Rust 1.98.0. The MSRV moves forward only when code or dependency requirements demand it.

The other crates

Four crates ship from this repository. They share a release process, not a dependency graph: lgwks_bot and lgwks_deps depend on lgwks_std, and lgwks_ast stands alone.

The repository README indexes the design documents.

License

Apache-2.0 — Copyright 2026 Logical Works Incorporated