Skip to content

Releases

v2.0.0

Choose a tag to compare

@rennf93 rennf93 released this 16 Oct 02:44
Immutable release. Only release title and notes can be modified.
9100597

v2.0.0 (2026-10-16)

The reference-parity release, training with the 4.4.0 engine: route country rules and the unknown client identity, live dynamic rules, validated config, strict routes, the body read timeout and the agent from config (v2.0.0)

Breaking

  • GuardConfigError gains the Config variant (the engine now runs SecurityConfig::validate before wiring) and the Agent variant (an agent built from the agent_* fields that fails under agent_strict), so an exhaustive match over it needs arms for both.
  • Trains with the engine: the guard-core-engine and guard-core-rs floors move to 4.4.0, and the optional guard-agent-rs to 3.2.4. SecurityConfig gains public fields, so a struct literal needs ..Default::default(); an invalid IP list entry is now reported as Config instead of IpGate.
  • Behavior to know before upgrading: a route whitelist match no longer overrides a blocked country, the unknown client identity is denied on a route with an ip_whitelist or whitelist_countries, route usage rules run after the security pipeline, each dynamic rule version applies over the base config instead of stacking, a request body that does not arrive within body_read_timeout is answered 408, and route_resolution_strict answers an unresolved route with 500.

The parity release: the reference exclude_paths, client and response-pass semantics, and the whole SecurityConfig through the facade's Wiring.

Added

  • Route country rules and the unknown client identity follow the reference check_route_ip_access: the route ip_whitelist / ip_blacklist verdict is combined with the route blocked_countries / whitelist_countries verdict (a route whitelist match no longer overrides a blocked country, blocked_countries is asked first, no loopback exemption on the route arm), the unknown client identity is denied by a route ip_whitelist or whitelist_countries, and a global whitelist denies it (it passed before). Verified against 2125 rows generated by running the reference (tests/route_country.rs)

  • Client resolution with the reference rules: the connecting peer plus X-Forwarded-For through trusted_proxies and trusted_proxy_depth, IPv4-mapped peers canonicalized. A request with no peer and no resolvable client answers 403 Client address could not be determined under fail_secure (check name client_address_unresolved on the on_block hook), after the exclusion decision. GuardFairing::with_client_policy and ClientPolicy install the policy (a bare fairing keeps fail_secure = false), and WebSocketGuardConfig::with_client_policy gives the upgrade guard the same resolution

  • GuardExclusionScoped, the marker an exclude_paths request carries (the reference guard_exclusion_scoped, read it as an Option<GuardExclusionScoped> request guard), and the scoped pipeline it runs: route resolution, bans, the global IP, country and cloud rules, and the rate limit. The response pass runs scoped (metrics, security headers, CORS and the modifier, no return rules)

  • GuardFairing::from_security_config_with(config, &WiringOptions) and from_wiring(Wiring), with the telemetry agent injected through the facade's TelemetryHandler. agent_stats() now reports the wired sink and its degraded state, telemetry() exposes the fan-out, spawn_dynamic_rules() starts the dynamic-rule poll loop on request, and the cloud-range refresh runs per request at the cloud check position. New builders: with_telemetry, with_dynamic_rules, with_cloud_refresh, with_auth_verifier, with_body_read_timeout, with_path_exclusions. GuardConfigError gained the Cloud, Redis and Geo variants

  • The security_bypass event for an all-checks-bypass route (all_checks_bypassed), whose request forwards with only the response modifier applied (no metrics, headers or return rules) and continues through the pipeline under passive_mode

  • Body return_pattern rules now read the response body: the response body is buffered when a rule needs it, bounded in time by body_read_timeout, re-emitted intact, and a read error or timeout answers the fail-secure 500

  • Reference parity: SecurityConfig::validate runs at construction (GuardConfigError::Config), the stages a dynamic rule can change (geo, cloud, user agent, emergency mode, the penetration toggle, the rate limit and ban knobs) are read from the live config on every request (LiveCell, re-exported with LiveContext and LiveStages), route_resolution_strict answers 500 Route resolution failed for a request that matched no route (decided in on_response, log-only under passive_mode, emits route_unresolved and fires on_block, GuardFairing::with_route_resolution_strict), GuardBody answers 408 Request body read timed out when the body does not arrive within body_read_timeout, and the cargo features redis (forwards guard-core-rs/redis) and agent (builds the guard-agent-rs agent from the agent_* fields, GuardConfigError::Agent, degraded state in agent_stats())

Changed

  • The route usage rules (process_usage_rules) run after the whole pipeline passed instead of before it: a request the pipeline or a guard refuses is no longer counted, and neither is a request with no client ip. Configs that were invalid but accepted before (for example auto_ban_threshold = 0) are now refused by from_security_config; Wiring::build_unvalidated is the unvalidated seam
  • exclude_paths uses the engine's reference matcher instead of an exact raw-path comparison: /static covers /static/app.js, percent-encoding and dot segments are resolved, and exclude_paths() reports the normalized entries. An excluded request is no longer exempt from the pipeline: bans, the global IP lists, country and cloud rules and the rate limit apply, and the request is counted in the metrics. Tests that encoded the old exact-match bypass were updated
  • The client identity no longer comes from Rocket's client_ip(), which honors the X-Real-IP header from any peer: it is the connecting peer, with X-Forwarded-For honored only through the trusted proxies
  • from_security_config builds through Wiring, so the fields it used to drop now land: geo country rules and geo_ip_handler, block_cloud_providers, endpoint_rate_limits, enable_rate_limit_auto_ban, custom_request_check, auth_verifier, custom_response_modifier, on_error, cors_expose_headers, trusted_proxies, the telemetry and event bus, dynamic rules, and the redis stores when guard-core-rs has its redis feature. The response processor now shares the ban manager with the ban stage, so a return-rule ban is enforced by the next request. A config with fail_secure = true (the default) rejects a request that carries no peer address
  • The custom response modifier runs even when no response processor is installed, and exactly once when the processor already carries it
  • The HTTPS stage matches trusted_proxies against the connecting peer instead of passing no client host, and the request scheme is the transport's own, so a forged X-Forwarded-Proto from an untrusted peer no longer skips the redirect
  • A route carrier's auth_required and api_key_required fall back to the config's global auth_verifier
  • GuardBody skips its body scan for an excluded request and for a route that bypasses all or penetration; the size cap stays as the memory bound
  • Documentation: the skill file no longer describes the crate as a scaffold, the README engine-dependency and status statements are corrected, and the new config surface, client policy, scoped exclusions and agent injection are documented

v1.5.0

Choose a tag to compare

@rennf93 rennf93 released this 09 Oct 10:03
Immutable release. Only release title and notes can be modified.
v1.5.0
0e5d397

v1.5.0 (2026-10-09)

The consumption release: the unified config, the route-config carrier knobs, the response-pass funnels, and the behavioral lanes land, training with the 4.3.2 route-config engine (v1.5.0)

Note

  • Trains with the engine: the guard-core-engine and guard-core-rs floors move to 4.3.2 (the route-config train)

Added

  • The get_cloud_providers_to_check route-over-global resolution (the RC2 rocket leg, over guard-core-rs#105's decide_route): the carrier route's block_cloud_providers list replaces the global one for the request (an empty route list falls back to the global config), an invalid route selector fails secure (the reference validates at decoration time), the global lane stays untouched off-route, and the clouds bypass skips the whole arm; six end-to-end twins drive the override, the route block, the off-route hold, the fallback, the fail-secure arm, and the bypass
  • The carrier's stage knobs at the per-stage seams (the RC1 rocket leg): the (method, path) carrier's remaining reference knobs consume at their pipeline positions through the engine's decision cores - ip_whitelist/ip_blacklist (the RouteIpGate arm before the global gate: a configured whitelist takes over the route verdict and skips the global lists, skip_ip_lists; the blacklist denies the reference 403 Forbidden; an invalid entry fails secure), per-route countries (blocked_countries/whitelist_countries through geo::check_countries, a passing route whitelist skipping the global geo stage, skip_countries; no geo handler leaves the request alone), required_headers plus the auth group and the api-key group (headers_auth::decide over the carrier rules with the route verifiers, the required sentinel, the fixed 401 shape), custom_validators (decide_custom_validators under the reference anonymous name, the validator's own status, the truthy non-response and the declining validator passing through), require_referrer (the referrer core's 403 shapes), time_restrictions (the start/end/timezone dict through the time-window core, missing bounds fail-open), and enable_suspicious_detection = false skipping the scan for its route (detection_enabled); thirteen end-to-end twins drive every knob on a matching route and its off-route silence
  • The security_headers_applied funnel (the H6 rocket leg, over guard-core-rs#103's composer and #104's accessor): when the security-header set lands on a forwarded response and the bus is installed, the fairing's on_response pass composes security_headers_applied_event and dispatches it over the bus - action headers_added over the security_headers handler, metadata path (display-redacted), headers_count (the rendered set, before the CORS verdict and the response modifier touch the view), has_csp, has_hsts; only the forwarded lane fires (the pipeline passed, Verdict::Clean, and no route guard refused - the reference process_response shape that carries the request path), guard-generated answers (blocks, the redirect, the fail-secure 500) apply the headers without firing (the reference's create_error_response lane), and a disabled set renders nothing and dispatches nothing
  • The CORS preflight short-circuit and the behavioral usage rules in the pipeline (the GAP-R10 rocket leg, over guard-core-rs#95's engine surface): an OPTIONS request carrying access-control-request-method has its preflight answer computed in on_request (the reference is_preflight + build_preflight_response; cors::is_preflight + build_preflight_response from the resolved CORS config) and on_response replaces whatever Rocket composed with it - a preflight answer is 200/400, statuses the fairing decides (Rocket's fairings cannot answer mid-flight, so the answer rides a request-local slot and the handler's output is never observed); CORS disabled or no response processor leaves OPTIONS to the pipeline. The route carrier's usage/frequency behavior_rules track per request through the response processor's shared tracker with a crossed ban rendering the activity-banned shape (the reference process_usage_rules, dispatched from the request pass before the check pipeline)
  • The maintenance trio and the full status payload (the GAP-R9 rocket leg): GuardFairing::reset (the reference reset(): the rate-limit windows drop, bans and violation counts untouched), refresh_cloud_ip_ranges + with_cloud_refresh_scheduler (the reference refresh_cloud_ip_ranges: one single-flight background refresh through the facade's CloudRefreshScheduler - the refreshed ranges land in the shared table, each provider's row restamped, false with no scheduler installed or while one is in flight, the reference's concurrent-caller gate), and agent_stats answering the reference property's no-agent shape ({"enabled": false, "degraded": false}, the AgentStats type re-exported); the status payload's provider rows carry the reference get_status shape - ready, last_refreshed (the unix-second stamp of the last range load, null before one, from CloudIpTable::provider_status), and entries - with the geo-ip component rendering the IpInfoManager health snapshot ({ready, last_refreshed, entries}) when the lifecycle manager is wired (the bare configured flag and null stay for the trait-only and absent arms)
  • The WebSocket guard for Rocket's official rocket_ws surface (fastapi-guard guard/websocket.py's make_guard_websocket, the GAP-A9 rocket leg): .manage(make_guard_websocket(WebSocketGuardConfig)) + the WebSocketGuard request guard on rocket_ws routes runs the reference check sequence before the handshake completes - fail-secure unknown address, the ban arm, the is_ip_allowed gate + country arms (a whitelist match skips countries), the ws rate limit (skipped for whitelisted IPs), then the path/query/header penetration scan - and a blocked handshake answers 403 Forbidden pre-accept with the close shape on x-guard-websocket-close / x-guard-websocket-close-reason (1008 Policy Violation policy denials, 1013 Try Again Later malfunctions, the panic in the check sequence contained). The guard also covers frames after the upgrade: WebSocketGuard::scan_frame scans one text/binary message through the engine (control frames pass), answers the reference close shape (close_frame + stream_error), and feeds the shared violation store installed by with_violation_feed (the reference's shared suspicious_request_counts): a crossed threshold bans the address through the shared IpBanManager, and the next handshake's ban arm rejects it; rocket_ws rides in as a dependency
  • The reference route-config carrier consumption (GuardFairing::with_route_configs + set_route_config, the GAP-R2 rocket leg): the engine's RouteConfigResolver ((method, path) -> Option<Arc<RouteConfig>>) resolves the route's RouteConfig once per on_request pass - a carrier stashed with set_route_config wins over the resolver (the reference request.state.route_config idiom) - and the pipeline consumes it with the reference semantics: bypassed_checks (and the "all" wildcard) skip the named reference checks at their pipeline positions (the fused stages map as documented: required_headers/authentication skip the headers-auth stage, ip_security skips the gate, ban, and geo arms, suspicious_activity skips the scan and its violation feed, rate_limit skips the whole tiers pass), require_https rides the HTTPS stage's carrier lane (decide_route; with no stage installed the route arm still composes the reference 301), max_request_size replaces the body cap the data guard enforces, blocked_user_agents runs additively before the global filter through the trusted-compile lane (a non-compilable route pattern fails secure 500), the rate-limit group becomes the route's tier (an invalid tier fails secure), and the detection-exclusion group resolves through the engine's detection view; RouteConfig/RouteConfigResolver re-exported
  • The unified-config consumption (GuardFairing::from_security_config, the GAP-R1 rocket leg): the 129-field SecurityConfig (the fieldized reference surface in guard-core-engine) builds the wired pipeline in one call - the detection budgets onto DetectConfig, the IP lists onto the gate, the rate-limit knobs onto the limiter, the ban group onto IpBanManager + IpBanConfig, enforce_https/trust_x_forwarded_proto onto the HTTPS stage, emergency_mode + its whitelist onto the emergency stage, custom_error_responses/on_block onto the response surface, the detection-exclusion group (with the reference's empty-set-disables-all-categories semantics) onto the scan, the observability group onto the log/redaction knobs, ReDoS-validated blocked_user_agents, and the security-headers/CORS/behavior response pass; invalid values fail closed through the new typed GuardConfigError; the reference exclude_paths carve-out lands as a first-class builder consumed first in the pipeline (an excluded path bypasses every request-side check, gate included, the response pass still renders); SecurityConfig, SecurityConfigError, GuardConfigError, and the LogLevel/LogFormat/BufferOverflowPolicy knob enums re-exported

Changed

  • The bypass consumption now uses the reference's coarse query vocabulary (the ip gate, the route IP restrictions, and the country arms query ip; the ban arm ip_ban; the cloud-provider check clouds; the rate limiter rate_limit; the penetration scan penetration; the "all" wildcard matches every query) - the previous wave keyed the bypass on the 17 stage names, a vocabulary the reference never queries (the stages it named are not route-bypassable in the re...
Read more

v1.4.0

Choose a tag to compare

@rennf93 rennf93 released this 07 Oct 07:12
v1.4.0
404d7e5

v1.4.0 (2026-10-07)

The reference-surface release: the status route lands in managed state, training with the 4.3.1 parity-completion engine (v1.4.0)

Note

  • Trains with the engine: the guard-core-engine and guard-core-rs floors move to 4.3.1 (the parity-completion release)

Added

  • The reference status route (fastapi-guard add_status_route + HandlerInitializer.get_initialization_status): GuardStatus in managed state plus the guard_status route handler mounted at /_guard/status, serving the cloud-provider readiness table and the geo-ip component from the handles the app already holds (#38). The WebSocket upgrade guard has no surface here: rocket has no stable 0.5 WS surface to guard

v1.3.0

Choose a tag to compare

@rennf93 rennf93 released this 01 Oct 21:57
v1.3.0
8b9c26d

v1.3.0 (2026-10-01)

The 4.3.0 engine train: the guard-core-engine and guard-core-rs floors move to 4.3.0, no adapter logic changes (v1.3.0)

Note

  • Trains with the engine: the guard-core-engine and guard-core-rs floors move to 4.3.0 (the safety-chain release). The adapter ships no logic changes of its own

Changed

  • Process and CI chores: the community and security process scaffold (#23), the 100% line coverage gate enforced with cargo-llvm-cov (#24), the CDLA-Permissive-2.0 license allowed from the engine sibling's graph (#30), and the routine GitHub Actions dependency bumps (#25-#29, #31-#33)

v1.2.0

Choose a tag to compare

@rennf93 rennf93 released this 27 Sep 19:11
v1.2.0
afcbe92

v1.2.0 (2026-09-27)

Trains with guard-core-rs 4.2.0: the 4.2.0 floors restore public registry resolution

Note

  • Trains with the engine: guard-core-engine and guard-core-rs floors move to 4.2.0 (the 4.1.0 engine dists were yanked; this release restores registry resolution)

Added

  • The wave surfaces are publicly configurable on GuardFairing, each wired to the engine facade's rate-limit stage (guard_core_rs::tower::RateLimitStage, built in on_ignite and carried in the managed engine state; every stateful decision and emission goes through it):
    • with_route_tiers(resolver) (path -> Option<RouteRateLimits>) and with_geo_handler(Arc<dyn GeoIpHandler>): the reference's endpoint/route/geo rate-limit tiers; the first tier that crosses answers the same 429 + Retry-After shape and feeds the auto-ban engine; the request-local set_route_rate_limits(&request, tiers) setter covers the per-route decorator idiom
    • with_detection_exclusions(DetectionExclusionConfig) + with_route_detection_exclusions(resolver) (+ the set_route_detection_exclusions setter): the reference per-route detection-exclusion surface, resolved per request through the engine's detection_exclusions::resolve + scan_request
    • with_event_bus(Arc<SecurityEventBus>): the penetration_attempt/rate_limited/ip_banned events with the reference fields, metadata, and redaction
    • with_observability(ObservabilityConfig): log_suspicious_level, muted_check_logs, and the log_sensitive_headers/params/body_fields redaction sets
    • with_on_block(OnBlockHook) and with_custom_error_responses(CustomErrorResponses): the hook fires exactly once per blocked request (and per passive-flagged detection with no status); the status-to-body map overrides every block body, honored by the catchers and the 404 rewrite
    • with_distributed_store(window_store, redis_prefix, redis_fail_open) + with_distributed_ban_store(store): the reference distributed mode (fail-closed backend errors answer the new 503 "Redis rate limiting unavailable" shape, fail_open = true degrades to the in-memory window)
    • with_passive_mode(bool): the reference passive mode - windows and counters record, log lines and events fire, no block ever renders
  • New re-exports: DetectionExclusionConfig, RouteDetectionExclusions, GeoIpHandler, BanStore, SlidingWindowStore, ViolationCounters, RouteRateLimits, RateLimitEntry, RateLimitTier, TierDecision, SecurityEventBus, ObservabilityConfig, RequestObservation, StageResponse, BlockPayload, OnBlockHook, CustomErrorResponses, and the set_route_rate_limits/set_route_detection_exclusions setters

Changed

  • guard-core-rs (the engine facade) joins guard-core-engine as a pinned 4.1.0 dependency with the sibling-checkout path fallback; the stage delegation keeps the existing with_rate_limiting/with_ip_banning shared-handle semantics (out-of-band bans and custom clocks honored) through the stage builder's limiter/ban_manager injection seams
  • Two-phase flow (documented framework mismatch, reference-matching order): Rocket's on_request never sees the body, so the fairing runs bans + rate-limit tiers + the metadata finding there (the request's single rate-window hit records at on_request), and the GuardBody data guard feeds the body finding through the engine stage's split feed_finding seam - no window double-recording, and rate limiting still precedes body processing exactly as the reference pipeline orders it
  • Scan semantics move onto the engine's reference surface: the query string is scanned as parse_qsl-decoded per-parameter pairs (previously one raw encoded blob), and the headers the exclusion resolution marks are scanned with their known false-positive categories suppressed (ssrf for address-chain values) instead of an adapter-level blanket skip. Exempt IPs now feed the violation counters (the reference suspicious-activity stage skips a whitelisted IP only; detection still scans and blocks them), so a crossed threshold bans even an exempt attacker

Added

  • Stateful stage (rate limiting, dynamic bans, auto-ban) over the engine's rate_limit and ip_ban modules, mirroring the tower reference implementation:
    • GuardFairing::with_rate_limiting(RateLimiter): the sliding-window limiter runs in on_request after the IP gate and the ban check, before the metadata scan - a crossing answers 429 Too Many Requests with Retry-After: <window seconds>, the references' rate-limit shape. With the limiter's enable_rate_limit_auto_ban on, every crossing counts one rate_limit violation toward the auto-ban engine (threat_ban_config["rate_limit"] first, then the flat threshold), the reference pipeline's _record_rate_limit_autoban
    • GuardFairing::with_ip_banning(IpBanManager, IpBanConfig): a live ban answers 403 Forbidden (IP address banned) before the limiter, so banned traffic never consumes rate budget; every detected threat counts its categories per client IP (the reference pipeline's suspicious-activity stage) and a crossed threat_ban_config entry or the flat auto_ban_threshold bans on the spot, answering 403 Forbidden (IP has been banned); config.enable_ip_banning = false counts violations but never bans; the plain detection block keeps the reference suspicious-activity stage's 400 Bad Request (Suspicious activity detected) shape
    • both stages honor the exempt_ips contract: whitelisted and exempt IPs are never rate limited, never banned (ban stage), and never have violations counted - which makes exempt_ips observable under load; unattributed requests (no client IP) cannot be held responsible and skip the stage, detection still screens them
    • the limiter and the ban store pair are shared with the managed engine state, and RateLimiter, IpBanManager, and ViolationCounters are cheaply clonable and clone-share their stores, so out-of-band handles (admin unban endpoints, stats) work alongside the installed fairing

Changed

  • Detection blocks answer 400 Bad Request (Suspicious activity detected) instead of 403 Forbidden, matching the reference suspicious-activity stage's status and the rest of the Rust family (the IP gate's 403 Forbidden and the fail-secure 500 are unchanged); the registered catchers and the fairing's unrouted-path 404 rewrite carry the family's five-shape contract

v1.1.0

Choose a tag to compare

@rennf93 rennf93 released this 26 Sep 18:48
v1.1.0
e220ace

v1.1.0 (2026-09-26)

The optional global IP gate

Added

  • Optional global IP gate (GuardFairing::with_ip_gate over the new engine IpGateConfig): whitelist, blacklist, and exempt_ips lists parsed once at startup (invalid entry is a config error, fail closed), evaluated in on_request before the metadata scan on the request's client IP - a blacklisted client IP, or one a non-empty whitelist matches neither directly nor through exempt_ips, is refused with 403 Forbidden, including the unrouted-path 404 rewrite so probe traffic never reveals route inventory. exempt_ips is the skip-list for known-friendly automation: it sets the same skip state a whitelist match sets but never adds a deny path and never opens the whitelist gate; the blacklist and detection still apply to exempt IPs. Requests without a client IP (Rocket's local test client) are not attributed and still screened by detection

Changed

  • guard-core-engine dependency pinned to the published 4.1.0 release (path dep kept for local builds and CI against a sibling guard-core-rs checkout), carrying the stateful sliding-window rate limiter and dynamic IP ban engine, the tower stage with a reusable decide(), and the new detection stages (request size/content, user-agent, headers/auth, cloud provider blocking, geo blocking)
  • The request body is no longer scanned as one lossy blob: it is routed by content type through the engine's body-value extraction (guard-core 4.0.4 parity, upstream commit 5f399234), and every extracted value is scanned through the normal detect path with its reference context - urlencoded field values under request_body:form_field, multipart part entries (label scan, filename="..." entry with RFC 2231 handling, raw part headers, payload) under request_body:multipart_field, embedded JSON leaves under the :embedded_json suffix, JSON mongo operator keys ($where, $ne, ...) as direct nosql hits, and the whole-body blob only as the fallback for plain or unparseable bodies
  • Binary-dense multipart file-part payloads are reduced to printable runs of at least detection_binary_min_run_length (default 16) before pattern scanning, so compressed upload bytes stop producing attack-shaped matches while text embedded in uploads still scans in full; text uploads, text parts without a filename, and whole-body fallback scans keep their full scan
  • 403/413/500 short-circuit responses now carry the bare message (Suspicious activity detected, Payload too large, Security check failed) as text/plain; charset=utf-8, matching the Python family's block-response convention, instead of the JSON {"detail":"..."} shape

v1.0.0

Choose a tag to compare

@rennf93 rennf93 released this 24 Sep 00:28
v1.0.0
8843971

[1.0.0] - 2026-09-24

Added

  • First stable release of rocket-guard-rs 1.0.0: application-layer security Fairing for Rocket 0.5, powered by guard-core-engine 4.0.4 (17/17 checks parity with guard-core 4.0.4, binary-noise gates)
  • Guard Fairing: one engine call per request view (path, query string, headers, buffered body), 403/413/500 fail-secure responses with the ecosystem JSON detail shape, configurable body cap (default: engine full-scan cap), catch_unwind panic recovery
  • Example apps: examples/simple_app and examples/advanced_app with Dockerfiles and docker-compose smoke stacks
  • Dockerized live smoke workflow (.github/workflows/live-smoke.yml): compose run of simple_app with curl assertions of real engine behavior (XSS block, traversal block, 413 body cap, passthrough)
  • Upstream drift guard (.github/workflows/upstream-drift.yml): daily test suite run against guard-core-rs@master
  • Security audit workflow (cargo deny), release gate (fmt/clippy/test at tag on stable and MSRV 1.92, tag/version consistency), automated crates.io publish on GitHub release via CARGO_REGISTRY_TOKEN
  • Makefile (install, test, lint, fix, bump-version, clean) and .github/scripts/bump_version.py (stdlib-only version bump across the crate, example pins, Cargo.lock, and a CHANGELOG scaffold)

Changed

  • guard-core-engine dependency pinned to the published 4.0.4 release (path dep kept for local builds and CI against a sibling guard-core-rs checkout)