Manual contentsPrologueBrowse 140 chapters
Manual 531 min read

Changelog

A readable, per-version log of what changed in Suprnova. Each version section is that version's release record. A version is released when its version commit and matching v<version> tag are pushed atomically. Newest first.

4.6.2 - 2026-10-23

Added

  • HttpEmbedder reports the usage its provider sends. Embedder gains embed_documents_metered and embed_query_metered, which return the vectors with the provider's own usage (prompt_tokens, total_tokens) as a Metered<T>; the HTTP provider reads it from the OpenAI-compatible response and sums it across batches, and every other provider reports None, so an application that pays per token settles the bill from the provider's count instead of an estimate (#212).
  • HttpEmbedder runs over an application-owned transport. HttpEmbedder::with_transport takes an EmbeddingTransport: the application sends each TransportRequest (the pinned endpoint, headers, JSON body, timeout and response cap) through its own HTTP client, credential resolver and admission rules and returns a TransportResponse with the status, headers and body. The embedding protocol, retries, Retry-After, parsing and vector validation stay in the framework, which also refuses a body over the cap whatever the transport did (#213).
  • LazyEmbedder registers a shipped profile and loads the model on first use. SearchRegistry::register_embedder can take a LazyEmbedder built from a shipped ModelProfile and a loader; the service starts and tests run without downloading weights. The generation coordinator calls the new Embedder::resolve_profile before it pins a generation, so the generation still records the loaded model's revision, and a loaded model whose id or dimensions differ from the shipped profile is refused by name (#214).
  • A search generation an interrupted build left behind can be reclaimed. generations::reclaim_generation(index, generation) and search:reclaim release the creation lease of a creating generation so the next create call resumes at once instead of waiting the 60-second lease out, publish a building generation that was never switched to, and report one that is already current. The caller vouches for exclusive ownership, such as its own migration lock; SearchEngine::release_creation_lease is the driver hook, a no-op for drivers without leases (#215).
  • A Cloudflare CDN driver for static publication. CloudflareDriver (feature cdn-cloudflare, on by default and free of new dependencies) works the way an R2 bucket with a custom domain already does: the bucket is the publication disk through S3Config with the R2 endpoint, the custom domain serves it, and nothing runs at the edge. The driver owns a few rules on the zone, created on the first switch and corrected on every later one: two URL rewrites that serve /about and /about/ from the mirrored about/index.html, a response header rule that carries the published headers, and a cache rule that caches a response only when its own Cache-Control allows a shared cache, as the published objects' does. It purges by URL in batches of 100 or by prefix, and removes its rules on a first-publication rollback. CloudflareDriver::for_origin covers a hostname that mixes dynamic pages: the proxied application serves the published objects itself and the driver keeps the cache rule and the purges. R2 charges no egress.
  • An application's own 5xx page is sent as built. With debug off, the framework answered every browser 5xx with its minimal status-only view, which also replaced a 503 page the application built on purpose, with its recovery link and Content-Security-Policy. HttpResponse::error_view() marks such a response as the application's own error view, and the production view leaves it alone, body and headers. Unmarked 5xx responses keep the minimal view; with debug on the development error page still replaces a marked response that carries an error report (#217).

4.6.1 - 2026-10-23

Fixed

  • A Live action's framework frames fit their stack budget again in a debug build. The static publication lookup that 4.6.0 added to every GET request built its 65 KB future in the request's own frame, so the frames below a Live action grew past the 1 MiB budget that leaves the action room on Tokio's default 2 MiB stack, and a deep action in a debug build could overflow it. The lookup now builds in a frame of its own that returns first.
  • A fresh scaffold passes its own page budget test and cargo fmt --check. The React, Vue and Svelte kits' tests/page_budget.rs audited routes::register() alone, so the Live script every page loads from /__live/assets returned 404 and the test failed on a new application. It now audits the router cmd/main.rs serves, and the notes topic's gate rule moved from bootstrap::register into live::authorize() so both can call it. The kits also wrote the Live topic setup, the asset share and the page budget test on lines rustfmt rewrites; the templates now carry rustfmt's layout, and the test's layout no longer depends on the application name.
  • The page budget audit's URL mode counts the bytes that cross the wire. budget:audit <url> and PageBudget::audit_url asked for uncompressed responses and counted decoded bytes as transfer, while a HAR capture of the same visit counted the compressed bytes, so the two modes disagreed on a page that serves gzip. A URL audit now asks for gzip, counts the compressed bytes for the transfer, asset and font rules, and reads the decoded body for the rest. This fix landed after the v4.6.1 tag.

4.6.0 - 2026-10-22

Added

  • Lossless PNG recompression. Image::recompress_png(PngEffort) runs oxipng over a PNG after the pipeline's pixel operations, and the synchronous suprnova::recompress_png helper does the same on PNG bytes. PngEffort::Fast is oxipng's default level; PngEffort::Maximum is level 6 with Zopfli. Pixels, transparency, indexed palettes, the ICC profile and the colour chunks are kept; text, time and location metadata are removed; the output is never larger than the input. The media feature carries the dependency.

  • Inertia pages in RenderCache. A page declares its cache shape on the InertiaProps struct: #[inertia(cacheable)] on the struct, and #[inertia(public)] or #[inertia(per_request)] on every field (a field without a marker, an unknown field name or the marker on a non-props type fails to compile). Inertia::cache_page::<Props>(route, component, public_shared, per_request_shared) registers the page at boot. RenderCache stores the public shell and stitches the per-request props in after the route guards run; the assembled response is private, no-store. Representations are keyed on X-Inertia, the partial set, the asset version and the other protocol headers, which the response lists in Vary; a stale asset version answers 409 before any cached bytes leave. suprnova generate-types writes the declarations into inertia-props.ts as inertiaPropCache (manual/render-cache.md, manual/frontend-typescript-types.md).

  • A page budget audit. TestClient::audit_page(url, &PageBudget) renders a page through the in-process request path, follows the assets the document references (scripts, stylesheets and their imports, images and source sets, fonts, icons, media, inline styles, the web app manifest) and returns every failed rule with the asset, the rule, the measured value and the allowed value. The rules cover total transfer, per-asset size, raster format against size (WebP or AVIF with a fallback above the threshold; a PNG within a margin of its oxipng fast-preset size), the one-year immutable policy on fingerprinted assets, no cookie on or for a static asset, no redirect on the first request, a font budget and the third-party hosts the page reaches. The budget:audit <url | file.har> console command applies the same rules to a live URL or a HAR capture. Every budget is configurable on PageBudget and, for the command, through PAGE_BUDGET_* environment variables (manual/page-budget.md). All three modes measure the application's own resources and list every third-party host, which the allowed-host rule governs, so a HAR capture and the in-process audit of one page agree. The React, Vue, Svelte and Live starter kits ship tests/page_budget.rs over their public pages; the dogfood application runs the same audit.

  • Static publication of public Inertia pages. A route declared with Router::public_page::<Props> (or a public group plus Inertia::public_page::<Props>) renders without a session, CSRF token or nonce, and the application publishes its HTML and JSON objects, its fingerprinted assets and its transcoded images to a storage disk the CDN serves. Publication runs as an application boot task after the listener is bound, so the health check never waits for it. Every page references its assets by versioned key and the manifest write is the only switch, so the previous publication stays live until the new one is complete; a storage lease and a conditional manifest write keep two publishers from racing, and graceful shutdown waits for a delivery in progress. Pages regenerate by dependency tag after a committed transaction or job, delivered across processes through the bound BroadcastHub, and on a revalidate interval. The CdnDriver trait ships a CloudFront driver (origin switch, invalidation, a viewer-response function that restores the recorded headers); without a driver the origin serves the published objects from the manifest and mirrors them to stable bucket keys after the switch. Public pages get a hash-based Content-Security-Policy with 'unsafe-inline' and nonces removed from every script directive; private pages keep their nonces, and the origin sends Strict-Transport-Security only on HTTPS it can trust. Images are published as WebP at quality 85 or higher, AVIF when ImageMagick is configured, with the metadata-stripped original as the fallback, and kept PNGs go through recompress_png at the maximum preset. Same-origin absolute image URLs and inline raster data: images go through the same preparation and are published as objects; a page whose own CSS (a style attribute or a <style> element) carries a raster image refuses publication, naming the route, and the origin keeps serving it. Third-party images and linked stylesheets are published unchanged. static:publish, static:status and static:prune are the console commands; prune keeps the live publication and retired versions inside their grace period. The React, Vue and Svelte kits ship a client that fetches the published JSON for public navigations and sends everything else to the origin (manual/static-publication.md).

  • Live bindings for Inertia pages. #[inertia(live(topic = "notes", only = ["stats"]))] on an InertiaProps struct binds a Live topic to a list of its props, checked at compile time against the struct and carried into the generated TypeScript. A bound page renders through InertiaResponse::live::<Props>("Dashboard"), naming each topic family instance with .scope(family, key) and loading its data in .load(...); the response reads the topic cursors before the loader runs and carries them under the reserved liveBindings page key. Topics are the Live registry's own: LiveRegistry::builder().topic(name) and .public_topic(name) register them, .topic_family(name) gives per-key instances such as notes.42 under one live:topic.{name} ability (.load_with(...) takes the response builder for deferred and optional props), and every binding goes through Live's subscription log, authorization and transports; a private topic without an authorizer refuses to boot, and a binding the viewer may not subscribe to is omitted from the page instead of leaking its cursor. A change registered with LiveTopics::changed signals after the commit of its transaction and never after a rollback, coalesced to one signal per topic per request or job and excluding the sender's own page; on_model_scoped publishes a model's saves and deletes to the instance it maps to. A signal carries only the topic, its cursor and generation, and the affected prop names. The configured BroadcastHub owns each topic's cursor and its rate (LIVE_TOPIC_SIGNAL_INTERVAL_MS, default 100 ms); with the Redis Streams hub a signal reaches pages on every node, without a hub it reaches the publishing process only; an instance with no member and no activity for LIVE_TOPIC_INSTANCE_RETENTION_SECS (default one day) retires and comes back with a new generation at cursor 0, which the client treats as a reset of its bound props. The React, Vue and Svelte kits ship one client core with an adapter each: a signal older than the render is dropped, a burst reloads once with the union of its props, a failed reload retries with bounded backoff, and polling stays as the fallback. The kit dashboards bind stats to the per-user notes family (manual/live.md, manual/frontend-pages.md).

  • Event sourcing. #[suprnova::domain_event(name, version)] declares a fact with a stable stored name and schema version, #[suprnova::aggregate] plus the AggregateRoot trait rebuild an aggregate from its history, and Aggregate::record(..).await then Aggregate::persist().await appends facts in their own transaction with an optimistic version check, so two writers never record the same aggregate version (a stale version is a 409 conflict). apply receives a Fact view that is identical when recording and when rebuilding, so a snapshot always equals a full rebuild. Projector handlers keep read models and Reactor handlers run side effects once; a QueuedProjector runs on the queue worker and never reads a synchronous projection. Projectors checkpoint by stored event id and EventReplay rebuilds them from the start in event order, synchronous handlers before queued ones per page, while reactors stay silent. Snapshots shorten rebuilds. Three tables (stored_events, snapshots, projector_checkpoints) ship as a framework migration for SQLite, PostgreSQL and MySQL/MariaDB; rolling it back drops the history. Two domain events with one stored name refuse to boot. The console commands are event-sourcing:replay, event-sourcing:events and event-sourcing:snapshot. A projector that changes a Live-bound topic signals once after the transaction commits, never on rollback and never during replay. The dogfood app shows a shared tally on a Live page (manual/event-sourcing.md).

  • DB_OUTCOME_SETTLE_TIMEOUT (DatabaseConfig::outcome_settle_timeout, default 30 s) bounds how long a caller whose persist was cancelled during the commit waits, on its next call, for the transaction's real outcome before reporting it as unknown; Aggregate::is_settled() says whether that wait is pending. It never cancels or bounds a transaction, query or commit.

Changed

  • The default lossy encode quality is 85, not 70. JPEG and lossy WebP encoded without an explicit quality call now use 85, which DEFAULT_IMAGE_QUALITY names. Quality below 85 blurs images.

  • Inertia protocol middleware runs before RenderCache whatever order the application registered them in, so an asset mismatch is answered before a stored page could be replayed. A cacheable Inertia route with an opaque share hook or provider fails boot with the route name; declare the shared props by name instead. Middleware boxed through the public into_boxed keeps its type identity, so ordering and boot checks see it.

  • Static files get a cache policy by file name. StaticFiles serves a fingerprinted file (Vite's name-<hash> convention, confirmed by the build manifest when one is configured, so an all-lowercase hash counts; fingerprint(pattern) changes the convention for other files) with public, max-age=31536000, immutable, and every other file with public, max-age=3600 unless cache_control(...) sets another value. Before, cache_control applied to every file and nothing was sent when it was unset. A static file response no longer sets the session or XSRF cookie when the request left the session untouched; a request that changed the session (a remember-me rotation, a regeneration) still gets its cookies.

  • cdn-cloudfront is a default feature. It reuses the AWS signing stack the S3 disk and the SQS queue driver already carry and adds quick-xml for the distribution configuration; turn it off with default-features = false.

  • LiveStreams::refresh follows the shared topic rules for cursor, fanout, scope, socket exclusion and rate, and LiveStreamErrorKind::RuntimeUnavailable also covers an unavailable configured publisher.

Fixed

  • The MariaDB vector driver reads a quoted index distance. MariaDB 12.3.3 renders the vector index option as `DISTANCE`='cosine' in SHOW CREATE TABLE, where 12.3.1 rendered DISTANCE=cosine. The driver kept the quotes, saw a distance mismatch and refused every similar call; it now strips them (#216).

  • A savepoint rollback discards the callbacks of the work it rolls back. Nested transactions and named savepoints in DB::transaction now record their after-commit and rollback callbacks under one lock with the savepoint they belong to, and each savepoint statement and its bookkeeping complete together even when the caller is cancelled. Before, a nested transaction rolled back to an enclosing savepoint could still run its after-commit callbacks when the outer transaction committed. A panicking callback no longer stops the callbacks after it.

  • The built-in driver honours the JPEG quality setting. The OxideAV registry encoder ignored the quality option and wrote every JPEG at 75. The driver now calls the JPEG encoder directly with the pipeline's quality.

  • Two tools with one name in different crates now fail the build at link time. Every #[tool] emits one marker symbol, __suprnova_tool_ followed by the tool's name, so the linker reports a duplicate symbol that names the tool when two crates declare the same name. Before, such a duplicate was only refused when the application booted; that check stays as a second net. A crate that forbids unsafe code still builds its tools.

  • Tool schemas publish integer fields with their bounds and no JSON Schema format. schemars wrote Rust's integer formats such as uint64 and int32, which clients do not know: Claude Code logged unknown format "uint64" ignored for every such field, and strict clients reject the schema. The bounds carry the same information. The WebMCP browser schemas and the tool-schemas.ts file that suprnova generate-types writes follow the same rule.

4.5.1 - 2026-10-21

Fixed

  • The locked dependency set no longer carries the webpki advisories RUSTSEC-2026-0381, 0382 and 0383. rustls-webpki 0.103.16, webpki-roots 1.0.10 and webpki-root-certs 1.0.10 replace versions whose bundled roots trusted distrusted emSign intermediates. Binaries built from the tag with --locked, the CLI among them, get the fixed versions.

4.5.0 - 2026-10-21

Changed

  • Three public enums have new variants. Revocation gains DocumentRelationsBefore, RegistrationOutcome gains Unavailable and MetadataErrorKind gains TooManyBrowserTools. A match over one of them with no wildcard arm no longer compiles. (#174, #167, #166)
  • Database search vector delivery now uses retryable claims. Concurrent delivery reports an in-flight error, and a stalled vector call times out after 45 seconds. (#202)
  • Search touches now report an error when a declared relation key is missing or cannot be read from the model. (#203)
  • Eloquent counter updates now use the saved row to check search eligibility and invalidate cached pages. (#198)
  • New starter kits offer more search results only when another accessible page is available. (#196)
  • Successful search requests now bootstrap session and CSRF cookies for new clients. Reuse them when reporting search clicks. (#195)
  • Event retries now resolve their original provenance before checking the target's current existence or access scope. (#192)
  • Newly generated starter explanations retain every contributing history event. Regenerate existing recommendations to refresh their stored provenance. (#193)
  • Starter recommendation reads load ranked candidates in bounded pages and load similarity histories only for selected peers and the viewer. Custom search engines now need key lookups for starter reads, as they do for graph reads. (#194)
  • Quoted phrases now constrain semantic and hybrid searches using each engine's lexical phrase matching rules. (#191)
  • Indexing and semantic queries now require the provider's model id and revision to match the generation. Rebuild with search:reindex after changing models. (#187)
  • Worker boot now constructs configured search providers before validating searchable indexes. (#188)
  • Configured search providers are now available inside application bootstrap hooks for server, worker and console processes. (#199)
  • Qdrant now supports retained flush fences and index deletion through the search maintenance commands. Flush fences use the configured tombstone lifetime. (#189)
  • Qdrant generation deletion can now resume from the dropping state while ordinary writes continue to reject that state. (#190)
  • Qdrant hash lookups now retain the source version when skipping unchanged documents, preserving stale-write protection. (#186)
  • Loading a searchable model without timestamps now reads its content and search version together. Locking model reads keep their row locks until the version is loaded; ordinary reads use one SELECT on Postgres, MySQL and SQLite. (#178)
  • Saving a searchable model without timestamps now updates the search version carried by that same instance, including saves in an explicit transaction. (#177)
  • Graph traversal now replaces earlier paths with stronger later paths, including when the node limit is full. (#176)
  • RecommendationRun now exposes ranking_digest. Apply the new recommendation migration when upgrading. (#175)
  • Custom graph stores must handle DocumentRelationsBefore, which removes stale relation facts while keeping the document node and its engagement edges. (#174)
  • Serialized recommendation explanations now omit social and shared-engagement edge references. Server-side explanations keep them for verification. (#173)
  • On MySQL and MariaDB, an email address now matches an account only when it equals the stored address after trimming and lowercasing. Accent variants and other collation folds, such as ss for ß, no longer match at sign-in, password reset, email verification, passkeys or OAuth linking; Postgres and SQLite already compared exactly. A user who typed an unaccented form of an accented address types it exactly after upgrading. (#167)
  • UserProvider gained rehash_password_for_sign_in(user, credentials, recorded_epoch), the rehash the session guard's attempt calls. It checks the stored epoch and the verified hash, writes atomically and returns the snapshot it wrote. The default calls rehash_password_if_required only for a user without a credential epoch, so a custom provider that upgrades hashes on sign-in implements the new method; once and logout_other_devices still call the old one. The built-in Eloquent and database providers implement it. (#168)

Fixed

  • Database search vector updates and deletions now release their SQL connection before calling the vector store, avoiding deadlocks on shared pools. (#202)
  • Search touches now find parent keys even when a child hides or renames them in JSON output. (#203)
  • Retiring a database search generation now removes list tables for attributes that have since been removed from the index definition. (#201)
  • Database search now detects MySQL and MariaDB separately for each named connection, so generation tables use the correct collation. (#200)
  • Incrementing or decrementing a counter now adds or removes search results when the new value crosses a model's indexing threshold. (#198)
  • Starter kit notes search now stops offering more results at the accessible hit cap, even when more notes match the query. (#196)
  • A first JSON search without a cookie now returns an impression that a later click from the same client can validate. (#195)
  • Retrying a recorded recommendation event now succeeds after its target is deleted or its access scope changes. (#192)
  • Starter explanations now include peers' shared-target events and all repeated positive events, so verification detects removed contributors. (#193)
  • Reading a short starter recommendation list no longer loads the whole visible catalog, and still fills the list after filtering inaccessible targets. (#194)
  • Semantic and hybrid searches now exclude documents missing required quoted phrases and refill filtered candidates to preserve result depth. (#191)
  • Replacing an embedding provider with another model of the same dimensions now reports a rebuild error instead of silently mixing incompatible vectors. (#187)
  • Workers with searchable models now start with an environment-selected HTTP or fastembed provider. (#188)
  • Fresh starter kits can create the notes search generation with the configured provider during bootstrap. Initialization failures now name likely causes. (#199)
  • Qdrant flushes now block delayed writes, including keys absent at the start, and deleting an index removes its collections and generation metadata. (#189)
  • Pruning a retired Qdrant generation now removes its collection and metadata instead of failing after deletion starts. (#190)
  • Unchanged Qdrant documents now keep their latest version, so delayed older removals cannot delete them. (#186)
  • A concurrent save can no longer make a loaded search document carry a newer version than the row content it contains. (#178)
  • A borrowed save no longer leaves a searchable model reporting its previous search version after the database has saved a new revision. (#177)
  • Graph recommendations now use a stronger indirect route even when a weaker direct route reached the item first, and explain the route used. (#176)
  • Recommendations created before an upgrade now obey the current peer minimum, and changing ranking settings refreshes unchanged users on the next full run. (#175)
  • Editing a document now keeps its recommendation engagement signals while rebuilding declared relations, including when a document job is retried. (#174)
  • Recommendation explanations no longer reveal which followed accounts engaged through edge keys that a client can recompute. (#173)
  • Cancelling a text stream from a response callback now leaves its status clear, and callbacks cannot overwrite a replacement request's state. (#184)
  • Event streams now stay open after a connection error so the browser can reconnect and continue receiving messages. (#183)
  • Stream readers mounted together with the same id now share their text and callbacks in all three Inertia kits. (#182)
  • Stream requests now use the fresh CSRF cookie after sign-in, so Inertia navigation no longer leaves them sending a stale token. (#181)
  • Adding a source to a Content Security Policy now changes only the policy containing its directive, keeping other policies in the header unchanged. (#180)
  • Live now announces interrupted actions to screen readers in the shipped browser bundles. (#172)
  • A sign-up whose address collides with an existing account only under the database's looser comparison answers the same generic response as a registered address and creates nothing, instead of a conflict error. (#167)
  • Schema watchers now report new form request refusals even when the generated file stays unchanged, without repeating unchanged refusals on every edit. (#171)
  • Postgres schema dumps now remove entire multiline extension comments even when they contain semicolons, preventing invalid snapshots. (#170)
  • Live components now reject more than 64 browser tools on the server, preventing oversized tool metadata from disabling ordinary clicks. (#166)
  • Headless Live tools now report when their growing state no longer fits a follow-up request, so agents can restart instead of receiving an unusable handle. (#165)
  • Concurrent fresh database migrations now recover when another migration creates the authorization server or agent auth tables first on Postgres. (#164)
  • Concurrent agent assertions now share one provider key-set fetch, preventing unknown keys from triggering duplicate requests to the provider. (#163)
  • Live tool actions now accept optional dates and date-times, and date-times in lists and maps, without failing before the action runs. (#169)
  • Password resets now cancel password sign-ins already in progress, so an old password cannot create a new session after the reset. (#168)
  • Agent tools now refuse guards that use a different user provider from the caller's default guard, preventing matching ids from signing in as another person. (#160)
  • Built-in approval and agent claim forms now refuse agent tool submissions, even when the tool has your signed-in session and a valid form token. (#161)
  • On MySQL and MariaDB, accent-insensitive email comparisons could let a different mailbox receive a magic link for another account. Account lookups now require byte equality after trimming and lowercasing, and magic links go to the stored account address. Conflicting registrations return the same generic response without issuing a token. (#167)
  • On MySQL and MariaDB, an email change that differed only by accents could still receive a verification stamp for the old address. Verification now checks the exact address atomically, so that change refuses the stamp. (#162)

4.4.0 - 2026-10-20

Added

  • Handlers become agent tools with #[tool]. A routed #[handler] marked #[tool] is a tool agents can call. #[tool_input] derives the input's JSON Schema (draft 2020-12) from the struct and its serde and validator attributes, so an agent is told what the server enforces. tool_scopes! declares scopes, and a ToolCaller argument tells the handler and its policies who is calling: a public guest, a user or an agent account. A tool call runs the route's middleware, validation, policies and rate limits, under per-caller and per-address budgets. An invalid or duplicate name, a missing description or an undeclared scope fails the build. See Agents.

  • An MCP endpoint serves the application's tools. Router::agents(AgentsConfig::new()) serves POST /mcp over MCP's Streamable HTTP transport, revision 2026-07-28, and to initialize-based clients of revisions 2025-06-18 and 2025-11-25, without sessions. It serves protected resource and authorization server metadata at the well-known locations under the application's root, lists every tool to a client without a token and only the tools a token may call to one with a token, runs public tools without a token, answers 401 and 403 with the scopes a call needs, so a client's first call of a tool that needs a token sends it to sign in, refuses a foreign Origin, and bounds the body, the answer and the run time. Structured results follow the session's revision: on 2026-07-28 a tool's output schema and result pass through as declared, and on the two older revisions a non-object output schema is left out of tools/list and a non-object result comes back as text alone.

  • Users approve MCP clients through a built-in OAuth server. AgentsConfig::oauth_server(OAuthServer::new()) mounts the new Magnetar authorization server plugin: OAuth 2.1 with the authorization code grant and PKCE S256, clients identified by a client ID metadata document or dynamic registration, exact redirect URIs, tokens bound to the MCP endpoint and the approved scopes, refresh tokens rotated on every use, revocation, and tokens stored only as digests. Default approval and connected-agents pages ship, and ConnectedAgents lists and revokes a user's grants. Its issuer is APP_URL.

  • Tokens from an outside identity provider sign users in. OutsideIssuer, added with AgentsConfig::resolver, accepts the user tokens a provider you name signs, checked against its published keys for issuer, audience, expiry and scope. It finds the user by sub, by an id the issuer assigns (id_claim, such as Microsoft Entra's oid) or by a claim the token marks verified.

  • Agents hold accounts of their own under auth.md. AgentsConfig::agent_auth(AgentAuth::new()) serves auth.md v0.6.0 from the new Magnetar agent auth plugin: anonymous, service_auth and ID-JAG registration, the /auth.md document, a claim page with a six-digit code, revocation by token and by Security Event Token, registration rate limits and audit events. A claim dispatches AgentClaimed, delivered at least once with a stable event_id. The agents:key, agents:revoke-all and agents:prune commands print a signing key, revoke every agent credential and run the maintenance pass.

  • Live actions can be agent tools, in the browser and headless. #[tool] on a Live action offers it to agents, with fields marked #[agent_visible] as the result. The Live runtime registers a mounted component's tools with WebMCP. An action marked headless is also callable over MCP with no browser, through a sealed state handle bound to the caller; the Gate ability live:{component}.mount checks the mount properties an agent sends, and #[resolve(...)] fills a property from the caller instead.

  • Pages offer server tools to agents in the browser. Router::share_tools, with_tools on a route, a group, an Inertia response or a Live document, and PageTools::add choose the tools each page registers with WebMCP. A page lists only the tools its viewer may call, a page of public tools stays shared in RenderCache, and the page refreshes its data after a write tool. With WEBMCP_ORIGIN_TRIAL_TOKEN set, every HTML response carries the Origin-Trial header.

  • The React, Vue and Svelte kits register page and form tools. New projects call installPageTools(router) and ship usePageTool, for a tool that lives while its component is mounted, and useFormTool, which makes a form a tool that fills and submits it through Inertia. A destructive form is filled and left for the user to submit. suprnova generate-types writes each form request's input schema to frontend/src/types/tool-schemas.ts. The kits' core.ts, suprnova-webmcp and the Live runtime read a page's tools by the keys they know and ignore the rest, so a later release can add a field without breaking a scaffolded application. A change an older reader must not ignore raises the payload's v.

  • Rust front ends compiled to WebAssembly register WebMCP tools. The new suprnova-webmcp crate registers typed page tools, with the input schema the server derives, for as long as their handles live, and calls the application's server tools with the session and the CSRF token. Built for a target without a browser it compiles and answers unsupported.

  • Tests call tools as any caller. TestClient::tool and TestClient::live_tool call a tool as a page does, and TestClient::mcp calls the MCP endpoint as a guest, a user with chosen scopes or an agent, claimed or not, without an OAuth or auth.md ceremony. Agents::fake mints a token for a chosen caller, and TestResponse::page_tools reads the tools a page offers.

  • Test requests can come from an address and carry any body. TestClient::with_peer_address sends requests as if from that TCP peer, so Request::ip() and limits keyed by the client address see it. TestRequest::body sends a body of any content type as it is.

  • Applications build their own consent pages on AgentApprovals and AgentClaims. AgentApprovals::of(&request) reads the signed-in user's pending authorization as a PendingApproval and records the decision as an ApprovalDecision. AgentClaims::of(&request) reads a PendingClaim and confirms it with the user's code as a ClaimConfirmation. Both answer 403 to a tool call, so an agent never approves or claims for the user it acts as. The framework's default pages use them too. ConsentPageHeaders refuses framing with frame-ancestors 'none', and sets no-store and no-referrer, on every answer of a consent route, error pages included, and keeps the application's nonce policy.

  • url::same_origin_path checks a return address, and Redirect::intended_url reads the intended one. same_origin_path accepts only a path that starts with a single / and holds no control byte, so a sign-in page checks a return_to with it before Redirect::set_intended_url stores it. Redirect::intended_url() returns the address Redirect::intended would follow, without spending it, as Laravel's getIntendedUrl does.

  • An application's migrator can create the agents tables and a case-insensitive email index. suprnova::agents::migrations() creates both plugins' tables, only what is missing. Its rollback leaves them in place, and its documentation gives the statements that drop them. suprnova::auth::migrations::UniqueEmailIgnoringCase::on(table, column) adds a unique index on LOWER(column) on SQLite, PostgreSQL and MySQL 8.0.13 or later. On MariaDB and older MySQL it checks that the column has a unique index of its own and a _ci collation. It refuses a table that already holds addresses that differ only in case, and its index name fits every engine's identifier limit.

  • Tests build a router with agent auth without a signing key. suprnova::testing::install_test_agent_auth_key() gives the test process a generated key when the environment names none.

  • #[tool_output] and #[tool_schema] derive schemas through the framework. #[tool_output] marks a tool's output type, any struct or enum, and derives Serialize and JsonSchema with no serde or schemars dependency of the application's own. #[tool_schema] gives a type nested in a tool's input or output its schema, and suprnova_webmcp::tool_schema does the same for a page tool's input.

  • Tools can carry WebMCP's debugging hint. #[tool(annotations(debugging))] on a server tool or a Live action, the debugging option of the kits' usePageTool and useFormTool, and PageTool::debugging mark a tool meant for debugging and developer tooling rather than end users. The MCP endpoint does not send it.

  • New projects serve agents. suprnova new writes a fresh agent auth signing key into .env, readable by its owner only (mode 0600), and .env.example names both variables with no value. Every kit serves the MCP endpoint, the OAuth server and agent auth from src/agents.rs, and its migrator creates both plugins' tables. The Inertia and Live kits' migrator also creates a case-insensitive unique email index, and their sign-in sends a signed-in user who opens a sign-in link on to a same-origin return_to and keeps the intended address through sign-in and registration. Every kit folds an email address to ASCII lowercase before validating it, and bounds names at 255 characters and addresses at 254.

  • The agents maintenance pass prunes the OAuth server's ended rows. The five-minute pass in serve and agents:prune delete lapsed pending authorizations and codes, expired tokens, and grants revoked longer ago than the retention, whenever the router mounts the OAuth server, with agent auth or without. A live grant or token is never pruned. agents:prune needs agent auth only for --retry-failed.

  • The Inertia and Live kits ship their own approval, claim and connected-agents pages. The React, Vue and Svelte kits render Agents/Approve, Agents/Claim and Agents/Connected at /oauth/approve, /agent/claim and /connected-agents on the consent facade, and an approval leaves for the client by a location visit. The Live kit serves the same three pages as plain server-rendered documents with native forms, and an approval leaves through a short page whose meta refresh and link go to the client, which form-action 'self' allows. Every route runs ConsentPageHeaders, no consent page offers a tool, and text a client, an agent or the user chose sits in <bdi>. See Starter Kits.

  • The API kit serves agents, with a sign-in for consent only. A new API project serves the MCP endpoint and both plugins with the framework's default pages. A browser signs in at /login only to approve a client or claim an agent: the session runs on the consent pages alone, ends after 15 minutes idle, keeps its cookie for the browser session, and ends at POST /logout. GET /api/connected-agents lists the user's connected clients and agents, and DELETE /api/connected-agents/clients/{grant} and /agents/{registration} revoke one. Registration mails a link that verifies the address, which a claim needs, and POST /api/email/verification-notification mails a new one.

  • Auth::email_verification() verifies an address for its signed-in owner. issue mints a single-use link token for the signed-in user, and issue_for one for an account the request just registered. The application mails the link. verify verifies the address only for the user signed in where the link opens, only while the account still holds the address the link was mailed to, and answers Verified, AlreadyVerified, OtherAccount, AddressChanged, Expired, Unknown or SignIn. Anyone can register another person's address with a password of their own, so a link that verified whoever opened it would verify that account. Verifying changes no credential and starts no session.

  • Consent pages refuse a form tool's submission. A kit's form tool sends the form it submits with the Suprnova-Form-Tool header, which suprnova::agents::FORM_TOOL_HEADER names. AgentApprovals::of and AgentClaims::of refuse it with 403, as they refuse a tool call, so a form tool on an approval or claim page cannot approve or claim.

  • New projects ship two notes tools. The Inertia and Live kits serve search_notes at GET /notes/search and create_note at POST /notes/tools, under the notes:read and notes:write scopes, each acting on the caller's own notes. The notes page offers both to an agent in the browser.

  • The Live input takes maxlength. The component library's input sets the attribute only when a caller passes one. The Live kit's account forms bound the name at 255 characters and the address at 254.

  • #[tool] warns over WebMCP's budgets. The build warns when a tool's name passes 30 characters, when its description passes 500, and when an input field has no description, and boot logs the same. The warnings never refuse a tool. A tool that keeps a long name on purpose sets budget = ignore in its marking, which quiets the build warning for that tool alone; boot still logs its budget warnings.

  • Live tools describe their arguments. arguments(amount = "How much to add.") on a Live tool marking gives each action parameter the description an agent reads; an argument name the action does not have fails the build. A mount parameter takes a doc comment.

  • The Inertia frontends pin webmcp-types. The React, Vue and Svelte kits' browser helpers use the community's webmcp-types 0.1.10 definitions for the model context, tool definitions and tool results.

Changed

  • Tool names are identifiers. A tool name is 1 to 64 ASCII letters, digits and underscores, so every model's tool calling accepts it; a name with a dot or a hyphen fails the build. The shipped tools are renamed verb first: posts.create is create_post, notes.search is search_notes. A browser instance of a Live tool joins the tool name and the instance key with a hyphen, and the whole fits in 64 characters: a root mount that does not fit fails at declaration, and the Live checker reports an island that does not. An application with dotted tool names renames them.
  • MagnetarLifecycleEvent and LifecycleEvent carry an attributes map. Agent auth events record the registration, the client address and the fields auth.md names for each kind in it; it is empty for the other kinds. Code that builds either struct field by field, or destructures it without .., no longer compiles.
  • Three public enums have new variants. LifecycleEventKind gains the nine agent auth audit kinds, from AgentRegistrationCreated to AgentRegistrationRevoked. CryptPurpose gains LiveAgentHandle and HandlerArgKind gains Context. A match over one of them without a wildcard arm no longer compiles.
  • The agents feature is on by default. An application that keeps the framework's default features compiles the agent tools, the OAuth server and agent auth, and Magnetar's migrate creates their eight tables when it next runs. Nothing is served until the router calls Router::agents.
  • generate-types and serve write frontend/src/types/tool-schemas.ts. The file holds the input schema of each form request, or an empty list, beside the Inertia props types. Each run brings it up to date and names each request it cannot describe exactly as the server does.
  • Redirect::intended follows only a path, an http or https URL, or a relative reference. It ignores a stored value with another scheme, such as javascript:, mailto: or localhost:3000/x, and one with surrounding whitespace or a backslash anywhere, and redirects to its fallback instead. A browser trims whitespace and reads \ as /, so such a value could leave the application. See Storing the intended URL.
  • An Inertia error page keeps a no-store the replaced response carried. The error page set Cache-Control: no-cache, private on every page it rendered. It now sets no-store when the response it replaces said no-store, so a page that must not be stored stays unstored when it fails.
  • Magnetar's auth_tokens table gains an address_digest column. A token that verifies an email address keeps the SHA-256 of the address it was mailed to. Magnetar's migrate adds the nullable column the first time it runs.
  • A custom Magnetar engine, store or token binding refuses email verification until it implements the new methods. MagnetarPasswordAuthEngine gains email_verification_issue and email_verification_verify, TokenStore gains issue_bound and inspect, and UserStore gains mark_email_verified_for. TokenFields gains read_address_digest and write_address_digest. Each has a default, so existing code compiles, and the defaults refuse, so Auth::email_verification() fails closed until they are implemented.

Fixed

  • Concurrent writes no longer fail on MariaDB 11.8 and later. These releases turn innodb_snapshot_isolation on by default, under which a transaction that updates a row another transaction changed after its first read fails with error 1020, "Record has changed since last read", where MySQL waits and works on the latest row. Two overlapping writes to one table failed one of them with a 500, because each advances the RenderCache ledger, and two requests spending one email verification or password reset link at once could fail the losing request with a database error instead of answering that the link was used. Every connection the framework opens to MySQL or MariaDB now runs SET SESSION innodb_snapshot_isolation = OFF once, when it opens. A server without the variable, MySQL included, refuses it as unknown and the connection opens as before. The statement never fails a connection: any other refusal, as a MySQL-compatible proxy or service may give, is logged once per pool at warn, and the connection opens with the server's own setting. See MySQL semantics on MariaDB.
  • DB::transaction_with_attempts retries by the database's error code. It re-runs an attempt the database refused with MySQL or MariaDB error 1213, 1205 or 1020, or Postgres SQLSTATE 40001 or 40P01, and returns any other database error at once, even one whose message mentions a deadlock. It used to match the word "deadlock" in the message, so a lock wait timeout and MariaDB's error 1020 were never retried. An error with no database code is still matched by its message.
  • A Postgres schema dump loads where an administrator installed an extension. schema:dump copied the comment an extension sets on itself, such as COMMENT ON EXTENSION vector. Loading that dump as the application's role failed with "must be owner of extension", because the extension belongs to the role that installed it. The dump now leaves those comments out, and CREATE EXTENSION sets them again.
  • Magnetar's tables hold long values on MySQL and MariaDB. Byte columns were limited to 255 bytes. These hold passkey and OAuth sign-in steps, two-factor secrets and recovery codes, and saved provider tokens. So were the session user agent and the passkey credential id, public key and provider scope columns. A longer value failed to save, so passkey, two-factor and social sign-in could fail there. Magnetar's migrate widens the existing columns the first time it runs. It keeps each column's character set and collation, and leaves a column that an index covers alone, with a warning.
  • Two servers migrating Magnetar's tables at once no longer collide. A table, index, column or marker that another process created first counts as created.
  • Registration answers a validation failure with 422. Auth::password().register answered a weak password or an unusable address with 401. It now answers the framework's validation error, with the message under the field.
  • Email addresses longer than 254 characters never reach the database. Sign-in with one answers as an unknown address does. Sign-up, the account import and OAuth email completion refuse one as a validation error. Such an address is still counted toward lockouts. An account that already holds one can no longer sign in by email; migrate logs how many exist, once per database.
  • Session metadata stays within its columns. A session keeps at most 1,024 characters of the user agent. A lockout records the client address only when it parses as an IP address.
  • New projects get every default feature of the framework. A new project's Cargo.toml turns the framework's default features off and lists the ones it keeps. The list lacked search-media and agents, so a new project had neither media search nor agent tools. It now lists both.
  • A form request on GET or HEAD reads its query. As Laravel validates the query of a GET, a form request on a GET or HEAD request without a body reads its query string as it reads a url-encoded body: it decodes, validates and names its fields as request.query_into() does. Such a request was refused with 415. A request with a body still reads the body, and other methods are unchanged.
  • Precognition and the real request read a query alike. A query value holding a JSON object reads as that object where a struct or a map belongs, and stays text everywhere else, in Precognition, a GET form request and request.query_into(). Precognition decoded the object wherever it stood, so a route could pass Precognition and fail the real submission.
  • An Option Live mount parameter can be left out. Every mount parameter was registered as required, and no codec decodes null, so an Option<T> parameter could never be None. It is now optional: left out or null, it mounts as None.
  • A page's scripts and styles no longer become the previous URL. The session recorded any successful GET as the previous URL: a script or stylesheet that StaticFiles served, a request a global middleware answered before any route matched, and an AJAX request. Without a Referer, Redirect::back() could then send the user to a .js file. As in Laravel, the session now records a GET only when a route answered it, the fallback route included, and skips a request that sends X-Requested-With: XMLHttpRequest. A file that StaticFiles serves is never recorded.
  • Two uses of one email verification link at once no longer answer 500 on MariaDB. MariaDB 11.8 and later end a transaction that writes a row a concurrent one changed, so the second of two concurrent uses of one Magnetar verification token answered 500. The losing use now reads the token as already used, on every engine. A consume the database ends in a deadlock or a serialization conflict runs again, up to three times, and answers a conflict rather than an internal error if every run conflicts.
  • Pages keep their styles under the Vite dev server. In development, SecurityHeaders allowed the dev server in script-src and connect-src only, so the browser refused the stylesheet link the framework puts in the head, and a page under the balanced preset rendered with no styles. The dev server is now allowed in style-src, font-src and img-src as well.
  • A panic the panic hook reports carries its request. A panic raised inside a request or job scope but outside the framework's own catch reached the tracker without the scope's request id, request, route and user, which an error reported in the same scope carries. It now carries them. The hook never waits on a lock the panicking thread may still hold: a field it cannot read at once is left out, and if the request's auth state is locked, the event names no user rather than a wrong one.
  • A panic reported while another report resolves its stack is kept. The panic hook gave up the whole event when the symbol resolver was busy, so the one event a reporter exists for could vanish and only a counter said so. The hook now sends the event without frames and says so in its payload; the message, location, request and release all arrive.

4.3.0 - 2026-10-18

Added

  • Searchable models can declare ordered media parts. Path fields name an image, audio or video kind and a storage disk. Indexing loads bounded parts through Storage. Boot and settings sync reject incompatible model profiles.
  • EmbeddingGemma 2 can embed images, audio and video locally. The media profile verifies both encoder graphs and their weights with the text model. Rust processors prepare image patches and WAV log-mel features. Video uses a host ffmpeg binary with a timeout. Reference fixtures run without ONNX.
  • A knowledge-graph recommender ranks from your own events and relations. RECOMMEND_ENGINE=graph selects it. A queued rebuild derives a graph of shared engagement (stored only where RECOMMEND_MIN_PEERS actors agree), public engagement for the types RECOMMEND_PUBLIC_EVENT_TYPES lists, and relations declared with Recommend::graph_relation. Reads authorize every node and edge first, blend graph paths, stored vectors, followed actors' agreement, freshness, negatives and trust risk per surface with diversity caps, cite the evidence each row rests on, and answer with the starter's rows when the graph's support is thin.
  • The graph lives in your database or in Memgraph. The GraphStore trait ships a database store and, behind the graph-memgraph feature, a memgraph store over Bolt. recommendations:graph-rebuild rebuilds the graph into a new generation and switches readers when it completes.
  • Search engines recommend and discover from their stored vectors. SearchEngine gains stored_vectors, recommend and discover; Qdrant answers the latter two natively, and the database and collection engines fold their stored vectors. Recommend::discover steers a discover query by the viewer's own events. SearchEngine::stored_keys reports which documents a generation holds, so the graph engine leaves out a document that left its index; every shipped engine implements it, and a custom engine needs it to serve the graph engine.

Changed

  • Recommendation, search and explanation structs carry new fields. RecommendConfig gains the graph settings and min_peers, SearchConfig gains media_max_bytes, IndexTimeSettings gains embed_media, and RecommendationExplanation gains engine, evidence and fallback_reason. Code that builds one of them field by field without ..Default::default() no longer compiles.

Fixed

  • A starter suggestion stands on at least three peers. The starter engine kept a collaborative candidate a single peer contributed, and its explanation showed a peer count of 1 beside the shared item, which points at that person; the candidate was one of their own views or purchases. Recommend::for_user and Recommend::similar_to now count a collaborative candidate only when RECOMMEND_MIN_PEERS distinct peers contribute it, default 3. With fewer, it can still arrive through the affinity, popularity or recent tier, which names no peers.
  • A model without updated_at keeps a search version per row. A searchable model without updated_at carried version 0 in every document, so a recommendation event or a graph fact could not tell one revision of the row from the next. Each save now raises a version kept in the new search_source_versions table, in the save's own transaction, and Eloquent loads the kept versions with the rows, so to_search_document() returns the row's version without a query of its own. Run your migrations: the table comes with suprnova::search::migrations().
  • A local embedding model keeps its memory bounded on long documents. The fastembed provider padded every text in a batch to the batch's longest, and attention memory grows with the square of that length, so one long document among short ones could take a single inference call past 24 GB. It now measures each text with the model's own tokenizer and batches texts of similar length: SEARCH_EMBED_BATCH counts texts of 512 tokens, a longer text takes the room of several by the square of its length, and a text longer than that runs alone.

4.2.1 - 2026-10-16

Added

  • Add a source to a preset's Content-Security-Policy (#156). SecurityHeaders::csp_source(directive, source) and ContentSecurityPolicy::with_source(directive, source) add one source to a directive of the policy from_env selected, keeping the preset, its report-only mode and its reporting origins. A directive the policy leaves out starts from the sources it falls back to. An application that allows an analytics host in connect-src no longer copies the preset's policy string.
  • Stream hooks in every Inertia kit. New React, Vue and Svelte applications get frontend/src/lib/stream/, Suprnova's own client for the responses HttpResponse::stream_bytes, stream_json and event_stream send: useStream, useJsonStream, useEventStream and useJsonEventStream, with the names, options and results of Laravel's stream packages. They send the CSRF token from the root template's meta tag or the XSRF-TOKEN cookie, and cancel their request when the component unmounts. An existing application can copy the two files from a new scaffold of its kit.

Fixed

  • View::share reaches the Inertia root template (#157). The root template rendered without the data shared with every view, so a value shared with View::share or View::share_for_request never reached it, where Laravel's shared data reaches app.blade.php. It now reads them with Askama's value filter, as other views do: {% if let Ok(domain) = "plausible_domain"|value::<String> %}. Keep such a read inside the if let unless every deployment shares the value, since a missing value fails the render.

4.2.0 - 2026-10-16

Added

  • Model search. Searchable and the typed Model::search builder provide native database, Qdrant, collection and null engines, filters, facets, highlights, scopes and generation rebuilds. Hybrid search uses fastembed or OpenAI-compatible HTTP embeddings, with EmbeddingGemma 2 as the default local model. Opt-in analytics, query suggestions, JSON search and click routes, the Live search-box, the kits' notes search and a judged relevance and latency baseline complete the search surface.
  • Starter recommendations. Recommend records immutable, deduplicated events and reads scoped collaborative recommendations with affinity, popularity and recent-document fallbacks. Completed runs carry projected explanations, metrics and event provenance; commands generate snapshots, report status and apply application-owned retention.
  • Opt-in local search inference. The search-fastembed feature enables local embeddings, sparse models and reranking. It is off by default; its ort build script downloads ONNX Runtime at compile time. The default search build downloads nothing.
  • pgvector driver. PgVectorDriver joins the vector drivers behind the vector-pgvector default feature: a Postgres application stores and searches embeddings in its own database.
  • Search pages in RenderCache. A search on a cached route is stored like any other render and goes stale when one of its indexes changes: a document write or removal, a generation switch or a settings sync. Viewer-scoped and analytics searches are never stored, and without_render_cache() keeps one search out of the cache.

Fixed

  • Head::canonical() keeps a // request path on the app's origin (#155). A request for //evil.example/x gave a canonical link to another host. The head now takes the request URL as url::current builds it, https://example.com//evil.example/x, under the public root.
  • Inertia kits paint styled under the Vite dev server (#153). The kits list src/app.css as its own Vite entry, so the first server-rendered page loads it as a <link> with the request's nonce instead of waiting for the entry's JavaScript. main.ts and main.tsx no longer import it. In an existing application, add .entry_points(["src/app.css"]) to its InertiaConfig, add 'src/app.css' to the Vite build input, and remove the import.
  • The CLI installs on macOS without warnings (#152). The browser certificate store helpers that only the Linux install path uses are now compiled on Linux only.
  • Public responses no longer carry the session or XSRF-TOKEN cookie (#154). A response marked Cache-Control: public or given an s-maxage could be stored by a CDN or caching proxy with its Set-Cookie lines and replayed to other visitors. The session and CSRF middleware now leave off the cookies the reader already holds; a public response that must deliver a cookie, such as a new session or a rotated remember-me cookie, goes out private, no-store instead.
  • The reset email greets the user by name under Magnetar. PasswordReset::send_link now looks the account up and greets its name, as the verification and password-changed emails do. A failed lookup sends the plain greeting and logs a warning.

4.1.0 - 2026-10-15

Added

  • Error reporting through Sentry-compatible trackers. Reporter drivers send scrubbed errors to Rustrak, Sentry or GlitchTip, with bounded background delivery and shutdown flushing. Laravel-shaped helpers and exclusions cover handled errors; requests and background work share the reporting path. Logs, traces and browser reporting are opt-in. The CLI offers local Rustrak, and the reporting chapter documents setup and privacy.
  • Security headers with per-request CSP nonces. SecurityHeaders provides strict, balanced and relaxed presets, validated environment configuration, report-only CSP and violation reporting, HTTPS-only HSTS, and route or group overrides. New full-stack projects register it before every other global middleware; existing applications opt in by registering it. The manual covers every header and the upgrade guide shows the registration.

Fixed

  • Framework scripts and asset links share the request's CSP nonce. Inertia documents and error pages, Vite tags, Head links and scripts, Live bootstrap assets and stitched RenderCache hits use the nonce the middleware generated. The document exposes it to Vite and Inertia's client through the csp-nonce meta element. Complete nonce pages render on every request.
  • The Live starter's Name boxes show the right name. The register form's Name box started with the word "name", and the profile form showed "name" instead of the user's display name, so saving it unchanged renamed the user. Both now read the component's own field.
  • Live component libraries cannot change the application's error handling. The component scan admitted Exceptions::reportable, dont_retry and dont_retry_when, so a library could change how the application handles errors and hide its own failures from the error tracker. live:add now refuses a library that names them, the reporting exclusions or Request::csp_nonce; reporting an error stays allowed.

4.0.4 - 2026-10-15

Fixed

  • A fresh Inertia starter app hydrates its first page without a mismatch. The React, Vue and Svelte kits loaded their Fluent catalog only in the browser, so with server-side rendering, on by default since 4.0.0, the server rendered the raw welcome key and the browser the translated heading, and React reported a hydration error. New projects render the same heading from the title prop in both places.
  • A field shows its own validation message. The Live response named each issue by its message identifier alone, so a live:error output under a rejected field read the runtime's generic "Validation failed" while the text a #[validate(message = "...")] rule or the validation catalog provides never reached the page. The server now resolves that text in the request's locale and sends it beside the identifier, and the field's error output shows it. An issue without text, such as a value the field cannot decode, keeps the generic announcement.
  • A user who changes their own password stays signed in. The session that made the change recorded the password's earlier epoch, so the check that ends sign-ins from before a password change ended it too on its next request, with every other session of the user. A request that resolved the signed-in user and writes that user's password column through the model (save, update, and their transactional forms) now binds its sign-in to the epoch of the values sent to storage once the write commits, so that session continues while every other session and remember-me cookie of the user still ends. EloquentUserProvider recognizes the written model; a provider of your own implements UserProvider::written_user to do the same, and a model whose hash lives in another column names it from Authenticatable::auth_password_name. A write that bypasses the model, such as a query-builder update, is not seen.
  • A fresh scaffold is rustfmt-clean. suprnova new wrote the shared backend templates, the Live kit and the API starter in a layout rustfmt's 2024 style edition rewrites (import order and line wrapping), so a developer's first cargo fmt changed files they had not touched. The templates now carry that layout, and a test formats a fresh scaffold of every kind with cargo fmt --check.
  • The account's own ImageMagick policy applies again. The magick driver starts ImageMagick with HOME naming its policy directory, which hid the service account's ~/.config/ImageMagick from its runs, so a policy or configuration the operator kept there stopped applying in 4.0.0. The driver now puts that directory ($XDG_CONFIG_HOME/ImageMagick, else $HOME/.config/ImageMagick) on MAGICK_CONFIGURE_PATH after the operator's value and before its own directory's last entry: the account's denials and configuration apply as before, and the framework's policy is still the last ImageMagick reads.
  • The framework's frames below a Live action fit Tokio's default stack. In a debug build the server, the after-response and task-local wrappers, the session middleware and the Live engine used about 1.75 MiB of stack before an action ran, so an action a little deeper overflowed a thread with Tokio's 2 MiB default. The request future is now boxed before each wrapper holds it, as are the Live dispatch and the session handler, and those frames use under 0.8 MiB. A test runs a Live action through the real server on a thread with the 2 MiB default and fails when the frames below the action pass 1 MiB.
  • The scroll area's size token is defined. 4.0.2 bounded the region with --sn-scroll-area-size and left the token undefined, so the shared stylesheet never named it and the engine's token check failed. The shared stylesheet now defines it at 16rem; a page or a region still sets its own.

Changed

  • Starter kits ship no translations. React, Vue, Svelte, Live and API scaffolds include no catalogs, browser translation modules or locale middleware, and their pages render English text. The framework's localization is unchanged. An existing application keeps its own files; one that translates in the browser under server-side rendering renders raw keys on the server, and the upgrade guide shows the two ways out: remove the browser translations as new projects do, or translate on the server with Lang::get and pass the text in props.

4.0.3 - 2026-10-13

Fixed

  • Breadcrumbs sit on one line. The base stylesheet spaces stacked list items with a top margin, which dropped every crumb after the first below the first in suprnova.breadcrumbs. The crumbs now carry no margin and the row aligns them on the baseline.
  • Avatar group members sit on one row. The same list-item margin dropped every member after the first in suprnova.avatar; the members now carry only their overlap.

4.0.2 - 2026-10-13

Added

  • A flash region can time its messages out. flash_region takes a duration in milliseconds; a region rendered with one hides each message that long after it appears and holds the timer while the pointer or focus is on the region, as the toast region does. The default, 0, keeps every message until the next document. The region is now wrapped in the sn-flash-region element on every branch, which does nothing without a duration.

Fixed

  • The horizontal separator has a width inside a grid or flex parent. A browser's own hr carries auto inline margins, which took the free space of the track and left suprnova.separator no width at all; the rule now sets them to zero.
  • The scroll area scrolls. suprnova.scroll-area bounded its block size by the measure token, about 640px, so most content fit without a scrollbar. The bound is now 16rem, and a page sets --sn-scroll-area-size on the region or an ancestor for another.

Changed

  • The tooltip bubble follows the color scheme. suprnova.tooltip drew its bubble in the text color with inverse text, a light bubble on a dark page. It now sits on the surface tokens with the border and shadow the popover and the dropdown menu use, so it re-themes with them.

4.0.1 - 2026-10-13

Fixed

  • The validation summary shows only while a field or the action is in error. suprnova.validation-summary rendered its red box and title on a form nobody had submitted, and listed nothing after a failed one: its stylesheet hid the section only when it was empty, and the macro always wrote the title inside it. The section now hides until one of its entries shows. The new summary_entry(name, label) macro, called inside the summary, renders one entry per field the action validates: hidden until that field's validation fails, then a link that focuses the field. The action's own failure shows as the last entry, announced politely. A summary called with no entries still shows the action's failure.

Added

  • The artisan generators. Twenty-one suprnova make:* commands each write one file from a stub and declare its module in src/lib.rs and the directory's mod.rs: make:factory (a Factory for a model, in src/factories/), make:seeder (a Seeder, src/seeders/), make:cast (a Cast, src/casts/), make:channel (a private broadcast Channel, src/broadcasting/), make:class (a plain struct, src/), make:enum (src/enums/), make:event (an Event, src/events/), make:listener (a Listener of one event or any event, src/listeners/), make:job (a queued Job, src/jobs/), make:job-middleware (a JobMiddleware, src/jobs/middleware/), make:mail (a Mailable, src/mail/), make:notification (a mail Notification, src/notifications/), make:observer (an Observer of a model, src/observers/), make:policy (a #[policy] with the seven model abilities, src/policies/), make:provider (the register function the bootstrap calls, src/providers/), make:resource (a JSON:API Data struct, src/resources/), make:rule (a validation Rule, src/rules/), make:scope (a GlobalScope, src/scopes/), make:test (an integration test in tests/, which declares nothing), make:trait (a trait with a default method, src/concerns/) and make:interface (a trait with required methods only, src/contracts/). A name that is not a Rust identifier is refused with exit status 1, an existing file is kept unless --force is given, and each command prints the path it wrote. make:factory, make:observer, make:policy and make:scope take --model, and make:listener takes --event.

  • The Live starter kit. suprnova new --frontend live, or the fourth choice of its prompt, scaffolds an application with no Node toolchain: no frontend/, no package.json and no Vite config. Its pages (home, register, sign in, forgot and reset password, verify email, the dashboard, the notes list and one note, and the error page) are server-rendered Live documents in a guest layout or an application layout with the navigation, the signed-in user and the toast. Live components carry the account forms, which show each validation message under its field; the dashboard's note counts, which refresh without a page load when a note is saved; the display-name form; and the notes page, with a search bound to the URL's ?search=, a form that writes a note, and a load-more list. The kit keeps the Inertia kits' models, migrations, account flows and route names, and installs the library components its views import under templates/suprnova-ui/, recorded in suprnova.toml. suprnova docker:init writes a Live project a Dockerfile with no Node stage, and suprnova make:inertia refuses in one.

  • MongoDB connections. The database-mongodb feature (off by default) adds the Mongo facade on the official mongodb driver: MONGODB_URI and MONGODB_DATABASE (or MongoConfig::builder(), with pool options and named connections) configure it, the server and the workers register it at boot, and Mongo::connection, connection_named, database, collection::<T> and ping reach it. A missing or malformed URI is an error naming MONGODB_URI, and an unreachable server fails the first call that needs it with a FrameworkError.

  • MongoDB queue. With database-mongodb, QUEUE_DRIVER=mongodb keeps jobs in a jobs collection (MongoQueueDriver), reserving each with one atomic findOneAndUpdate, and brings MongoFailedJobStore over failed_jobs and MongoBatchRepository over job_batches, whose settlements move the counters with $inc in one update and count a redelivered job once.

  • MongoDB cache. With database-mongodb, CACHE_DRIVER=mongodb selects MongoCache over the cache and cache_locks collections, with TTL indexes on the expiry, atomic add and counters, tags, and locks shared by every process.

  • MongoDB sessions. SESSION_DRIVER selects the session store: database (the default) or, with database-mongodb, mongodb, which keeps sessions in a sessions collection (MongoSessionDriver) and promotes a two-factor session with one atomic update. Config::init refuses an unknown SESSION_DRIVER.

  • MongoDB document models. #[suprnova::document(collection = "...")] stores a struct in a collection with the Eloquent calls of the DocumentModel trait: create, find, find_or_fail, all, query, save, update, delete, fresh, refresh, make and fill. The key is an ObjectId stored as _id unless primary_key names a field; fillable, guarded, casts, hidden and visible take the #[model] syntax; chrono dates are stored as BSON datetimes and decimals as Decimal128; created_at and updated_at are managed; soft_deletes adds with_trashed, only_trashed, restore and force_delete; #[embeds_one] and #[embeds_many] fields store embedded documents with relation methods; push, push_unique, pull, increment and decrement change one field; the model events reach listeners and a DocumentObserver registered with #[suprnova::observer]; and the model serializes through serde and binds from routes by its key.

  • MongoDB document queries. A document model's query() answers a DocumentQuery with where_ (=, !=, <, <=, >, >=, like), or_where, where_in, where_not_in, where_null, where_not_null, where_between, where_date, where_exists, where_raw, order_by, skip, take, project, get, first, count, exists, pluck, distinct, sum, avg, min, max, paginate, simple_paginate, update, upsert, delete, force_delete, increment, decrement, push, pull and unset, and group_by with count, sum, avg, min and max aggregates. to_filter() and to_pipeline() answer the BSON the builder sends, and a chain MongoDB cannot run as written, such as take before update, is an error naming the call.

  • MongoDB relations. relations = { ... } on #[suprnova::document] declares HasOne, HasMany, BelongsTo and BelongsToMany between documents (the many-to-many kept as arrays of keys on both sides, written by attach, detach, detach_all and sync) and BelongsToModel<M> to an SQL model, and #[suprnova::model] declares HasManyDocuments<D> and HasOneDocument<D>; each reads through its own store, DocumentQuery::with and the SQL with and with_count load them with one query per relation, dotted paths cross the stores, and a relation whose key types cannot match fails the build naming both models.

  • Concurrent tasks. The Concurrency facade runs #[concurrent_task] functions (an async fn with serde input and output, registered by name) side by side: run answers each TaskResult in order, run_named answers them by key, with_timeout ends a task that outlives it with an error naming it, and driver picks a driver for one call. The tokio driver (the default), the process driver (each task in a console process through the hidden concurrency:run command) and the sync driver implement ConcurrencyDriver; CONCURRENCY_DRIVER selects the default, and Concurrency::extend adds a driver.

  • Deferred concurrent tasks. Concurrency::defer returns at once and runs its tasks after the response has been sent, logging a failed task without touching the response; outside a request the returned handle runs them when it is awaited or dropped.

  • A guard in use per request. TestClient::acting_as_with_guard selects the named guard as the one Auth::user, Auth::id, Auth::check and the auth middleware without a guard name answer through for that request, as Laravel's actingAs with a guard calls shouldUse; the configured default guard is untouched outside that request.

  • One guard instance per request. Inside a request the auth manager builds one instance per guard name and keeps it, so a custom guard's factory runs once per request and a guard may keep its user on the instance.

  • Factory record batches. create_many accepts a count or per-record attribute maps, with each map overriding the factory definition.

  • Custom ULID lengths. ulid_with_length and the length modifier create ULID columns with the length your schema needs.

  • Schema SQL previews. Blueprint::create_sql returns the validated CREATE statements for your selected database engine.

  • Seeder composition. call runs children in order with console progress; call_silent suppresses progress and call_once skips completed children.

  • Seeder parameters. call_with passes an attribute map to run_with while existing run implementations keep working.

  • Root seeders. register_root selects the seeder a bare db:seed runs.

  • Seeder connection selection. db:seed --database scopes default queries and factories to the named connection for the invocation.

  • Conditional resource field groups. merge_when merges an object into resource attributes when its condition holds, with sparse fieldsets applied to the merged fields.

  • Relation existence flags. with_exists loads a boolean per parent without loading related models, alongside any requested rows or counts.

  • Resources read existence flags. when_exists_loaded emits loaded true and false values and omits fields whose flag was not loaded.

  • Application-wide JSON:API information. jsonapi_default sets boot-time implementation information for every resource document; a response can override it.

  • Cursors over several columns. Cursor pages preserve each ordered column and direction, with named typed boundaries available through Cursor::parameter.

  • Page item transformations. through changes a length-aware, simple or cursor page's item type while preserving all pagination metadata.

  • Missing-row messages on query builders. first_or_fail names the model or table, and first_or_fail_with accepts your message while keeping HTTP 404.

  • Nested closure transactions. Inner DB::transaction calls use savepoints; an inner rollback keeps the outer transaction open.

  • Transaction depth. DB::transaction_level() reports the ambient nesting level.

  • Rollback callbacks. DB::after_rollback runs compensation for the enclosing rollback and preserves callbacks from successful inner scopes until the outer outcome.

  • Guards before transactions. DB::before_starting_transaction runs listeners before BEGIN or a savepoint and propagates a listener's error without starting it.

  • Raw query expressions. DB::raw supplies SQL for updates, grouping and aggregate filters while ordinary values and raw-fragment bindings stay bound.

  • Table query ranges. where_between, where_not_between and their OR forms accept inclusive bounds, raw expressions and scalar subqueries.

  • Table query maximums. max reads typed values and returns none for an empty set.

  • Table queries ordered by age. oldest and oldest_by order rows ascending.

  • Seeded random query ordering. in_random_order() orders rows randomly on both builders, and in_random_order_seeded(seed) repeats an order with RAND(seed) on MySQL and setseed with random() on Postgres; SQLite orders by a seed-derived expression over each row's rowid, then by the rowid, on both builders, so the same seed repeats the order for any primary key type, a union and its pages included.

  • Inspect applied model scopes. apply_scopes returns the builder with its registered global scopes and soft-delete filter applied once.

  • Polymorphic existence queries. has_morph, doesnt_have_morph and their constrained forms query the relation's targets and registered types and aliases; the wildcard covers the targets the relation declares, and wildcard absence includes rows with a null type.

  • Delete loaded pivots by their keys. Pivots without an id delete their original key pair; morph pivots also keep the type in the predicate.

  • Eager limits apply per parent. Has-one, has-many, morph-one and morph-many constraints use a partitioned window for limit and take.

  • Morph relations fill ownership on writes. create, save and upsert set the owner's id and type on morph-one and morph-many children.

  • Loaded model lookup by key. Collections find one model, another model's key, or several keys, and return a supplied fallback for a missing key.

  • Constrained loading on model collections. load_with loads a relation onto existing models with a typed builder constraint.

  • Model collection deduplication by key. unique_models keeps the last copy of each model while retaining the first occurrence's key order.

  • Model collection differences by key. diff_models removes matching identities even when the models' other attributes differ.

  • Enum collection casts. AsEnumCollection reads and writes JSON arrays of the same variant strings as AsEnum.

  • Runtime appended attributes. append selects registered accessors for every later conversion of one model instance.

  • Complete raw original snapshots. get_raw_originals returns every loaded column before casts; get_raw_original_or supplies absent values.

  • Instance visibility changes. make_hidden, make_visible, and their conditional forms update the lists used by later model conversions.

  • A single-server default for scheduled tasks. Schedule::always_on_one_server() elects one replica per tick for every task; .on_every_server() opts out.

  • Interrupt running schedules. schedule:interrupt writes a shared cache mark. Runs stop before starting another task, and the next run clears it.

  • Stored keys for chunk cursors. chunk_by_id advances from the raw stored key, so primary-key casts cannot skip or repeat rows.

  • A database default scoped to one task. DB::with_default_connection(name, future) routes default database and model queries to that pool. DB::default_connection() names the current pool, and concurrent tasks keep their own defaults.

  • Declared model defaults. #[model(defaults(field = value, ...))] fills new instances and partial creates while preserving supplied attributes.

  • Related records map in chunks. chunk_map on belongs-to-many and through relations maps each record in bounded batches and returns values in order, with pivot context on many-to-many records.

  • Related records are found or created with their keys. first_or_create on has-one, has-many and belongs-to-many sets the relation's foreign key or attaches the pivot row, including custom relation keys.

  • Relation counters create or increment. increment_or_create on has-one, has-many and belongs-to-many uses the default for a new record or adds the supplied step and extra columns to an existing record.

  • Through relations return an unsaved fallback. find_or_new searches the relation's reachable records and returns a new instance when none match.

  • Has-one-through compares in one query. is asks the database whether the relation reaches a model without loading the target.

  • Queue worker idle delays. queue:work --sleep sets the seconds between empty polls beside the existing millisecond --poll option.

  • Queue worker attempt controls. --tries and --timeout set a worker's attempt budget and timeout without changing the queued payload.

  • Queue workers with a stopping point. --once settles one job and --stop-when-empty drains available jobs before the worker exits.

  • Queue worker memory limits. --memory checks resident memory from procfs after each job and returns status 12 when it exceeds the limit.

  • Filtered queue absence assertions. assert_not_pushed rejects a captured job that satisfies your predicate.

  • Filtered queue assertions. assert_pushed_on_queue matches the queue and your predicate against the same captured job.

  • Commands after the response. Bus::dispatch_after_response runs a command after the response body is written and the socket flush succeeds.

  • Typed bus capture lists. dispatched, dispatched_sync and dispatched_after_response return captured commands for iterator filters.

  • Markdown responses. HttpResponse::markdown and markdown preserve your source with a UTF-8 Markdown content type.

  • QUERY routes. query! and the fluent routing methods accept QUERY, and any! includes it with the other supported methods.

  • Sign out your other devices. Auth::logout_other_devices verifies your password and revokes other sessions and remember credentials while keeping the current browser signed in.

  • Typed notification assertions. The notification fake filters recorded notifications by concrete type, recipient route, and notification contents. Existing name-based assertions keep working.

  • Copy files across disks. Storage::copy_to_disk streams between disk names or ready-made disk handles and keeps the source.

  • Move files across disks. Storage::move_to_disk copies the file before deleting the source and reports transfer or deletion failures.

  • Forget several disks. Storage::forget accepts one name or a list and reports whether any registered disk was removed.

  • Purge one disk or every disk. Storage::purge(name) drops one named disk and purge_all drops every disk.

  • Store a ready-made disk. Storage::set registers an operator under a name and replaces the previous disk and its public URL.

  • Language-specific slugs. Str::slug_in applies the named language's ASCII spelling, including German ä as ae.

  • Word limits keep markup. Str::words limits space-separated runs while retaining markup and whitespace between words.

  • Esperanto and Italian word forms. Plural and singular helpers now use all eight languages from doctrine/inflector, selected by the current locale.

  • Plurals for class names. Str::plural_studly and Str::plural_pascal inflect the last word of a class name.

  • Counted labels use exact integers. Str::plural_with_count adds the count in the current locale's number format, preserving every digit.

  • Redis environment connections. With REDIS_URL unset, the default connection reads REDIS_HOST, REDIS_PORT, REDIS_PASSWORD, and REDIS_DB.

  • A cache connection for Redis. The cache connection uses the same server and credentials with REDIS_CACHE_DB, defaulting to 1.

  • Redis scripts by SHA. RedisConnection::evalsha runs a loaded script with prefixed keys and unchanged script arguments.

  • Raw Redis command lines. RedisConnection::execute_raw sends a command line with the existing read retry policy and shared-connection guards.

  • The built-in custom log channel. Set LOG_CHANNEL=custom and LOG_CHANNEL_DRIVER to a driver registered with Log::extend in the bootstrap. A missing or unregistered driver fails boot.

  • Percentages in a named locale. Lang::percentage_in formats in the named locale without changing the current one.

  • Precision controls for numbers. Lang::format_with_max_precision and Lang::percentage_with_max_precision cap fraction digits and drop trailing zeros. Lang::format keeps fixed precision.

  • Default number locales. Lang::use_locale sets the default outside request scopes.

  • Temporary number locales. Lang::with_locale restores the previous locale when its closure returns or panics.

  • Generated downloads stream as you produce them. HttpResponse::stream_download(stream, name, content_type) sends each chunk without buffering the export and writes a safe download filename.

  • File response headers and dispositions. HttpResponse::file_with and download_with, and Storage::response_with and download_with, accept caller headers and a disposition. Your content type and cache policy reach the client.

  • Schema dumps without migration data. schema:dump --without-migration-data writes the schema while leaving applied migration rows out of the file.

  • Named connections for schema dumps. schema:dump --database reporting dumps DATABASE_REPORTING_URL; an unknown connection fails with its name.

  • Input preparation before authorization. Form and multipart request hooks expose prepare_for_validation. Request::transform_input normalizes text when parsing starts, preserving authorization before the body is read.

  • MIME family allowlists. MimeType accepts entries such as image/* while retaining content detection and rejecting spoofed image headers.

  • Column comparisons take an operator. Both query builders expose where_column_op(a, op, b), with the existing identifier and operator checks.

  • Cross joins take conditions. Both query builders expose cross_join_with(table, closure); the closure's ON values stay bound.

  • Equality shortcuts on both builders. r#where(column, value), db_where(column, value) and or_where(column, value) use =.

  • Previous values after a model save. get_previous(attribute) reads the stored value before the last save changed that attribute, alongside was_changed, get_changes and the original-value accessors.

  • Precognition with per-route opt-in. Add Precognitive to a route or group to validate a draft without running the handler body. A passing request answers 204 with Precognition-Success: true; every marked response carries Precognition: true, and every response from the route adds Precognition to Vary.

    • Precognition-Validate-Only narrows rules before every validation stage, including the asynchronous hook. Names match exactly, with * matching one segment; an empty list validates no fields. An unlisted parse failure does not block the answer, and after-validation hook errors are never filtered.
    • Live validation reads query data for GET and DELETE, multipart files and fields, and inline Request::validate::<T>().
    • A marked request neither saves the session nor becomes the previous URL, so live validation leaves flash data for the next page.
    • The 422 message summarises the first error and the count of the rest, with the count suffix localized through the catalog and the field-keyed errors bag kept.
    • with_precognition() sends the request header, and assert_successful_precognition() checks the status and success header. The new Precognition chapter covers the Inertia 3.8 Vue, React and Svelte clients, uploads, narrowed rules and side effects.
  • The Svelte kit on Inertia 3.8 and its Vite plugin. The kit pinned @inertiajs/svelte to the 3.6 client, globbed its pages by hand in both entries, and passed createInertiaApp no title, serverHead or nonce. It now declares @inertiajs/svelte, @inertiajs/core and @inertiajs/vite at ^3.8.0. The plugin resolves pages: './pages' and wraps src/ssr.ts, a single createInertiaApp call, into the SSR server, which npm run build:ssr still writes to frontend/bootstrap/ssr/ssr.js. The entry reads its nonce from <meta property="csp-nonce"> when the document has one (K01, K05, K18, K19).

  • Svelte kit layouts, links and titles. Every page drew its own frame, reached other pages through anchors that reloaded the document, and set no tab title. layouts/AppLayout.svelte and layouts/GuestLayout.svelte now frame the pages through createInertiaApp's layout option and stay mounted across visits. Both layouts show the signed-in user from the shared auth prop, or sign-in and register links for a visitor, through components/AccountLinks.svelte. Every navigation is a Link, and sign-out is a Link with method="post" rendered as a button. The dashboard sets the layout's heading with setLayoutProps. @inertiajs/svelte has no Head component, so components/Head.svelte titles each page Title - App through <svelte:head> (K06, K07, K16).

  • A flash toast in the Svelte kit. No page read page.flash, so an action showed no feedback. Both layouts now show page.flash.toast on the one page that carries it, typed by the generated flashDataType (K17).

  • The Svelte kit's dashboard, notes pages and auth forms. The dashboard now loads its stats with Deferred and polls them with usePoll, loads recent_notes with WhenVisible, and changes the display name through useHttp, showing the new name at once in the page and the layout and putting the old one back with the field's error on a 422. The new Notes/Index page creates a note with the Form component, remembers its search with useRemember, scrolls with InfiniteScroll, and opens Notes/Show with a prefetched, instant Link. The auth pages submit through Form instead of useForm, and Login turns its remember checkbox into a boolean with transform (K11, K12, K13, K14, K15, K21).

  • The React starter runs on Inertia 3.8 through its Vite plugin. The kit pinned @inertiajs/react at ^3.6.1, resolved pages with its own import.meta.glob in both entries, and passed createInertiaApp no title callback, no server head and no CSP nonce. It now declares the adapter, @inertiajs/core and @inertiajs/vite at ^3.8.0, resolves pages through the plugin's pages: './pages', and builds src/ssr.tsx through the plugin, so npm run build:ssr still lands frontend/bootstrap/ssr/ssr.js for suprnova ssr:start. Both entries pass a title callback that appends the project's name (from frontend/src/lib/app.ts) and serverHead: true; the browser entry passes the nonce of <meta property="csp-nonce"> when the document carries one. A new npm run check script type-checks the kit (K01, K05, K18, K19).

  • The React starter has persistent layouts, Link navigation and page titles. Each page drew its own frame and reached other pages through <a href>, which reloaded the document on every click, and no page set a title. layouts/GuestLayout.tsx (the auth/ pages) and layouts/AppLayout.tsx (navigation and a heading) now come from createInertiaApp's layout option and stay mounted between pages that share them. Both show the signed-in user from the shared auth prop: the name and a sign-out Link with method="post" rendered as a button, or the sign-in and register links for a guest. Every application link is a Link, every page sets <Head title>, and the dashboard sets the layout's heading with setLayoutProps (K06, K07, K16).

  • The React starter shows the flash toast. No page read page.flash, so a sign-in, a registration or a reset showed no feedback. Both layouts render components/FlashToast.tsx, which shows page.flash.toast, typed by the generated flashDataType, read from the page on every render, so it is gone on the next visit (K17).

  • The React starter demonstrates deferred, optional, polled, optimistic and infinite-scroll pages. The dashboard sent one prop, nothing was paginated, and the auth pages posted through useForm. Dashboard now renders stats with Deferred and a fallback, polls it with usePoll(10000, { only: ['stats'] }), loads recent_notes with WhenVisible, and changes the display name through useHttp, showing the new name at once and putting the old one back with errors.name on a 422; a saved name reloads the shared auth prop, so the layout shows it too. The new Notes/Index page creates a note with Form, remembers its search with useRemember, lists the signed-in user's notes with InfiniteScroll over the cursor paginator, and opens a note through a prefetched instant visit to the new Notes/Show page. Every auth page, the verification resend included, submits through Form and disables its button while processing (K11, K12, K13, K14, K15, K21).

  • Third-party Live component libraries. A library is a git repository with one fixed tree: library.json at its root and, under components/, one directory per component holding its manifest.json, the files the manifest names and a manifest.sig. A component can carry the Rust of a Live component as well as a view, a stylesheet and a script. suprnova live:add acme/acme-ui/counter installs one by address from GitHub, or from GitLab or Codeberg with the host first, at the newest v<semver> tag or the one @<version> names; an https:// URL of a component directory and a ./path on disk work too. Every component is signed with Ed25519 over a hash of everything that arrived. The first install pins the library's key in suprnova.toml once you confirm on a terminal, and every later version must be signed by that key, or by a new key the pinned one handed over to in library.json's previousKeys. Before it writes anything, live:add scans every view, stylesheet, script and Rust file as data, runs none of it, admits only what it can classify, and shows a plan of every file, module declaration, registration and capability. A component reaches a database, the network, files, mail, a queue, a cache, the session, the environment or a process only through Suprnova's API, and you approve each of those nine capabilities by name, on a terminal or with --allow; --yes confirms a plan and never approves a capability or pins a key. live:add writes a component's Rust under src/live/<namespace>/, registers it in your registry builder, never changes Cargo.toml or Cargo.lock, and records the source, version, commit, digests, hash, signature, registrations and approvals in suprnova.toml, which live:check now verifies offline. An install holds a lock on the project and writes a journal before its first write, so a failed or killed install leaves nothing behind, and suprnova serve waits for it before it builds (suprnova live:wait). Authors scaffold, check and sign a library with suprnova live:registry new, check and sign, and move it to a new key with rotate-key; new adds a preview/ application that renders each component from where it sits, and keeps the private key in your configuration directory, or where SUPRNOVA_LIBRARY_KEY names it. Each library's stylesheets and scripts are served at /<namespace>-ui/{component}/{file} by one Router::try_live_ui_assets_for("<namespace>") call, which live:add names at the library's first install. See Installing Live Components and Live Component Libraries.

  • Route model binding by type. #[handler] binds an argument by its type alone (post: Post) whenever the type implements RouteBinding, which every #[model] does, and Option<T> binds None when its optional parameter is absent. Routes take {post:slug} segments, #[model(route_key = "...")] sets a model's default column, children bind through their parent's relations (scope_bindings(), without_scoped_bindings()), and routes, groups and resources take with_trashed() and missing(). A generic #[handler], and a #[handler] that a closure route, middleware, another handler or a missing() handler calls with the request, binds at the request as the route's own handler does. Such a handler that takes a scoped child without its parent finds it through the parent the route's handler binds; where the router cannot see how the route's handler binds that parent, the request answers 500 and names the parent to take. One that cannot return the missing() response hands it to the middleware or route handler that called it, which answers with it in place of a 404, so the middleware outside that caller sees it as it sees the route's own. Router::bind and Router::model register custom resolution, #[model(custom_route_binding)] with suprnova::database::resolve_model_route_binding overrides a model's own, and #[derive(RouteBinding)] binds a unit-only enum. resource! and api_resource! build resources from a module's #[handler] functions, nested resources (users.posts) included. route() and try_route() take bound values, named or as one positional value: a #[model] row, a derived enum, a RouteParam<T>, or any type that implements RouteValue with one call to bound_route_value. try_route is re-exported at the crate root. Router::prepare_bindings() runs the startup checks for a router a test builds. See Routing.

  • Serving under a path prefix. Behind a trusted proxy, an application serves under the prefix X-Forwarded-Prefix names, or under the path in APP_URL. Every URL the framework builds for the browser carries that public root once: route() and the signed URLs, redirects and the previous and intended URLs, Inertia's page URL and Vite tags, Live's endpoints, assets and reflected URLs, pagination links, storage URLs and the session, XSRF and remember-me cookie paths. url::root() returns the root for a template, and a third-party component's view may call it before a constant path. RootShare gives every Inertia page the root, and a new scaffold works under a prefix. See Deployment Overview and URL Generation.

  • The rest of Laravel's Image API. Image::orient, using, transform, rotate_with_background, flip, flop, optimize, width, height, to_webp, to_jpg, to_jpeg, to_png, to_gif, to_bmp, to_base64, to_data_uri and store_as, with Color, ImagePixels, CustomTransformation and register_transformation for a step of your own. See Images.

  • Running on a Laravel database. A Suprnova application runs on a database a Laravel 13 application created, and beside that application. jobs, job_batches, failed_jobs, sessions, notifications, the scaffold's users, features (laravel/pennant) and roles, permissions, model_has_roles, model_has_permissions and role_has_permissions (spatie/laravel-permission) take the layouts Laravel's and the packages' migrations create. Data those layouts have no column for lives in suprnova_jobs_reservations, job_batch_settlements, suprnova_feature_details, suprnova_role_details and suprnova_permission_details. The framework ships queue::migrations::{CreateJobsTable, CreateJobBatchesTable, CreateFailedJobsTable} and session::migrations::CreateSessionsTable, and each migration leaves a table Laravel or a package created exactly as it is. NOTIFICATIONS_MORPH_KEY and RBAC_MODEL_KEY pick int, uuid or ulid keys, and FEATURES_USER_SCOPE names the user scope Pennant stores. See Running on a Laravel Database.

  • LARAVEL_SHARED_DATABASE. For an application that shares its database with a running Laravel application: the framework and Magnetar write $2y$ bcrypt hashes Laravel 13 accepts with HASH_VERIFY=true, a valid sign-in rewrites a $2b$ or Argon2id hash as $2y$ and fails with the storage error, signing nobody in, when that rewrite cannot be stored, Magnetar no longer upgrades bcrypt to Argon2id, and an unrouted database-queue job is stored on the queue suprnova, which Laravel's worker does not read. LaravelDatabase::share turns it on from code.

  • Morph aliases. #[model(morph_type = "App\\Models\\Post", morph_aliases = ["post"])]: MorphTo, MorphOne and MorphMany, direct and eager, has, with_count and the aggregates accept every name; writes store the morph_type.

  • Application::run_with_args parses the given arguments instead of the process's and returns its failures to the caller as a FrameworkError; run() still prints them and exits.

  • HasRoles::rbac_model_types() names every model_type a model's role and permission assignments are read under: its morph_type, its aliases and the Rust type path an earlier release stored.

  • Merge props merge at nested paths in either direction. Prop::append_at(paths, match_on) and Prop::prepend_at(paths, match_on) are Laravel's append($path, $matchOn) and prepend($path, $matchOn): they take one path or a list, add {path}.{match_on} to matchPropsOn when a field is named, and one prop can append at one path and prepend at another, which the single direction of merge_with_path could not express. .append_at(["a.items", "b"], "id") on a prop feed emits mergeProps: ["feed.a.items", "feed.b"] and matchPropsOn: ["feed.a.items.id", "feed.b.id"].

  • Once props take Laravel's options. until takes a moment or a span, as Laravel's until(DateTimeInterface|DateInterval|int) does: a DateTime<Utc>, a std::time::Duration, a chrono::Duration or whole seconds, through the new OnceUntil. fresh takes a bool, OnceOptions::once(false) turns the flag off, Prop::once_with(options) sets the flag, key and expiry in one call (Laravel's once($value, $as, $until)), and as_key takes an enum whose Display names the key. expiresAt is the expiry in milliseconds counted in whole seconds, as Laravel counts it. The server still refuses a client's cache claim past a DateTime deadline, which Laravel leaves to the client.

  • App::inertia_share_once returns the shared once prop, a SharedOnceProp that takes as_key, until, fresh and once_with as Laravel's shareOnce returns a chainable OnceProp. A shared once prop could not take a cache key, an expiry or fresh before; only the InertiaSharedData provider could reach them. InertiaRegistry::share_once returns the same handle.

  • Scroll props take any page-facts provider and can read them from the loaded value. Every .scroll builder and Prop::scroll take a ScrollMetadata or anything implementing ProvidesScrollMetadata, so .scroll("posts", &page, &page) is Laravel's Inertia::scroll($paginator). InertiaResponse::scroll_lazy, scroll_lazy_with and Prop::scroll_lazy describe a lazily loaded list from the value its resolver returns, as Laravel's callable metadata does, and ship the scrollProps entry with that value.

  • Paginators report the scroll facts Laravel's fromPaginator does. A CursorPaginator's current page is 1 on its first page, else the cursor it was fetched with (Pagination::cursor records it in the new current_cursor, with_current_cursor sets it), else the request's cursor parameter; it was always null. Paginator (the simple paginator) takes a page parameter name, with_page_name, used by its URLs and its pageName, where it was fixed to page.

  • Prop providers, page and shared. A type implementing ProvidesInertiaProperties expands into props once per render with a RenderContext of the page component and the request, Laravel's interface of the same name. A page takes any number with InertiaResponse::provide, the shared props any number with InertiaRegistry::share_provider; shared providers' keys count as shared keys, and flush_shared clears them. A page also takes any number of #[derive(Data)] objects with with_data (and try_with_data), where it took one, through Inertia::data, with no request or component context.

  • A prop value can convert itself with its context. A type implementing ProvidesInertiaProperty (Laravel's interface of the same name), attached with InertiaResponse::with_property or Prop::property, is converted when the prop is sent, with a PropertyContext of its key path, its sibling props and the request, so a price can format itself with the page's currency. No value type received its key path, siblings or request before.

  • An application-owned Inertia root document. The framework wrote every first visit's whole document itself, so an application had no place for its own favicon, fonts, meta tags or attributes on <html> and <body>. #[inertia_root(path = "app.html")] declares an Askama template under templates/ that receives the framework's parts (title, head, body, lang, csrf_token, nonce, ssr and view), checked at compile time, and InertiaConfig::root_template renders every first visit through it. root_template_with chooses the template per request, Laravel's rootView(Request), and error pages go through the same choice; InertiaResponse::with_view_data hands the template values of any serializable type that never reach the page props, Laravel's withViewData. The page JSON is written straight into the template's output: a first visit with a 1 MiB prop allocates 5,386,301 bytes through a template against 5,386,925 through the framework's document, and a 3 MiB page comes back whole. A template that fails to render is an error response, never part of a document. InertiaConfig::mount_id names the mount element and the page data element, app by default, for a client that mounts on another id. Without a template the first visit is byte for byte what it was.

  • Inertia::version and Inertia::get_version. Laravel's runtime setter and getter for the asset version. Inertia::version takes a string, a function called on every read, or None::<String> for the empty version (Laravel's null), and replaces the installed config's version; Inertia::get_version returns the current one. Every page built after the call advertises it, and the version middleware Inertia::install registers now reads Inertia::get_version per request instead of the version captured at install (RF-05).

  • Big integers survive the trip to the browser. JavaScript reads integers exactly only up to 9007199254740991, so a 64-bit id beyond it, 9007199254740993 for one, reached an Inertia page as 9007199254740992. With the new InertiaConfig::preserve_big_integers(true) setting, or InertiaResponse::preserve_big_integers(true) for one response, every integer beyond plus or minus 9007199254740991 in props and flash, at any depth, is sent as {"$bigint": "<digits>"} and the page carries preserveBigIntegers: true, so the Inertia client restores it as an exact BigInt, as Laravel's preserve_big_integers does. Off by default; when off nothing is wrapped and the flag is absent (JE-04, JE-05).

  • Inertia::back(status, fallback) and InertiaConfig::store_previous_url. back is Laravel's Inertia::back(): the request's Referer when it is a path on this host under the public root, else the session's previous URL, else the fallback, else / (RF-18). store_previous_url (on by default) turns the previous-URL recording of Inertia visits off (MW-06).

  • Inertia flash on the facade: Inertia::flash, flash_many, get_flashed, pull_flashed, clear_history and preserve_fragment. flash takes a string key or any type implementing the new FlashKey trait, such as an application's enum of toast kinds; get_flashed(&req) returns exactly what pull_flashed(&req) removes (RF-17, RF-19, RF-08, RF-09).

  • Shared data and render settings on the Inertia facade. Inertia::share(key, value), share_many, share_data (a #[derive(Data)] object's eager fields) and share_provider take the forms Laravel's Inertia::share takes; get_shared(key, default) and get_shared_all() read shared data back. transform_component_using renames components before they render, and InertiaConfig::ensure_pages_exist (with pages_dir and page_extensions) makes a component with no page file an error naming the component and the directory, for a name given as a string too (RF-02, RF-03, RF-07, RF-15).

  • SSR controls on the Inertia facade. Inertia::disable_ssr(bool) and disable_ssr_if(fn) replace the configuration's switch, per request for the function, and can turn SSR on as well as off; without_ssr(patterns) adds exclusions; configure_ssr_request_using(fn) adjusts the request sent to the worker through the new SsrRequest (headers, a bearer token, the timeout), so a worker that needs a token can be reached (RF-11, RF-12, RF-13).

  • Inertia::location(url or redirect), Laravel's Inertia::location, beside InertiaResponse::location, both taking a URL or a Redirect through the new InertiaLocation (RF-16, HM-04).

  • Inertia middleware hooks and the stack on a route group. The InertiaMiddlewareHooks trait carries Laravel's overridable middleware decisions (version, share, share_once, root_view, url_resolver, on_empty_response, on_version_change, on_redirect_with_fragment), each defaulting to the framework's behaviour; InertiaConfig::hooks installs an implementation, DefaultInertiaHooks is the framework's answer to start from, and InertiaVisit is the request an on_* hook answers. Inertia::middleware(&cfg) is the whole stack as one middleware for a route group, and InertiaConfig::register_globally(false) makes Inertia::install register it as the named middleware inertia instead of on every route, so an API group carries no Vary: X-Inertia and has no redirect turned into 303 (MW-08, MW-10).

  • The SSR call is a driver you can replace. The SsrGateway trait carries dispatch, is_healthy and the capabilities disable, except and configure_request_using, each a default an implementation overrides, as Laravel's Gateway, DisablesSsr, ExcludesSsrPaths, ConfiguresSsrRequests and HasHealthCheck do. HttpGateway is the default; App::bind::<dyn SsrGateway>(Arc::new(..)) makes an application's own gateway render every first visit. Inertia::disable_ssr, disable_ssr_if, without_ssr and configure_ssr_request_using act on the bound gateway and log a warning naming the capability it lacks. Inertia::ssr_is_healthy() returns the gateway's health: the HTTP gateway asks GET {url}/health within the SSR timeout, through the request configurator, Some(true) on a 2xx and Some(false) otherwise, and None means the gateway has no health check. detect_ssr_bundle and CONVENTIONAL_BUNDLE_PATHS are Laravel's BundleDetector (SS-10, SS-13).

  • SsrRenderFailed, the event of a failed SSR render. It carries the page's component and URL and the worker's error JSON: error, error_type (an SsrErrorType: browser-api, component-resolution, render, connection or unknown), hint, browser_api, stack and source_location. A worker that cannot be reached dispatches it with type connection and the transport error. It is dispatched before the visit falls back to the client, and only when something listens or a fake records it (SS-08).

  • SSR through the Vite dev server in development. While the Vite hot file exists, a first visit in development is posted to the dev server's /__inertia_ssr without the bundle check, so no SSR bundle or worker process is needed while developing. suprnova serve writes the dev server's URL to public/hot when it starts Vite and removes the file when Vite stops or serve exits, as Laravel's Vite plugin does, and the full-stack scaffold ignores /public/hot. SsrConfig::hot_url (InertiaConfig::ssr_hot_url) sends every first visit in development to another address, and SsrConfig::hot_file (InertiaConfig::ssr_hot_file, default public/hot) names another file; the address is the hot URL, else the file's content, else the vite_dev_server URL. Without the file the visit takes the worker path, whatever listens at the dev server's port, and production never goes hot. suprnova serve writes the file only when frontend/package.json declares @inertiajs/vite, the Inertia Vite plugin that serves /__inertia_ssr: without it the dev server serves no SSR, so no file is written and a first visit takes the worker path (SS-05).

  • SSR runtime settings. SsrConfig::runtime (node by default, or bun, deno or a path) and ensure_runtime_exists (off by default), set with InertiaConfig::ssr_runtime and ssr_ensure_runtime_exists, are Laravel's inertia.ssr.runtime and ensure_runtime_exists for ssr:start.

  • Inertia::handle_exceptions_using(callback) decides every error response, Laravel's Inertia::handleExceptionsUsing. The callback receives an InertiaErrorResponse for each error response the framework renders - a handler's or a middleware's Err, a panic, the router's 404, a middleware's own {"message": ...} answer - for every request type, an API client's included. It reads status(), error() (the error report, or the panic's message and location), request(), method() and response(), which with debug on is the development error page where that page applies. It returns render(component, props) for an Inertia page at the original status, respond_with(response) for any other response, or None to keep the response. A callback that panics is a bug the panic boundary reports as the sanitized 500 with its report, inside the stack and at the server alike. A JSON client's validation 422 reaches the callback like any other error, as in Laravel; an Inertia visit's validation failure reaches it as the 303 back to the form, since the error-response middleware sits outside the validation redirect, so an Inertia form still goes back with its errors flashed. A rendered page carries the shared props, the middleware hooks' share and share_once included, only after with_shared_data(). InertiaConfig::error_page is now the default callback and keeps its rule; an app that sets both gets its callback. A later call replaces the callback, which lives on the active container, so a callback installed under TestContainer::fake() stays in that test (EX-01, EX-02, EX-03, EX-06, EX-07).

  • ssr:start, ssr:stop and ssr:check on the application binary, Laravel's inertia:start-ssr, inertia:stop-ssr and inertia:check-ssr. They read the Inertia configuration the application installed, so they start, stop and check the worker first visits dispatch to; they run both bootstrap hooks, since the scaffold installs Inertia in http_bootstrap, bind no port and boot no runtime driver, and fail naming Inertia::install when nothing is installed. ssr:start --runtime overrides InertiaConfig::ssr_runtime, and the command exits with the status its worker exited with (CM-01, CM-02, CM-03, SS-10).

  • suprnova ssr:stop [--graceful], the CLI's inertia:stop-ssr: it runs the application binary's ssr:stop (above) from the project directory, passing --graceful through, so it stops the worker at the URL the application installed (CM-02).

  • suprnova generate-types types wide integers as number | bigint in a project that preserves big integers. With preserve_big_integers on, an i64 past 2^53 reaches the page as a BigInt, which a number type misnames, so i64, u64, i128, u128, isize and usize are number | bigint when a .rs file under src/ calls preserve_big_integers(..) with anything but a literal false (parenthesized or not), such as true or a variable, or with the new --big-integers flag, which generate-types and serve both take and serve keeps for every regeneration on save, and number otherwise, as every integer and float was in 3.2.1. Narrower integers and floats stay number, and a wide map key stays number (T03).

  • suprnova generate-types writes page types and types usePage(). In 3.2.1 inertia-props.ts held only the props interfaces, so a page picked its interface by hand and typed any shared props inline. The file now opens with import '@inertiajs/core' and ends with Pages, which maps each component to the struct a handler renders it with (read from inertia_response!, InertiaResponse::new(..).with_data(..) and Inertia::data, given the struct itself or a local binding or parameter that declares or builds it, with Rust's shadowing applied), SharedProps (root and the fields of the struct Inertia::share_data is given or marked #[inertia_props(shared)]), Errors, PageProps<C>, and a declare module '@inertiajs/core' block setting sharedPageProps, errorValueType and, for a struct marked #[inertia_props(flash)], flashDataType, so usePage() is typed with no argument. Errors is Record<string, string> and errorValueType is string, or both say string[] when a with_all_errors(..) call under src/ passes anything but a literal false (read as preserve_big_integers(..) is), since the server then sends every message per field as an array. The InertiaProps derive takes the two markers and refuses any other form. A component rendered with two structs, two shared or two flash structs, or a struct named like a generated declaration fails the command with every conflict named and leaves the file as it was (T01, T02).

  • A route helper names the page its route renders. routes.ts helpers returned only url and method, so <Link instant> and <Form instant> could not make an instant visit through one. A helper now carries component, Inertia's UrlMethodPair.component, when its handler names exactly one component as a string literal (in inertia_response!, InertiaResponse::new or the Inertia facade's render calls) or its route is a Router::inertia route. A handler naming none, several, or one it computes gets none. A handler inside an impl block (#[handler(Self = Posts)], registered as controllers::posts::Posts::index) is read from its method like a free function, for its component and its request type, and a free function of the same name in the same file keeps its own. Router::inertia routes, which routes.ts left out, now get helpers under controllers.inertia, and RouteConfig declares component?: string (T05).

  • suprnova::testing::TestClient, one in-process test client. Every HTTP test copied its own loopback harness - a port, a hyper client and hand-carried session cookies - because handle_request takes a body only hyper builds. TestClient::new(router, registry) sends get, post, put, patch, delete and send(method, path) requests with header, json, form and inertia() (an Inertia visit's headers with the installed asset version) over an in-memory connection, never a port, in the task that awaits it, so a TestContainer scope still applies. It carries every cookie a response sets to the next request and drops the ones a response expires, keeps each response's error report, gives every TestResponse the session store with_session_store names, and fails a request that has not answered after 10 seconds, naming its method and path. Under a public path prefix (APP_URL=https://example.test/billing) a page's url is the public /billing/users while the router matches /users, so the client keeps the root each request was served under and replays a reload to the internal path, /users with the page's query, sending again the X-Forwarded-Prefix header the page's request sent. See HTTP Tests (TS-01, TS-10).

  • Laravel's prop assertions and scopes on AssertableInertia. It had has, missing, where_ and count only. It now has has_all, has_any, missing_all, count_between, where_not, where_null, where_not_null, where_all, where_type (string, integer, double, boolean, array and null, joined by |; an unknown name fails), where_all_type and where_contains, and count counts an object as well. scope, first, each, has_with and has_count_with run a callback over a nested object or array whose failures name the full dotted path (user.name). A scope fails when it ends with a prop no assertion touched, unless etc() was called in it; the page's top level never checks, as Laravel's assertInertia does not (TS-06).

  • Inertia reloads through the client, full and by deferred group. A reload needed a with_reload closure wired to the test's own harness. A page from a TestClient response now reloads through that client with its cookies, and with_reload still replaces it for a custom harness. reload() replays the page with no partial-reload header and asserts the same component, url and version; load_deferred_props_of(groups) requests the props of the named groups only, every group for an empty list, and fails naming a group the page does not defer instead of requesting nothing. reload_with, reload_only_with, reload_except_with and load_deferred_props_with run a callback over the reloaded page (TS-07, TS-08).

  • Inertia page readers, the flash a redirect leaves, and big integers in tests. AssertableInertia gains missing_flash, to_page() (with encryptHistory and clearHistory only when the page set them), encrypt_history() and clear_history(), and TestResponse gains inertia_page() and inertia_props(path). A handler that flashes and redirects leaves its Inertia flash in the session, and the redirect carries no page to assert it on; assert_inertia_flash(key, expected) and assert_inertia_flash_missing(key) read it through the attached session store. A page with preserveBigIntegers sends integers beyond 2^53 - 1 as {"$bigint": "<digits>"} markers, and the markers in props and flash are decoded before any assertion or reader sees them, so where_("id", 9007199254740993_i64) passes against the page the handler built. A marker whose digits fit no 64-bit integer, such as {"$bigint": "18446744073709551616"}, which only a hand-built page object carries, fails naming its path and digits rather than staying an object that where_type("id", "integer") rejects and to_page() shows (TS-12, TS-13, TS-14, TS-15, TS-16).

  • InertiaConfig::testing_ensure_pages_exist, on by default. AssertableInertia::component(name) passed for a component with no page file, so a test stayed green while the browser showed a blank page. With an Inertia configuration installed it now also looks for the file under pages_dir with one of page_extensions, the lookup ensure_pages_exist does at render time, and fails with Inertia page component file [Name] does not exist., the directory and the extensions it tried. component_exists(name, bool) decides the check for one assertion, and with no configuration installed nothing is checked (TS-03).

  • Inertia DevTools records each request. The Inertia DevTools browser extension reads its entries from the server, and Suprnova had no server side, so the extension showed nothing. InertiaConfig::devtools takes a DevToolsConfig with Laravel's settings, read from the same INERTIA_DEVTOOLS_ENABLED, _TTL_HOURS, _PRUNE_INTERVAL_SECONDS, _LIMIT and _GATE variables. The application opts in with .devtools(DevToolsConfig::new()), as a new project's bootstrap does. With enabled unset, it records only when APP_ENV is set and names local; an unset APP_ENV, which Laravel reads as production, records nothing. enabled(true) and enabled(false) decide outright. Inertia::install and Inertia::middleware then put DevToolsMiddleware outermost in the Inertia stack, and it skips the except paths (_inertia/devtools* and _suprnova/* by default). A failure while recording drops the entry and leaves the response as it was; a write failure is logged at warn once and pauses recording into that directory for 30 seconds. See Inertia DevTools (DT-01, DT-10).

  • The entry of a request, its headers and the first-visit tag. Each recorded request stores Laravel's entry key for key: a ULID, the tab, batch and visit ids from the extension's headers, the timestamp, method, URL, status, redirect location and server time, the request type (precognition first, then initial or http, deferred, poll, partial, prefetch, navigate), the request and response headers, the request body (an Inertia write's JSON or form input with uploads summarized, read up to the request body cap) and the response body (the page object, or text up to 256,000 bytes), the route with its handler's type name, and for a rendered page the component, its page file and the render call's file and line, which InertiaResponse::new, inertia_response!, Inertia::paginate, Inertia::data and Router::inertia take through #[track_caller]. The response carries X-Inertia-Devtools-Id, -Parent-Out, and -Base-Path under a public root, and a first visit's 200 document carries the id in a <script data-inertia-devtools-id> tag before </body> (DT-02, DT-04, Precognition row 057).

  • Prop kinds and their sources in DevTools entries. An entry lists each prop the client received with its kind in Laravel's order (always, defer only on the extension's deferred visit with its group, optional, merge, scroll, once), reset, once, mergeDirection, deepMerge for a deep merge or a match_on, and rescued. A shared key names the Inertia::share, share_many, share_data or App::inertia_share* call that shared it, and the InertiaConfig::hooks call for a hook share; a render prop names the line that gives its key. Deep paths without metadata are pruned, and propValues holds what the client received (DT-03).

  • The DevTools entry endpoints. GET /_inertia/devtools/entries lists entries newest first, filtered by component, type, exclude, offset and limit, and GET /_inertia/devtools/entries/{id} answers one entry, or 404 {"message": "Not found."}. An APP_ENV naming the local environment admits every request; elsewhere, an unset APP_ENV included, only the user the configured gate ability allows is admitted, else 403 {"message": "Forbidden."}. An entry request reflashes the session, never becomes the previous URL, and is never recorded (DT-05, DT-06, DT-09).

  • DevTools storage and redaction. Entries are one JSON file each under storage_path("inertia-devtools"), listed newest first in _meta.json, pruned after 24 hours once the last prune is 300 seconds old, and kept to the newest 100 per browser tab. Before a write, the redaction keys (password, token, api_key and seven more) and headers (cookie, authorization and four more) become [REDACTED] in bodies, prop values, headers and URL query parameters, without regard to case, and a header value that is not text becomes [UNSERIALIZABLE] (DT-07, DT-08).

  • The scaffold's notes: a list, a page and a form over the signed-in user's own notes. A new application had nothing a kit page could scroll, open or write: its dashboard sent one eager prop and no handler paginated anything. suprnova new now writes a create_notes_table migration and a Note model that belongs to a user (the User model gains has_many notes), and three routes behind the dashboard's authentication: GET /notes lists the user's notes 10 at a time with cursor_paginate through Inertia::paginate, filtered by the search query parameter in title or body without regard to case, and sends search back; GET /notes/{id} shows one, and answers 404 for a note of another user; POST /notes validates title (1 to 255 characters) and body (at most 10000), writes the note and flashes a toast. Every handler reads notes through Note::owned_by, and none lists accounts (K12, K14).

  • The scaffold's dashboard defers stats and leaves recent_notes optional. The dashboard sends the user's note count and the notes written today as a deferred stats, and the user's five newest notes as an optional recent_notes the page asks for when it scrolls them into view (K14).

  • The signed-in user on every page of the scaffold. A layout had no way to name the signed-in user outside the dashboard. The scaffold now shares auth, the signed-in user or null, with App::inertia_share_lazy, read from the request's session for each response that sends it, and SharedData in src/props/shared.rs, marked #[inertia_props(shared)], adds auth to the generated SharedProps (K12).

  • A JSON handler for the display name. POST /profile/name takes {"name": ...}, saves it on the signed-in user, and answers 200 with {"user": {...}}, or 422 with the framework's validation body for an empty name or one over 255 characters, for the dashboard's useHttp form (K21).

  • Flashed toasts after every account action. Nothing a new application did told the user it worked: the server sends page.flash, but the scaffold flashed nothing. A Toast in src/props/flash.rs is now flashed under toast after sign-in, registration, a reset-link request, a password reset, email verification, a verification resend, sign-out and a saved note, and the Flash struct beside it, marked #[inertia_props(flash)], makes suprnova generate-types type page.flash.toast as Inertia's flashDataType (K17).

  • Laravel's route names in the scaffold. The scaffold's routes carry the names Laravel's kits give them: dashboard, notes.index, notes.show, notes.store, profile.name, login, register, password.request, password.email, password.reset, password.update, verification.notice, verification.send, verification.verify and logout (K12).

  • The sources and the manual cite the Inertia.js client at 3.8.0. The framework's comments cited the client at 3.6.1 and 3.1.1, and the frontend chapter named 3.4.0. Each rule they cite was read again in the 3.8.0 client, and every citation names its 3.8.0 file and line; the frontend chapter and the CSRF chapter name 3.8.0, and the frontend chapter lists @inertiajs/vite (K01).

  • The Vue kit runs on Inertia 3.8 and its Vite plugin. The kit pinned @inertiajs/vue3 at ^3.6.1, found its pages with a hand-written import.meta.glob in each entry, and passed createInertiaApp no title, no server head and no nonce. It now declares @inertiajs/vue3, @inertiajs/core and @inertiajs/vite at ^3.8.0, and vite.config.ts runs inertia(). Both entries name their pages with pages: './pages'. The SSR entry is the createInertiaApp(..) statement the plugin wraps with createServer, so npm run build:ssr still writes frontend/bootstrap/ssr/ssr.js. Because the kit declares the plugin, suprnova serve writes the hot file, and with SSR on, a first visit in development renders through the dev server's /__inertia_ssr with no worker running. The browser entry passes a title callback that appends the application's name, the same name the server's default_title uses, serverHead: true, and the nonce from <meta property="csp-nonce"> when the document has one. npm run check, npm run build and npm run build:ssr pass on a fresh scaffold (K01, K05, K18, K19).

  • Vue kit pages navigate with Link, title themselves with Head, and share two persistent layouts. Every page drew its own frame, reached other pages through <a href>, which reloads the whole document, and left the tab untitled. The kit now ships layouts/AppLayout.vue (navigation, the flash toast and a heading) and layouts/GuestLayout.vue for the pages under auth/, applied through the layout option so a layout stays mounted between two pages that share it. Both show components/AccountLinks.vue, which reads the shared auth.user: the name and a sign-out Link that posts as a button without keeping the page's state, or the sign-in and register links for a guest, so the home and error pages never offer a guest a sign-out. Every application link is a Link built from root, every page sets its title with Head, and the dashboard sets the layout's heading with setLayoutProps, which the next page clears (K06, K07, K16).

  • The Vue kit shows the flash toast. The server's page.flash reached no kit page, so a sign-in, a sign-out or a saved note gave no feedback. components/FlashToast.vue renders page.flash.toast, typed by the generated flashDataType, in both layouts, straight from the page, so it shows once, on the page it was flashed for (K17).

  • The Vue kit's dashboard and notes pages use Inertia's client features. The dashboard rendered one eager prop and the kit had no list page, so a new application had nothing to copy for deferred, optional or scroll props. Dashboard.vue now renders stats inside Deferred with a fallback, polls it with usePoll(10000, { only: ['stats'] }), loads recent_notes with WhenVisible when it scrolls into view, and saves the display name through useHttp with an optimistic update that a 422 reverts while showing errors.name; a saved name reloads the shared auth prop, so the layout shows it. The new Notes/Index.vue creates a note with Form, remembers its search with useRemember, lists the signed-in user's notes with InfiniteScroll, and opens one as an instant visit to the new Notes/Show.vue from a prefetching Link whose page props keep the shared props, root among them. The five auth pages submit through Form in place of useForm, read errors and processing from its slot, and keep the sign-in page's remember checkbox, sent as a boolean (K11, K12, K13, K14, K15, K21).

  • Signed-route middleware. ValidateSignature lets a request with a valid signature reach the handler and answers a missing, wrong or expired one with 403 and Invalid signature., as Laravel's InvalidSignatureException does. Build it with ValidateSignature::new() or ValidateSignature::relative(ignore), or register ValidateSignature::from_alias_args as the signed alias, which reads signed:relative,utm_source.

  • Signature checks that ignore added parameters. ignore(names) on the middleware, the alias arguments, ValidateSignature::except(names) for the whole application, url::has_valid_signature_ignoring and verify_signature_ignoring leave the named query parameters, such as a utm_source a mail client appends, out of the verified text. signature and expires cannot be ignored.

  • The previous path. url::previous_path(fallback) returns the path of the session's previous URL without its query, the public root or a trailing slash, as Laravel's url()->previousPath() does.

  • Secure URLs with segments. url::secure_with(path, segments) appends each segment percent-encoded as one path segment and upgrades the URL to https like url::secure. It is Laravel's url()->secure($path, $parameters).

  • Error reporting callbacks. Exceptions::reportable runs your callback for every reported error, or only for errors that wrap the type its closure takes; .stop() keeps later callbacks and the framework error log line from running for an error that callback receives.

  • Reporting an error you handle. Exceptions::report sends an error through your callbacks and then the framework error log line.

  • Errors that end a job's retries. Exceptions::dont_retry::<E>() and Exceptions::dont_retry_when name the errors that make the worker fail a queued job at once, whatever tries it has left; Exceptions::should_stop_retries answers for one error.

  • Error types on the development error page. The page names the wrapped error's type, the FrameworkError variant, or panic above its headline, and ErrorReport::type_name returns the same name.

  • Editor links on the development error page. With APP_EDITOR set, each frame's location links to its line in your editor: a Laravel editor name uses that editor's URL format, a value holding {file} is a template, and any other name opens <name>://open?file=...&line=....

  • Required while a condition holds. RequiredIf::when(condition) takes a bool or a closure answering one, requires the field with the required message while it holds and passes the field otherwise, as Laravel's Rule::requiredIf does.

  • Image dimensions on uploads. Dimensions<D> reads an image's width and height from its header and refuses the file with validation-dimensions when it breaks the min_width, max_width, min_height, max_height, width, height or ratio a DimensionLimits type sets, or when its size cannot be read.

  • The IP address message. #[validate(ip)] reads The address field must be a valid IP address. in place of the generic failure message.

  • Nested middleware names. make:middleware Admin/EnsureRole writes src/middleware/admin/ensure_role.rs and declares each module on the way.

  • Middleware tests. make:middleware --test writes a test under tests/ that runs the middleware in front of a route through TestClient.

  • make:view. make:view admin.dashboard (or admin/dashboard) writes templates/admin/dashboard.html and a #[suprnova::view] struct naming it in src/views/admin/dashboard.rs, declares its modules, keeps existing files unless --force is given, and with --test writes a test that renders it.

  • Nested Inertia pages. make:inertia Admin/Users writes frontend/src/pages/Admin/UsersPage.<ext>, --force overwrites an existing page, and --test writes a test that renders the page and checks its file.

  • Trusted hosts. The TrustHosts middleware answers 400 Bad request. to a request whose host is invalid or matches none of your patterns. TrustHosts::new() trusts the APP_URL host and its subdomains, TrustHosts::at(patterns, subdomains) trusts the regular expressions you list, matched without regard to case, and the local environment trusts every host.

  • CSRF tokens in JSON bodies. CsrfMiddleware reads a top-level string _token from a JSON body as it reads one from a form, ahead of the X-CSRF-TOKEN and X-XSRF-TOKEN headers, with "" and "0" counting as no value.

  • Controller middleware. A ResourceController lists ControllerMiddleware values in its middleware method, and a module named by resource! in a pub fn middleware(). Each runs on the actions only and except scope it to, after the group's middleware, and a name no alias or group carries fails the registration.

  • Resource middleware at registration. ResourceRoutes::middleware and ResourceDef::middleware scope a ControllerMiddleware to some actions, running before the controller's own list.

  • Resources inside groups. resource! is an item of group! and takes the group's prefix, name prefix, middleware, session block and binding settings.

  • Routes leave group middleware out. without_middleware::<M>() and without_middleware_named(name) remove a middleware a route's group or its own registration gives it, by type or by alias; the global middleware still runs.

  • route_has. Returns true only when every route name in a list is registered, as Laravel's Route::has does.

  • Encrypters with their own key. Encrypter::new(key) encrypts and decrypts with encrypt_string_for, decrypt_string_for, encrypt and decrypt under the key you give it, and leaves Crypt as it was. It writes the payload Crypt writes, so a value either one wrote under a key opens with the other.

  • Key generation that returns its error. EncryptionKey::try_generate and Crypt::try_generate_key return the refusal of the operating system random source as an error, where EncryptionKey::generate panics.

  • Gate checks for the signed-in user. Gate::inspect_current and Gate::none_current check the user of the route's guard, the user #[authorize] checks. A guest reaches only the gates defined with define_optional, which receive None, and every other ability answers the default denial.

  • After hooks that see the resource. Gate::after_with_arguments registers an after hook that receives the resource with the user, the action and the running decision, and fills only an undecided result.

  • GateEvaluated events. Every gate check dispatches GateEvaluated with the user's type, the user's identifier when the check found the user itself, the action, the resource's type and the decision.

  • Request guards that receive their provider. Auth::via_request_with_provider hands the resolver the request and the user provider that the guard's configuration names.

  • Rate-limiter hits with a default or a date. RateLimiter::hit_for_minute counts a hit in a 60-second window, as Laravel's hit($key) does, and RateLimiter::hit_until counts one in a window that ends at a given time; a time that has passed opens no window.

  • Guest and user throttle limits. throttle:10|60,1 allows a guest 10 requests a minute and a signed-in user 60, as Laravel's throttle reads its first argument.

  • Throttle counts that stop at the limit. The throttle middleware checks every limit before it counts a request, then counts each bucket with one conditional increment that leaves a full bucket's count where it was, so a request refused at either step is not counted in the bucket that refused it, and a concurrent burst admits at most the limit. Limits whose keys collide count under the keys the limiter returns, so two limits on one key share one bucket, the bucket RateLimiter::attempts reads.

  • Conditional increments. CacheStore::increment_if_below and Cache::increment_if_below add to a counter only while it is below a ceiling and answer ConditionalIncrement::Incremented with the new value or ConditionalIncrement::Unchanged with the value as it stands. The in-memory and Redis stores compare and write in one atomic step; a custom store gets a default that reads and then increments. RateLimiter::increment_if_below does the same for a rate-limiter bucket and opens its window as increment does.

  • Named hasher drivers. hashing::extend registers a driver under a name and HASH_DRIVER selects it, as Laravel's Hash::extend does; it refuses a built-in algorithm's name, a name registered before, and a registration after the first hash.

  • ARGON_TIME. The hashing configuration reads Laravel's ARGON_TIME as the Argon time when HASH_TIME is unset; HASH_TIME still wins.

  • The verified gate redirects by route name. EnsureEmailVerifiedMiddleware::redirect_to_route(name) resolves the route on each request; a name no route carries fails the request with a 500 whose error names it.

  • Your own verification message. MustVerifyEmail::send_email_verification_notification sends the verification link, and a model overrides it to send its own message. EmailVerification::send_link calls it, and resend calls it through the new UserProvider::send_email_verification_notification. The default sends the new VerifyEmailNotification, a mail notification through Notify that reads as the mail did, and needs no notification setup.

  • Your own reset message. CanResetPassword::send_password_reset_notification sends the reset link on the provider path, through the new UserProvider::send_password_reset_notification; the default sends PasswordResetMail to email_for_reset().

  • A timebox on reset links. PasswordReset::send_link holds every answer, a refusal and an error included, until PASSWORD_RESET_TIMEBOX_MS milliseconds (200 by default) have passed, so an unknown address answers no sooner than a known one.

  • A rehash step in the sign-in. UserProvider::rehash_password_if_required runs after the password validates and before the user is signed in, in attempt, once and Auth::logout_other_devices.

  • Attachments compared by content. Attachment::is_equivalent and is_equivalent_with compare the name, bytes and content type, and OutgoingMessage::has_equivalent_attachment and has_attached_data check a sent message with them; has_attachment still matches the name only.

  • Raw data attachments on the builder. MailBuilder::attach_data(bytes, name, content_type) attaches in-memory data, as Laravel's attachData does.

  • A mailable's own recipients. Mailable::to, cc, bcc and reply_to give a mailable its own lists; a send or a queue merges them ahead of the builder's, skips an address already present, and Mail::always_to still replaces every recipient.

  • Mailables sent alone. Mail::send, Mail::queue, Mail::later, Mail::on_queue and Mail::queue_on send or queue a mailable to its own recipients and refuse one with none before anything is sent or pushed.

  • Boolean mail fake checks. MailFake::has_sent, has_sent_mailable::<M>() and has_queued answer whether a mailable was sent or queued; a queued mailable does not count as sent.

  • Mailable delays. Mailable::delay delays Mail::queue and MailBuilder::queue; an explicit later delay wins.

  • Notification delays per channel. Notification::delay(channel) delays that channel's job when Notify::queue pushes it.

  • BroadcastNotificationCreated. The broadcast notification channel dispatches it with the notification's name, the route, the data and the message's queue and connection, after the publish or the push.

  • Queued broadcast notifications. A notification that implements NotificationBroadcast::to_broadcast and is registered with register_broadcast_renderer supplies a BroadcastMessage; one that names a queue or a connection with on_queue or on_connection is published by a queued BroadcastNotificationJob, which the worker knows without registration.

  • Notification mail attachments by path. MailRendering::attach, attach_data, attach_path and attach_many attach files, the last two with AttachOptions for the name and content type; files are read at delivery, the content type follows the extension, and a file that cannot be read fails the delivery naming the path.

  • Delayed queued listeners. QueuedListener::delay(duration) and delay_until(|event| ...) delay the listener's job, winning over the job's own Job::delay.

  • Per-connection after-commit. QUEUE_<CONNECTION>_AFTER_COMMIT and Queue::set_connection_after_commit give a queue connection its own after-commit setting, which Queue::connection_after_commit reads.

  • A job's own after-commit choice. Job::after_commit_choice() answers Some(true), Some(false) or None, so a job can push ahead of the commit even when its connection or QUEUE_AFTER_COMMIT waits.

  • A Pusher HTTP API client. PusherClient::new(config, registry) and PusherBroadcastHub::client() query channels and presence users, publish a batch in one request, end a user's connections and send any other signed GET, with channel names through the registry's wire mapping and errors that never quote the secret or a signature.

  • Marked console lines. console::error, console::warn and console::info print one line marked ERROR, WARN or INFO, on the standard error for the first two and the output for the third, styled on a terminal unless NO_COLOR is set and plain text in a test.

  • Console verbosity flags. Every command accepts -q or --quiet and -v to -vvv before its name, and after it unless it takes raw arguments or declares a flag of that name itself. console::verbosity() reports the level, console::line_at and console::error_at write only at or above a level, and --quiet silences a command's lines while the error of a failed command still prints.

  • Console prompts. console::ask_with_default, console::secret, console::select, console::select_keyed and console::multiselect read one line each, from a terminal or a pipe; secret does not echo on a terminal and is never captured, and a menu refuses an answer that is no option by naming the options.

  • Answers for menus in tests. ConsoleTest::expects_choice(question, answer, options) answers a menu and fails the command when the menu offers other options.

  • Progress bars. console::Progress and console::progress(label, items, f) redraw a terminal line, and write one plain line such as Sync 3/3 where the output is not a terminal.

  • Console forms. console::form() chains text, secret, confirm and select steps and returns every answer by name from submit().

  • Up-front console test expectations. ConsoleTest::expects_output(line) expects exact lines in order, expects_output_to_contain(text) and doesnt_expect_output_to_contain(text) search one write at a time on both streams, and expects_confirmation(question, answer) answers a confirm with yes or no.

  • Exit codes of a command's own. FrameworkError::exit(code) ends a console command with code, printed and reported nowhere, and FrameworkError::exit_code() reads the code the console binary ends with; ConsoleRun::assert_exit_code(code) and assert_not_exit_code(code) assert it, and exit code 0 is a success.

  • MaintenanceModeEnabled. down dispatches the event after it records maintenance mode, on a first down and on an update alike.

  • Prerendered maintenance pages. down --render <view> renders the Tera template at resources/views/<view> with retry_after and serves the result; a template that cannot be read or rendered fails down before maintenance mode starts.

  • Retry dates. down --retry takes a date as well as seconds and sends it as Retry-After in the RFC 7231 form; a value that is neither is refused.

  • Tasks limited to environments. TaskBuilder::environments keeps a task to the named environments at every tick.

  • Tasks in maintenance mode. While the application is down, schedule:run and schedule:work skip every task that does not ask TaskBuilder::even_in_maintenance_mode; a maintenance state that cannot be read counts as down.

  • Day splicing on expressions. CronExpression::with_days_of_week replaces the day-of-week field and keeps the others.

  • Loaded migrations. Application::load_migrations_from(list) adds a list that migrate, migrate:status, migrate:rollback, migrate:fresh, schema:dump and the migration on boot run after the application's migrator, each migration name once.

  • Registered migrations. A crate registers its own list with suprnova::register_migrations!(owner, list), and every application that links the crate runs it.

  • One list for two-factor migrations. auth_flows::two_factor::migrations() returns the four two-factor migrations in order.

  • Directories that may exist already. DiskExt::ensure_directory_exists creates a directory unless it is there, and succeeds when it is.

  • Upload URLs from your own callback. Storage::build_temporary_upload_urls_using(disk, callback) answers the disk's temporary_upload_url from the callback, which receives the path and the lifetime, ahead of the disk's own presigning; a read-through disk and an S3 disk answer from it too.

  • Asking a disk about upload URLs. Storage::provides_temporary_upload_urls answers whether a disk has an upload URL callback or presigns writes.

  • Faked processes keep their argument list. A recorded process keeps its arguments, None for a shell line, and its quoted command line; assert_ran_args and assert_ran_command_line compare them exactly, while assert_ran keeps matching the arguments joined by spaces.

  • One-side resizes. Image::resize_width_only and resize_height_only set one side and keep the other at the size the image has at that point of the pipeline, on the oxideav and magick drivers alike.

  • Custom transformations with settings. register_transformation_with registers a function that receives per-call settings of its own type, and Image::transform_with(name, settings) records a step that hands them to it. The image holds the settings and releases them with its last clone; a step whose settings are of another type fails the image with an error naming the transformation.

  • HEAD requests. Http::head(url) sends HEAD.

  • Global HTTP middleware and options. Http::global_request_middleware, global_response_middleware and global_options apply to every request created after them, and Http::without_global_configuration creates requests without any of them. Registered inside an Http::fake scope they belong to that scope.

  • Building the request URL. RequestBuilder::base_url goes in front of a URL without a scheme, query merges pairs into the URL's query, and url_parameters expands {name} placeholders with each value percent-encoded, so a value cannot add a path segment, a query or a host.

  • Multipart uploads. RequestBuilder::attach(name, contents, filename) sends the body as multipart/form-data.

  • A connect timeout per request. RequestBuilder::connect_timeout replaces the shared client's 10 seconds for one request.

  • HTTP stubs that stay. Http::fake_url answers every request whose URL matches a pattern, Http::fake_using asks a callback that may pass with None, and Http::fake_sequence answers in turn and then with its when_empty response, each with a FakeResponse.

  • Reading a recorded request. RecordedRequest::header, has_header, is_json, is_form and is_multipart compare header names without regard to case.

  • Laravel's stray-request names. Http::prevent_stray_requests(on) and Http::preventing_stray_requests() move and read the switch fail_on_real_calls moves, and Http::allow_stray_requests(patterns) lets a request inside a fake that no stub answers reach the network when its URL matches.

  • Vite tags for any page. Vite::tags(entries), Vite::to_html() and InertiaConfig::vite_tags(entries) render the build manifest's scripts, stylesheets and preloads for any number of entry points, each file once and every stylesheet before the first script, under the public root; a missing manifest is an error that names its path, and a missing entry one that names the entry.

  • Entry points beside entry_point. InertiaConfig::entry_points adds entries, such as a stylesheet entry, that the Inertia document and Vite::to_html() load with the main one.

  • The hot file, readable. InertiaConfig::hot_file, Vite::hot_file, Vite::is_running_hot and Vite::dev_server_url answer the hot file's path, whether it exists and the dev server URL it holds; production never reads it.

  • The document head. Head resolves the title (with an inherited prefix or suffix), description, canonical URL and robots directives from the defaults, route groups and routes (with_head), run-time calls and error statuses (Head::errors), field by field; Head::render_html renders the escaped tags and Head::to_array returns them as data.

  • The head on Inertia pages. Every Inertia response that a head layer sets something for shares the head as a head prop of keyed tags, left out of partial reloads and renamed with Head::inertia; the first visit writes the tags once, deduplicated against the SSR head, and Head::inertia_globals adds tags for the first visit only.

  • Head metadata beyond the title. Open Graph values and media, X cards filled from the page, theme colors, application metadata and icons, pwa, resource hints, locale alternates, feeds, pagination links, custom meta and link tags, and JSON-LD schemas with breadcrumb and FAQ builders.

  • Precognition answers from any error bag. Precognition::after_validation(&request, errors) answers a precognitive request with 204 or 422, and passes an ordinary one or fails it with the ordinary validation error.

  • The Precognition selection in hooks. Precognition::should_validate(field) answers whether a precognitive request listed the field while a form request's, a data object's or a multipart form's after-validation hooks run.

  • Fallible CSRF helpers. try_csrf_token() and try_csrf_field() return an error that names the missing session.

  • Raw cookies. Cookie::raw(name, value) writes its value without percent-encoding, and refuses a name that is not an RFC 6265 token or a value byte outside cookie-octet; Cookie::is_raw tells the two forms apart.

  • Shared view data. View::share, View::share_for_request and View::shared hand values to every checked view through Askama's runtime values; a value shared for one request never reaches another request, the render cache included.

  • Inline Markdown. Str::inline_markdown and MarkdownRenderer::render_inline render emphasis, code, links and line breaks with no paragraph around them, and keep block markers such as # as text; Str::markdown renders a whole document as a string.

  • Markdown input choices. MarkdownRenderer gains html_input(HtmlInput::Sanitize | Strip | Escape | Allow), allow_unsafe_links and autolink; a renderer that calls none of them renders as before.

  • Fluent strings. Str::of returns a Stringable that chains the Str helpers, markdown and inline_markdown, and converts to and from String.

  • Purpose-bound string encryption. Stringable::encrypt, encrypt_for, decrypt and decrypt_for seal and open a value through Crypt under a CryptPurpose.

  • Descending sort. Collection::sort_desc orders Ord items from greatest to least and keeps equal items in their order.

  • Ordered key maps. Collection::map_with_keys collects pairs into an IndexMap in the collection's order; a repeated key keeps its first position and its last value.

  • Dates from text. Date::parse, Date::parse_in and Date::raw_parse read RFC 3339, dates, date-times, Unix seconds and named relative forms such as tomorrow 09:30, +2 days and first day of next month, reading the framework clock, and refuse other text with a DateParseError that names it.

  • Priority list controls. default_middleware_priority, set_middleware_priority, add_to_middleware_priority_before and add_to_middleware_priority_after read, replace and insert into the middleware priority list.

  • Value pipelines. Pipeline::of(value) sends any value through steps, with through, pipe, pipe_all, finally, within_transaction, then and then_return; a step is a function, an async closure, or a type that implements PipelineStep.

  • Appending several middleware. The HTTP Pipeline::pipe_all appends middleware after those through set.

  • More catalog directories. Lang::add_path merges a directory after lang/ and Lang::add_fallback_path one before it; the translator the framework binds at boot reads every directory registered before then.

  • Namespaced translations. Lang::add_namespace reads a package's catalogs as namespace::key, overridden by lang/vendor/<namespace>/<locale>/; the browser catalog holds them as namespace__key, and the starter kits' t() encodes keys the same way.

  • Translation sources. Lang::loader answers the directories and namespaces the translator reads, and FluentTranslator::from_sources builds a translator from them.

  • Bindings chosen by environment. #[service] takes bind(Concrete, env = [...]) entries; at boot the first entry whose pattern matches the environment is bound, and impl when none does.

  • Renamed route parameters. #[route_param("name")] on a handler argument reads the route parameter of that name, and an argument spelled r#type reads type.

  • Lazy singletons. App::singleton_lazy and App::singleton_lazy_if_absent, and the same on Container and TestContainer, build a singleton on its first resolve and share it; a factory that resolves its own type gets an error.

  • AI-assisted development chapter. The manual shows how an assistant reads it as Markdown and through llms.txt, how to install the Suprnova language server, and how to point an assistant at a project.

  • Configuration defaults that never overwrite. Config::register_default registers a value only when none of its type is registered and answers whether it did; Config::merge merges a map of defaults under the registered one, the application's keys winning, through MergeConfig.

  • Environment detection that tells unset from named. Environment::detect_explicit answers None when APP_ENV is unset.

  • Cache connections by name. With CACHE_DRIVER=redis the store runs its commands on the Redis connection REDIS_CACHE_CONNECTION names, cache by default, and its locks on REDIS_CACHE_LOCK_CONNECTION, default by default; CacheConfigBuilder::connection and lock_connection name them in code, and RedisCache::connect_named builds the store on them.

  • Moving the cache to another connection. Cache::set_connection moves the bound Redis store's later commands to another named connection, and answers an error for a store without one.

  • Cache hit and miss events. Cache::get, has and missing, and every read built on them, dispatch CacheHit and CacheMissed with the store's name and the key; a hit that fetched the value carries it, and its Debug output leaves it out.

  • A lifetime read from the cached value. Cache::remember_with_ttl takes the lifetime of a computed value from a closure over it: None stores it for the configured default, Some(Duration::ZERO) returns it unstored.

  • MySQL character set and collation. On a MySQL or MariaDB URL, DatabaseConfig carries charset and collation from DB_CHARSET and DB_COLLATION (utf8mb4 and utf8mb4_unicode_ci), a URL parameter winning, and every connection sends them with SET NAMES.

  • Table character set and collation. Schema::create gives a new MySQL table the configured character set and collation, and Blueprint::charset and Blueprint::collation name its own.

  • The Log facade's level methods. Log::emergency through Log::debug, a *_with form of each and Log::log write to the default channel through tracing, and a file or stack channel keeps their own level, CRITICAL included.

  • Logger context. Logger::with_context and without_context return a logger whose writes carry a context, and Logger has a *_with form of every level.

  • Shared log context. Log::share_context adds a context to every later write of the current request or job, with Log::shared_context, Log::without_context and Log::flush_shared_context.

  • Log listeners. Every write that reaches a channel dispatches MessageLogged, and Log::listen registers a callback for each write.

  • Placeholders per channel. LogChannel::replace_placeholders(false) keeps a channel's messages as templates, and a stack gives each channel its own form.

  • Log level names. LogLevel::parse reads the eight PSR-3 names and warn and trace, and LOG_LEVEL accepts the PSR-3 names.

  • Test client default headers. TestClient::with_header and with_headers send headers on every request the client builds, a request's own header winning, and flush_headers clears them.

  • QUERY requests in tests. TestClient::query_json sends a QUERY request with a JSON body and the JSON content type and accept headers.

  • Acting as a user in tests. TestClient::acting_as signs a user into the default guard for every request, and acting_as_with_guard into a named guard; an unregistered guard fails the request naming it.

  • No-content assertions. TestResponse::assert_no_content passes only for an empty 204, and assert_no_content_status for an empty response of another status.

  • Typed queued mailables in the mail fake. MailFake::queued_of::<M>() and queued_where::<M>(filter) rebuild queued mailables as M, and assert_queued_mailable::<M> and assert_not_queued_mailable::<M> assert on them; a payload that does not rebuild fails the call, and the try_* forms return the error.

  • Fallible typed pushes in the queue fake. queue::testing::try_pushed::<J>() returns the decode error that pushed::<J>() now panics with.

  • Workers on the queue fake. QueueFakeGuard::driver() returns a driver a worker reserves the recorded jobs from, and queue::testing::reserved::<J>() and try_reserved::<J>() return each reservation typed.

  • Full-text search. where_full_text and or_where_full_text on DB::table and the model builder render MATCH ... AGAINST on MySQL and MariaDB and to_tsvector ... @@ on Postgres, with FullTextOptions for the mode, the language and query expansion; SQLite returns an error.

  • Full-text indexes. Blueprint::full_text creates a FULLTEXT index on MySQL and MariaDB and a GIN index over to_tsvector on Postgres, with .language(..), and drop_full_text drops it; SQLite refuses both.

  • Tests on the configured database. TestDatabase::refresh migrates the database DATABASE_URL names once per test process and holds each test in a transaction rolled back when the helper drops; refresh_lazily does the same on the first query.

  • Migrations rolled back after a test. TestDatabase::migrate runs the migrations on DATABASE_URL's database and rolls back the ones it ran when the helper drops.

  • Seeding test databases. TestDatabase::seed runs a named seeder and seed_root the root seeder before the test body.

  • #[suprnova_test] database keys. refresh runs the test through TestDatabase::refresh, and seed or seed = Path seeds before the body.

  • A Web Push endpoint allowlist. In 3.2.1, EndpointPolicy offered Strict, which refuses local and private destinations but passes any public host, and AllowAny, so a tampered subscription could still make the server POST to a public host of the attacker's choice. EndpointPolicy::Allowlist takes an EndpointAllowlist of push-service origins, https://host or https://host:port, where a leading *. label matches exactly one label, as https://*.notify.windows.com needs. It runs every Strict check and refuses an endpoint at any other origin before the host name is looked up, with the new WebPushError::OriginNotAllowed, which carries the origin and never the path of the endpoint and is not retryable. WebPushChannel sends under that policy, in place of its client's own, when WEB_PUSH_ENDPOINT_ORIGINS names one or more origins, and logs a refused endpoint as a subscription that cannot be used. WebPushChannel::new reads the variable and returns a Result: an entry that is not an origin fails it with an error that names the variable. WebPushClient::send_with_policy sends under a policy other than the client's own, and EndpointPolicy is no longer Copy. The Web Push chapter lists the origins of the Firefox, Chrome, Safari and Edge push services.

Changed

  • Runtime threads have an 8 MiB stack. #[suprnova::main] builds its Tokio runtime with thread_stack_size set to 8 MiB for the worker and blocking threads, the size Linux gives the main thread, in place of Tokio's 2 MiB default. In a debug build the frames the framework puts under a Live action (the server, the middleware, the session, the render cache and the Live engine) use about 1.75 MiB of a 2 MiB stack, so an action a little deeper, such as a password reset, overflowed it and aborted the server. The size is reserved address space; a thread uses memory only as its stack is touched.

  • Typed factory counts. count and times make make and create return vectors while uncounted factories keep their single-model results.

  • Laravel boolean storage. MySQL and SQLite boolean columns use tinyint(1) and retain false and true when you read their rows.

  • Default float precision. Float columns use 53 binary digits on MySQL and Postgres, with explicit precision available through the column modifier.

  • Whole-second zoned timestamps. Postgres uses timestamp(0) with time zone by default, and SQLite declares datetime for zoned timestamp columns.

  • Production seeding requires force. db:seed returns an error in production unless you pass --force; suprnova db:seed --force passes the flag through to the console binary.

  • Console test assertions check every expectation. ConsoleRun::assert_successful fails on a prepared question the command did not ask and on every unmet output expectation, which unmet_expectations() lists; a question the test did not expect fails assert_successful, assert_failed and the exit-code assertions, naming it, even when the command goes on, and unexpected_questions() lists it.

  • The console binary ends with the command's exit code. A new project's src/bin/console.rs ends with ExitCode::from(error.exit_code()); an existing project replaces Err(_) => ExitCode::FAILURE with that arm to end with the code of FrameworkError::exit.

  • A wrong method answers 405. A request whose path a route of another method matches answers 405 with Allow and Laravel's message in place of the 404, and an OPTIONS request answers 200 with Allow. Both run through the global middleware; a path no route matches keeps the 404 or the fallback.

  • Collection metadata belongs to the collection. JSON:API collections keep their document metadata at the root without merging the first item's metadata.

  • Empty results have page one. Length-aware pagination reports one last page and includes its page-one link when there are no matching rows.

  • Model ordering follows timestamp declarations. oldest and latest use the model's declared creation column, including renamed timestamps.

  • Force destruction includes trashed rows. force_destroy physically removes matching soft-deleted rows and counts each existing key once.

  • Model visibility applies to serde and appends. Array, JSON, and serde outputs share the hidden and visible lists, including appended accessors.

  • Storage::purge takes the disk name. The zero-argument purge() that dropped every disk is purge_all(); purge(name) drops one disk and reports whether it was registered.

  • Excerpts trim invisible characters. Cut ends now remove Laravel's invisible character set, including zero-width spaces, while preserving characters inside the excerpt.

  • Redis prefixes typed keys. Typed methods, scripts, blocking commands, and typed pipeline methods apply REDIS_PREFIX, defaulting to the app name's slug followed by -database-. Raw commands retain their arguments.

  • Redis events reach application listeners. Enabled command and failure events now dispatch through EventFacade, alongside the existing Redis listeners. Pipeline and transaction commands stay outside these events.

  • Daily logs keep seven files by default. The daily channel and LogChannel::daily keep 7 files unless LOG_DAILY_DAYS or .days(...) sets another count; 0 keeps every file.

  • Syslog names the application. Datagrams use APP_NAME as the ident, with suprnova when unset, and keep each record's facility and severity.

  • Percentages round decimal ties half up. Percentages now round 0.12345 at four fraction digits to 0.1235%.

  • Special number spellings. Number formats use ∞ and NaN for values without a finite decimal representation.

  • File and disk responses answer byte ranges. A GET range receives 206 with the selected bytes and Content-Range; an unsatisfiable range receives 416. Responses advertise Accept-Ranges: bytes and include the file's modification time as Last-Modified.

  • Production browser failures show a minimal HTML view. With debug off, a browser's 5xx page shows its status without error details. Inertia visits keep the application error page and JSON clients keep their JSON response.

  • Debug frames show source and separate error traces. Application frames include nearby source lines when the file is readable. Each recorded source error has its own trace.

  • The implicit default disk is local. Without a default named in code or FILESYSTEM_DISK, Storage::default_disk() returns local or an error naming local and FILESYSTEM_DISK when it is not registered.

  • S3 accepts Laravel's AWS variables. Bucket, region, credentials, public URL, endpoint and path-style settings read the AWS names when their S3 names are unset. Each explicit S3 value wins.

  • Nullable-user policies authorize guests. A policy accepting Option<&User> receives None for a guest and decides whether the handler runs. Policies requiring a user keep the 401 response.

  • Handler authorization accepts enum abilities. An enum variant implementing Into<String> reaches the same async gate as a string ability.

  • Merged validation hook errors. Real form and multipart requests run both after-validation hooks after field rules and return their combined errors.

  • Classic form validation redirects. A failed form that prefers HTML redirects back with errors and old text input flashed to the session.

  • Unsigned MySQL IDs by default. id() and foreign_id() match Laravel's unsigned keys. unsigned_ids = false keeps signed IDs through #[suprnova::main] or Schema::set_unsigned_ids(false).

  • Nullable default timestamps. timestamps() creates nullable created_at and updated_at on every database. The scaffold documents the schema defaults and carries the signed-ID opt-out and model cast setting commented out.

  • Query conditions follow SQL precedence. Every or_ helper adds a flat OR, so where(a).or_where(b).where(c) is a OR b AND c. The grouped column helpers keep their parentheses, and model scopes still constrain the whole caller condition list.

  • Null equality values compile to IS NULL. Both builders rewrite a null where or or_where comparison instead of binding it after =.

  • Joined builders update and delete matching rows. Both builders preserve the join when writing the base table; model deletion still honors soft deletes. The model builder also exposes update and delete.

  • A clean model save skips the update. Dirtiness comes from the instance's original values in memory, and a clean save runs no update, where 3.2.1 ran the update and fired Updating and Updated on every save. Saving and Saved still fire, while Updating and Updated fire only for a dirty save.

  • Pivot sync returns the changed ids. sync and sync_without_detaching return SyncChanges with attached, detached and updated id lists instead of ().

  • Pivot sync updates per-id columns. Both methods accept (id, Attrs) records and update existing rows only when their supplied columns change. Unchanged rows keep their pivot columns and timestamps.

  • Pivot filters constrain sync. Both methods honor where_pivot and its companions for the current set, updates and detachments, leaving rows outside the filter untouched.

  • Pivot sync touches a configured parent. A relation's .touch_parent() or a related model's inverse touch declaration enables the parent timestamp update, in the same transaction as the pivot changes.

  • Queue assertions filter unchained jobs. assert_pushed_without_chain takes a closure, so a matching job must also carry no chain.

  • Queue counts and clearing accept a queue name. You can select one queue on every driver; SQS uses SQS_QUEUE when you pass none.

  • SQS accepts FIFO queues. Jobs carry a message group and deduplication ID, with default and a payload digest as defaults, and sends omit delays.

  • SQS overflow supports named cache stores. SQS_OVERFLOW_STORE takes precedence over the disk, and clearing keeps other queues' payloads.

  • Processes remove inherited environment variables. Passing None to env removes the variable before starting the program.

  • TTY processes require terminal input and output. An error names the redirected stream; a terminal process captures no output.

  • Process diagnostics quote command arguments. Results and errors use POSIX shell quoting while fake patterns keep the arguments joined by spaces.

  • Stopping a process accepts a signal. The default sends terminate and waits 10 seconds before killing the process and its descendants.

  • Process fake handlers accept closures. You can inspect the pending command, path, environment and input before returning a result.

  • Described process fakes replay mixed streams in order. Each described output or error output line ends with one newline.

  • Process run-count assertions default to once. assert_ran_times checks one run; assert_ran_count accepts an explicit count.

  • Precognition requires the route middleware. A route must carry Precognitive for the header to count. Previously every form request answered the header; a route without the middleware now handles it as a real request.

  • Inertia DevTools recording is opt-in. 3.2.1 had no Inertia DevTools. An application records requests and serves the entries endpoints only when it passes .devtools(DevToolsConfig::new()) to its InertiaConfig; without the call nothing is recorded and no entries are served. The scaffold and dogfood application opt in. A configured instance records when APP_ENV names local, or as its enabled(..) says (DT-01).

  • The starter keeps an existing notes table. The scaffold's notes migration, new in 4.0.0, checks for the table before creating it, like the users migration, so a project using an existing Laravel database keeps its own notes schema and rows (K21).

  • The built-in image driver's PNG, BMP and WebP codecs come from the eas4ai forks of oxideav-png, oxideav-bmp and oxideav-webp while the upstream pull requests are open (OxideAV/oxideav-png #18 to #25, oxideav-bmp #11 to #17, oxideav-webp #35 to #43). The encoders copy less: a PNG is written into a buffer with room for the metadata added after it, so adding an orientation tag to a 512 x 512 noise PNG does not move its 1 MiB file a second time, and a BMP into a buffer reserved at the file's exact size; lossy WebP is encoded from the converted planes where they lie, and lossless WebP from the pixels, instead of from a copy of each. Lossless WebP chooses its transforms in one pass rather than by exhaustive search: a 1024 x 1024 photo encodes in about half a second instead of 47.8 s in a release build, and processing a 64 x 64 image to lossless WebP allocates 0.76 MB in all instead of 1.23 GB. Its files are at most 8.7 percent larger. The forks carry three fixes of their own, each offered upstream (oxideav-png #26, oxideav-bmp #18 and #19): a PNG is decoded without inflating its iCCP profile or XMP packet, which oxideav-png 0.1.11 and later inflated, up to 64 MiB each, before IMAGE_MAX_ALLOC_BYTES could count them (a crafted profile held 118,213,096 bytes under a 4 MiB budget); a BMP is decoded without a copy of its embedded profile (5,242,912 bytes allocated for a 1024 x 1024 RGBA file with a 1 MiB profile, now 4,194,336); and a BMP with a profile is written by an encoder that borrows the profile. An RGBA PNG is also decoded without the second copy of its pixels the crate's RGBA entry made (1 MiB for a 512 x 512 image). The forks follow upstream master, which changes three kinds of output: an image decoded from a lossy WebP, whose colour conversion oxideav-webp 0.3 corrected to within one level of libwebp's (pixels move by up to 16 levels); a PNG with more than 1 MiB of filtered data, which oxideav-png 0.1.12 deflates in 1 MiB pieces, so its bytes can differ (a 1024 x 1024 noise PNG is 4,196,716 bytes instead of 4,196,676); and lossless WebP with transparency, written in the simple lossless layout, its alpha declared in the VP8L header, rather than behind a VP8X header.

  • The project file is suprnova.toml, all lowercase. suprnova serve reads its extra dev processes from suprnova.toml, and live:add keeps its records there. A project that holds a Suprnova.toml must rename it: until it does, serve and live:add refuse to run and name the rename.

  • live:add --manifest installs only from a signed library tree. A third-party manifest now sits in a library tree, beside the library.json that names its namespace and key, and installs only with a valid signature. A manifest holds no version, and the shipped components' manifests dropped theirs. Each component directory's .suprnova-installed.json now keys its digests by the path from the project root, Rust files included; live:add reads a record in the earlier form and rewrites it.

  • Scaffolds ignore live:add's lock and journal. The .gitignore of a new project lists /.suprnova-live.lock and /.suprnova-live-journal.json; add both lines to an existing project's.

  • RouteBinding is the one binding trait, shaped like Laravel's UrlRoutable: route_key_name, route_key, route_field, resolve_route_binding, resolve_child_route_binding and their soft-deletable forms. AutoRouteBinding is a second name for it, and <T as AutoRouteBinding>::from_route_param(value) keeps working. A type that implemented the old AutoRouteBinding by hand implements RouteBinding instead. The unused route_binding! macro and the old RouteBinding trait with param_name are gone.

  • A #[handler] inside an impl block names its type, as #[handler(Self = Posts)], so the startup checks can find it. Without it, such a handler is a compile error that names the fix.

  • Some string-pair route() calls need .as_str(). route() and try_route() take bound values as well as strings, so the forms that compiled only because the old slice parameter set the pairs' type or coerced them no longer do: a name or value whose type the parameter inferred (s.as_ref(), s.borrow(), Default::default()), one that reaches &str through more than one dereference or through a type of the application's own (&&&str, &Box<String>), a container of pairs reached the same way (&&&Vec<_>, &Box<Vec<_>>, a SmallVec), an array whose pairs mix &String and &str values, an array of more than 32 pairs holding &String values, and route used as a fn(&str, &[(&str, &str)]) pointer. Write .as_str(), &* or .as_slice(), or a closure in place of the pointer. Every other string-pair call compiles as before.

  • A dotted resource name nests. Router::resource("users.posts", ...) registers /users/{user}/posts/{post}, as Laravel's Route::resource does; it registered /users.posts/{users.post}.

  • A route key that does not parse answers 404. A key that does not parse, or breaks a unique_id key's format, gets the body a missing row gets, naming the model and never the value. On 3.2.1 a key that did not parse answered 400 and repeated the value, and a key that broke a unique_id key's format was looked up as given and answered 404.

  • The bare x::Model form no longer binds a soft-deleted row of a soft-deleting #[model]'s table unless the route calls with_trashed().

  • Bound arguments are bound before every other argument, after the route's middleware, so a missing row answers 404 before a form request is validated, whatever the declaration order.

  • The router refuses a route it cannot run, at startup. A handler that reads a parameter its path does not declare, reads the request body twice, names a binding field that is not a parseable column of the bound model, scopes a child through a relation the parent does not declare, or uses a binder that cannot run is an error from the boot path. Two body readers were a compile error; they are now a startup error, except two Request arguments, still a compile error.

  • URLs carry the public root. When APP_URL has a path or a trusted prefix arrives, route(), try_route, route_with_params and try_route_with_params return the root in front, so an application whose own routes begin with its APP_URL path gets that path twice. Signed URLs cover the root, so a link signed before an application gained a root stops verifying. url::current and LiveAssetCatalog::url include the root. RenderKeyInput has a public root field.

  • Redirect::intended ignores a stored network-path reference. A stored intended URL that starts with //, /\ or \, or that holds a control character, is ignored in favour of the fallback. Store an external destination as an absolute URL.

  • Cookies follow the root. SessionConfig.cookie_path and the XSRF cookie path default to unset, which means the root of each request. When a request carries two cookies of one name, the framework reads the first.

  • Images are upright and carry no metadata. Images are oriented by their EXIF tag on decode (IMAGE_AUTO_ORIENT, on by default), and processed output keeps only the ICC profile under both drivers: EXIF and GPS, XMP, IPTC, comments, text chunks and date chunks are stripped. Rotation corners and flattened transparency are white in JPEG and GIF, not black, and GIF output is converted to sRGB.

  • The image types changed shape. Transformation and ImageConfig are #[non_exhaustive]: build an ImageConfig from default() or from_env() and set its fields, and give a match on Transformation a wildcard arm. Transformation::Rotate(f32) is Rotate { degrees, background }. Image::store(disk, path) is replaced by store(directory, disk), which stores under a generated name and returns the path; store_as(directory, name, disk) takes a name.

  • The shipped migrations upgrade an existing application in place. failed_jobs, jobs, job_batches and sessions move into Laravel's layouts, and notifications, features, roles and permissions into the layouts above, with every row. A queued, delayed or reserved job runs once, a failed job keeps its id, a batch keeps its counts, and no user is signed out. A migrate that stops part way resumes on the next run. The manual gives the migration that moves an earlier scaffold's users.

  • Workers check failed_jobs before they start. run_worker returns Result<(), FrameworkError>. A worker whose failed-jobs store is the database store refuses to start on a table it cannot write, and queue:work then exits non-zero. Each failed job gets a fresh uuid, and its connection is suprnova:<connection>, so Laravel's queue:retry refuses it.

  • Laravel's $2y$ hashes verify through Auth::attempt and Magnetar for passwords of 72 bytes and longer, judged on their first 72 bytes as PHP does.

  • Suprnova never writes users.remember_token. The scaffold's User drops update_remember_token, reads id as u64 and its timestamps as Option<DateTime<Utc>>.

  • The RBAC, feature and notification entities follow Laravel's layouts. rbac::entity::Role and Permission have u64 ids and no display_name, and the earlier pivot entities are gone. FeatureRow and StoredNotification timestamps are Option. The session::driver::database::sessions entity is gone. The down of CreateNotificationsTable, CreateFeaturesTable and CreateRbacTables leaves the shared tables, so a rollback never drops rows Laravel wrote, and a new scaffold's users and sessions migrations leave their table on rollback too.

  • Schema-qualified table names. On Postgres, Schema::create, table, drop, drop_if_exists and rename read schema.table as that table in that schema, and a . becomes _ in index and foreign key names. On MySQL and SQLite a qualified name is refused with an error naming it.

  • The naive date-time casts read MySQL TIMESTAMP columns.

  • Password hashing runs under one process-wide limit. hash_async, verify_async, hash_with_cost_async and Magnetar's sign-in hashing each took a blocking-pool thread with no limit, so a burst of sign-ins could hold up to Tokio's 512 blocking threads at once, and an Argon2id hash under the framework's defaults holds 64 MiB: up to 32 GiB. They now share one limit, HASH_MAX_CONCURRENCY, which defaults to the host's available parallelism; work past it waits as a task holding no thread, so a burst holds at most the limit times one hash's memory. A hash keeps its place under the limit until it returns, even when its caller stops waiting. 0 or a value that is not a whole number is refused when the hashing configuration loads; a blank value is the setting left unset. The two dummy hashes Magnetar's verifier warms as it is built run under the limit too, instead of inline on the runtime worker that installs the engines (#146).

  • A WebSocket upgrade no longer waits behind the shutdown drain. The registry of WebSocket handler tasks sat behind an async lock that the shutdown drain held for up to its 5 s deadline, so an upgrade in flight waited out the whole drain before its handler was registered. The registry is now a synchronous lock held only to reap finished handlers and register a new one, and the drain takes the set out under it and waits holding no lock, still up to 5 s before it aborts what runs. A handler registered while the drain waits is waited for in its turn and aborted with the rest at the deadline; one registered after the drain has closed the registry is not started (#149).

  • A streamed file is one blocking task, not one per chunk. A file above 1 MiB, served by HttpResponse::file, HttpResponse::download or StaticFiles, spawned a blocking-pool task for every 64 KiB chunk, so a 1 GiB download made 16,384 trips through the pool and queued behind every other blocking task at each one. One blocking task now reads the whole file in 256 KiB chunks and hands them to the response over a channel of four: one pool trip per file, a client that stops reading leaves at most five chunks read ahead, and a dropped response stops its reader. The bytes and Content-Length are unchanged, and a read error or a file that shrinks still ends the body short (#147).

  • The in-memory rate limiter keeps answering while it sweeps. Its buckets sat behind one lock: every request locked the whole map and copied its key into a new String even when the key had a bucket, and the periodic sweep and purge_inactive held that lock across the whole map, so each sweep stalled every throttled request for a time that grows with the number of keys an attacker can rotate. The buckets now sit in a sharded map: a request locks only its key's shard, a key that has a bucket allocates nothing, and the sweep locks one shard at a time. During a sweep over 200,000 buckets (about 45 ms), no request on another key completed before; about 4,800 do now. Acceptance, rejection and retry-after answers are unchanged, and no request fails with "rate limiter poisoned" any more, since the shard locks do not poison (#148).

  • Prop::match_on replaces the match fields on each call instead of adding to them, as Laravel's matchOn does. .match_on("x").match_on("y") emitted matchPropsOn: ["posts.x", "posts.y"] and now emits ["posts.y"]; name several fields in one call with .match_on(["x", "y"]).

  • until on a once prop reads an integer as seconds from now, as Laravel's until(60) does, where it read an absolute timestamp in milliseconds: .until(60) emitted expiresAt: 60 and now emits the render time plus 60 seconds. Pass a DateTime<Utc> for a fixed deadline (chrono::DateTime::from_timestamp_millis(ms)). fresh() on Prop and OnceOptions takes a bool: write .fresh(true).

  • Scroll props merge under the wrapper data by default, as Laravel's Inertia::scroll($value, $wrapper = 'data') does: .scroll("posts", metadata, paginator) emitted mergeProps: ["posts"] and now emits ["posts.data"], where a paginator or resource keeps its rows. .paginate and Inertia::paginate ship bare rows and still merge at the prop's root; Prop::scroll_at_root() does the same for any other bare list. A scroll prop's match_on path is now relative to the prop, with no wrapper prefix: .match_on("data.id") on posts emits posts.data.id, where a wrapped prop used to prefix the wrapper itself and emit posts.data.data.id. A deferred scroll prop announces its bare key under mergeProps on the visit that withholds it and {key}.{wrapper} when the data arrives, where a wrapped one announced {key}.{wrapper} on both. The manual's two divergence entries for these are gone.

  • sharedProps lists errors, and a setting turns the list off. Every response shares the validation errors, as Laravel's middleware does, so sharedProps now starts with errors: a page with nothing else shared carries ["errors"] where it carried no sharedProps, and after a failed form errors reaches the client's instant-visit carry with the other shared keys. InertiaConfig::expose_shared_props(false) leaves sharedProps out of the page object, Laravel's inertia.expose_shared_prop_keys; it is on by default.

  • suprnova new ships a root template in place of frontend/index.html. The server never served that file: Vite builds from the entry module, and the first visit was the framework's own document, titled Suprnova on every page. A new project has templates/app.html, declared as AppDocument with #[inertia_root] in src/bootstrap.rs, which renders every first visit through it and sets the project's name as the default title. The Dockerfile suprnova docker:init writes copies templates/ into the stage that compiles the application, since Askama reads templates at compile time; it copied only cmd/ and src/, so that build could not find a root template or a Live view.

  • X-Inertia counts as an Inertia visit for any value PHP reads as true. A request was an Inertia visit only when X-Inertia was exactly true, so a client sending X-Inertia: 1 received the HTML document where Laravel sends the JSON page object. Request::is_inertia and the InertiaRequestExt default now read the header as PHP's boolean cast does: every value but an empty one and 0 is an Inertia visit, and JSON responses still carry X-Inertia: true. Every middleware that asks is_inertia follows the same rule, and so does the development error page, which a visit sending X-Inertia: 1 now gets in place of a JSON error (HD-01).

  • The Inertia asset version follows Laravel's order and is empty by default. With no Vite manifest to hash, the page carried the version 1.0; Laravel's carries an empty one. The version now resolves from the new InertiaConfig::asset_url setting when it is set (a hash of the URL, as Laravel's app.asset_url; it defaults to the ASSET_URL environment variable, and the builder's value wins), else from the manifest's hash, else to the empty string. An explicit .version(...) or .version_with(...) still wins. MANIFEST_VERSION_FALLBACK stays exported, but no resolver returns it now, and a client that holds 1.0 from before the upgrade is bounced once (MW-11).

  • The asset-version 409 names an absolute URL and the current version. InertiaVersionMiddleware answered a stale Inertia GET with a root-relative X-Inertia-Location (/users?page=3) and no version, so the client forced a full reload even for a poll or a background prop load. The 409 now carries the request's absolute URL (http://example.test/users?page=3, scheme and host as Request::scheme_and_http_host reads them, a trusted proxy's forwarded host included) and X-Inertia-Version with the current version, as Laravel's onVersionChange does. It still answers before the handler runs, and a visit by another method still passes through. InertiaResponse::version_conflict(url), the 409 a handler builds itself, now carries X-Inertia-Version with Inertia::get_version() too (MW-02, HD-10, R04).

  • Partial reload headers are parsed as Laravel parses them. X-Inertia-Partial-Data and X-Inertia-Partial-Except were trimmed entry by entry, and an empty X-Inertia-Partial-Data was a list that matched nothing, so the client received no props at all. The lists are now split on , with empty segments dropped and nothing trimmed (a, b names a and b), and a header that names nothing counts as absent: an empty X-Inertia-Partial-Data now returns every prop except allows, as Laravel's does. X-Inertia-Reset and X-Inertia-Except-Once-Props were trimmed too and now follow the same rule (HD-03).

  • Dotted partial-reload entries narrow literal values only, as Laravel's do. only: ['users.name'] narrowed every prop's resolved value, a resolver's and a defer, optional, merge or once prop's included, so the client received {"users": {"name": "Ada"}} where Laravel sends the whole users. Dotted only and except entries now walk literal values alone (a flag-free resolver under a dotted key counts, since Laravel calls it before the walk), and the walk is Laravel's: an entry whose path resolves to nothing yields [] instead of {}, a path walks into lists by index, and a scalar a deeper path reaches ships as it is instead of being dropped. The manual's divergence entry on narrowing is gone (PR-08, HD-04).

  • Optional and deferred props resolve on an except-only partial reload. An optional or defer prop resolved on a partial reload only when X-Inertia-Partial-Data named it, so router.reload({ except: ['stats'] }) returned none of them where Laravel returns every one it does not exclude. They now resolve whenever their key passes the only and except lists, a reload with except alone or neither list included; a standard visit still leaves them out (PR-07, PT-01).

  • merge and once instructions follow Laravel's partial-reload rule. Any only entry that selected a prop also sent its instructions, so only: ['items.data'] against a merge prop items told the client to append a value it had asked for in part, and a .merge().once() prop the client already held still sent a mergeProps entry beside its onceProps entry. mergeProps and onceProps entries now ship only when an only entry names the prop or an ancestor of it, so a deeper entry sends the whole prop with no instruction, and a held once prop that is not deferred sends its onceProps entry alone. A scroll prop keeps its scrollProps cursor in both cases (PR-12, PR-13).

  • The Inertia page url carries the query as Laravel normalises it. page.url repeated the query as the request sent it, so /s?b=2&a=1%20x stayed /s?b=2&a=1%20x where Laravel's fullUrl() sends /s?a=1%20x&b=2, and the client's comparisons of page URLs differed between the two. The query is now parsed as PHP parses it, sorted by key and re-encoded per RFC 3986, as Symfony's Request::normalizeQueryString does: + becomes %20, reserved characters stay percent-encoded (a=%2Fx stays a=%2Fx), a bare key gains an =, a repeated key keeps its last value, and a[]=x becomes a%5B0%5D=x. The version 409's X-Inertia-Location carries the same query. A url_resolver's URL is left as it returns it (RS-07).

  • An empty Inertia response redirects back as Laravel's does. An empty 200 on an Inertia visit was answered with 303 to the session's previous URL or /, whatever the method, so a POST from /form with no previous URL landed on /. It now goes to the same-origin Referer, then the previous URL, then /, with 302, and 303 only for PUT, PATCH and DELETE; a browser follows a 302 after POST with a GET, so the blanket 303 protected nothing (MW-03, R09).

  • A redirect with a fragment keeps it on an Inertia visit. A redirect to /page#section reached the client as a plain 302, and the fragment was lost inside the XHR that followed it. It now arrives as 409 with X-Inertia-Redirect: /page#section, which the client visits with the fragment intact, except on a prefetch, which X-Moz, Purpose or Sec-Purpose: prefetch marks (HD-12, HD-13, R06).

  • Inertia visits record the previous URL. The session middleware skipped every Inertia visit, so after Inertia navigation Redirect::back and a failed validation landed on the last page loaded in full. An Inertia GET that matched a route now records its URL, unless it is a prefetch, a Precognition request or a partial reload of the component it rendered, and a browser prefetch no longer records one in the session middleware (MW-06, HD-13).

  • errors under X-Inertia-Error-Bag takes Laravel's shape. With the header, a visit with no session errors got {"<bag>": {}} and a session default bag was dropped for {"<bag>": {}}. It is now {} with no errors, {"<bag>": <default bag>} with a default bag, and the named bags as they are otherwise (HD-08).

  • Inertia flash data lives in the session until a page shows it. App::flash kept its value in the request: a request that answered plain JSON lost it, and one that redirected twice dropped it at the second hop. App::flash, Inertia::flash and InertiaResponse::flash now write the session entry inertia.flash_data, the next Inertia page emits it under page.flash and removes it, and every redirect keeps it for one more request (RF-17, MW-05).

  • clearHistory and preserveFragment survive any number of redirects. App::clear_history() and Redirect::preserve_fragment() flashed a flag for one request, so a logout that redirected twice rendered the login page without clearHistory: true and left the previous user's encrypted history readable. The flags are now the session entries inertia.clear_history and inertia.preserve_fragment, which last until a page emits them; a flag an earlier release flashed is still read (RF-08, RF-09).

  • A dotted shared key nests when it is shared. App::inertia_share stored user.age as a literal key and nested it at render, so share("user", {"name": "A"}), share("user.age", 3), then share("user", {"name": "B"}) rendered {"name": "B", "age": 3}. It now nests at share time as Laravel's Arr::set does, and renders {"name": "B"} (RF-02).

  • SSR exclusion patterns match as Laravel's ExcludesPaths does. ssr_exclude matched the raw path with * stopping at /, so admin/* copied from a Laravel app excluded nothing (/admin/users starts with a slash) and /admin/* missed /admin/users/edit. Slashes at either end of a pattern are now ignored, * matches any characters including /, the path is decoded first, and each pattern is also tried against the full URL; ** keeps working (RF-12).

  • InertiaResponse::location answers a hard navigation with a redirect. It always answered 409 + X-Inertia-Location, which a browser that did not send X-Inertia cannot follow, so an OAuth or SSO bounce started outside the SPA dead-ended on a blank page. Under the Inertia middleware it now answers an Inertia visit with the 409 and anything else with a 302

    • Location, or the Redirect it was given, as Laravel's does, on every route the server dispatches, the Inertia middleware installed or not; location_for(&req, url) stays for code outside a dispatched request (RF-16).
  • A component's script can no longer replace a built-in. The live:add scan, new in 4.0.0, refuses a write to a member of a built-in object or function (script-builtin): Object.keys = f, JSON.parse = f, Math.random = f, and a write to a member of a parameter given a built-in member, as function f(p) { p.call = g } f(Array.prototype.slice) would change the call every other script borrows slice with. It refuses such a write in every form it refuses a write to a prototype's member (=, ??=, +=, ++, a destructuring or for loop target, delete), named directly, through the global object (globalThis.Object.keys, window.JSON.parse), or through a name that holds one: a variable, a parameter's default, or a parameter a call of its function by name hands one. A member read under a built-in method's name from a value the script did not make ([].slice, an element's addEventListener) counts as that method, and a method of document, location or history may not be assigned. A built-in is refused where the scan stops following it: passed to anything but a function the script calls by name or a browser API that only calls it back, put in an array or object, written to a member, destructured, returned, thrown or exported. That also names the built-in in Object.defineProperty(Object, "keys", ...) and Reflect.set(Math, "random", f), whose calls other checks refuse too. The parameter form through a prototype's member is refused as script-prototype, as the variable form is. Calls, reads, comparisons, map(Number), constants such as Number.MAX_SAFE_INTEGER, the page's own properties (document.title, location.hash) and writes to the script's own objects and functions stay admitted. Nineteen bypass fixtures pin it (script-builtin-alias, script-builtin-compound, script-builtin-default-parameter, script-builtin-define-property, script-builtin-delete, script-builtin-destructured, script-builtin-export, script-builtin-function-member, script-builtin-globalthis, script-builtin-handed-back, script-builtin-inherited-method, script-builtin-math-random, script-builtin-namespace-member, script-builtin-page-method, script-builtin-parameter, script-builtin-reflect-set, script-builtin-window, script-prototype-member-alias and script-prototype-member-parameter), and the own-members accepted fixture pins what stays admitted. A member read off a literal, an operator's result (-1, "a" + b), a constant that holds one, or a class that extends a built-in and does not declare that static is the built-in it inherits, whatever its name, so (0).toPrecision, "".anchor, [].copyWithin and /x/.compile are built-in methods though no list of the scan names them. call, apply and bind, through which every script borrows a built-in method, may be written only on a value the script made, which refuses (0).toPrecision.call = f, Math.random().toPrecision.call = f and an element's requestFullscreen.call = f. getRootNode() on any node is the page, as ownerDocument is, so document.getRootNode().createElement = f is refused, Object(value) is the value, and a method of the page whose name is never ordinary data (62 of them, from createElement and querySelector to addEventListener and pushState) may be assigned only on a value the script made, which also refuses it through a parentNode, an event's currentTarget, an array, a promise, a function that returns document, and this in a method the page calls as a listener. The window window.open returns is a global object too, so window.open("/x").JSON.parse = f is refused. Writing call on a value the scan cannot trace (api.call = f on a parameter, this.state.call = c) is refused as well, since the scan cannot tell it from a built-in method's. Eighteen more bypass fixtures pin these cases (script-builtin-literal-number, script-builtin-literal-string, script-builtin-literal-template, script-builtin-literal-regexp, script-builtin-literal-array, script-builtin-literal-name, script-builtin-literal-held, script-builtin-class-static, script-builtin-borrowed-call, script-builtin-borrowed-call-element, script-builtin-root-node, script-builtin-root-node-this, script-builtin-object-of-page, script-builtin-page-method-held, script-builtin-page-method-parent-node, script-builtin-page-method-listener-this, script-builtin-opened-window and script-builtin-opened-window-name), and the ordinary-writes accepted fixture pins what an ordinary component still writes: textContent, value, classList, this.state.open, o.call on its own object.

  • A handler panic reaches the Inertia error page. The panic boundary wraps the whole middleware chain, so a panic unwound past the error-page middleware: an Inertia visit to a panicking handler got the JSON {"message":"Internal Server Error"} 500 and the client's "plain JSON response" modal, even with error_page set. The middleware now runs the chain inside it under the boundary's rule, so the same 500, with the panic's error report, reaches the error callback, and with error_page("Error") the visit gets the Error page at status 500. An API client still gets the JSON 500. Inertia::install now registers the error-response middleware whatever the config says, where 3.2.1 registered it only when error_page was set, because the callback can be installed after it; with neither a callback nor an error_page it hands every request on and changes nothing.

  • SSR is on by default, behind bundle detection. SsrConfig::enabled defaulted to false, so an application had to opt in to SSR, where Laravel's inertia.ssr.enabled is true. It is now true, with the worker at http://127.0.0.1:13714, and while ensure_bundle_exists is on (the default) a first visit is sent to the worker only when a bundle is found at ssr_bundle_path or at one of the six conventional paths (frontend/bootstrap/ssr/ssr.js, app.js, ssr.mjs and app.mjs there, then public/js/ssr.js and public/js/app.js). An application without a bundle renders on the client as before and never contacts the worker; one with a bundle at a conventional path gets SSR without configuration. Turn SSR off with InertiaConfig::ssr_disabled(), and the check off with ssr_ensure_bundle_exists(false) for a worker whose bundle this process cannot see (SS-03, SS-04).

  • A missing SSR bundle is no longer logged. With a bundle_path set and no file there, every first visit wrote "SSR bundle not found" to stderr or the on_ssr_error hook. With SSR on by default that would reach the log of every application without a bundle on every first visit, so the visit now renders on the client quietly, as Laravel's gateway returns null; ssr:start reports a missing bundle. The on_ssr_error hook is for worker failures, and under ssr_throw_on_error such a visit now fails with Laravel's SsrException text, naming the component and, when the worker gave one, the source location: SSR render failed for component [Dashboard]: window is not defined at resources/js/Pages/Dashboard.vue:12:5 (SS-04, SS-08).

  • suprnova ssr:start makes Laravel's checks before it starts a worker. It checked that one bundle path existed and then ran runtime bundle whatever the application's SSR configuration said: it started a worker with SSR switched off, looked for no other bundle path, never checked the runtime, started a second worker beside a running one, and died of a SIGTERM that left its worker running. It now runs the application binary's ssr:start, which reads the installed Inertia configuration: it finds the bundle as the SSR dispatch does (the configured path, then the six conventional paths, warning when the configured one is missing and a conventional one runs), refuses a runtime it cannot find when ssr_ensure_runtime_exists is set, asks the worker at the configured URL to shut down first and refuses to start while that worker is still running, forwards Ctrl-C and SIGTERM to the worker as the signal received (a second one kills it), and reports each line of the worker's stderr as an error (CM-01).

  • suprnova ssr:check asks the SSR gateway's health check. It probed /health with a client of its own, so its answer could differ from the health check the framework uses, and its messages and exit codes were its own (2 for a URL without a scheme). It now runs the application binary's ssr:check, which asks the installed SSR gateway's health check and prints Laravel's messages: Inertia SSR server is running., Inertia SSR server is not running., or The SSR gateway does not support health checks., exiting 0 or 1 (CM-03, SS-10).

  • The CLI's ssr:start, ssr:stop and ssr:check run the application binary, and the CLI does not link the framework crate. The CLI read its own SSR settings from --bundle, --url, --timeout-ms and the SUPRNOVA_SSR_URL, SUPRNOVA_SSR_RUNTIME and SUPRNOVA_SSR_BUNDLE variables, so it could start or check a worker other than the one the application's first visits dispatch to. Each command now runs cargo run --bin <package> -- ssr:<command> from the project directory, as suprnova serve runs the backend, with --runtime and --graceful passed through: the application's output reaches the CLI's stdout and stderr, and the CLI exits with its status, or 128 plus the signal number when a signal ended it. The application runs in a process group of its own, so a terminal's Ctrl-C reaches it once, through the CLI, which forwards each SIGINT and SIGTERM it receives to the application and each SIGHUP, SIGQUIT, SIGTSTP and SIGCONT to the application's process group, worker included, and stops with it at a SIGTSTP, so Ctrl-Z and fg stop and resume them together. The flags and the variables are gone: set the URL, the bundle, the runtime and the timeout with InertiaConfig::ssr, ssr_bundle_path, ssr_runtime and ssr_timeout. The CLI's manifest names the framework crate for its tests only, as in 3.2.1, since the application binary already has these commands (CM-01, CM-02, CM-03).

  • The starter kits declare @inertiajs/core and read root through the generated types. In 3.2.1 a kit reached @inertiajs/core only because its adapter depends on it and npm hoists it, and no page had a root prop. Each kit's package.json now declares @inertiajs/core at ^3.8.0 beside its adapter, the generated inertia-props.ts augments that package, and every kit page that builds URLs from root reads it with a bare usePage(), typed by the augmentation. The Error page keeps its inline props, since no handler renders it with a struct. A project upgrading with its own declare module '@inertiajs/core' block, in a .ts, .tsx, .mts or .cts file under frontend/src such as global.d.ts, keeps it: generate-types and serve then write inertia-props.ts without the augmentation or its import '@inertiajs/core' and print a notice naming that file (serve once, not on every save), since two augmentations merge key by key and fail the type check on any key they set to different types. Delete the hand-written block and regenerate to get the generated augmentation, with root and the shared struct typed (T06).

  • TestResponse::assert_inertia() reads a first visit. It refused any response without X-Inertia: true, so the HTML document a plain GET of a page route returns could only be asserted through AssertableInertia::from_response on an HttpResponse. It now reads the page from the document's data-page element as well, and assert_inertia_with(callback) runs a callback over the page and returns the response for chaining, as Laravel's assertInertia(fn) does. Both entry points find that element by its type="application/json" and data-page attributes in either order, with others between them or in single quotes, and skip the text of any other script. They looked for <script type="application/json" data-page=" only, so the document of a server-rendered first visit, which Inertia 3.8's buildSSRBody writes as <script data-page="app" type="application/json">, failed with "no Inertia page object" (TS-01).

  • An image wildcard leaves SVG out. A MimeType allowlist takes type/* wildcards, new in 4.0.0, and a wildcard admits every subtype of its type except image/svg+xml, since an SVG document is markup that can run script, as Laravel's image rule leaves SVG out unless asked. An SVG passes only when the allowlist names image/svg+xml, as in 3.2.1, whose entries matched the type exactly. text/* and application/* admit every subtype.

  • has and its kin read a polymorphic owner relation. On a MorphTo, has, or_has, has_count, doesnt_have and or_doesnt_have rendered a probe that is always false, so has matched no row and doesnt_have matched every row. They now ask every owner type the relation declares, as Laravel's has routes a MorphTo to hasMorph($relation, ['*']): a row has its owner when its type names a declared owner whose table holds its key under that owner's scopes, and doesnt_have keeps every other row, a null type or a type no owner answers to included. has_count compares the owner count, 0 or 1, with =, <>, !=, <, <=, > or >= and refuses any other operator. where_has::<R, _>, where_doesnt_have and their or_ forms apply the closure to the owners of R's type, as where_has_morph with that one type does.

  • url::current is the absolute URL without the query. It returned the path and the query, such as /posts?page=2, where Laravel's current() returns the APP_URL origin, the root and the path. It now does the same; use url::full for the URL with its query. The framework's own redirects, the session's previous URL and signature verification still read the path and the query.

  • Redirect::guest stores a page to come back to. It stored the request's own URL for every request, so a sign-in after a POST or a JSON call sent the browser back to a form submission or an API response. It now stores the request's own URL only for a GET that does not expect JSON, and the session's previous URL for any other request. It never reads the Referer.

  • Errors are reported through Exceptions. A 5xx response, every failed attempt of a queued job, and a console command that returns an error now run your reportable callbacks before the framework error log line; a console command's error is logged as well as printed.

  • The frame that created an error shows where. In a build without debug info, the development error page gives the innermost application frame the error's creation site as its location.

  • The numeric max message. #[validate(range(max = 10))] reads must not be greater than 10, Laravel's wording; a string's length(max = ...) keeps its message.

  • ImageFile accepts Laravel's image types. It accepts JPEG, PNG, GIF, BMP, WebP, AVIF, HEIC and HEIF and refuses every other type, TIFF, PSD, ICO and JPEG XL included; an SVG passes only a MimeType allowlist that names it.

  • Generated middleware passes the request on. make:middleware writes a handle that returns next(request).await, as Laravel's stub does, in place of a body that printed request timing.

  • CSRF checks every method but GET, HEAD and OPTIONS. CsrfMiddleware now checks QUERY and extension methods such as PROPFIND as it checks POST; a QUERY request without a token gets 419.

  • Regenerating the session issues a new CSRF token. regenerate_session_id() sets a new CSRF token beside the new id, so a token read before the regeneration gets 419 after it.

  • Request::ajax() compares exactly. It is true only for X-Requested-With: XMLHttpRequest, not for another spelling.

  • Request::host() reads the host as Symfony does. It lowercases the host, strips only a numeric port, and returns None for a host with a character no host has, so http_host(), scheme_and_http_host() and url() never carry such a host.

  • Deletion cookies follow the session configuration. Cookie::forget, without_cookie and without_cookies take Path, Domain and SameSite from SESSION_PATH, SESSION_DOMAIN and SESSION_SAME_SITE, so the deletion cookie matches the cookie it deletes; an explicit path or domain given to Cookie::forget_with still wins.

  • Denial codes survive authorize. GateResponse::authorize returns FrameworkError::Denial for a denial built with with_code, and FrameworkError::code() reads the code after ?; a denial without a code maps as before.

  • Rate-limiter keys are cleaned as Laravel cleans them. RateLimiter::clean_rate_limiter_key, and every counter method through it, applies PHP's htmlentities before it strips entity markers, so café and cafe count in one bucket and a&b is stored as aab.

  • Named limiters rename shared keys. RateLimiter::limiter returns a callback that gives each limit sharing a key with another limit of the same result its fallback key, and throttle:<name> counts each limit under <name>:<key> from that result, so the middleware and a direct caller read the same buckets.

  • One rate-limit header pair. The throttle middleware writes one X-RateLimit-Limit and X-RateLimit-Remaining pair, the limit with the fewest attempts left, and none when the handler's response already carries an equal or lower X-RateLimit-Remaining.

  • Refused requests are not counted. A request the throttle middleware refuses leaves every bucket's count where it was; the decision still uses the atomic post-increment count.

  • throttle:60,1 counts signed-in users by user. The inline throttle keys a signed-in user by the user's identifier and a guest by address, each per path, so one user cannot buy a fresh budget from another address.

  • The verified gate answers each request. EnsureEmailVerifiedMiddleware::redirect_to answers a request that expects JSON with 403 Your email address is not verified., and sends any other request through Redirect::guest, so the intended URL is stored and Redirect::intended returns the user after verification. new() still answers 403 to every caller.

  • Verification refusals tell the two cases apart. EmailVerification::verify answers 403 This action is unauthorized. for a live link of another account or one mailed to an address the account no longer has, and keeps 400 for an unknown, expired or used token.

  • Verifying a verified account keeps its time. verify consumes the token and returns the user ID without a new stamp and without EmailVerified.

  • Checking a password writes nothing. validate_credentials on EloquentUserProvider and DatabaseUserProvider verifies the password and writes nothing, as in 3.2.1, so Auth::validate and a guard's validate leave the hash as it is. The sign-in (attempt, once and Auth::logout_other_devices) rewrites an outdated hash, the one a database shared with Laravel needs included, through UserProvider::rehash_password_if_required, and a rewrite that fails fails the sign-in.

  • One attachment per name and bytes. A message drops an attachment whose name and bytes equal an earlier one's, from the mailable's attachments() or the builder, on the send and the queued path; two attachments with one name and different bytes are both sent.

  • Notification mail without a subject. An empty MailRendering subject is sent as the notification's name in title case (InvoicePaid gives Invoice Paid) instead of empty.

  • Unique queued listeners take the lock. A QueuedListener whose job declares unique_id pushes through Queue::push_unique, so a second event while the lock is held pushes nothing and dispatches UniqueJobSkipped.

  • The after-commit decision follows an order. A push waits for the commit by the first of its own override, the job's after_commit_choice, the connection's setting and QUEUE_AFTER_COMMIT, for push, push_unique and bulk alike, instead of the job's after_commit or QUEUE_AFTER_COMMIT.

  • down prints Laravel's lines. It prints Maintenance mode options updated. when the application was already down, the bypass address as You may bypass maintenance mode via [<APP_URL>/<secret>]., and Failed to enter maintenance mode: <error>. on a failure.

  • Single-server tasks need a cache store. A schedule with an on_one_server() task and no cache store bound refuses to start in every environment, and a tick with no store skips the task with an error log instead of running it on every server.

  • Day helpers keep the schedule. days, weekdays, weekends and sundays to saturdays replace only the day-of-week field after a frequency, time or cron call, so .hourly().mondays() is 0 * * * 1; alone they still run at midnight.

  • Hour-only and seconds times. at, try_at, daily_at and try_daily_at read 9 as 09:00 and 09:30:00 as 09:30.

  • migrate:status prints its list. It writes one line per migration with Applied or Pending to the standard output, where it wrote them to the log.

  • make_directory takes a path without its trailing slash. make_directory("a/b") creates the directory as "a/b/" does; it used to fail on every disk. An empty path and a path that ends in / reach the backend unchanged.

  • No image driver receives a zero side. Image::resize, cover, resize_width and resize_height record a side of 0 as 1, as Laravel clamps it; the magick driver failed on the 0x0 geometry.

  • ImagePipeline carries the settings of its custom steps. The new settings field holds what Image::transform_with recorded, and a custom driver runs a custom step with CustomTransformation::apply_with(pixels, &pipeline.settings). A struct literal of ImagePipeline ends with ..ImagePipeline::default() or names the field.

  • A started fake process reveals its output a line at a time. Each output() or latest_output() call reveals the next line, output() answering every line so far and latest_output() the new one; the error output works the same way, and wait() still returns the whole output.

  • The HTTP fake records a request as it is sent. The recorded headers include the Content-Type a JSON, form or multipart body sets, the user agent, and the headers global middleware adds, and the recorded URL has its base URL, URL parameters and query applied.

  • Development pages load an existing build when no hot file exists. In development the Vite tags point at the dev server only while the hot file exists, and at the manifest's files while it does not and a manifest exists. A frontend that declares no @inertiajs/vite and holds a manifest from an earlier build now loads that build instead of the dev server: declare @inertiajs/vite, as every starter kit does, or delete the stale build.

  • Database rules in hooks follow the Precognition selection. AsyncRule::check_async, Exists::check_value and Exists::check_each (selected under <field>.*) skip a field a precognitive request did not list, so they neither query nor fail; errors a hook adds stay unfiltered.

  • The CSRF field turns autocomplete off. csrf_field() renders autocomplete="off", so a browser does not restore a stale token into it.

  • A default middleware priority. The priority list starts as Precognitive, SessionMiddleware, AuthMiddleware and ThrottleRequestsMiddleware, so a route that lists AuthMiddleware before SessionMiddleware loads the session first, and a route-listed Precognitive runs before a global SessionMiddleware.

  • lang/vendor is not a locale. The translator skips it as a locale directory; it holds overrides of namespaced catalogs.

  • #[service(impl = ...)] parses. The named form beginning with impl was refused as a keyword; it now registers the implementation.

  • An unset APP_ENV is production. A deployment that sets no APP_ENV now runs every production check: debug is off, APP_KEY is required, the SQLite fallback, a mail driver that delivers nothing, plaintext SMTP, the in-memory rate limiter, an unknown queue driver and the mock payment provider are refused, the Inertia shell needs its Vite manifest, on_one_server tasks need a shared cache, and db:seed, migrate:fresh and suprnova migrate:fresh ask for --force. No .env.<environment> file loads for an unset APP_ENV; .env.local still does. Set APP_ENV=local (the scaffold's .env does) to keep the old behaviour.

  • CacheConfig gained connection and lock_connection. A CacheConfig struct literal names both fields, or spreads ..CacheConfig::default().

  • The Redis cache moves to the cache connection and CACHE_PREFIX. The store runs on the cache connection's database (REDIS_CACHE_DB, 1 by default) and its keys are REDIS_PREFIX, then CACHE_PREFIX (the slug of APP_NAME and -cache-), then the key; REDIS_PREFIX no longer names the cache prefix, and Cache::flush deletes only keys under both prefixes. An upgraded deployment finds its Redis cache empty; REDIS_CACHE_CONNECTION=default, an empty REDIS_PREFIX and CACHE_PREFIX set to the old prefix (suprnova_cache: by default) keep the old keys.

  • MySQL tables default to utf8mb4_unicode_ci. Tables created before the upgrade keep the server's default collation, and MySQL refuses to compare string columns of two collations; an application whose tables use the server's default keeps it by setting DB_COLLATION to that collation (utf8mb4_0900_ai_ci on MySQL 8).

  • File and stream log channels keep LOG_LEVEL's bare level. single, daily, monthly, stderr, errorlog and syslog keep only records at or above it, debug when it names none, and a bare level that is no level fails the boot.

  • queue::testing::pushed::<J>() fails on a payload that does not decode. It panics, naming the job and the decode error, where 3.2.1 left the push out of the list, so neither the list, assert_pushed nor the new assert_not_pushed passes over a push it cannot read.

  • Queue::reserved_jobs under Queue::fake() answers the fake. It lists the reservations workers made from the fake instead of reading the installed driver.

  • The server caps concurrent connections at 10000 by default. In 3.2.1 an unset or blank SERVER_MAX_CONNECTIONS left the number of concurrent connections unbounded, so a crowd of slow clients could use up the process's file descriptors. An unset or blank value now caps them at 10000, the new suprnova::config::providers::DEFAULT_MAX_CONNECTIONS, and ServerConfig::builder() and Server::new start from the same cap. Zero or a value that does not parse still falls back to 10000 with a warning, and an explicit positive value is the cap. No value of the variable removes the cap: a server with no cap is a choice made in code, with ServerConfig::builder().unbounded_connections(). A deployment that holds more than 10000 connections at once sets SERVER_MAX_CONNECTIONS to its figure.

  • Zero tries is unlimited. In 3.2.1 a job whose Job::max_tries() returned 0, or a push whose EnvelopeOverrides::max_tries was Some(0), reached the worker with no attempt to spend and was dead-lettered before it ran. Zero now means unlimited, as Laravel's $tries = 0 and the worker's --tries=0 do: the envelope of a pushed, batched or chained job and of a queued notification carries u32::MAX, so the job is retried until it succeeds and is never dead-lettered for running out of attempts. An error named with dont_retry or dont_retry_when, a middleware such as FailOnException, a timeout under fail_on_timeout and a worker started with --tries still end it.

Fixed

  • The full-stack Dockerfile copies the localization catalogs. The Dockerfile docker:init writes for a Svelte, React or Vue project copies lang/ into the runtime image, which 3.2.1's left out, so Localization::bootstrap finds the catalogs the pages' lang share and __! lookups read.

  • The Laravel parity map holds the Inertia adapter and client. feature-map/laravel/surface.jsonl held laravel/framework alone, so no Inertia protocol row (HD-01, MW-06, RF-16 and the rest) could name its Laravel side, and the row ids in these notes were the only link between a row and what shipped. The map now also holds inertia-laravel 3.5.1, read through the same PHP reflection, and Inertia.js 3.8.0, read with TypeScript's parser: classes, facade methods, macros, Blade directives, config keys, every package export and each X-Inertia* header the client sends or reads, each record tagged with its package. The rows' parity decisions are in feature-map/laravel/inertia-protocol-parity.jsonl for fmap parity-import.

  • The error callback sees the error responses from outside the Inertia stack. In 3.2.1, InertiaConfig::error_page decided only what passed through the error-response middleware Inertia::install registers. A middleware registered before install that answers without calling next - CsrfMiddleware's 419, TimeoutMiddleware's 503, an outer rate limiter's 429 - and a panic that only the server's boundary caught never reached it, so an Inertia visit got the plain-JSON modal for them. The server now runs the same decision after the whole stack, the panic boundary and the development error page, for every error response nothing inside the stack decided, at each of the three places it dispatches a request. A page decided there carries the shared registry and the shared providers, but no session data, no detected locale and none of the middleware hooks' shares, since every scope a middleware opened has closed. A JSON client's validation 422, {message, errors}, was also kept from it: the error-response middleware sat inside the validation redirect and skipped every 422 with an errors object so it would not replace an Inertia visit's before the redirect back. It now sits outside the redirect, which turns an Inertia visit's 422 into the 303 first, and the 422 exclusion is gone; the default callback still keeps every 422.

  • An error page placed outside the Inertia stack follows a fragment redirect. In 3.2.1, with error_page set, InertiaErrorPageMiddleware passed a response carrying X-Inertia-Location through but not one carrying X-Inertia-Redirect: it read the empty body of the 409 that InertiaResponse::redirect builds as an error and sent the error page in its place, so the client never followed the redirect. In 4.0.0 that 409 also carries an Inertia visit's redirect to a #fragment. Inertia protocol responses (X-Inertia, X-Inertia-Location, X-Inertia-Redirect) are never handed to an error callback now, the default one included, wherever the middleware is registered.

  • A drop-in Inertia form with a file, and a GET filter form, read as the client shapes them. The Inertia client sends a form that holds a file as multipart/form-data under bracketed and indexed names (user[name], photos[0]), and a GET visit's data as filters[status]=x&tags[]=a. A form request answered 415 for the multipart body, and every reader matched names literally, so filters[status]=x arrived as one literal key and a field declared as user.name read nothing. Bracketed and indexed names in a url-encoded body, a multipart body and a query string now decode into nested data as PHP's parse_str reads them: objects, lists in index order, up to 64 levels deep. A form request and Request::input read a multipart body, an UploadedFile field takes a part that carries a file and runs its validators, and a field that fails is named by its dotted path (user.name, photos.1). A multipart body stays under the form request's max_body_bytes (8 MiB by default) and the multipart part ceiling (1,000 parts). A multipart body a middleware read first, as a body-keyed rate limit does, is parsed from the buffer where the reader answered 400 naming a framework bug.

  • JPEGs from the built-in driver show the right colours everywhere. The oxideav driver wrote RGB samples behind a JFIF header, so libjpeg-based decoders, ImageMagick and most browsers among them, showed the wrong colours. It now writes standard JFIF YCbCr.

  • Redirects stay on the origin for a request-target that names another host. Redirect::refresh_for, Redirect::guest and Redirect::intended no longer send the browser elsewhere when a request such as GET //evil.example/x or GET /\evil.example reaches a fallback route, and url::full stays on the APP_URL origin for it.

  • Images are no longer copied on their way through a driver. Image::from_bytes hands the driver the caller's bytes, the built-in driver writes PNG and BMP from the pixels it holds, without the copies the codec registry's encoders made of every frame, and returns the buffer its encoder writes instead of a copy of it (when metadata needs more room than the encoder left, that buffer grows once), and the magick driver writes an image to ImageMagick's standard input without copying it first and adds the metadata a source keeps (PNG colour chunks, an orientation tag) to ImageMagick's output without copying that either. An ICC profile split across a JPEG's or GIF's segments is read for its header and length where it stands, and joined once, only when the output carries it or converts from it; a WebP's or BMP's profile is carried without a copy, and a profile is written into the output once. IMAGE_MAX_ALLOC_BYTES charges a profile for what is held: every inflate of a PNG's profile at its declared size, a check of its length included, the compressed copy PNG output makes, and the output's copy, but nothing for a profile that is dropped or lent without being inflated; a refusal names what it charged. Between two magick runs an RGB profile goes on as the chunk ImageMagick wrote.

  • Queue and failed-job table names with capitals or reserved words work. The jobs driver and the failed-jobs store quote each part of the configured table name, as the migrations do.

  • generate-types reads {post:slug} as the parameter post and no longer takes a leading bound argument for the form request.

  • The Inertia CRUD tutorial compiles: its inertia_response! calls pass the request, and its handlers bind Todo.

  • Live upload and async routes follow the configured endpoint, and the header bar's default brand link carries the root.

  • Batch settlement counts work on MySQL against a job_batches table Laravel created: job_batch_settlements, new in 4.0.0, takes that table's collation, so a count never compares two collations.

  • On Postgres, a session write for a guest binds sessions.user_id as a NULL that the bigint or uuid column of Laravel's sessions layout, new in 4.0.0, accepts.

  • A component's scripts import by relative path only. The live:add scan refuses a static import of an absolute path such as /acme-ui/x/x.js, even to the component's own script, as it refuses a URL (script-import), since an absolute path breaks when the application serves under a path prefix. The refusal says the specifier must be a relative path (./ or ../) to a script of the component or of a component it depends on. A relative path with one ../ more than the component is deep (../../../acme-ui/x/x.js from acme-ui/x/) is refused for the same reason: the browser resolves it outside the prefix.

  • A component's script can no longer reach a built-in prototype through a computed key or a name. The live:add scan refuses Array.prototype.map = ..., and also Array["prototype"].polluted = 1 and const p = Array.prototype; p.polluted = 1;, each of which adds a property to every array on the page. A script may read a member of a prototype (Array.prototype.slice.call(list)) but not keep or pass on the prototype: the scan refuses it in every position where it is a value (an initializer, an assignment, an argument, a return, an array or object element, a default, a template substitution), under a computed key that traces to prototype, and from getPrototypeOf (script-prototype). A write to a prototype's member is refused in every form (=, ??=, +=, ++, a destructuring or for loop target, delete), as is a method called on the prototype itself (Array.prototype.push(1)), which runs with the prototype as this, and destructuring prototype out of an object (const { prototype: p } = Array). Twelve bypass fixtures pin it: script-prototype-computed, script-prototype-template-key, script-prototype-alias, script-prototype-argument, script-prototype-getprototypeof, script-prototype-parameter, script-prototype-destructured, script-prototype-compound, script-prototype-destructuring-target, script-prototype-delete, script-prototype-receiver and script-prototype-destructured-key.

  • A destructuring assignment's defaults, nested keys and shorthand targets are scanned. The live:add script scan walks every key and default of a destructuring target at any depth, as it walks any value, so eval, a prototype or any other refused expression is refused in the default of [a = eval("alert(1)")] = [] or ({ a = ... } = {}) and in the keys of a nested target, and a nested or shorthand key gets the property checks a top-level key gets (({ constructor } = []) is refused as script-eval). A shorthand target (u in ({ u } = o)) is a target like any other: after it the scan does not trace u to the constant it held before, since the name holds a value the scan does not follow, and a name the script does not declare is a global write, so ({ location } = { location: "javascript:alert(1)" }) is refused (script-url for location, script-global otherwise). Four bypass fixtures pin it: script-destructuring-default-eval, script-prototype-assignment-default, script-destructuring-shorthand-url and script-destructuring-shorthand-global.

  • The script scan follows a value by the names it was written with. To check a URL, a timer handler or a computed key, the live:add scan follows a name to its initializer, its assignments and the arguments of its function's calls, and each name in a followed value names the binding it had where it is written, not a name that shadows it where the value is used. So const y = "https://evil.example/x"; const x = y; followed by function show() { const y = "/ok"; img.src = x; } is refused (script-url), a timer cannot be handed a string that way, and a constant shadowed by a remote URL where it is used is not refused. The script-trace-shadowed-initializer fixture pins it.

  • The script scan sees the global object through an expression. The live:add scan refuses window.localStorage, a global it does not admit, and its rules about the global object's members see through a sequence's last expression, a conditional's branches, a logical expression's sides and an assignment's value. So (0, window).localStorage, (0, self)["localStorage"] and (0, globalThis).fetch = f, which would replace a browser API, are refused as the bare form is (script-global), and (flag ? window : self).localStorage and (w || globalThis).localStorage name localStorage in their refusal. A write through such an expression does not make a global of the script's own. The script-global-sequence fixture pins it.

  • Writing a browser global no longer unlocks reading it. A name a script writes on the global object does not become a global of its own that it could read back. So try { window.localStorage = 1 } catch {}, whose write throws into a catch that swallows it, does not make window.localStorage readable: the read, which would return the browser's storage, stays refused, and the live:add scan refuses the write too. The script-global-write-unlocks-read fixture pins it.

  • Magnetar's API documentation builds without the two-factor feature. The doc comments on LockoutFields::IDENTITY_IS_EMAIL and LockoutService::without_user_lock linked two_factor::lockout_identity, which exists only with that feature, so rustdoc failed on two broken links under Magnetar's default features. They now name it as text, with the feature that provides it.

  • API documentation writes ranges in words. The docs of PhoneNumber::new, PaymentMethod::Card's exp_month, Batch::progress and SseEvent::keep_alive wrote their ranges with an en dash; they now read "8 to 15", "1 to 12", "0 to 100" and "15 to 30 seconds".

  • A prop holding <!--<script> no longer breaks the first Inertia page. The first visit's page JSON escaped / but left < and > raw inside its <script> element, so a prop such as <!--<script> put the HTML tokenizer into its escaped script state: the real </script> no longer closed the element, the mount element <div id="app"> became script text, and jsdom found no #app and a page JSON it could not parse. < and > are now written as \u003c and \u003e beside the / escaping, in the same single buffer, as Laravel's JSON_HEX_TAG and Inertia 3.7.1 do (JE-01, H02).

  • An Inertia page that cannot be encoded answers an error. A failure to encode the page object answered 200 with {} as the page, as JSON for an Inertia visit and inside the first visit's document, so the client mounted an empty page. It now answers 500 through FrameworkError, as Laravel's JsonResponse throws (JE-03). Encoding a serde_json::Value page does not fail today, so this closes a path rather than one seen in use.

  • An empty SSR answer renders on the client. A worker answer of {}, or an object without a body, was inlined as an empty body, so the first visit's document had neither the page data element nor the mount element and the client could not start. An answer whose JSON is empty, null, false or not an object, that has no non-empty body string, or that is not JSON at all, now renders on the client from the page data, as Laravel returns null for it, and is not reported as a failure (SS-02).

  • SSR workers at https URLs are reached. The SSR client was hyper's plain-HTTP connector, which refused an https URL, so a worker behind TLS was never contacted and every first visit fell back to the client. The client now speaks TLS through rustls, the stack the HTTP client facade uses, and keeps the 5 second whole-call timeout over headers and body, the 8 MiB response cap and the refusal of an oversized Content-Length (SS-14).

  • DevTools redacts a flattened key by its parts. A multipart field keeps its flat name, so user[password]=hunter2 is stored under that name, and a dotted prop path such as auth.password keeps its own propValues leaf beside the nested page value. A key is sensitive when the whole name, or any part of it split on [, ] and ., names a redaction key, at any depth of the entry and in query parameter names alike, so both values are redacted; a longer word such as passwords is kept (DT-07, DT-08).

  • DevTools redacts the URLs in headers and bodies. The query of every string that is a URL (it holds a ? and starts with a scheme, / or ?) is redacted wherever the entry holds it, not only under a url or redirectLocation key, so a response's Location: /reset?token=abc and X-Inertia-Location, a request's Referer, and a redirect_to field carrying ?token= never reach the entry file as sent. In both header bags so is the whole value of Location, X-Inertia-Location, Referer and Content-Location, each <...> target of a Link and the target of a Refresh; a header that is not a URL is stored as sent (DT-07, DT-08).

  • A lost DevTools index no longer drops the entries it listed. The index, _meta.json, is rebuilt from the entry files whenever it is missing, empty or not a JSON list, before a rewrite as well as a read, so the older entry files stay in the list and under the 24-hour prune and the per-tab limit. Each rewrite writes a new file and renames it over _meta.json under a lock on _meta.lock, so an interruption leaves the previous index in place, never an empty one (DT-07, DT-08).

  • A commented-out augmentation no longer hides the generated one. generate-types and serve read a project's files as TypeScript tokens when they look for its own declare module '@inertiajs/core', with // and /* */ comments and the text of '...', "..." and template literals set aside, so only a declaration in code counts. A frontend/src/global.d.ts holding only // declare module '@inertiajs/core' {} keeps the generated augmentation and its import, and a comment between declare, module and the name hides no real one (T02).

  • A DevTools entry and Request::route_name name the route that matched by its method. The router kept one process-wide table from name to pattern, and a request's name was looked up by its pattern alone, so GET /users named users.index and POST /users named users.store both reported whichever name the table listed first, and an unnamed PUT /users reported one of them too. The router now records each name against the method and pattern it was given for, through .name(..), a route group's names and a resource's names, and the server sets the matched route's name on the request, so each method reports its own and an unnamed one reports none. A request that never went through dispatch still falls back to the pattern lookup (DT-04). MatchedRoute::name, which a Router::bind resolver reads, reports the name the request carries too.

  • A hook-shared prop names a file and line. InertiaConfig::hooks takes its caller's location through #[track_caller], and every key the middleware hooks' share supplies names that call's file and line as its shareSource, a place the extension can open (DT-03).

  • A page whose document fails is recorded as the error the client got. The render hands DevTools its page only once the response is built, after the JSON encoding, the SSR dispatch and the root template. When any of those steps fails, the entry records the 500 the client got and its body as a response with no page, no component and no prop values, never the page object or propValues the client did not receive (DT-03, DT-04).

  • Every render prop has a renderSource. A render prop's source is the line below the render call that names its key. When no such line exists, as for a page rendered with InertiaResponse::new("Home").with_data(props) whose struct is defined in another file, or in a deployment without its Rust sources, the prop names the render call's own file and line (DT-03).

  • DevTools reads a request body as the handler would. The recorder reads a request body up to the request body cap (8 MiB by default), with or without a declared length, so a long or chunked body is recorded; PAR-072 allows an omission for the response body only. A body over the cap records too-large and reaches the handler whole: unread when its length is declared, else as the bytes read and the rest of the stream, the new BodyState::Partial. A failed read records unreadable and leaves its error in the new BodyState::Failed, which the handler meets only when it reads the body (DT-02, DT-10).

  • A DevTools JSON request body is recorded whatever it parses to. A parsed JSON body is present in the entry whatever its value, {}, [] and null included, one that does not parse is kept as its text, and only a body of 0 bytes is empty (DT-02).

  • DevTools no longer reads an upload before its authorization. The recorder does not read a multipart body itself: the multipart extractor hands DevTools a summary of what it parsed, after MultipartRequestHooks::authorize has passed the upload. An upload no extractor read records not-read, and one whose parse failed, such as one without its closing boundary, records unparsed, both with the declared length as size; the raw text, which redaction does not look into, is never stored. A name sent more than once, or one that ends in [], is the list of its parts, so all three files of a photos[] field are recorded (DT-02, DT-10).

  • The DevTools id tag finds a closing body tag in any case. The tag goes before the closing body tag, found in any case and with space before its >, so a first visit whose root template closes with </BODY> or </Body > carries it, and a document with none gets the tag at its end (DT-02).

  • A tagged first visit no longer carries the untagged page's length. A Content-Length the handler set on its page is dropped when the tag is added, and the server sends the tagged document's length, since the untagged length on the longer document breaks the HTTP/1 framing in a release build and fails hyper's assertion in a debug build (DT-02, DT-10).

  • A console command whose boot fails is reported. A failure before the handler runs reaches Exceptions::report: a bootstrap that panics, as DB::init().await.expect(..) panics when the database does not answer, and a framework boot that returns an error, such as a log channel nothing defines. The console dispatcher and the application binary's commands catch a panic in the bootstrap, report the failure, so the callbacks the bootstrap registered before it failed see it, and then print it and stop the supervisors, as Laravel's console kernel reports a failure of its bootstrap. The application binary's commands report their own errors as the console's do; a silent error is not reported (PAR-111).

  • schedule:interrupt boots the cache it writes its mark to. The command, new in 4.0.0, boots the store CACHE_DRIVER names, after the MongoDB connections with database-mongodb, and keeps a store the bootstrap bound, so it writes its mark in a real process whose bootstrap binds no store (PAR-089).

  • A queue driver installed in the bootstrap survives the boot. The server and the worker commands ran queue::bootstrap_from_env after the application's bootstrap, and it replaced the driver Queue::set_driver had installed with the one QUEUE_DRIVER names, so the manual's failover example did not hold. bootstrap_from_env now keeps a driver the application installed and does not read QUEUE_DRIVER then; it still registers the QUEUE_CONNECTIONS entries beside it, and still replaces a driver an earlier call installed. A test that boots the queue from the environment empties the slot first with the new queue::testing::forget_driver (PAR-017).

  • Every Live engine type a public signature names is named through suprnova. live::testing::request_cancellation_for_test returned the Live engine's cancellation flag, AdjustableTestClock implemented the engine's clock trait with its clock error, and StitchSlotDescriptor, LiveNestedSegment::into_segment, the RenderCache stores, lease stores and instance record stores named engine types suprnova did not re-export, so an application could not write those types down. suprnova::live now re-exports Clock, ClockError, ClockErrorKind, CancellationFlag, BuildId, ComponentName, ContentDigest, IslandSlot, RouteIdentity, DocumentMountKey and MountedDocumentPath, and suprnova::live::ledger the instance record store contract (InstanceRecordStore, InstanceRecordKey, PromotionRecordKey, StoredRecord, CasOutcome, LedgerError, LedgerErrorKind). suprnova::render_cache re-exports RenderCacheError, RenderCacheErrorKind, RenderKey, Segment, ShellIsland, SlotFailurePolicy, AuthorizationConsult, GenerationLedger, GenerationSet, LeaseStore and LeaseAttempt, and suprnova::render_cache::store the L1 store contract (RenderStore, PublicationFence, PublishOutcome, StoreInspection, StoredEntry).

  • The Inertia DevTools gate's GateEvaluated event names the signed-in user. The DevTools entry endpoints check their gate with the user as Gate::inspect_current and #[authorize] do, so the event carries the user's own type name and identifier, for a user type that registered no gate or hook too.

  • where_relation on a MorphTo relation matches the owners. where_relation, where_relation_op and or_where_relation on a polymorphic owner relation built the generic probe, which has no table to read, so they matched no row. They now go through the morph engine, as has and where_has do: the condition runs against every owner type the relation declares, under each owner's own scopes, as Laravel's whereRelation reaches hasMorph through whereHas (PAR-121).

  • cursor_paginate keeps the query's order. It replaced every ordering with the primary key, ascending, so a newest-first query such as latest() came back oldest first. Every ordering is now kept and carried in the cursor: a descending order walks downward, the primary key breaks ties, and a query with no order still walks the primary key ascending. An ordering the cursor cannot carry, such as order_by_raw alone, fails with a 400 error instead of being dropped, and so does an ordering on a joined table's column, such as owners.id. In a joined query the primary key that breaks ties names the model's table, and the query quotes the columns it orders by, as it quotes its other references to the model's table, so an ordering on a table whose name has capitals works on Postgres (PAR-080).

  • #[model(timestamps = true)] without the columns fails the build. An explicit timestamps = true, or the bare timestamps flag, on a struct with neither created_at nor updated_at was accepted and managed no timestamps. It is now a compile error that names both columns, as #[suprnova::document] reports it. The default and timestamps = false compile as before (PAR-183).

  • An Inertia visit the fallback route answers records the previous URL. An Inertia GET the fallback answered left the session's previous URL where it was, where Laravel's shouldStoreCurrentUrl reads a fallback route as a matched route. The fallback route's request now carries a fallback mark, Request::is_fallback_route, which the Inertia middleware reads beside the route pattern when it records a visit; the request still has no route pattern and no route name, so RenderCache, the debug page and DevTools see no routed match (PAR-048).

  • Request::full_url and url::full normalise their query as Laravel's fullUrl does. They returned the query as it arrived, where Laravel's fullUrl() and url()->full() sort the pairs by key and re-encode them per RFC 3986 through Symfony's normalizeQueryString: /s?b=2&a=1 is now /s?a=1&b=2, and a query that normalises to nothing leaves no ?. full_url_is, the SSR exclusion patterns, the InertiaVisit a hook receives and the DevTools entry URL read the normalised URL, as Laravel's do. The previous URL a page load or an Inertia visit records is normalised too, as Laravel's StartSession and Inertia storeCurrentUrl store fullUrl(), so the session holds the query as the page url and the version 409's location spell it. full_url_with_query and signed URL checks keep the query as the client sent it (PAR-056).

  • simple_paginate takes a page name, and cursor_paginate records its cursor. Builder::simple_paginate_using(page_name, per_page) reads the page from that query parameter and sets the paginator's page_name, so its URLs and the Inertia scroll metadata's pageName use it, as paginate_using does for the length-aware paginator. A cursor_paginate page keeps the cursor it was fetched with in current_cursor, which the scroll metadata reports as the current page (PAR-052).

  • A CLI built between two releases pins the framework commit it was built from. suprnova new pinned a new project's suprnova dependency at v<CLI version> even when the CLI was built from a later commit, as on main between two releases, whose templates can use API the last tag lacks, so such a scaffold could fail cargo check until the next release. The CLI's build script now records the commit it is built from and whether the tag v<version> names that commit. Only then does the scaffold pin tag = "v<version>". The script reads the tag from its own checkout, or, when the checkout has none, from an origin on the same machine, so a release installed with cargo install --git --tag pins the tag: Cargo's checkout carries no tags, and the script reads the release tag offline from Cargo's git database. An origin reached over the network is never asked. With the tag on another commit, or in a checkout with no tag information, such as a shallow clone, the scaffold pins rev = "<commit hash>", which at the release names the same source as the tag. A build where git cannot answer pins the tag. templates::framework_pin returns the choice, and templates::cargo_toml_pinned and templates::api::cargo_toml_pinned render a manifest with a pin you give.

  • What the script scan learns from member writes does not depend on statement order. A member a class writes on this is the instance's own, a name a script writes on an object of its own may be its method rather than a browser API's, and a write on the global object (window[key] = value) is refused under the name its key traces to. The live:add scan settles those names after its first walk has met every name and every call, so a computed key's name, a name the script defines further on and a function's later calls count wherever they stand: a script is admitted or refused in any statement order, and a read of a global name nothing wrote is refused. eval, Worker and every other property refused by name are refused in any order.

  • The script scan refuses every write to a member of the global object. As REG-032 requires, the live:add scan refuses a write to a member of the global object, or of the window window.open returns (script-global), whatever the name, in every form of write, delete included, so a component cannot overwrite a name the application or the Live runtime keeps on window. That covers a capitalised name the browser does not define (window.AcmeState = {}, globalThis["Acme" + "State"] = 1), which does not become a global of the script's own, names the scan's lists do not hold (window.onload = f, window.name = "x") and delete window.fetch, and a later read of the name is refused as a read of any global the scan does not admit is. A component keeps its state in its module scope. The shipped combobox no longer writes globalThis.SuprnovaCombobox: its script's function returns the stale-suppression decisions, and the fixture that evaluates the file takes them from the script's completion value.

  • #[derive(MultipartRequest)] reads indexed and bracketed part names. The derive matched a part's name to #[field(...)] letter for letter, so the Inertia client's photos[0] and photos[1] never reached a #[field("photos[]")] list and user[name] never reached a field. A part now goes to the field its name addresses, read as a form request reads it (PAR-055): photos[0] and photos[] fill the list declared as photos[] or photos, in index order, and user[name] fills the field declared as user.name. A name sent exactly as declared still matches. A failure is named by the index the part was sent under (photos.3), and max_count and the file checks that run while the body streams apply to every part the field takes, whatever name it was sent under. Parts are read in the order they were sent, as PHP reads them: a later part sent under a parent name, such as user or a bare photos, replaces what user.name or photos[] held, and a later user[name][first] or photos[0][caption] makes user.name or that element an array, which fails as the wrong kind of value.

  • suprnova generate-types pairs a page built with the builder. In 3.2.1 generate-types wrote no Pages map, and a field a handler deferred or marked optional was written as required, though the first response leaves it out (PAR-068). The component named in the first call of a chain (InertiaResponse::new, Inertia::paginate, Inertia::data, Inertia::try_data) now pairs with the struct .with_data(..) gives anywhere in it, and a key the chain passes to .defer(..), .defer_with(..) or .optional(..) after it gives the struct is optional in the struct's interface.

  • A database session read keeps a session another request refreshed. DatabaseSessionDriver::read found a row idle past the lifetime and then deleted it by id alone, so a request that loaded and refreshed the same session between that read and the delete lost its write, and the next read found no session. The delete now matches the row only while its last_activity is still older than the lifetime, as the MongoDB driver's does; the read that saw it expired still answers no session (PAR-188).

  • The Laravel-database tests run each SQLite test on one connection. The SQLite fixture of the Laravel-database tests holds one connection. sqlx returns a released connection to the pool on a spawned task, so with more than one connection a test that awaits every statement in turn can still spread the fixture, the migrator's CREATE TABLE and a model's first write over connections the runtime chooses, and run that write on a connection other than the one that created its table. kit_scaffold_notes_belong_to_laravels_users_sqlite checks that the fixture holds one (PAR-080).

  • The Inertia facade shares a once prop. In 3.2.1 only App::inertia_share_once and InertiaRegistry::share_once registered a shared once prop, so Laravel's Inertia::shareOnce($key, fn () => ...) had no facade form (PAR-052). Inertia::share_once(key, resolver), beside the facade's share, share_many, share_data and share_provider, makes the same registration and returns the same SharedOnceProp, which takes as_key, until, fresh and once_with as any once prop does.

  • The component allowlist refuses test fakes, app-wide hooks and installs. The live:add scan of a component's Rust refuses Http::fake, Queue::fake, Mail::fake, Storage::fake, Process::fake and their siblings, Http::global_options and the global request and response middleware, Queue::set_driver, Cache::set_connection, the install of a service, and the test container and clock, whatever capability the facade's chapter grants, so a component granted network cannot rewrite every request the application makes or swap a driver for every caller (REG-030). The allowlist generator refuses them by name, and the embedded allowlist carries the refusal.

  • Every Live and Magnetar type a public signature leads to is named through suprnova. A public signature of suprnova, or of an engine item it re-exports, names only types an application can write down; 330 of them had no suprnova path. suprnova::live re-exports the 212 Live engine types those signatures lead to: the typed identities, input limits, upload inspection, finalize evidence and field policy, the host context, component hooks and child composition, snapshot schemas, model state and proposals, the update protocol, the asynchronous stream contracts and the mount failure, with the engine registry's error kind as EngineRegistryErrorKind; suprnova::live::action the action table, its dispatch and the registered emissions; suprnova::live::metadata the component, field, action, event and effect metadata; suprnova::live::validation ValidationBagError and ValidationSelection; and suprnova::render_cache the render key input and variance, Generation, QueryUnknown, ResponseSignals and the snapshot key ring. The 118 Magnetar types are re-exported under suprnova::magnetar_integration: the factor gate, sessions, schema, storage, password verifier and lockout, passkey ceremony, lifecycle event, first email proof and two-factor types, and with magnetar-oauth the OAuth ceremony, error and verified identity types, the broker error and Apple's ID token claims. The Live engine exports ValidationBagError, which ErrorBag::from_issues and ValidationMessageId::parse return.

  • Web Push refuses endpoints that resolve to private or local addresses. In 3.2.1, EndpointPolicy::Strict checked the shape of a subscription endpoint (https, a host name in place of an IP address, and a list of local and cloud metadata names) but not where the name resolved, so an endpoint whose name resolved to 127.0.0.1, a private network or a metadata service was sent to, and the transport looked the name up again when it connected, or handed it to a proxy set on the builder or named by HTTPS_PROXY, which resolved it itself. A client passed to WebPushClient::with_client sent under Strict once allow_unconfined_redirects was called. A PushServiceRejected also kept up to 8 KiB of the push service's response body, which WebPushChannel put in the error a NotificationFailed listener received. The strict policy now resolves the name and refuses the send with WebPushError::RefusedDestination when any answer is a loopback, private, link-local, multicast, unspecified, documentation, reserved or cloud metadata address; the error names the class (AddressClass), never the address, and a failed lookup returns the retryable WebPushError::Lookup. The transport WebPushClient::new and WebPushClient::with_client_builder build connects to an address that was checked, keeping the name for TLS and the Host header, and does not look the name up again; it sends through no proxy, so neither a proxy on the builder nor HTTPS_PROXY can resolve the name past the check. A strict send over a client passed to with_client, which resolves the name itself, returns the new WebPushError::UnpinnedTransport before anything is sent, until the caller accepts that by name with WebPushClient::allow_unpinned_destinations, which keeps the address check. PushServiceRejected carries the status and the Retry-After hint and no part of the body, whose first 200 bytes go to the debug log, and WebPushChannel names the status alone and logs a refused destination as a subscription that cannot be used.

  • The same-origin WebSocket policy compares the scheme. In 3.2.1, OriginPolicy::SameOrigin, the default policy of a WebSocket route, compared the Origin host and port with the Host header and ignored the scheme, so a page at http://app.example.com could open a socket on the application served at https://app.example.com. It now compares the complete origin: the Origin scheme, host and port against the request's public scheme (Request::scheme, which reads X-Forwarded-Proto and X-Forwarded-Ssl from a trusted proxy only), its host (Request::host) and its port (Request::port, or 443 for https and 80 for http). It refuses the upgrade with 403 when the public scheme cannot be determined: a trusted proxy that sends neither header or names a scheme other than http or https, or either header from a peer that is not a trusted proxy. The check reads the request the handler receives, so a malformed handshake is now answered 400 before its origin is checked.

  • The dogfood application's password reset reports success only when both revocations succeed. In 3.2.1, the dogfood application's POST /auth/password/reset called PasswordReset::complete, which discards the outcome of revoking the user's other sessions and remember-me tokens, and redirected to /?reset=ok once the password was written. It now calls PasswordReset::complete_with_outcome, as the scaffold's controller does, and redirects only when both revocations succeeded. A failed revocation is logged at error level with the user's id and answered with a 500 through the framework's error path; the password stays changed.

  • A password reset whose revocation fails queues a retry. In 3.2.1, when the provider path of PasswordReset::complete or PasswordReset::complete_with_outcome could not revoke the user's other sessions or remember-me tokens, it logged a warning, reported the error in the outcome, and nothing tried again. The reset token was spent and the password changed, so a stolen session or remember-me cookie kept working. Both now push the new RevokeUserCredentials job for the user before they return. A queue worker runs it until both stores confirm the revocations, with no bound on the tries: the first retry after about 10 seconds and each later one twice as long, up to an hour between tries, with a 60-second timeout per try. The job reaches failed_jobs only when the worker's --tries bounds it or a try returns an error that ends retries. It is idempotent, so running it again, from queue:retry or by hand, is always safe, and the framework registers it with the worker. PasswordResetOutcome has a revocation_retry field, a RevocationRetry that says whether the job was queued (Queued) or not needed (NotNeeded). When the push fails too, both return an error instead of the outcome: it says that the user's password changed, names each failed revocation with its error and the push's error, and asks for RevokeUserCredentials::new("<id>") to be queued once the queue works. The framework logs it at error level with the user's id, and that reset sends no PasswordChangedMail and dispatches no PasswordResetCompleted. An application can queue RevokeUserCredentials itself after any other credential change whose revocation failed. The dogfood application logs the queued retry with the user's id before it answers its error, and answers a failed push with its 500 too.

  • Static files and Live UI assets are read through the directory they were checked in. In 3.2.1, StaticFiles checked a request's canonical path against its root and then opened the file by name, and opened an extensionless file a second time to sniff its type; the Live UI asset routes of try_live_ui_assets() and try_live_ui_assets_for() compared canonical paths and then read the file's size and its bytes by name. Someone able to rename entries under the served directory could swap a directory for a symbolic link between the check and the open, and the server sent a file from outside the root, or a script past the 1 MiB bound. Both now walk the path one directory at a time through held directory handles, opening every entry with O_NOFOLLOW as a local disk does, and take the type, the length and the bound from the handle they read the bytes from. StaticFiles still follows a symbolic link that stays inside its root, and either root may itself be a link. A link whose relative target climbs above the root is refused even when it leads back in, and StaticFiles answers 404 for a FIFO instead of holding the request open. On a platform without openat the two servers serve nothing, since no check by name holds there.

  • The magick driver names the coder it hands ImageMagick. In 3.2.1 the magick driver named the coder only for PNG, JPEG, WebP, GIF and BMP. It handed every other input to ImageMagick on a bare -, so ImageMagick chose the coder from the upload's bytes: an MVG or MSL document ran as a script, and the host's policy.xml was the only barrier. In 4.0.0 the driver also recognises HEIC and the other HEIF images, AVIF, TIFF and BigTIFF, PSD and PSB by their leading bytes, and reads them as heic:-, avif:-, tiff:-, psd:- and psb:-. It refuses any other input before ImageMagick starts, with a 4xx FrameworkError that says the format is not one Suprnova names, in process, dimensions and dominant_color alike. Autodetection is an opt-in by name: IMAGE_MAGICK_AUTODETECT=true, held as ImageConfig::magick_autodetect, hands unrecognised input to ImageMagick on a bare - as before. The oxideav driver is unchanged.

  • A request body that stops arriving is abandoned. In 3.2.1 the server bounded only the request head (SERVER_HEADER_READ_TIMEOUT): every read of a request body waited for each piece with no deadline, so a client that sent complete headers and then sent the body a byte at a time, or stopped sending it, held its connection, and with SERVER_MAX_CONNECTIONS set a connection slot, for as long as it liked (HRD-001). Every read of a request body now waits at most SERVER_BODY_READ_TIMEOUT (default 30 seconds) for the next piece and SERVER_BODY_TOTAL_TIMEOUT (default 3600 seconds) for the whole body, counted from when the server read the request head: body_bytes, json, form, input, the form request and multipart extractors, the multipart parsers, the middleware that read a body before the handler, and a handler that reads the raw stream from Request::into_parts itself. A body that misses either deadline is abandoned: the read fails with 408 Request Timeout, and the server closes the connection after the response. A body nothing reads, such as one a handler keeps while it waits on other work, is abandoned at the total deadline and its connection closed. Every 408 response carries Connection: close. Zero or a value that does not parse falls back to the default, as for the header deadline. ServerConfig has the fields body_read_timeout and body_total_timeout, which ServerConfig::builder() and Server set. BodyState::Streaming and BodyState::Partial, which Request::into_parts returns, hold the new suprnova::http::TimedBody, the body under its deadlines, where they held hyper's Incoming, and collect_body_with_cap and collect_body take either.

  • New projects install the timeout middleware. In 3.2.1 no bootstrap suprnova new wrote installed TimeoutMiddleware, so in a new project a slow handler or a hung query held its connection until the client gave up. Every bootstrap now installs TimeoutMiddleware::default(), a 30-second ceiling on the time to a response that answers 503. The Inertia kits install it after Inertia::install and the Live kit after its error page, both after SessionMiddleware and before CsrfMiddleware, so the 503 renders as the error page in the visitor's session and locale and the deadline bounds the CSRF body read. The API kit installs it first.

  • A session or remember-me cookie from before a password change stops working. In 3.2.1, a password reset ended the user's other sessions and revoked their remember-me tokens at once, and nothing checked a session or a remember-me cookie against the password again: when the session store or the token table refused the revocation, a stolen session or cookie kept working until it expired. In 4.0.0, every sign-in issued through a user provider records the user's auth epoch: Authenticatable::auth_epoch, or, when the model returns none, a digest of the password hash get_auth_password returns. Every request that resolves the user from the session or a remember-me cookie compares it with the user's current one. On a mismatch, that guard's identity leaves the session, the remember-me row it holds is deleted and its cookie cleared, and the request continues as a guest's, so AuthMiddleware answers 401 or redirects to the login page; the framework logs the user id and dispatches no Logout event. Each remember_tokens row is bound to the epoch inside its hash, with no column added. A user whose model returns neither records no epoch and is not checked. Auth::login_id, session::set_auth_user and TwoFactor::complete_challenge ask no provider themselves, so the request that signs in reads the epoch through the default guard's provider before SessionMiddleware stores the session; when the provider fails that read, the sign-in is not stored and a warning is logged. BasicAuthMiddleware::new(), which in 3.2.1 let a session pass on its stored identity alone, now lets it pass only after the guard has resolved the user and compared the epoch, so a session from before the change gets the 401 challenge unless the request carries valid credentials. Each remember-me credential is bound to the epoch the guard's provider read for the sign-in, and a SessionGuard built by hand under a name the AuthManager does not know, which in 3.2.1 issued remember-me credentials, issues none: its login completes without a remembered session and logs a warning that names the guard. A remember-me cookie issued by 3.2.1 carries no epoch: once its user has one, it fails verification once, its row is deleted and the cookie cleared. A session signed in by 3.2.1 is checked from the user's next sign-in. Auth::logout_other_devices binds the current session and remember-me cookie again when it rehashes the password. With the Magnetar engine installed, the default guard keeps Magnetar's own epoch check. No signature changed; suprnova::auth::remember::issue and verify_and_rotate now bind and check the default guard's epoch, and verify_and_rotate deletes a row whose verifier fails.

  • The magick driver runs ImageMagick under the framework's own policy. In 3.2.1 every ImageMagick run read the host's policy.xml alone, so on a host with ImageMagick's default policy, which denies nothing, the script, network, text and Ghostscript coders and every delegate stayed open: PostScript or PDF on a bare - started Ghostscript. In 4.0.0 the driver writes a policy.xml of its own before each run, at .config/ImageMagick/policy.xml in a directory it makes once per process under the system's temporary directory, open to its owner alone; it checks the file byte for byte and writes it again when it differs. The policy denies the URL, HTTP, HTTPS, FTP, MVG, MSL, TEXT, LABEL, CAPTION, PANGO, SCREENSHOT, X, EPHEMERAL, PS, PS2, PS3, EPS, PDF and XPS coders, every delegate, and @file path reads, whether or not IMAGE_MAGICK_AUTODETECT is on; MagickCliDriver::POLICY holds its text. ImageMagick reads every policy.xml it finds and applies the last entry that matches, and it reads $HOME/.config/ImageMagick after MAGICK_CONFIGURE_PATH, its own configuration directory and $XDG_CONFIG_HOME/ImageMagick. So the driver starts it with HOME naming the policy directory, and with MAGICK_CONFIGURE_PATH naming the directory that holds the file first and last, around any MAGICK_CONFIGURE_PATH the operator set. The framework's policy is then the last ImageMagick reads, and it outranks every other policy on the host, the system, XDG and user files and an entry marked stealth="true" included, while the host's denials still apply. A policy.xml in the service account's own ~/.config/ImageMagick no longer applies to the driver's runs. Before the first run of each process, for each binary and operator MAGICK_CONFIGURE_PATH, the driver checks that order under the same environment: magick -list policy must show the last entry that matches each denial denying and the framework's file as the last one read, and one MVG probe, a one-line MVG script read as mvg:-, must be refused by ImageMagick's security policy. A check that fails refuses every run, with or without IMAGE_MAGICK_AUTODETECT, with a 5xx FrameworkError that names the cause and the file, until the host is fixed and the process restarts. A listing or probe that cannot be had refuses the run, and the next run asks again. A directory the driver cannot make, or a policy file it cannot write and check byte for byte, refuses the run before ImageMagick starts, naming the path and the cause.

3.2.1 - 2026-10-05

Fixed

  • A console binary builds in release again. The console dispatcher awaited the application's bootstrap inline, so its whole state machine sat inside the dispatcher's, next to the process boot that 3.2.0 added there. A console main over a substantial bootstrap, the dogfood app's included, failed to compile in a release build with "queries overflow the depth limit!" while debug builds passed. The dispatcher now holds the bootstrap boxed, as Application::run holds its own.

3.2.0 - 2026-10-04

Added

  • Second-factor attempt limits. TWO_FACTOR_MAX_ATTEMPTS (default 5) and TWO_FACTOR_LOCKOUT_MINUTES (default 15, at most 43,200) set the sliding window in which second-factor failures lock an account's second factor; TwoFactor::unlock and Magnetar's TwoFactorService::unlock lift it. Password and second-factor lockouts count separately, so a password reset no longer lifts a second-factor lock. Authenticatable::auth_epoch lets a provider carry the epoch it read with the password hash through sign-in.
  • Lang::reload. Lang::reload().await reloads the translation catalogs and, when their text changed, makes RenderCache pages built from the old translations miss; dev hot reload does the same. Call it from a deploy hook instead of Translator::reload, which left cached pages in the old language until their TTL.
  • Action directives pass arguments. live:click="remove(42)" and live:click="rename('draft', true)" send literal arguments to the action's parameters in declared order; before, every action directive sent none, so an action with parameters could not be called from a template. Only literals are accepted (numbers, quoted strings, true, false, null), and live:check reports a wrong count or a literal of the wrong type at its line and column. The island root lists each action's parameter names in data-suprnova-live-actions.
  • OAuth identities carry the account's picture. OAuthIdentity has avatar_url: the picture URL the provider reports, or none. Google fills it from picture, TikTok from avatar_url, Facebook from picture.data.url and X from profile_image_url; Apple reports none, and an empty value, or one of an unexpected shape, is none and never fails sign-in. Treat it as untrusted profile data, and check its scheme and length before you render, fetch or store it. A provider supplies it through OAuthProvider::avatar_url, which returns none unless the provider implements it, so a provider written before it compiles and signs in unchanged (#140).
  • An asynchronous multipart hook. MultipartRequestHooks has after_validation_async, for checks that need the database before the handler runs. A multipart request runs authorize before it reads the body, then extraction with its field validation, after_validation, after_validation_async and the handler, each only after the one before succeeded. A hook that returns errors answers 422 with them, and an empty set of errors is success. An override needs #[async_trait] (#139).
  • Unsigned keys on every database. A model field declared u64 or Option<u64>, its key and foreign keys included, reads and writes on SQLite, Postgres and MySQL through the new AsU64 and AsOptionalU64 casts: the whole range on MySQL's unsigned columns, and 0 to i64::MAX on SQLite and Postgres, which store it signed. There a write of a larger value is refused before anything is sent, as a database error that names the column in the log, and a negative stored value fails to read the same way. A read by such a value answers what is true of every row: find returns none, so a model bound from a route answers 404, find_many skips the id, and a filter on the key or any narrower integer field matches as it would on MySQL. DB::table compares and writes such a value the same way. A u64-keyed model binds from a route, chunk_by_id and lazy_by_id walk the whole u64 range on MySQL, and the built-in user providers sign in a user whose id is a u64 (#137).
  • Settings that match Laravel's schema. In a package's Cargo.toml, [package.metadata.suprnova.model] datetime_cast = "native" makes every DateTime<Utc> field of that package's models without a cast of its own, the managed timestamps included, use AsNativeDateTime, for a time-zone-aware column, and "naive" uses AsNaiveDateTime, for the time-zone-free columns Laravel creates on Postgres. In the binary's package, [package.metadata.suprnova.schema] unsigned_ids = true makes id() and foreign_id() create unsigned columns on MySQL in every migration the binary runs, and changes nothing on Postgres and SQLite; #[suprnova::main] installs it, and Schema::use_unsigned_ids() does the same for a program without it. An unknown key or value fails the build. New applications carry both settings commented out (#137).

Changed

  • Empty form fields are null, and a repeated name keeps its last value. In a MultipartRequest and in url-encoded FormRequest, req.form(), req.input() and Request::query_into, an empty field is now a key holding null, as Laravel's default ConvertEmptyStringsToNull leaves it: a required String fails, an Option is None, a #[serde(default)] field is null, and a map or serde_json::Value keeps the key, so it can tell a cleared field from one never sent. An empty value used to pass as "" or fail to parse as a number. A HashMap<String, String> target now fails on an empty field; use Option<String> values or serde_json::Value. A list keeps a null element in its place: None in a Vec<Option<T>>, and validation-required under its index, such as ids.1, in a Vec<T>. #[derive(MultipartRequest)] accepts Vec<Option<T>>, and a list of files still leaves out an empty file input. A field name sent more than once keeps its last value, where multipart kept the first part (even an empty one) and url-encoded forms answered 422 for a duplicate field; names ending in [] still collect every value. A url-encoded or query bool reads 1/0, true/false and on/off in any case, as a multipart one does; JSON stays strict true/false. A url-encoded, JSON or query field that is missing or does not parse answers as a validation failure naming every such field (validation-required, validation-integer and the like), where it was a bare 422 with no errors, so an Inertia form gets the usual redirect with each error under its input. CSRF checks the form's _token (its last value) before X-CSRF-TOKEN and X-XSRF-TOKEN, as Laravel orders them, and an empty or 0 value counts as absent; a form body larger than 64 KiB has its _token read up to the server's request body limit, where it used to fail CSRF. The requests and CSRF manuals list what still differs from Laravel.
  • The session, remember-me, auth-flow token and ceremony entities read whole rows on every column type. Their time fields are the new public suprnova::StoredDateTime, which reads DATETIME, TIMESTAMP, timestamp, timestamptz and SQLite text, instead of NaiveDateTime, which failed on TIMESTAMP and timestamptz. Set them with .into() and read them with .naive_utc() or .and_utc().
  • Magnetar rotations and second-factor lockouts. Magnetar's re_enroll keeps the confirmed second factor gating sign-in until a code from the new secret confirms the rotation; the rotation waits in new auth_two_factor columns, pending_secret and pending_recovery_codes, which default_schema::migrate adds. TwoFactorRow gains those two fields, and a custom TwoFactorStore implements the new confirm_rotation. A second-factor lock or unlock never touches an app_users row (LockoutFields::IDENTITY_IS_EMAIL, LockoutService::without_user_lock), so an account registered as two-factor:{id} is never locked or unlocked by it. An account holds the framework's TOTP or a Magnetar second factor, never both: enrolling or confirming either answers 409 while the other exists, and disabling either one recovers an account that already has both. A custom host attaches FrameworkTotpEnrollment to its TwoFactorService through with_other_second_factor.
  • Live field and argument names must be ASCII and at most 128 bytes. Such names used to panic at registration or fail later. A view-visible field may be named component; the view then reaches the component as component_ (or the first of component__, component___ that no field takes). A field or argument may be named like suprnova_live_count.
  • Cron steps count from the first value. */N in the day-of-month and month fields counts from 1, as cron and Laravel do, so */2 means odd days and schedules using it shift; the timezone display now agrees with the scheduler. Ranges with steps (1-15/7) and mixed lists parse.
  • Workflow steps are named by module path and function name, so same-named steps in different modules are different steps. Runs recorded with bare names still replay.
  • TestContainerGuard can no longer be built directly; use TestContainer::fake(). dispatch_argv_with_init boots the process and waits for queued listeners after the command; dispatch_argv does neither.
  • save and update refuse a model that was never inserted. A replica, or a new model from first_or_new or find_or_new, still has its reset key, and save updated the row with key 0. It now returns an error naming persist(), which inserts the model and returns it with its new key. Laravel's save inserts such a model; save here takes &self and cannot hand the new key back, which the Eloquent manual explains.
  • The broadcast fanout no longer uses sea-streamer. SeaStreamerBroadcastHub keeps its name and runs on the framework's own Redis client, and sea-streamer and sea-streamer-redis left the dependency tree. It supports redis://, rediss:// and memory://, a stream shared by hubs in one process; stdio:// is an alias for memory:// and no longer reads or writes stdin and stdout. kafka:// and file://, which were never compiled in, now give a clear error, and new_loopback behaves like new. An event published after the constructor returns always arrives. Stream entries keep their msg field, so hubs of the earlier version on the same stream interoperate during a rolling deploy.
  • New applications' session, remember-me and auth-flow token tables use DATETIME on MySQL, so these columns stay writable past 2038-01-19. Postgres and SQLite are unchanged.
  • The features table holds times after 2038 on MySQL. A new features table uses DATETIME on MySQL and MariaDB. Add suprnova::features::migrations::FeatureTimestampsToDatetime after CreateFeaturesTable in your migrator: it converts an existing TIMESTAMP table, keeping its UTC times and defaults, and does nothing on Postgres and SQLite.
  • Two-factor needs two new migrations. Add suprnova::auth_flows::two_factor::migration_attempts (the two_factor_attempts table) and migration_rotation (the two_factor_rotations table) to your migrator. Without the first, every two-factor proof path answers 503 and names the migration; without the second, TwoFactor::re_enroll answers 503. A pending rotation keeps the confirmed secret gating sign-in until confirm promotes the new one, enroll cannot replace a pending rotation, and disable discards it. enroll answers 422 for a user id longer than 255 characters.
  • Auth::password().register returns a Registration: Created(user) or Accepted, never the existing account. The MagnetarPasswordAuthEngine::password_register trait method returns it, and a custom engine gains admit_host_sign_in and issue_host_session, which refuse with 503 by default. The API starter answers every registration with one generic 202.
  • Magnetar's second-factor lockouts have their own table. The default schema's migrate creates auth_second_factor_lockouts (DefaultSecondFactorSchema), and TwoFactorService::new takes a lockout service over it. TwoFactorStore::set_confirmed takes the enrollment snapshot that was checked, and the MySQL migration failures (SwapFailure, MySqlMigrationFailure) are boxed.
  • Cache::tags_put without a TTL applies CACHE_DEFAULT_TTL, as Cache::put does. A tagged value that must never expire uses the new Cache::tags_forever.
  • DiskExt::temporary_upload_url returns a TemporaryUploadUrl with url, method and headers, instead of a String. An S3 disk with server-side encryption signs headers such as x-amz-server-side-encryption, and an upload that did not send them was refused. Use .url and send .headers with the upload. Its Debug output redacts the signature and header values.
  • Queue::bulk honours debounce. Every copy of a debounced job pushed through Queue::bulk used to run. A debounced burst now collapses onto its last job, and a job declaring both debounce_for and unique_id is refused, as Queue::push does. Laravel's bulk skips debounce; the queues manual explains the difference.
  • Multipart failures answer as validation errors under the field's input name. A missing field, a text part that does not parse as its type or is not UTF-8, a part of the wrong kind, and a file a validator refuses (too large, not an image, a type MimeType does not allow) answer 422 with errors under the form input name, so the second file of a files[] field is files.1, and the Inertia validation middleware shows each error under its field. Before, a text part that did not parse answered 400, a file over MaxSize 413, and the others 422 without errors. The messages come from the validation catalog (validation-required, validation-max-file and the rest), so an application's lang/<locale>/validation.ftl overrides them. A file over MaxSize stops the body at the chunk that crossed the limit and leaves no temporary file. A field's max_count answers 413 with the other request-wide limits, instead of 422, and so does a text part longer than the in-memory spill threshold (2 MiB by default), instead of 400, as Laravel answers post_max_size. A file validator checks only the file parts its field takes: a text part sent where a file belongs fails as validation-file, and a later part for a field that holds one file is ignored without being read into memory or a temporary file. For a field that holds one value, its first part decides it, valid or not, so several failing parts report one error; an empty part does not decide a field that is not a String, so the next part of its name can. An UploadValidator returns FrameworkError::invalid_upload for a validation failure, and its other errors keep their status. A bool field accepts 1, 0, true, false, on and off. An empty part, which Inertia sends for null, is none for an optional field that is not a String and missing for a required one, and a part of the wrong kind sent to an optional or list field fails instead of being ignored. MultipartValue, which the streaming parsers return, has a new NonUtf8Text variant for a text part that is not UTF-8, so a match over it needs an arm for it (#139).
  • #[model] takes the key type from the key field. Without key_type, the key type is the type of the field primary_key names; it was i64 whatever the field said. A key_type that disagrees with that field fails to compile, naming both (#137).
  • pluck, value and the aggregates read every key type, and say why a value does not read. pluck, pluck_keyed, value, value_or_fail, sole_value, sum, min, max and DB::scalar take any type that implements the new ColumnValue trait, which every type SeaORM reads already does, and u64, which they now read on SQLite and Postgres too. A generic caller bound by TryGetable needs ColumnValue instead. avg reads an f64 or a rust_decimal::Decimal (the new AvgValue trait); another type no longer compiles. Postgres and MySQL average exactly, so a Decimal average is exact there. SQLite averages as a REAL, so there the Decimal holds the shortest decimal that round-trips SQLite's floating-point answer. pluck, pluck_keyed and value used to drop a row whose value did not decode, so pluck::<u64> returned an empty list; they still skip a NULL, and any other value that does not decode is an error naming the column (#137).
  • The combobox submits the chosen option's value. A selection used to write the option's label into the one bound field, so the value each option carries never reached the server. suprnova.combobox now binds two fields: name is the chosen option's value, held by a hidden input that a selection fills and an edit of the text clears, and <name>_query is the typed text, which a remote listbox answers. The macro takes the island's value as value, and the script marks that option selected. Bind the query field where you bound name before, and read the choice from name.
  • Live's limits are settings sized for large pages. Every limit Live applies is a LIVE_* key in the application's .env file or a LiveConfig::builder() method, and a value outside a key's range fails boot with an error that names the key. The browser runtime had smaller limits of its own: it refused an island render over 32 KiB and a morph past 10,000 nodes or one second while the server allowed 1 MiB, and an action whose island root passed 1 MiB failed. The bootstrap now writes every limit into the page's configuration element and the browser applies those values, so it never refuses what the server allows. Requests, responses and island HTML default to 16 MiB; a morph takes up to 1,000,000 nodes and keys with no deadline; an upload sends 8 MiB chunks of a file up to 1 GiB; an open document holds and replays up to 4,096 asynchronous events; and a session streams to 64 open tabs, where it was 8. A replay log holds up to 4 MiB per subscription and 256 MiB across the process, dropping its oldest entries first, and a reconnect that needed a dropped entry renders fresh. A tripped limit's message names the limit, the measured and configured values and the key, in the browser console and in the server log. suprnova live:inspect prints every limit by its key, and the Live chapter lists them with their ranges. live:check and live:inspect speak tooling protocol 2 and fall back to protocol 1 with an application built before it.
  • Framework payments, features and RBAC models carry DateTime<Utc> timestamps. The SeaORM Model of the six payments entities, of features::entity, and of the RBAC Role and Permission carries DateTime<Utc> (Option<DateTime<Utc>> for canceled_at, paid_at and processed_at) where it carried String, because their migrations create native timestamp columns. Code that read those fields as text needs the date-time type.
  • A mail message is checked on the dispatch path, and a refusal is a 500. Mail::send, Mail::raw, Mail::html, the queue worker and the notification mail channel check the message before MessageSending fires and before any transport sees it, including a transport bound with Mail::set_transport and the one behind Mail::fake. Mail::queue and Mail::later check it when they push. A refusal is an internal error, a 500 with the detail in the log, where it was a 400 that echoed the address. Headers the message structure owns (To, Cc, Bcc, From, Sender, Reply-To, Return-Path, Subject, Date, Message-ID, MIME-Version and Content-*) are refused as caller headers. Postmark refuses a second tag, and SES refuses a tag or metadata it cannot carry, instead of dropping them. The address and header serializer is public as suprnova::mail_wire for transport authors.
  • The framework registers its own mail and notification jobs. A worker dispatches SendMailJob and SendNotificationJob with no register_job line. Registering the same job type again is quiet; only a different type taking over a job name still warns.
  • A full Live instance ledger evicts instead of refusing mounts. At LIVE_LEDGER_MAX_INSTANCES, a new mount or promotion removes the instance that expires soonest, preferring one with no claim in flight, and the evicted page's next action gets refresh_required and reloads fresh. Before, a full ledger refused every mount on the site until records expired, and anyone who could mount in a loop could keep everyone else out. CapacityExceeded now means only a record over a codec bound. A custom InstanceRecordStore implements two new methods, soonest_expiring_instances and compare_and_remove; the memory, SQL and Redis stores ship them.
  • Live form controls match the density of the suprnova.app forms. Controls read at 14px through --sn-density-control-font-size (16px on a coarse pointer), fields are 40px tall, labels are 12px and sit 6px above their control, legends are 14px, and hints and errors are 12px. A textarea shows three rows and is at least two control heights tall. --sn-density-field-gap puts 12px between fields, checkboxes, switches and groups, and a group's options sit 8px apart. To pick it up in an application, run live:add again for button, checkbox, combobox, datatable, date-picker, field, fieldset, input-otp, label, load-more, pagination, radio-group, switch, textarea and upload.
  • Content negotiation treats q=0 as a refusal. accepts, accepts_json, prefers, wants_json, expects_json and acceptable_content_types leave out an Accept type weighted q=0, as RFC 9110 says, even beside */*; the most specific matching range decides. Laravel lists such types as acceptable.
  • Vendor HTTP clients no longer follow redirects, and SQS overflow payloads move. Pinecone and the HTTP mail drivers treat a 3xx as an error. SQS overflow payloads live under sqs-payloads/<queue>-<digest>/, so SQS_OVERFLOW_FLUSH_ON_CLEAR no longer deletes a same-named queue's payloads from another account, region or endpoint; payloads written before still read, but clear no longer sweeps them. Qdrant ids "01", "+1" and non-canonical UUID spellings no longer map to the point of "1" or the canonical UUID, so items stored under such ids must be written again. A caller's version 5 UUID id is hashed like any other string, so it can never name a point a derived id holds; items stored under v5 UUID ids must be written again too. Resend tags go out as tag_<i> name and value pairs, and a tag Resend cannot carry is refused before sending. DynNotification gains as_any, with a default.
  • build_docs refuses chapters that would overwrite each other. Two chapters with the same file name, or one named catalog.md, now fail with the new ContentError::DuplicateChapterSlug or ContentError::ReservedChapterSlug, naming the files, so an exhaustive match on ContentError needs the two arms. The same file listed twice is still allowed.
  • IMAGE_MAX_ALLOC_BYTES bounds the whole decode, and defaults to 1 GiB. It used to bound only the decoded RGBA size, so a decoder could allocate several times the limit while it worked. It now covers every buffer a decode and its source read hold, measured per format (the cost table is in manual/images.md), and the default rose from 256 MiB to 1 GiB so a 48-megapixel photo in any 8-bit format still decodes. JPEGs decode through zune-jpeg (pinned at 0.5.16-rc2, the first release that decodes every Huffman and arithmetic sampling correctly); lossless JPEGs still decode through oxideav-mjpeg and are refused by name above 67 million samples.
  • Guard names, verification links and the default auth schema. A guard name other than the default session or token guard may not contain : or be empty, because a non-default guard's principal is now <guard>:<id>, and a default-guard id that contains : is now the principal :<id> in Live gates, uploads, subscriptions and memberships, Pusher's user_id and the RenderCache key, so admin:9 on the default guard is never guard admin's user 9. Ids without : are unchanged. A token guard other than the default no longer copies its user into the default Auth view, so Auth::has_user() stays false for it. Email verification links issued before this change are refused and must be sent again. The default auth schema enforces one account per email with a unique index, so a migration over an app_users table that already holds duplicate emails stops with an error until they are merged. New, with defaults: TokenGuard::named, UserProvider::verification_email, UserProvider::mark_email_verified_for and TwoFactorStore::withdraw_enrollment.

Fixed

  • Unsigned keys, relation min and max, and raw bindings on every engine. with_min and with_max read 32- and 16-bit integer columns on Postgres, and dates, text and times on every database, without an error; _min_of and _max_of return Some(None) for a value that is not a number, and the new <rel>_min_as::<T>() and <rel>_max_as::<T>() read the value itself. DB::table, raw fragments and joined-table columns compare a u64 above i64::MAX as the database does for the stored data, including a REAL held in an INTEGER column on SQLite, and DB::table writes store such a value exactly in numeric and text columns while integer columns, and NUMERIC columns on SQLite, refuse it. attach, attach_with (extras included), detach and sync bind pivot ids by their column's type: on Postgres and SQLite a u64 above i64::MAX is refused, naming the column, before anything is sent; on MySQL sync no longer duplicates unsigned pivot ids, and BelongsToMany and MorphToMany get() load rows whose pivot column is unsigned, where they returned none. On Postgres, a raw fragment sent first with an integer and later with a value above i64::MAX no longer fails with "incorrect binary data format". Model update_all and upsert of such a value to a field that is neither an integer nor text follow the column, as DB::table writes do (#137).
  • Durations too long for a date are errors, not panics. A workflow lease or retry backoff too long for a date is refused at boot: WORKFLOW_LOCK_TIMEOUT_SECS above 253402300799, or WORKFLOW_RETRY_BACKOFF_SECS times WORKFLOW_MAX_ATTEMPTS above it, stops the worker at start with an error naming the setting, and lease refreshes return an error for such a lease. Queue::later and its variants, a job's delay(), and requeues in the default, SQS and database drivers return an error naming the delay, where they panicked or, past a chrono duration's range, requeued with no delay at all.
  • A refused cookieless request stores no session. CsrfMiddleware marks a new, untouched session for storage only when the response succeeds or redirects. An anonymous request that creates a session and is refused with 401, or any other 4xx or 5xx, gets no XSRF-TOKEN and writes no session row, so it no longer turns into a 500 when the session store is unavailable; a session that was loaded or changed keeps its token. A cookieless JSON or HEAD bootstrap that succeeds still gets its token with its session. SessionMiddleware marks every session that SessionStore::read returns as loaded from the store, so a custom store that builds its sessions with SessionData::new no longer gets a write on each successful request through CsrfMiddleware.
  • Live uploads, private responses and tooling. Finalized uploads free their pending slots when finalization commits, so a session no longer runs out of upload capacity until restart, and are reclaimed when they expire. A finalization that failed or stalled is reclaimed at expiry, and an app without a finalizer leaves uploads Ready instead of stuck in Finalizing. Cleanup deletes only temporary and uncommitted bytes; bytes finalization committed as output are never deleted. Every RenderCache response without shared-cache permission, public pages without s-maxage and zero-slot composites included, is private, no-cache. Making room for a file-store publication reads only the entries it evicts. A Live tooling timeout kills every process the helper started, and Ctrl+C still reaches the helper. A Live action with validate = "arguments" and a typed #[validate(action = ...)] hook compiles without a component-level #[validate] hook. Generated route helpers handle optional parameters ({id?}) as route() does, leaving an empty one out of the URL. Schema dump and load reach Postgres over a Unix socket named in the URL host (postgres://%2Frun%2Fpostgresql/db).
  • Scaffolded apps on MySQL 8.4 and Postgres, and dates past 2038. The auth-flow token table's hash is VARCHAR(64); MySQL 8.4 refused the UNIQUE key on the old TEXT column (error 1170), so a new app's migration stopped at the fourth step and the app could not boot. Run migrate again on an app that stopped there. The --api starter's app_users time columns are timestamp with time zone on Postgres and DATETIME on MySQL, which its User model and Magnetar read; an existing API app on Postgres converts them with the ALTER TABLE in the CLI chapter. The notifications and RenderCache ledger migrations create DATETIME, so writes keep working after 2038-01-19 on MySQL; tables created before keep TIMESTAMP and still work, and the new NotificationTimestampsToDatetime migration moves an existing MySQL or MariaDB notifications table to DATETIME, keeping its UTC times. A remember-me, auth-flow token or ceremony lifetime too large for a date is an error instead of a panic.
  • Generated routes and types, Inertia props and JSON:API. generate-types --routes applies group! path and name prefixes, gives each repeated-handler alias its own helper, percent-encodes path values like route(), and uses serde's input keys in request interfaces; helpers for a second route of one handler get a new params interface name. An SSR exclusion glob such as **/foo/* matches where ** spans a repeated literal. The redirect back for an empty Inertia response keeps the handler's cookies, security headers and error report. Replacing a lazy prop drops its ?include= gate, a later dotted prop wins over an earlier lazy parent, and App::inertia_shared("users.0.name") reads into shared lists. A JSON-style inertia_response! prop that fails to serialize returns an error instead of panicking. JSON:API documents no longer repeat primary resources in included, an empty collection refuses unknown includes with 400, a requested include always returns an included array, and error pointers are escaped per RFC 6901. i128 and u128 route-parameter fields in Data DTOs extract instead of answering 422, and DTOs with route-parameter fields compile without a direct url dependency. Live route intents can target resource routes, and route() and try_route() fill a catch-all {*rest} by the name rest, keeping its slashes. Numeric expect! matchers fail on NaN and other unordered values. Schema dump and load accept every TLS parameter spelling the application's connection accepts and pass the Postgres password through password=. The Idempotency::remember example key includes the authenticated user. Live component names, views and action text that mention development crate names compile, action arguments named target or request no longer break generated code, and #[session] Live fields load from and persist to the visitor's session once the action's outcome is accepted (they need SessionMiddleware).
  • Workers, the console and process lifecycle. Queue, schedule and workflow workers, the queue:* commands and console commands boot the #[injectable] and #[service] inventory, so a job or command that resolves an action no longer fails with ServiceNotFound. The console also boots the runtime drivers and #[policy] gates, warns on stderr and goes on when a driver cannot boot, and waits for queued listeners before it exits. Workers, the queue and maintenance commands and console commands cancel and drain the supervisors the bootstrap started before they exit, with the same 5-second grace as serve, and so does any command or console that fails after the bootstrap ran; down, up and schedule:list run the application's bootstrap hook, and the hook's docs name the migration commands that skip it. schedule:work stops on SIGTERM while an inline task runs, stopping a task still running after the 30-second grace. A panicking Terminable hook no longer skips the hooks after it, and a graceful shutdown waits up to 5 seconds for hooks still running. Context::get and Context::hidden_get no longer deadlock when a custom Deserialize writes to the context. A TestContainerGuard or TestQueryGuard dropped on another thread clears only what it installed. Binding an #[injectable] by hand before boot no longer requires the dependencies only its generated constructor reads. db:seed --class=<Name> fails with not-found on an empty registry, and a poisoned registry fails instead of reporting nothing to run. A supervisor spawned during or after shutdown no longer starts outside the drain. A second init_telemetry while the first guard lives no longer takes over the global meter provider. start_workflow! accepts imported, re-exported, crate::, self:: and super:: paths, and workflow:work on a database other than Postgres exits with an error at startup instead of retrying forever.
  • Relations and soft deletes. destroy, delete_quietly, delete_or_fail and trait-dispatched delete permanently deleted soft-delete rows; they now tombstone them, and delete_or_fail on an already trashed row is a 404. with_count and the with_sum family counted trashed rows and rows hidden by global scopes; they now cover exactly the rows with loads. with([..]) and with_count([..]) on one relation no longer panic, a count no longer makes load_missing skip the rows, and a failed or cancelled nested load_missing no longer erases relations already loaded. Relations declared with lk = "..." read and write by that column, and an lk naming no field is a compile error. Eager many-to-many honours related_key, a relation's pivot_table override is used when loading pivot context, and eager HasManyThrough skips rows reached through a trashed intermediate. Eager loads of a with_tx(&tx) or on(name) query run on that transaction or connection, MassPrunable deletes on the connection its dry run counted, and factory inserts of plain SeaORM rows join the surrounding DB::transaction. with_min and with_max of an integer column read on Postgres. has, where_has and doesnt_have work on models whose primary key is not id, and join a many-to-many on its declared related_key. Lazy HasManyThrough and HasOneThrough get and count apply the target model's global scopes, as eager loads do. A pivot model's own global scopes and soft-delete filter no longer drop attachments from many-to-many reads; as in Laravel, they apply when the pivot model is queried on its own. A soft delete() sets updated_at along with deleted_at, and delete_or_fail touches the owners named in touches, as delete() does. A BelongsTo declared without an owner key finds its owner by the owner model's primary key instead of id, in lazy and eager reads, counts and aggregates, has and owner touches. has, where_has and doesnt_have on a MorphedByMany relation work; they named a pivot column that does not exist. Every relation key default now comes from the models' primary keys, never a literal id: HasManyThrough and HasOneThrough without second_local_key join on the intermediate model's primary key, MorphMany and MorphOne report their parent key or the declared lk, and a MorphTo reports its targets' primary key, through the morph registry when the targets differ; MorphTypeEntry gains a primary_key field.
  • Magnetar hashing and sign-up races. Magnetar password hashing runs on Tokio's blocking pool instead of stalling async workers. A magic-link or passkey sign-up that loses a race for a new email address answers as the existing account instead of failing.
  • RenderCache stays coherent under cancellation, races and flags. A write that was cancelled at its generation advance, including a bulk write, increment, a soft delete, restore or force delete, could commit while cached pages stayed current; the write and its advance now share one transaction. An unrelated successful write no longer resumes serving pages whose invalidation failed: the missed invalidation is applied first, and an advance that lands clears only the failures recorded before it began, so a newer failure for the same tables keeps pages suspended until a later advance covers it. A process that wrote before installing RenderCache advances generations after the install. Pages rendered with a flag's compiled default refresh when the first rule for that flag is stored, and a page rendered during set_flag or reload no longer stays cached with the old answer. DB::unprepared, DB::statement and statement_on with a batch that begins with SELECT invalidate cached pages. Pages built from EntityExt or QueryBuilder reads, relation counts and aggregates, or through-relation loads refresh when those tables change, and lazy HasManyThrough get, first and count and HasOneThrough get refresh when an intermediate row changes. The payments webhook advances its mirror tables, and its receipt insert, retry error clear and failure record, in the transaction that writes them, so a request cancelled during COMMIT no longer leaves them committed but cached pages current. A write on a named connection that is dropped during its COMMIT suspends serving until a later advance repairs it. RenderCache::advance_epoch reaches the next request even with another request's authority read in flight. A rebuild that fails after the stale-on-error window closed returns its error instead of the expired entry, a node runs at most one background refresh per key and at most RENDER_CACHE_MAX_BACKGROUND_REFRESHES across keys (new, default 32 per CPU, 0 turns background refresh off; past it a stale hit serves the stored copy and starts nothing), a cancelled L1 publish can no longer overwrite a newer entry, and L1 sweeps no longer scan the whole store. SQL Live record cleanup no longer deletes a fresh instance or reservation another node just created. Renewing an async subscription from an evicted position is refused, so the membership degrades instead of claiming continuity, and a degraded delivery lane replays what it missed from the subscription's log, or retires the transport when the log no longer holds it, instead of streaming on past the gap. A finalized direct-storage upload is retired through the application's direct upload provider when cleanup reclaims it. The Live tooling helper's timeout ends the call even when a process it started keeps its output open or the helper wrote a complete exchange and kept running.
  • Query builder, pagination and Eloquent. Paginating, ordering and taking first of a union works on every engine, and total counts its rows; as in Laravel, ordering, limit and offset set before union apply to the first query and those set after it to the whole union. count, sum, avg, min and max work after select(...), after an ordering, on a union and with having. in_random_order works on MySQL, and skip or offset without limit works on SQLite and MySQL. chunk_by_id, lazy_by_id, cursor_paginate and Pagination::cursor visit every row once whatever the query was ordered by, and apply an offset once. chunk, chunk_map, each, chunk_by_id and lazy_by_id honour the query's limit as a cap on the whole walk and its offset as a one-time skip, so .limit(5).chunk_by_id(2, ..) visits 5 rows instead of the whole table. cursor_paginate on a union pages the whole union. count, sum and avg return 0, and min and max return None, when an offset skips the aggregate's row or a grouped query has no rows, instead of failing with "aggregate query returned no row". filter_json_contains works on Postgres and MySQL with strings, objects and arrays. create_or_first inside a Postgres transaction returns the existing row, and a lost race creating a Live record no longer aborts the host's Postgres transaction. Unique and Exists inside DB::transaction see the transaction's own rows and no longer wait on its connection. Collection::sort_by and the by-value Distinct rule compare integers above 2^53 exactly. Index and foreign key names holding a backtick or double quote create and drop. decrement(col, i64::MIN) subtracts instead of panicking. UniqueIdKind::Ulid.is_valid rejects strings that overflow 128 bits. QueryExecuted::to_raw_sql() returns the SQL unchanged when a binding is missing or left over, and QueryBuilder::count and Pagination::length_aware report the COUNT(*) they ran to DB::listen and the query log. Inertia infinite scroll asks for the paginator's own page or cursor parameter. Concurrent Schema::dump calls to one path each write a whole file. test_database!() with no argument compiles and uses the crate's own migrations::Migrator.
  • Typed counts, union walks and decimal relation minimums. Typed QueryBuilder::count keeps the whole count under a limit and returns 0 past an offset, exists asks about the rows the limit and offset leave, and a Pagination::length_aware total counts every match, as Laravel does, and DB::table(..).count() keeps the limit and offset the same way. QueryBuilder::offset(n).all() and first() with no limit run on SQLite and MySQL instead of failing with a syntax error. chunk_by_id, lazy_by_id, lazy and cursor over a union visit each row once and finish; the cursor bounded only the first query, so the batches repeated forever. <rel>_min_as::<Decimal>() and <rel>_max_as::<Decimal>() read a NUMERIC or DECIMAL minimum or maximum exactly on Postgres and MySQL, and ::<String>() reads its decimal text.
  • Overlapping drains of queued listeners wait for each other. A second EventFacade::drain_queued running while another drain held a listener reported the dispatcher drained at once, so a console command could return, and a shutdown could finish, with a queued listener still running. It now waits for that listener, and counts it if its deadline passes.
  • Debounced jobs, queue events, log subscribers and process timeouts. Overlapping debounced dispatches keep the one that armed last: each takes its place from an atomic counter in the cache, so a newer push is never dropped for an older Queue::bulk, and a stalled dispatch does not also run. When max wait runs out inside one Queue::bulk, the bulk's last job runs at once instead of being dropped as superseded. A debounce id ending in :first_dispatched_at no longer shares a cache key with another id's first-dispatch stamp, which failed that id's dispatches. JobProcessed fires whenever the job's pipeline returns without an error, as Laravel's worker fires it: after middleware deletes the job, then JobAttempted; after middleware releases it, before JobReleased; after a middleware failure without an error; and after a debounced dispatch is dropped as superseded, between JobDebounced and JobAttempted. The worker raises the rest of its lifecycle events in Laravel 13.27's order for every outcome too: JobAttempted after a retry and after a release by middleware; JobExceptionOccurred after JobFailed for an error or panic on the last attempt, for a job already out of attempts, and for FailOnException; JobFailed before JobTimedOut, with no JobAttempted after a timeout; and JobProcessing first for a job already out of attempts. Building a log subscriber with logging::build_subscriber changes nothing until it is used: each subscriber writes file lines in its own format, and building no longer resets the default channel, so a caller that relied on that calls check_channels. A process timeout's kill can no longer reach a process or group id that the owner reaped in the meantime.
  • Docs reading order, memory fanout streams and the image budget docs. A docs chapter listed twice in the table of contents keeps one place in the previous and next chain, its first listing, and every catalog entry for it matches its JSON file. A memory:// fanout stream is freed when its last hub drops instead of staying registered until the process exits. The ImageConfig docs give the real 1 GiB default for IMAGE_MAX_ALLOC_BYTES.
  • Rate-limit identities, RBAC races, email verification and second factors. A request that names more than one identity in its query or body is also refused by, and counted against, each identity's own bucket. Creating a role or permission and granting one succeed when two requests make the same one at once, on every engine. Email verification stamps only the address the link was mailed to, even if the address changes while verify runs; a custom provider closes the remaining window by overriding UserProvider::mark_email_verified_for, as its docs explain. session::destroy_all_for_user destroys only the sessions of the default guard's user, so a password reset for web user 7 no longer signs out admin 7, and the new destroy_all_for_guard_user does the same for another guard; every Live membership issued under a destroyed session now ends, whichever guard's user held it. On Postgres, a user id above i64::MAX binds by the column type of the table the lookup actually reads. A framework TOTP enrollment and a Magnetar enrollment that race each other leave the account with one second factor; in a tight race both answer 409 and the user enrolls again.
  • Sessions and remember-me tokens restore on MySQL and MariaDB. A scaffolded application's session, remember-me and auth-flow token time columns are TIMESTAMP there, and the framework read them as a type the MySQL driver decodes only from DATETIME. Every session read failed: a form POST answered 419 and the next page 500, the remember-me cookie never signed anyone back in, and verification and reset links could not be used. The notification inbox and the ceremony store failed the same way, and on Postgres each failed on a timestamptz column. They now read DATETIME, TIMESTAMP, timestamp, timestamptz and SQLite text, and existing tables need no migration. A notification whose read_at does not decode is an error instead of unread. On MySQL, an expiry past 2038-01-19 03:14:07 UTC is stored as that moment.
  • A new application registers and signs in on every database. The users table and User model that suprnova new writes disagreed on the time column type, so registering failed on MySQL 8.4, MariaDB and Postgres. The migration now uses .date_time() and the model names AsNaiveDateTime. An existing application gives its User the casts for its columns: the native casts on MySQL and MariaDB, the naive ones on Postgres. See Authentication, "The scaffolded User model".
  • Two-factor flows on every engine. A framework login completed with TwoFactor::complete_challenge stays signed in under the Magnetar engine. The two-factor credentials table and the attempt-counter migration create on MySQL and MariaDB. Concurrent second-factor admissions no longer deadlock across users on MySQL. On Postgres, a correct Magnetar second-factor code, every ceremony state change, passkey registration and removal, and account unlinking answered 500; they work. A committed two-factor confirmation is reported as confirmed even when its attempt record cannot settle. A password reset keeps an encrypted column that changed while it ran, and stores the new hash verbatim whatever the model's mutators.
  • Cache, maintenance mode and read-through disks. Cache::remember_forever and Cache::sear no longer expire after CACHE_DEFAULT_TTL, and down with MAINTENANCE_DRIVER=cache no longer ends by itself after it. On Redis, Cache::flush matches REDIS_PREFIX literally, so a prefix holding *, ?, [ or \ no longer deletes other applications' keys or misses its own, and a value extended with Cache::touch is still removed by Cache::flush_tags. Tag indexes no longer grow without bound for tags written often and rarely flushed. Concurrent down runs with the file driver no longer publish a half-written down file. The production guard for on_one_server() checks the bound cache store instead of CACHE_DRIVER; a custom shared CacheStore overrides the new locks_are_shared to return true. The cached feature-flag evaluator sees an admin change made during a concurrent miss and holds at most 4096 entries. Read-through promotions stream into the primary instead of holding the object in memory, unpromoted reads fetch only their range, and a delete or move during a promotion is not undone, on the same node or another one: a promotion asks the fallback again just before it publishes and after, a cancelled read still finishes that check, and a withdrawal deletes only the exact version the promotion wrote, never a writer's newer object. An equal length no longer counts as proof that the fallback object is unchanged: a fallback without an ETag, version or modification time, such as the in-memory disk behind Storage::fake(), is checked by content, so a same-size overwrite is never promoted as the old bytes. On a primary without versioned deletes (local, memory, and unversioned S3, Azure Blob and GCS) the promotion keeps its copy and logs a warning instead, so a delete on another node that lands between the last check and the publish can leave that copy behind. Versioned and conditional reads reach the fallback, and a refused move keeps the fallback copy. Ranged reads stop at the requested range: a server that ignores Range can no longer make a small read buffer the whole object, and S3, Azure Blob and GCS refuse a response that is not the requested range before reading its body, open-ended ranges included.
  • Queues, events and processes. Cancelling Transaction::commit() while its COMMIT was in flight could drop its after_commit callbacks and push_after_commit_with_tx jobs although the rows committed; they now always run. A queued listener that dispatches another queued event no longer hangs queued event dispatch, drain_queued waits for and counts listeners admitted while it drains, and EventDispatcher::defer buffers only its own dispatcher's events. A debounced dispatch claims its window only after its envelope is queued, so a failed or cancelled dispatch can no longer get queued work dropped as superseded, and max_debounce_wait longer than the debounce token's lifetime forces a run again. Batches on the sync driver finish and fire their callbacks, a batch whose dispatch failed part way fires catch and finally once its queued jobs settle, and two concurrent first batch dispatches no longer lose one batch's tracking. JobAttempted fires for jobs that fail or time out terminally. A cache error while ThrottlesExceptions clears its counter no longer fails a completed job, and one while it counts a failure no longer replaces the job's own error or turns a backoff release into a failed attempt. A cancelled memory-queue pop, delayed nack or release keeps the job. FailoverQueueDriver counts a driver registered under two labels once. An after-commit push_unique whose job fails to serialize releases its lease. A started process whose child left its group can no longer have its timeout, stop() or drop signal an unrelated process group.
  • A Fluent message named NUMBER or DATETIME keeps the function callable. Such a message broke every NUMBER(...) or DATETIME(...) call in its catalog. The message keeps its key and the functions still format.
  • Presence channels and WebSocket upgrades. A presence channel whose last member left stayed in memory, so parameterized presence channels grew with churn; empty channels are now removed. A connection aborted at shutdown or cancelled during a re-subscribe left its presence member visible and its forwarder tasks running; cleanup, presence.left included, now runs on every exit. Headers middleware adds to a successful WebSocket upgrade, such as a session Set-Cookie, now reach the client on the 101, and terminable middleware runs for upgrade responses with status 101 or the refusing status. WebSocket route parameters are percent-decoded like HTTP ones, subprotocol negotiation echoes the client's own spelling as RFC 6455 requires, and sse::last_event_id returns Unicode event ids instead of None.
  • Each named middleware runs once per route. A middleware group included by two sibling groups, an alias listed twice, or a middleware named both through a group and on the route itself ran twice per request, so a throttle there counted each request twice. A route now runs each named middleware once, identified by its alias and parsed arguments, at its first occurrence, as Laravel's uniqueMiddleware does. Middleware added by type with .middleware(M) is never dropped.
  • Gates, OAuth starts, CSRF bootstraps and registrations. A gate callback that calls Gate::define no longer deadlocks the request. An OAuth start that is the browser's first request (JSON or POST) sets the session cookie, so the callback binds instead of answering 400. A cookieless JSON or HEAD request that receives XSRF-TOKEN also receives its session, so the next POST no longer gets 419. Two registrations racing for one email create one account.
  • Images decode correctly at the sizes the framework allows. JPEGs above about 22 megapixels decoded on no driver; they now decode up to the budget. JPEG colours were off by about 6 levels, arithmetic-coded, odd-sized 4:2:0 and 4:2:2, 4:4:0 and 4:1:1 JPEGs decoded wrong or not at all, and small progressive JPEGs could fail. GIFs from ImageMagick and Pillow decode, and the GIFs the default driver writes open in other software. The magick driver processes and sizes only the first frame of an animation, as the default driver does, and reports a GIF's logical screen as its size.
  • Localization. Accept-Language negotiation honours q-values: en;q=0.1, fr picks fr, and a language sent with q=0 is never chosen. DATETIME() formats in the catalog's own locale. A catalog edit saved during a reload is picked up by the next one. Lang::has is false for a message that has only attributes, matching Lang::get. A Fluent term and a message with the same name both resolve on the server, as in the browser.
  • Logging. A custom driver's failed write or flush, and a file channel that cannot flush (a full disk), are reported once on stderr instead of dropping lines silently. LogChannel::stack([...]).level(...) filters every channel the stack lists. A refused second init_subscriber or init_telemetry no longer changes the live file format or the default channel. Log::forget_channel after rotation reopens the file in every stack that lists the channel. A default stack with several stdout channels writes an event when any of them keeps its level. Nested spans that share a field name log the inner value in the message and the context.
  • Markdown heading ids are unique, and process output keeps its characters. A heading titled like a numbered duplicate (Overview 2) no longer shares an anchor with a repeated Overview. Streamed process output no longer drops a character split across reads after an invalid byte, and wait_until sees a final incomplete character.
  • Payments, mail, notifications and queues. PhoneNumber and CountryCode validate when deserialized, where invalid values were accepted and digits() could panic. MailFake::assert_not_outgoing fails when the mailable was sent, not only queued. The file mail driver never overwrites a preview written in the same millisecond. Tagged Resend mail is accepted by Resend. Notification mail renders from the notification itself, so data() no longer has to hold every field to_mail reads. An SQS overflow job whose first send went unanswered keeps its payload when the retries are refused, and when SQS took both an unanswered send and its retry, each message now carries its own payload copy, so acknowledging one no longer leaves the other unreadable. The Redis queue and the broadcast fanout work with redis://user:password@... and rediss:// URLs, taking credentials, database and TLS from the URL.
  • Middleware, sessions, uploads and test helpers. A middleware group reused by two sibling groups no longer fails with CycleDetected. A RateLimiter counter that expired in the middle of a hit gets its expiry back, where it could refuse every later request until cleared. Flash keys containing _flash.new. or _flash.old. survive the next request, and SessionData::decrement(key, i64::MIN) saturates instead of panicking. A form body sent as Application/X-WWW-Form-Urlencoded (any case) is read by Request::input, CSRF, Pusher channel auth and identity rate limits. set_global_upload_spill_threshold(usize::MAX), the documented way to keep uploads in memory, no longer panics. The Inertia error page compares Accept qvalues to three decimals. A redirect on a route without a session keeps App::flash values for the current response. TestResponse::assert_cookie matches only cookie names, not attributes such as Path or HttpOnly.
  • A Live page with several islands on SSE keeps its updates. When an island's first event arrived before its subscribe answer, the browser treated it as traffic for an unknown subscription, retired the shared stream and showed every island on the page as "Updates degraded". Such an event is now held, counted against LIVE_ASYNC_MAX_QUEUED_EVENTS, and applied once that exact answer arrives, or dropped if the subscribe is refused; the same holds for the replacement subscribe that follows a failed island. A WebSocket transport still fails closed, as before. A document whose held and queued events pass the limit now reports the breach with the limit's key and reconnects, instead of degrading every island.
  • Payment webhooks, feature flags and RBAC work on Postgres, MySQL and MariaDB. Their models used a text cast for native timestamp columns, so every payment webhook answered 500, set_flag and the feature admin failed, and Role and Permission could not read a row the RBAC helpers wrote. They now read and write the native columns; text written on SQLite still reads back.
  • Job batches settle on Postgres. The documented job_batches schema declares INTEGER columns, which Postgres stores as 32-bit, and the repository read them as 64-bit, so every settlement failed: the job ran again after each visibility timeout and the batch callbacks never fired. The repository reads either width, and the documented epoch columns are now BIGINT; tables created from the earlier schema keep working.
  • The MariaDB vector store works against a real server. similar looked for the vector index in a form MariaDB never prints, so every call failed, and the table ensure_table_sql emits could not be created because its key was too long for a vector index. The id column is now VARBINARY(254), which also compares ids byte for byte as the other drivers do.
  • Native JSON columns have their own cast. The structured casts bind and read text, which Postgres refuses for json and jsonb and MySQL for JSON, although their documentation said those columns worked. The new AsNativeJson<T> and AsOptionalNativeJson<T> store any serde type as JSON. The AsBool documentation now names a BIGINT column and sends a native boolean column to a plain bool field.
  • SMTP mail goes out from the return path. A return path reached SMTP only as a header, so bounces still went to the author; the envelope sender is now the return path.
  • Queued mail and queued notifications send. Nothing registered their jobs with the worker and the manuals never said to, so every one failed as an unknown job and dead-lettered, and with the sync driver the push itself failed.
  • Queued and notification mail fire MessageSending and MessageSent. Only a direct send fired them, so switching to queue or sending through a notification cut off audit and metrics listeners.
  • A Live primary button looks like the primary action. A type="button" button with the default primary variant rendered as a secondary control, and so did dialog, sheet and drawer triggers.
  • sum and avg of an integer column read on Postgres and MySQL. Postgres answers numeric and MySQL DECIMAL for them, which sum and avg could not read, so they failed there while passing on SQLite. They now read either: an integer sum exactly, refusing a fractional or out-of-range sum with an error that quotes it, and sum::<f64> of an integer column now reads on SQLite too. with_sum and with_avg stored 0.0 on Postgres and MySQL; they now hold the value, and a value that is not numeric is an error instead of a silent zero.
  • Facebook sign-in receives the email. The Facebook provider requested a bare /me, for which the Graph API returns only id and name; it now names id, name, email and picture. X requests profile_image_url among its user fields (#140).
  • live:check finds unescaped output wherever a template writes it. It read |safe from an expression's text and skipped {% let %}, so {% let y = x|safe %}{{ y }}, x|safe|lower and escape("none") passed. It now reads the parsed template and follows a raw value through let and set, macro arguments, macros called as expressions, caller content, inherited blocks and super(), loops, if let, let chains and match, to the place it is written. A filter outside Askama's builtins and the framework's, a Rust macro in an expression, and a dynamic value in an unquoted attribute, an on* attribute or script or style text are reported as unproved, so a view that passed before can now need a change.
  • live:check handles views with many conditionals. It counted every combination of if blocks, so eight independent ones exceeded its limit; each conditional's branches are now checked once. Its limits are sized for real templates (4 MiB of source, 262,144 nodes) and configurable.
  • live:check reports the real column. Directive and markup diagnostics reported column 1; they now point at the attribute or tag, in the template that wrote it.
  • An action can dispatch more than 128 events. An action's outcome refused more than 128 flash messages, events or effects; it now takes as many as LIVE_MAX_RESPONSE_ITEMS allows, 65,536 by default.
  • Reordering a long keyed list morphs in linear time. The morph looked up each keyed element in the list of moved elements, so reordering every row took time quadratic in the row count; 10,000 rows took about 67 ms and now take under 20 ms.

Security

  • Input-only relationships stay out of JSON:API output. A relationship marked #[data(input_only, allow_include)] was linked and includable in responses; it is now never sent.
  • The environment is written only where that is sound. Config::init and config::load_dotenv refuse to write the process environment inside a Tokio runtime or after #[suprnova::main] loaded it, where another thread could read it mid-write. A failed load restores the real system values and registers no config.
  • Route bindings and pivot extras respect what models declare. RouteParam<Model> ignored global scopes on models without soft_deletes, so a guessed id of another tenant's row bound to the handler; the binding now applies every global scope, and a hidden row is a 404. attach_with wrote pivot extras past the pivot model's casts, so an AsEncrypted column was stored as plaintext and an AsHashed one unhashed; extras now go through the pivot's casts and mutators, and an extra that does not decode into its field is a validation error.
  • RenderCache never stores or reuses a personalized page as shared. Work a handler joined beside an identity-bound island mount (tokio::join!) had its principal, session and table reads dropped from the stitched shell's report, so a personalized shell could be stored as public; those reads now count. PrivateCached responses send Cache-Control: private, no-cache instead of private, max-age, which let a browser show the previous account's page to the next account on the same browser. Oversized Redis hint payloads are dropped before they are copied or queued.
  • Redis credentials stay out of the boot log. When Redis was unreachable at boot, the cache error held the whole REDIS_URL, password included, and CacheConfig and CacheConfigBuilder printed it when debug-formatted. The error now names only the host and port or socket path, and the configurations print the URL as redis://<redacted>.
  • Second-factor codes are rate limited and single use. TwoFactor::verify and consume_recovery_code ignored the account lockout, so a caller with the password could guess TOTP codes without limit; both now refuse while the second factor is locked, and every framework login is refused before it spends a code. A confirmation code and a TOTP code straddling a timestep are accepted once, and confirm confirms only the secret whose code was checked, in the framework and in Magnetar. Second-factor failures are counted in a table that no password identity can reach, so a decoy account named after the second-factor key can neither clear nor lock it. A password reset during the password check cancels the sign-in or challenge. HTTP Basic once, Auth::once and once_using_id refuse an account with a Magnetar second factor, and Magnetar's password, magic link, passkey and OAuth sign-ins refuse an account with framework TOTP. A remembered framework login is refused before it issues a credential, and account flows write only the verified-at or password column.
  • Local disks stay inside their root. On Unix, a directory inside a local disk root swapped for a symlink during an operation could redirect a read, write, copy, rename, delete, listing or publish outside the root. Every path is now resolved one component at a time without following symlinks, and each operation runs relative to the directory it resolved.
  • Cached feature flags stay per identity. Two identities whose user and team strings joined to the same text could share a cached flag decision. The cache key now keeps each part separate.
  • Fanout URL errors no longer print credentials. A broadcasting fanout URL that failed to parse was copied into the error message, password included. The error now names the problem without the URL.
  • A JSON login is rate limited by its address. identity_key and names_identity ignored JSON bodies, so a JSON login was keyed on the caller's IP and a ?email= decoy opened a fresh per-address bucket on each request. A top-level string field of a JSON object body now names the identity under the same query-versus-body rule as a form field.
  • An SVG allowlist accepts only SVG. A MimeType allowlist naming image/svg+xml accepted any non-markup text declared as SVG, script included, and refused real SVG files. A part now passes only when its root element is <svg>; anything else declared as SVG fails as the wrong type.
  • A route uses the guard that authenticated it. Behind a guard other than the default, the email-verified gate, the role and permission middleware, the Live principal and render-cache identity reads all used the default guard's user, so a verified or privileged default-guard user let another guard's user through, and a page built for one guard could be served from cache to a visitor without that sign-in. A second token guard over another provider answered with the first guard's user. Each now reads the user of the route's own guard through that guard's provider. Live gated actions, uploads and subscriptions, EmailVerification::verify and the Pusher user and presence endpoints do the same: behind AuthMiddleware::for_guard(name) they act for that guard's user, as <guard>:<id> (default-guard principals are unchanged), a named guard's logout ends that guard's Live memberships, and a stream with a :principal topic is refused behind a non-default guard.
  • Encoded cookie names cannot stand in for prefixed cookies. A cookie named %5F%5FHost-suprnova_session resumed the __Host- session; a prefix that appears only after decoding is now dropped.
  • A verification link verifies only the address it was sent to. Changing the account's email no longer lets an old link verify the new address.
  • Password reset checks the token before hashing. A dead or made-up token made the server compute an Argon2id hash first, in the framework's reset flow and in Magnetar's PasswordManagementService.
  • A session that loses its Magnetar authority ends its Live memberships on this node, so it stops receiving events.
  • An image cannot allocate past its decode budget. A crafted PNG inflated past IMAGE_MAX_ALLOC_BYTES, a lossless WebP's prefix-code tables were unbounded, a JPEG could be measured at one frame header and decoded at another, and path and disk sources were read into memory before the size check. Each is now counted against the budget before the memory is taken.
  • A JPEG's Extended XMP cannot hold a core. A JPEG whose Extended XMP segments would make the decoder's reassembly read more than IMAGE_MAX_ALLOC_BYTES is refused before decoding; 100,000 stalled segments used to hold a core for minutes.
  • The mock payment provider refuses unsigned webhooks outside development. It accepted them when the application registered a production or staging AppConfig in code with APP_ENV unset; it now requires both the configured environment and APP_ENV to be local, development or testing.
  • Queued notification events carry only data(). The queued NotificationSending, NotificationSent and NotificationFailed events carried the whole serialized notification, including fields kept out of data() such as reset tokens.
  • Vendor API keys stay with their vendor. Pinecone and the HTTP mail drivers followed redirects, forwarding Api-Key and x-postmark-server-token to another origin. Web push transport errors no longer carry the subscription endpoint URL into logs and NotificationFailed.
  • CORS patterns anchor every alternative. allow_origin_patterns anchored only the first and last alternative of a pattern such as a|b, so https://app.example.evil.test matched https://app\.example|... and got a credentialed allow. Every alternative must now match the whole origin.
  • Rate limits cannot be sidestepped. On the Redis limiter, a shorter-window quota sharing a key with a longer one deleted the longer quota's history; history now lasts for the longest window used on the key, as the memory driver already did. An identity-keyed limit read the query string or the body, so ?email=decoy or a blank ?email= reached a body address under a fresh quota; both are now read, and a request that names two different addresses shares one {prefix}:{field}-ambiguous bucket.
  • MimeType sniffs before it trusts the header. Script text, or markup hidden after 16 KiB of whitespace, passed an image allowlist on a spoofed Content-Type. The header now counts only for types without magic bytes, such as text/csv.
  • An Inertia validation redirect stays on the host. A same-host Referer such as https://app.test//evil.test/x sent the redirect to another host; it now falls back to the previous URL.
  • Signed URLs sign the order of a repeated parameter. Swapping the values of a repeated key (?mode=a&mode=b to ?mode=b&mode=a) kept the signature valid while changing what the handler read. URLs minted before still verify.
  • Mail headers and recipients cannot be injected. Postmark and Mailgun received recipient lists joined from unquoted display names, so a name such as attacker@example.com, Victim added a recipient, and SMTP and the file transport wrote header names carrying CR, LF or NUL verbatim. Every transport now builds addresses and headers through one validating serializer: an address is exactly one RFC 5322 address with its display name quoted when needed, a header name follows the RFC 5322 grammar and is at most 76 bytes, and a header value, the subject included, refuses control characters other than tab.

3.1.0 - 2026-10-03

Added

  • Heap profiling. With the framework's heap-profiling feature an application profiles its heap with dhat: the framework installs dhat's allocator, #[suprnova::main] starts the profiler, and a command that finishes or a server that shuts down gracefully writes dhat-heap.json, or the file SUPRNOVA_HEAP_PROFILE names, for DHAT's viewer, and prints the bytes allocated, the peak and the heap left at the end. Without the feature no dhat code is compiled. The workspace and new applications have a profiling Cargo profile, the release profile with debug symbols, and new applications a heap-profiling feature that turns on the framework's.
  • The in-memory cache sweeps its expired entries. The cache the framework binds removes every entry whose time is up every CACHE_SWEEP_INTERVAL seconds (60 unless set; 0 turns it off), so keys written once and never read again no longer stay for the life of the process. InMemoryCache::with_periodic_sweep builds such a cache, and CacheConfig::sweep_interval sets the interval in code.
  • Schema dumps. suprnova schema:dump writes the database's schema and its migration ledger to database/schema/<engine>-schema.sql, with pg_dump, mysqldump or mariadb-dump, or straight from SQLite. migrate, migrate:fresh, serve and TestDatabase::fresh load it into a database that has run no migration, then run only the newer migrations; --schema-path names another file. --prune deletes the migrations the dump records and keeps each name as a PrunedMigration, which fails with an error if a database ever needs to run it.
  • Strings and numbers. Str::slug, Str::mask, Str::limit, Str::limit_words and Str::excerpt work in characters, never bytes. Str::plural and Str::singular follow the language of the current locale with doctrine/inflector's rules for English, French, Norwegian Bokmål, Portuguese, Spanish and Turkish, English for any other, and keep the word's case. Lang::percentage writes a percentage as the locale does, and Lang::abbreviate shortens a number to 1.23M with the locale's digits.
  • A Redis facade. Redis::connection("default") reaches REDIS_URL, and Redis::define names other connections in the bootstrap, or Redis::define_client with a client built elsewhere. A connection opens on its first command and opens again after the server drops it; Redis::purge and Redis::connections manage them. The common commands are typed methods (get, set, incr, hgetall, lrange, zadd, scan and the rest), command runs any other and returns a RedisValue, refusing, as pipelines and transactions do, those that would change the shared connection (SUBSCRIBE, MULTI, SELECT, CLIENT REPLY and the like), and client() gives the redis crate's connection, now re-exported as suprnova::redis. Reads are sent again after a lost connection, as REDIS_COMMAND_RETRIES says; writes never are. A subscription the server closes subscribes again. rediss:// URLs connect over TLS, for the facade and for the cache, queue and rate limiter URLs; the framework installs rustls's ring provider unless the application installed one. pipeline sends its commands before reading a reply and transaction wraps them in MULTI and EXEC. subscribe, psubscribe and the blocking commands (blpop, brpop, blmove, brpoplpush, bzpopmin, bzpopmax) each run on a connection of their own. With Redis::enable_events, Redis::listen and Redis::listen_for_failures hear every command outside a pipeline or a transaction.
  • Log channels. LOG_CHANNEL names the channel tracing's events go to, still stdout unless set: stderr (or errorlog), single (storage/logs/suprnova.log), daily (a file a day, keeping LOG_DAILY_DAYS, 14), monthly (keeping 3), syslog (the local socket, LOG_SYSLOG_FACILITY), null, and stack (the channels LOG_STACK lists). Log::define adds a channel in the bootstrap and Log::extend a driver, through the LogSink trait. Log::channel, Log::stack and Log::build return a logger with Laravel's eight levels and a JSON context whose values fill {key} placeholders; a broken channel in a stack stops none of the others. File channels flush at once for errors, within a second otherwise, and on Log::flush and shutdown. MAIL_LOG_CHANNEL routes the log mail transport. A channel that does not exist fails boot. logging::build_subscriber builds the subscriber the server installs, for an application or a test that installs its own.
  • A Process facade. Process::command(["git", "status"]) runs a program with its arguments, each passed as it is through no shell, and Process::shell("npm ci && npm run build") runs a command line through the system shell, as Laravel runs a string command. run returns the exit code and the captured output; a nonzero exit is a failed result, and throw makes it an error. path, env, input, quietly, tty, an output callback, a timeout (60 seconds unless set) and an idle timeout are options. A timeout, an idle timeout, stop, or dropping a started process or the future of run kills the program with every process it started: its process group on Unix, its tree for a tty process and on Windows. A started process's timeouts hold whether or not anything waits on it. Results keep the raw bytes as well as the text. start returns the program running; Process::pool() runs processes side by side with an optional concurrency limit, and Process::pipe() feeds each output to the next input. Process::fake() stops every process in a test, answers by pattern, describe and sequence, and records each run for the assertions.
  • An SQS queue driver. QUEUE_DRIVER=sqs queues jobs on Amazon SQS standard queues, configured by Laravel's variables: SQS_PREFIX, SQS_QUEUE and SQS_SUFFIX build the queue URL, AWS_DEFAULT_REGION (or AWS_REGION) names the region, and AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY sign the requests, or the default credential chain of AWS when they are not set. SQS_ENDPOINT points it at LocalStack or ElasticMQ, and QUEUE_CONNECTIONS and failover accept sqs. A job goes to the queue it names, and a worker receives from the queues --queue lists, or from SQS_QUEUE. A nack counts an attempt and a release does not, as on the other drivers, and a delay longer than the 15 minutes SQS allows still holds. With SQS_OVERFLOW_ENABLED=true, a job of 1 MiB or more is stored on a disk and SQS carries a pointer to it. The boot fails with no region, with a queue name and no SQS_PREFIX, and for a FIFO queue. A receive waits up to SQS_WAIT_TIME_SECONDS (default
    1. for a message, a throttled or failed request is tried up to three times, and SqsConfig with SqsQueueDriver::new builds a driver in code for a second connection. SqsQueueDriver::call sends any other SQS action. The driver is behind the queue-sqs feature, on by default.
  • A default disk. Storage::default_disk() returns the disk Storage::set_default_disk names in code, or else FILESYSTEM_DISK. When the named disk is not registered once the bootstrap has run, filesystem::bootstrap_from_env fails and the server does not boot. With nothing named there is no default, and default_disk() returns an error that names FILESYSTEM_DISK. Calls that name their disk are unchanged. What to check when you upgrade: FILESYSTEM_DISK was not read before, so an application that carries FILESYSTEM_DISK=local from a Laravel .env now refuses to boot unless it registers a disk named local: register it, or remove the variable. An application that calls filesystem::bootstrap_from_env in its own bootstrap calls it after it registers its disks and sets the default.
  • A failed request's error report reaches TestResponse. A response the framework builds from an error carries an ErrorReport in its in-process extensions: the error and each of its sources, or, for a panic the panic boundary caught, the panic message and the location it was raised at. That covers a FrameworkError a handler or middleware returns, a panic on an HTTP route or in a WebSocket upgrade's middleware, the 5xx the framework's session, session lock, throttle, rate limit, login throttle, timeout, and RenderCache middleware answer a failure with, and the 5xx of the payment webhook route and of the Live endpoints when the endpoint holds the error. The report never reaches a header or the body, so what a client receives is unchanged; with debug on, a 5xx body still carries debug_message as before. The new TestResponse::from_response builds from the response handle_request returns and keeps the report, and every failing assertion then ends with an error report: section, so a 500 says why it happened. assert_inertia() and the AssertableInertia assertions print it too, and the Inertia error page and validation redirect keep the report of the response they replace. TestResponse::error_report and HttpResponse::error_report expose it. The report belongs to its own response, so two requests in flight in one test process never mix their errors. To find a panic's location, the framework wraps the process panic hook once and calls the hook it replaced. This landed on main after the v3.0.0 tag.
  • A development error page. With debug on, a 5xx the framework built from an error or a caught panic, sent to a browser (an Accept that lists text/html) or an Inertia visit, becomes one HTML document with the same status: the error chain or the panic message and location, the stack frames recorded where the error was created, and the request's method, path, query, headers, matched route pattern and request id. The application's frames are shown; the frames of the framework, the async runtime, other dependencies and the standard library are collapsed behind a count. The FrameworkError and AppError constructors, the From conversions into FrameworkError, the abort_with, abort_if and abort_unless helpers and the #[domain_error] conversions are now #[track_caller], so the page names the line that called them even in a build without debug info; a call from inside Result::map_err names that line of the toolchain, and the frames name the handler. Without debug info, the handler and middleware the framework's dispatch polls are the application's frames. The page redacts the Authorization, Proxy-Authorization, Cookie and Set-Cookie headers, every header and query parameter whose name contains token, secret, password, key or signature, every such parameter in any other shown value (a Referer or X-Original-URI that repeats the URL), and the password of a URL, and it never shows the request body, environment variables or configuration values. It loads nothing and runs no script, so it renders when the frontend build, the Vite manifest or Inertia is what failed, and it carries Cache-Control: no-store and a Content-Security-Policy that allows no script. For those responses it takes the place of the app's Inertia error page. A JSON client keeps the JSON body with debug_message, a 4xx and a 5xx built without an error are unchanged, and with debug off the framework records no frames, captures nothing about the request, and sends every response as before. This landed on main after the v3.0.0 tag.
  • A Pusher-protocol broadcast driver. PusherBroadcastHub publishes broadcasts through the REST API that Pusher Channels, Soketi and Laravel Reverb share, and still delivers them to in-process subscribers, so a ws! broadcasting route keeps working. PusherConfig::from_env() reads Laravel's PUSHER_* variables, and from_env_prefix("REVERB") reads Reverb's. pusher_channel_auth and pusher_user_auth answer Laravel Echo's authorization requests for private, presence and end-to-end encrypted channels. The new Channel::visibility picks each channel's Pusher name and defaults to private, so a channel that restricts authorize can never leak through a public Pusher channel. A name that would read as another channel's Pusher name, and an encrypted presence channel, are refused rather than published, and an invalid configuration fails when the hub is built. Publishing to an encrypted channel without a master key is an error, never a plaintext send. This landed on main after the v3.0.0 tag (#130).
  • InertiaProps and Data follow serde's field names. Both derives honor #[serde(rename_all = "...")] on the struct, and rename, skip, skip_serializing and skip_deserializing on a field, including the split serialize = .., deserialize = .. forms; any other serde attribute is a compile error. The names reach everything the client sees: Inertia props and partial reloads, the ?include= allowlist, JSON:API members, request input, route-parameter injection, and suprnova generate-types. Validation errors of a Data, #[derive(FormRequest)] or #[request] struct are keyed by the input names at every nested level, so Precognition-Validate-Only matches what the client sent, and a message labels unitPrice as "unit price", as Laravel does. A raw identifier such as r#type is sent and read as type. A plain nested #[derive(Deserialize, Validate)] struct registers its names with the new #[derive(suprnova::InputNames)]. This landed on main after the v3.0.0 tag (#124). Two consequences for existing code. A #[serde(...)] attribute on an InertiaProps or Data struct used to compile only next to another derive that registers serde (such as schemars), and did nothing there; it now takes effect, and an attribute the derive does not apply is a compile error. A localized validation message labels every key snake-cased, so a hand-written key userID reads "user i d", as in Laravel; snake_case keys read as before. A #[json_resource] struct may no longer send an attribute or relationship named type or id, which JSON:API reserves: a struct with a custom id_field and a field named id, or a field r#type (sent as r#type before), is now a compile error that asks for a #[serde(rename = "...")].
  • The schema builder covers the rest of a Laravel migration. unsigned_id() and unsigned_foreign_id() create Laravel's BIGINT UNSIGNED keys on MySQL, so a new table can point a foreign key at an existing Laravel table, and a model reads them with key_type = "u64". New columns: tiny_integer, the unsigned_ integers, medium_text, long_text, enumeration (Laravel's enum) and remember_token. New modifiers: .unsigned(), .index(), .primary(), .precision(n), .use_current() and .after(column). t.primary(&[..]) makes a composite primary key, t.foreign(column) a foreign key on a column declared on its own, .name(..) names a key, and drop_constrained_foreign_id drops a key with its column. The actions have Laravel's shorthands, cascade_on_delete() and the rest. Where the databases differ the builder does what Laravel does: unsigned and after apply on MySQL only, and an enumeration is a string with a CHECK off MySQL. This landed on main after the v3.0.0 tag (#122).
  • Native date-time columns for models. AsNativeDateTime and AsOptionalNativeDateTime store a DateTime<Utc> in a column that keeps the zone (timestamp with time zone on Postgres, TIMESTAMP or DATETIME on MySQL); AsNaiveDateTime and AsOptionalNaiveDateTime store the UTC wall clock in one without a zone, the shape Laravel's timestamps() creates on Postgres. The schema builder gains Laravel's timestamps_tz(), soft_deletes_tz(), datetimes() and soft_deletes_datetime() to create them. Automatic timestamps, touch(), soft deletes and the touch of an owner all store through the declared cast, and query comparisons (filter, where_between, where_date, update_all, where_has) bind through it, so Postgres gets a native parameter. A model may declare created_at and updated_at as Option<DateTime<Utc>> for a table another application leaves NULL. suprnova generate-types now emits chrono's date and time types as string instead of unknown. This landed on main after the v3.0.0 tag.
  • Laravel's exists, accepted, digits, date_format, date comparison, prohibited, missing and exclude_if rules. Exists checks that a value names a row, scoped with where_eq; check_value binds a typed id, which Postgres needs for an integer column, and check_each checks every element of an array, one query per distinct value, with each failure under field.<index>. Accepted, Digits, DateFormat (chrono's format syntax, checked by a round trip like Laravel's), After::new, AfterOrEqual::new, Before::new and BeforeOrEqual::new (against a fixed date, Now, Today, Tomorrow, Yesterday or another field, with .format(..) for a field that is not ISO 8601), Prohibited, Missing, ExcludeIf and ExcludeUnless join the built-in rules. validate! now runs a row's rules in order, each expression evaluated once, and stops at an exclusion, as Laravel does. This landed on main after the v3.0.0 tag.
  • A Data Object runs validate! and database rules. The derive writes a Data Object's FormRequest impl, so it had no place for cross-field rules or for Unique and Exists. #[data(after_validation = "fn")] and #[data(after_validation_async = "fn")] name the functions that impl calls, and the impl a from_route_param field selects now runs the async stage too. That impl now calls the hooks through the trait, so an inherent after_validation method on such a Data Object, which it used to call by accident, no longer runs: name it with the attribute. The derive refuses both attributes on a struct that gets no FormRequest impl. This landed on main after the v3.0.0 tag.
  • Joins and the remaining where helpers on both query builders. DB::table and model queries gain join, left_join, right_join and cross_join with table aliases; closure conditions combining on, or_on, where and or_where; join_sub and left_join_sub against another builder; where_exists and where_not_exists; where_any, where_all and where_none with their or_ forms; subqueries in where_in and where_not_in; the or_where_* family; and reorder. Every value stays bound and every identifier is quoted for the backend, so reports and exports no longer need raw SQL. A joined model query selects its own table's columns, so the joined table's id never overwrites the model's, and its soft-delete filter names its table. DB::table now quotes identifiers in every statement, so on Postgres a mixed-case name is case-sensitive, as in Laravel. An update or delete on a query with a join is refused rather than run without the join. This landed on main after the v3.0.0 tag (#125, #128).
  • File and download responses. HttpResponse::file shows a file inline, HttpResponse::download sends it as an attachment, and HttpResponse::download_bytes sends generated bytes; Storage::response and Storage::download do the same for a path on a named disk, through the disk's path guard. Files stream, the content type comes from the extension, a missing file answers 404 and a path the guard refuses 403. Every Content-Disposition follows RFC 6266, with an ASCII fallback transliterated as Laravel does and a filename* for the full name, so Certificat·Joan Pérez.pdf arrives intact and no name can inject a header. This landed on main after the v3.0.0 tag (#126).
  • A configurable Inertia page lookup. inertia_response! reads an optional [package.metadata.suprnova.inertia] table from the application's Cargo.toml: pages_dir moves the pages directory, and page_file maps a component name to its file with {dir}, {name} and the lower, kebab and snake filters. Angular and other layouts keep the compile-time page check, and a missing page names the exact path the macro looked for. Without the table nothing changes. This landed on main after the v3.0.0 tag (#129).
  • The queue fake can let jobs through and records raw pushes. Queue::fake_except and QueueFakeGuard::except record every job but the named ones, which reach the real queue. Queue::push_raw pushes an envelope's JSON form, and under the fake raw_pushes and pushed_raw read those pushes back. assert_pushed_without_chain fails for a job pushed with a chain. A chain whose first job except names runs on the real queue, and each later link is recorded unless except names it too. This landed on main after the v3.0.0 tag.
  • Declarative authorization on handlers. #[authorize("update-post", post)] on a #[handler] checks the gate against the model the route binds to post, and #[authorize("create-post", Post)] checks it against the type, for the user of the guard the route authenticated with. The check runs after route model binding and before the request body is read, so a forgotten Gate::authorize call can no longer leave a route open. Policies, async gates and the RBAC gate bridge all answer it. A guest gets 401, a denial 403, and deny_as_not_found() 404. A parameter name the handler does not take fails to compile. This landed on main after the v3.0.0 tag (#127).
  • Model changes after a save, sync_without_detaching, and after-commit callbacks. A model reports what its last update changed (was_changed, was_changed_any, get_changes), and get_original and get_raw_original return the loaded values while its updated and saved observers run, as Laravel's do; once the save returns, the original is the saved row. An encrypted column counts as changed only when its decrypted value changed. sync_without_detaching attaches pivot rows without touching the existing ones. DB::after_commit runs a callback after the ambient DB::transaction commits, and never on rollback; a transaction started with DB::begin_transaction takes its own tx.after_commit and Queue::push_after_commit_with_tx, because ambient code is outside that transaction. This landed on main after the v3.0.0 tag (#128).

Changed

  • Less memory for the same work. Model events are built only when a listener, a fake or a deferral will see them, so a query no longer copies every row it reads for a Retrieved event nobody hears. Eager loading reads each key from its field instead of serializing the whole row, and a runtime cast converts its column where it sits. The first Inertia page is written into one buffer, a file download reads each chunk straight into the bytes it sends, a body sent in several frames is held at its length, CORS path patterns are compiled once per configuration, and a broadcast's last channel takes the payload instead of a copy. A queue job receives its envelope's payload, the SQS driver parses a message once, sends a retried request's bytes without copying them and holds a reservation's body rather than a second envelope. Context::push, image transformations and encoding, filesystem append and prepend, Collection::pluck, the in-memory vector search, the feature-flag snapshot, Mailgun's form, composite render-cache shells and the docs builder each keep or copy less. A process result holds its output once when the output is valid UTF-8. In the Live engine a mount no longer copies its signed snapshot, action arguments are kept once, a full upload read returns the store's bytes, and the resource queue compacts in place. The Live browser runtime reads a server-sent event stream without copying what it already holds for every chunk, and an upload control response no longer allocates 16 KiB. Magnetar writes hex into one buffer, and its single-flight map holds a key only while a caller holds or waits on it. Every response, file, digest and snapshot is byte for byte what it was.
  • CacheConfig has a sweep_interval field. Code that builds a CacheConfig as a struct literal has to set it, or use CacheConfig::builder(), which defaults it to 60.
  • DynCast has a from_storage_json_owned method that converts a stored value the caller no longer needs. Its default calls from_storage_json; a cast whose in-memory value is the stored value returns it without copying.

Fixed

  • A workflow step can take an integer argument. #[workflow_step] handed the step's body to the workflow context in a closure that borrowed its arguments, and the context needs one it can keep, so a step taking a Copy argument such as user_id: i64 failed to compile with E0373 ("closure may outlive the current function"). The closure now takes its arguments by value.
  • Workers wait for their queued listeners. queue:work, schedule:work and workflow:work now wait, up to ten seconds, for the queued event listeners still running when they stop, as the server does, and schedule:run does once its tasks have run; returning dropped them part way.
  • Cache::bootstrap keeps the cache store the application bound, as the localization chapter says it does, instead of replacing it at boot.
  • The event dispatcher forgets its finished queued listeners as it starts new ones; it kept every one until shutdown.
  • DB::flush_query_log releases the log's buffer rather than keeping its capacity.
  • The in-memory vector search no longer panics on a NaN score; such an item ranks below every other.
  • A #[json_resource] keeps its attributes in declaration order when it drops a missing one; the last attribute used to move into its place.
  • The brute-force lockout map sweeps once each time it doubles. With more than 1,024 current lockouts it swept on every new lockout.
  • The toast region lets go of toasts a morph removed, which it timed and later dismissed for the life of the page, and resumes its timers when the focused toast is removed or the pointer has left it without the region hearing it.
  • The Live browser runtime reads a network chunk larger than one record when the chunk holds only complete records; it ended the stream.
  • The Live chart follows the document's theme. render_chart drew its SVG with charts-rs's light theme, a white background and fixed colors and font, so in a dark document the chart showed as a white box. The SVG now has a transparent background and no color or font of its own: its text, axis, grid and series carry classes that the chart component's stylesheet colors from --sn- tokens, and the chart's text takes the --sn-font-sans font. Series take the new --sn-color-chart-1 to --sn-color-chart-6 palette in order, defined for light and dark and mapped in the Tailwind preset, and a seventh series starts the palette again. An application that vendored the chart keeps its old stylesheet, which has no rule for these classes, so every series, axis and grid line draws in the text color. Run suprnova live:add chart to take the fix into it. This fix landed on main after the v3.0.0 tag.
  • A cached render whose COMMIT fails answers 500 without a panic. When a cache-miss render's handler ran and the database then refused the render transaction's COMMIT (a deferred constraint, a dropped connection), the render cache took the failure for a transaction that never opened: a debug build panicked, and the log said nothing about the commit. It now logs the database error under suprnova::database and answers the same 500, because the handler's writes rolled back and the rendered page would claim they landed. A render transaction that cannot open still renders uncached, as before. This fix landed on main after the v3.0.0 tag.
  • A savepoint can be named with a reserved word. tx.savepoint("inner") failed with a syntax error on PostgreSQL and MySQL, because the validated name went into the statement unquoted. Savepoint names are now quoted for the backend; they stay case-insensitive. This fix landed on main after the v3.0.0 tag.
  • The sync queue driver runs a whole chain. SyncQueueDriver ran a chain's first job and dropped every later link. It now runs the chain inline, link by link, as Laravel's sync queue does; a link that fails returns its error and the rest of the chain does not run. This fix landed on main after the v3.0.0 tag.
  • authorize_resource checks the user of the route's guard. On a route whose AuthMiddleware names a guard other than the default, authorize_resource checked the default guard's user instead of the one the route authenticated, so that user was refused. It now checks the route guard's user, as Laravel's can middleware does. This fix landed on main after the v3.0.0 tag (#127).
  • A cached page that reads through a raw fragment is never served stale. A select_raw, where_raw, filter_raw or order_by_raw on a model query can read a table the query doesn't name, but the render cache stored the page anyway, so a write to that table left it stale. A query carrying a raw fragment now keeps the page out of the cache, as raw DB::select does; the page is still served. A select_raw that is a bare number, such as select_raw("1"), doesn't count. This fix landed on main after the v3.0.0 tag.
  • A destructured route parameter binds. A handler parameter written RouteParam(user): RouteParam<User>, as the RouteParam docs show, looked up a route parameter named param and answered 400 to every request. It now reads the parameter its binding names, and a pattern with no single binding is a compile error. This fix landed on main after the v3.0.0 tag.
  • SQLite rows keep computed columns. An aggregate or select_raw expression came back missing from DB::table and DB::select rows on SQLite, because SQLite declares no type for a computed column. Such a column is now read by its value's runtime type. This fix landed on main after the v3.0.0 tag.
  • A union arm keeps its soft-delete and scope filters. A union of model queries rendered each arm's WHERE without its scopes, so soft-deleted rows came back. This fix landed on main after the v3.0.0 tag.
  • A page cached from where_has sees writes to the related table. has, where_has, doesnt_have and where_relation did not record the related or pivot table for the render cache, so a write there left the cached page stale. This fix landed on main after the v3.0.0 tag.
  • The notifications table ships as a migration. The manual said suprnova migrate creates it, but the schema was a SQL file only the framework's own tests loaded, so the database channel failed on its first write in a fresh app. Register suprnova::notifications::migrations::CreateNotificationsTable in your Migrator: it creates the same table and indexes, and running it over a table you created by hand from the old SQL file is safe on every engine. The SQL file is gone. This fix landed on main after the v3.0.0 tag (#134).
  • Nullable JSON columns have casts. AsJson, AsArray, AsObject, AsCollection and AsArrayObject store a non-null string, so AsJson<Option<T>> wrote the text null instead of SQL NULL, and a row whose column was NULL failed to load. AsOptionalJson, AsOptionalArray, AsOptionalObject, AsOptionalCollection and AsOptionalArrayObject map None to NULL and back, and store a value exactly as their non-optional cast does. This fix landed on main after the v3.0.0 tag (#133).
  • SESSION_TABLE names the session table. SessionConfig::table_name was read and then ignored: the database session driver always used sessions. The driver now reads and writes the configured table, DatabaseSessionDriver::with_table builds one over another table, and Config::init refuses a name that is not 1 to 63 ASCII letters, digits or underscores starting with a letter or underscore. What you have to change: an app that already set SESSION_TABLE now stores its sessions in that table, which its migration must create, and an empty SESSION_TABLE now fails boot. The driver also stops logging a session id when it skips a write, and the content of a stored payload it cannot parse. This fix landed on main after the v3.0.0 tag (#132).
  • Re-running a framework migration no longer fails on an existing index. The workflow and RenderCache migrations relied on IF NOT EXISTS, which MySQL and MariaDB drop from CREATE INDEX, and the payments, features and RBAC migrations created their indexes without it, so running one over tables that already existed failed with a duplicate index and blocked every migration after it. Each framework migration now creates an index only when it is missing, with the same columns and uniqueness as before. This fix landed on main after the v3.0.0 tag (#136).
  • A Data object with a route-parameter field answers 422 for a body that does not fit. Its extractor answered 400 where the default extractor answers 422 for the same malformed or unknown-key body. This fix landed on main after the v3.0.0 tag.
  • A Data field may be named key or map. The generated Deserialize named its locals after the fields, so such a field shadowed the visitor's own variables and the struct failed to compile. This fix landed on main after the v3.0.0 tag.
  • has, where_has and where_relation work through a BelongsTo relation. The existence query compared the related table's key with the foreign key as if the relation were a HasMany, so every existence query through a BelongsTo failed with an unknown column. It now joins the related row's owner key to the parent's foreign key. This fix landed on main after the v3.0.0 tag.
  • A model declared beside use sea_orm_migration::prelude::* compiles. That prelude brings ExprTrait into scope, whose max and is_null took over calls the #[model] macro emitted for relation counts and MorphTo relations. The macro now names those methods by path. This fix landed on main after the v3.0.0 tag.
  • Persisting a replica stamps its timestamps. replicate resets created_at and updated_at for the insert to fill, but persist wrote them as built: 1970-01-01, or NULL for an optional field. It now stamps a timestamp its builder left unset, as create does, and keeps one the builder set, so a factory can still backdate a row. This fix landed on main after the v3.0.0 tag.
  • Touching an owner writes the owner's own date-time storage. The touches cascade bound the time as RFC 3339 text whatever the owner's updated_at cast stored, which Postgres refuses for a native date-time column. It now stores the time through the owner's cast. This fix landed on main after the v3.0.0 tag.
  • The temporal casts' documentation said Postgres accepts RFC 3339 text for a native column. It refuses a text parameter for timestamp and timestamp with time zone; the module documentation now says so and points to the native casts. This fix landed on main after the v3.0.0 tag.
  • Unique and Exists keep database errors out of the response. A database rule that could not run returned the driver's error as its validation message, and a validation message is rendered into the 422 body, so a client could read table names, column types and SQL. The rule now logs the cause under the suprnova::validation target and fails the field with validation-unchecked. This fix landed on main after the v3.0.0 tag.
  • Precognition keeps the errors of an array's elements. A Precognition-Validate-Only header naming tag_ids dropped the errors reported under tag_ids.0, tag_ids.1 and so on, so a form validating the field saw success for an invalid array. A field now keeps the errors nested under it, and tag_ids.* matches the elements as Laravel's rule key does. This fix landed on main after the v3.0.0 tag.
  • The date picker, upload, account menu and notification bell follow the theme. Their stylesheets read --sn-color-accent and --sn-color-on-accent, which the token stylesheet never defined, so the selected day, the upload progress bar, the avatar and the unread count fell back to inherited colors and ignored every theme. The token stylesheet now defines both, from --sn-color-primary and --sn-color-primary-contrast, and the Tailwind preset maps them as accent and on-accent. An application that vendored these components with live:add needs no change: the framework serves the corrected stylesheet. This fix landed on main after the v3.0.0 tag.
  • A first live:model edit on a public seed promotes it. The browser runtime sends an immediate live:model edit on a public-seed island as a model synchronization with no action, and the action endpoint promoted a seed only for an action, so the first keystroke in such an island answered 500. The endpoint now promotes the seed on that request, applies the proposals as it does on an instance, and runs no action. This fix landed on main after the v3.0.0 tag.
  • The date picker's "Pick the parts" toggle no longer looks like a second field. The base layer draws every details as a bordered surface for the collapsible, and the date picker's disclosure inherited it, so an empty box sat under the date input. The disclosure is now a plain toggle; the year, month and day strips keep their borders. Run suprnova live:add date-picker to take the fix into an application that vendored the component. This fix landed on main after the v3.0.0 tag.
  • suprnova generate-types names and omits plain-struct keys the way serde does. A struct a prop reaches that derives serde's Serialize sends the keys its #[serde(...)] attributes give it, but the generator declared every field under its Rust name. It now leaves out skip and skip_serializing fields, declares skip_serializing_if fields optional, names keys by rename and rename_all (and their serialize = ... forms), and drops the r# of a raw identifier. Other serde attributes, such as flatten and transparent, are still not read. A key that is not an identifier is now quoted, which also makes a raw identifier on a derived struct valid TypeScript ("r#type", the key its derive sends). #[derive(Data)] and #[derive(InertiaProps)] structs keep their Rust names: their own Serialize never reads #[serde(...)]. This fix landed on main after the v3.0.0 tag.

3.0.0 - 2026-09-29

Added

  • FrameworkError::Timeout tells a passed deadline from a failure. WorkflowHandle::wait_with_timeout documented a timeout error that did not exist and returned FrameworkError::Internal, so a caller could not tell a workflow that is still running from a failed status query. The variant carries the deadline and what was awaited, FrameworkError::timeout(elapsed, message) builds one, is_timeout() asks for it, and it renders as 504 Gateway Timeout. wait_with_timeout and wait_with_options return it when the deadline fires.
  • Queue::fake() and Bus::fake() install their fakes. Every other facade had fake(); these two had only the free function testing::install_fake(). Both return the same guard, and the free functions stay.
  • Failed-job commands: queue:failed, queue:retry, queue:forget, queue:flush and queue:prune-failed. The manual and the code's own docs sent operators to commands that did not exist; the failed-job store could only be reached from code. The application binary now has all five, and the suprnova CLI forwards them. queue:failed lists id, connection, queue, job, failure time and the first line of the error. queue:retry takes one or more ids, or all. queue:flush deletes every failed job, or with --hours N the ones older than that. queue:prune-failed is the same with --hours defaulting to 24. A command exits non-zero when an id names no failed job.
  • Queued mail and notifications can wait for the commit. Mailable::after_commit(&self) and Notification::after_commit(&self) default to false. When one answers true, Mail::queue, Mail::later and Notify::queue inside DB::transaction push at the commit, and a rollback discards the push, as Job::after_commit already does for a job. QUEUE_AFTER_COMMIT=true turns the same behavior on for every push in the process, as the after_commit option of a Laravel queue connection does; EnvelopeOverrides { after_commit: Some(false), .. } still sends one push ahead of the commit.
  • Queue connections select a driver. One process-global driver received every push, and a job's connection was only a name on the lifecycle events. Queue::register_connection(name, driver) now registers a named connection next to the default one that Queue::set_driver installs, and a push goes to the connection it resolves to: a per-push EnvelopeOverrides::connection, then a Queue::route, then Job::connection(), then the default. Queue::push, push_with, later, bulk and push_unique all resolve it, the jobs of a batch each go to their own connection, and a failed job is retried on the connection it failed on. queue:work --connection <name> and queue::worker::run_worker_on drain one connection, and the worker carries its name on its events and failed-job records. queue:pause and queue:resume take --connection. Queue::connection(name) returns a connection's driver and Queue::connection_names() lists the registered ones; Queue::size() and the other counts and listings read the default connection. While no connection is registered nothing changes: every push reaches the one driver, and a connection name is a label. Once one is registered, a push to a name that is neither registered nor the default's is an error and pushes nothing, and a push that waits for a commit is refused before the commit. A chain runs on the connection of its first job, because the worker enqueues the next link in the step that settles the one before it; Queue::chain().dispatch() refuses a chain whose links resolve to different connections. QUEUE_CONNECTIONS=redis,database registers one connection per entry from the environment, each named for its driver. One driver has one label: an entry that names the driver QUEUE_DRIVER selects is a second name for the default connection, so a pause or a Queue::forward_on set under either name reaches the whole queue, and an entry that would put a second connection over a Redis stream or a jobs table that is already in use is refused at boot.
  • Context travels with queued work. A value added to Context during a request was gone when a queued job, a queued mail or notification, or a queued event listener ran. A push now takes a ContextSnapshot of the visible and hidden bags and stores it on the envelope, and the worker runs the job inside a scope restored from it. The snapshot is taken when the push is made, so a push that waits for a commit carries it too. The lifecycle events around the job, such as JobProcessing, JobProcessed and JobFailed, are dispatched in the same scope, so a listener reads what the job read and what the job added. Every link of a chain and every job of a batch gets the snapshot of the code that dispatched it, and a queued listener gets the snapshot of the dispatch. The work runs on a copy, so what a job adds reaches neither the request nor the next job, and every attempt starts from the snapshot. Under the sync driver the copy shadows the caller's context for the length of the job. The query bag does not travel, so a job run inline no longer reads the request's query parameters. A job queued while a request is served carries the request's id as _request_id, which the request middleware adds to the context; a push made outside a request with nothing in its context writes the envelope it wrote before. Context::dehydrating and Context::hydrated register callbacks for the two ends, as Laravel's hooks of those names do, with Context::dehydrate, Context::hydrate and Context::restored as the functions behind them. Envelope gains the public field context, so code that builds one with a struct literal has to name it; an envelope written before the field existed decodes without context. Hidden values reach the queue store and the failed-job store, because the job needs them. They do not reach a log: the envelope a worker logs when no failed-job store is bound carries no hidden context, and the Debug output of ContextSnapshot and ContextStore names hidden keys only, and that of FailedJob gives the size of the envelope and not its text.
  • ThrottleRequestsMiddleware::default(). The plain throttle alias had no limit to register: every constructor asked for a limit, a window and a key prefix, and the manual registered the alias with a default() that did not exist. The default is 60 requests a minute, counted for each signed-in user and for each client IP when nobody is signed in, the shape of Laravel's default api limiter. The numbers are ThrottleRequestsMiddleware::DEFAULT_MAX_ATTEMPTS and DEFAULT_DECAY_SECONDS. The user's bucket follows the user across routes, and the address's bucket is shared by every route; .prefix(...) gives a group of routes a budget of its own.
  • RateLimitMiddleware::ip_based(max_requests, window). The per-IP limit that every login form and public API needs took a backend Arc, a SlidingWindowConfig and a hand-written key closure, and the manual used an ip_based that did not exist. It uses the rate limiter the application installed, the one RATE_LIMIT_DRIVER selects, looked up when a request arrives, so the middleware can be built where routes are registered. The key is the address Request::ip() resolves through the trusted proxies, and it names the limit as well, so two limits with different numbers share no bucket. A request with no address to resolve gets a bucket of its own. on_backend_error, only_when and key_reads_body chain onto it; when no limiter is installed the backend error policy decides.
  • Middleware by name on routes. Aliases and groups could be registered and resolved, but no route took a name: every .middleware(...) wanted a type, and nothing parsed throttle:60,1. Routes, groups of routes and the macro builders now have .middleware_named("auth"), which takes an alias, an alias with arguments, or a group that adds every middleware of the group in order. The name is resolved when the route is registered, so a name that is not registered stops the boot and never a request; .try_middleware_named(...) returns the error. register_middleware_alias_with_args(name, |arguments| ...) registers an alias that reads the arguments after the colon, and a group may list such an alias. try_resolve_middleware_alias says why an alias gave no middleware. ThrottleRequestsMiddleware::from_alias_args is the factory for the throttle alias: throttle, throttle:60, throttle:60,5, throttle:60,5,prefix and throttle:api for a named limiter.
  • Route groups take a name prefix and a controller. Every route in an admin. group had to spell its full name, and every handler its full path. group!(...).name("admin.users.") now puts the prefix in front of the name of every route in the group, and a group inside adds its own after it; a route without a name stays without one. group!("/admin/users", controller = controllers::admin::users, { get!("/", index), post!("/", store) }) names the module the handlers live in, so a route names its handler by function alone. A handler written as a path is taken as it is written, and a group inside names its own controller. The path prefix stays the first argument of the macro.
  • Optional route parameters and parameter constraints. /posts/{id?} now matches /posts and /posts/42, and the handler finds no id on the short form. Several optional parameters fill from the left, the colon spelling /posts/:id? works, and an optional parameter can only be followed by optional ones. The route's middleware and name apply to every form, and route(...) leaves an optional segment out when it has no value. A route can hold a parameter to a constraint: .where_number("id"), .where_alpha, .where_alpha_numeric, .where_uuid, .where_ulid, .where_in("status", [...]) and .where_pattern("year", "[0-9]{4}"), on Router routes and on get!, post! and the other route macros, where a constraint may name a parameter of the group's prefix. A value the constraint refuses is a 404, as if the route had not matched, and neither the route's middleware nor its handler runs. On a Router route .try_constrain(param, ParamConstraint) returns the error a constraint on a parameter the route does not have gives; .constrain and the where_* spellings stop the boot on it. A pattern has to match the whole value, and \d matches the digits of every script, so write [0-9] for ASCII digits. A WebSocket route takes optional parameters as well. A pattern with an optional parameter and an empty segment, and a second route for one form of an optional route, are refused when they are registered.
  • Console commands can be tested for what they print and ask: console::test. dispatch_argv returns a Result and nothing else, so a test could tell that a command ran and not what it said, and a command that asks a question waited on the standard input of the test runner. console::test(["users:purge", "--days", "30"]).expects_question("Delete 12 users?", "yes").run().await runs the command through the dispatcher the console binary uses and returns a ConsoleRun with output(), errors(), exit_code(), error() and unasked_questions(), and with assert_successful, assert_failed, assert_output_contains, assert_errors_contain and assert_every_question_was_asked. Help, the version, parse errors and the error of a failed command are collected as well. A command prints with console::line and console::error_line and asks with console::ask and console::confirm; what it prints with println! a test cannot see. Questions have to come in the order the test gave them, and a question with no prepared answer fails the command. The framework's own commands, db:seed and model:prune among them, print through the console now, and make:command generates a command that does.
  • Schedule::command("emails:send --force") puts a console command on the schedule. The schedule took a Task or a closure, so a command of the application, or a builtin such as model:prune, could only be scheduled by wrapping it by hand. command takes the line the way it is typed behind the name of the console binary, splits it into words the way a shell does, and returns the TaskBuilder every other task uses, so daily(), without_overlapping() and on_one_server() apply. The command runs in the scheduler's process. The line is checked when the schedule is built: a name no command has, arguments the command does not take, and a quote that is not closed stop the boot, and try_command returns the error. The task is named by its command line and described by the command's about text.
  • suprnova db:seed and suprnova model:prune. The console binary has had both commands, and the manual shows them through the CLI, but the CLI forwarded migrate and its siblings and not these two, so the step after suprnova migrate was cargo run --bin console -- db:seed. suprnova db:seed runs every seeder, and suprnova db:seed UserSeeder or --class=UserSeeder runs one. suprnova model:prune takes --model=<Name> and --pretend. Both run the project's console binary, which checks the names.
  • QdrantVectorDriver::from_env() and MariaDbVectorDriver::from_env(). Only the Pinecone driver read its configuration from the environment, so choosing the vector store by environment needed hand-written std::env::var code for the other two. The Qdrant driver reads QDRANT_URL and, when it is set, QDRANT_API_KEY. The MariaDB driver reads MARIADB_URL, and DATABASE_URL when that is not set and names a MariaDB or a MySQL database, which is the setup with one engine for rows and vectors. A DATABASE_URL of another engine is not taken. A mysql:// URL is taken as well, because a MariaDB is written that way too. The Qdrant client is built without its version check, which connects and blocks while the application boots. A variable that is missing is named in the error at boot, and the error never shows a URL.
  • Storage configures an S3 disk from the environment. Mail, the queue and the rate limiter read their configuration from .env when the server boots; storage read no variable, so an S3 or S3-compatible disk (MinIO, RustFS, R2, B2) existed only when the application built an S3Config by hand, and the .env the Docker guide shows configured nothing. When S3_BUCKET is set, the server now registers an S3 disk named s3 from S3_BUCKET, S3_REGION, S3_ENDPOINT, S3_ACCESS_KEY, S3_SECRET_KEY and S3_ROOT. With no keys set the driver uses the default credential chain of AWS, and AWS_REGION is read when S3_REGION is not set. What to check when you upgrade: an application that already sets S3_BUCKET for a disk of its own gets the s3 disk as well, and the server does not boot when the variables describe no usable disk: no region, or one key without the other. A disk the application registered under the name s3 is left as it is, and the variables are not read then. S3Config::from_env() returns the same configuration for a disk with a name of your own, and filesystem::bootstrap_from_env() is the function the server calls; the console binary boots no driver of the environment, so an application whose commands use the disk calls it in its own bootstrap. There is still no default disk, and FILESYSTEM_DISK is not read.
  • Storage::url(disk, path) returns the public URL of a file. Storage had presigned links that expire, temporary_url and temporary_upload_url, and nothing for a file that is meant to be public, so applications built those URLs by hand and repeated the base URL of the disk wherever they did. A disk gets its public base URL with Storage::set_public_url("public", "https://cdn.example.com/files"), or a path of the application's own host, /storage. Storage::url("public", "avatars/7.png") joins the two and writes every character of the path that a URL gives a meaning to as %XX, so c++ notes.pdf is c%2B%2B%20notes.pdf. A disk with no public base URL returns an error, so a private disk hands out no link that can be guessed, and a path with a . or .. segment is refused. A base URL is refused when it has a user or a password, a query or a fragment, a backslash, a . or .. segment, or another scheme than http and https, and the error does not repeat the URL. S3_PUBLIC_URL gives the disk of the environment its base. The function takes the name of the disk, because Storage::disk returns the opendal operator itself, which carries no name.
  • DB::monitor(max) and the db:monitor command dispatch DatabaseBusy. The event was public, exported from the crate root and listed with the database events the framework fires, and no code dispatched it: an application that listened for it to alert on a database that runs out of connections waited for an event that never came. DB::monitor(max) asks the server of each connection, the default one and every named one, how many connections it has from every client, and dispatches DatabaseBusy for a server with max or more. PostgreSQL counts pg_stat_activity, and MySQL and MariaDB give threads_connected, the way Laravel's db:monitor asks. SQLite has no server and is never busy. The server does the counting, so the answer is the same from every process, and the check can run on the schedule: schedule.command("db:monitor --max 80").every_minute(). Nothing runs it by itself. DB::connection_counts() returns the numbers and DbConnection::server_connections() the number of one connection. DbConnection::connections_in_use() is the other number, the connections of this process's own pool that are out of it now.
  • suprnova::fake is the fake crate, for factories written by hand. The crate root had Dummy, Fake and Faker, and everything else a factory uses, the fakers of fake::faker and rand::Rng for fake_with_rng, was reachable through the hidden suprnova::__fake alone, which the factories chapter showed as the supported path. An application that added fake to its own dependencies had to keep its version the one of the framework, or the traits did not line up. use suprnova::fake::faker::internet::en::SafeEmail and use suprnova::fake::rand::Rng now work. __fake stays for the code #[derive(Factory)] generates. #[derive(Dummy)] generates code that names the crate ::fake, so in an application without fake among its dependencies the struct says where the crate is: #[dummy(crate_name = "suprnova::fake")].
  • WorkflowWorker::try_with_config(config) and workflow::assert_no_duplicates(). WorkflowWorker::new() refuses to start when two #[workflow] functions have one name. with_config skipped that check and told the caller to run registry::assert_no_duplicates, a function of a module that is hidden from the documentation and was exported nowhere, so a worker with a config of the application's own lost the check without a word. try_with_config checks the config and the registry and returns the error where new() panics, and assert_no_duplicates is exported from suprnova::workflow. with_config stays the constructor with no check, and says so. new() makes its checks through try_with_config, so the two cannot come apart.
  • Crypt::decrypt_string_with_origin and its siblings return where a value came from. DecryptOrigin, KeyOrigin and AadVersion were public, and every function that returned one was hidden, so the two questions of a key rotation, does this value still need a previous key and does it still use the legacy label, were answered in log warnings alone. Crypt::decrypt_string_with_origin, Crypt::decrypt_string_for_with_origin and Crypt::decrypt_with_origin return the value and its DecryptOrigin, and DecryptOrigin::needs_reencryption() says whether the value is to be written again. With them the job that ends a rotation can be written: read every encrypted value, write again what needs it, and remove the previous key when nothing does. For tests, crypto::testing::encrypt_string_under and encrypt_string_for_under write a value under a key and a label of the test's choice; they are compiled with the testing feature and replace the hidden _test_encrypt_with names the manual pointed at. The three types are exported from the crate root. An error for a decrypted value that does not decode as JSON no longer quotes the value: it says which kind of mistake it was and at which line and column. That is the error of Crypt::decrypt, of a pagination cursor, and of the casts AsEncryptedArray, AsEncryptedObject and AsEncryptedCollection, whose error is a validation error and was shown to the client with the decrypted value in it.
  • Metric attributes have types. inc_with, record_with and set_with took &[(&'static str, &str)] and sent every value as a text, so a status 404 matched no filter on a number and no range, and the attributes the semantic conventions type as a number or as yes and no arrived as the wrong type. A value is now anything that becomes an AttrValue: a text, a whole number, a number with a fraction, or a bool. counter.inc_with(&[("http.response.status_code", 404)]) sends a number. Values of one type are written as they are, and values of several types are each made an AttrValue: ("route", AttrValue::from("/posts")), ("error", AttrValue::from(true)). Every call that passes texts compiles as before. A u64 or usize that no i64 holds is sent as the largest i64. A text is also a reference to what holds one, &String, &&str, &Box<str>, &Arc<str>, &Rc<str> and &Cow<str>, as it was when the values were &str. Two calls have to be written another way: an empty list, inc_with(&[]), is inc(), and a value that is .as_ref() names its type, .as_str(). AttrValue is #[non_exhaustive].
  • A WebSocket handler sends from another task: WsSocket::sender() and WsSocket::split(). Every method of WsSocket takes &mut self, so while a handler waited in recv nothing could send on the connection, and a broadcast, a timer or a finished job had to go through a select! loop and a channel of the handler's own. sender() returns a WsSender: it clones, its send_text, send_binary and close take &self, and every clone sends on the same connection. split() takes the socket apart into a WsSender and a WsReceiver, and the WsReceiver is also a Stream of the messages. The connection does not wait for its senders: when the handler returns the connection closes, every later send returns an error, is_closed() returns true and closed() completes, so a task that keeps a sender learns when to stop. The receiving half has to be read, because the answer to the heartbeat's ping arrives there.
  • An upload policy says which rule it breaks: UploadPolicy::validate() and UploadPolicyError. A Live upload field whose policy the engine refused failed the registration of its component with one closed error, invalid_component_upload_metadata, whichever of the rules was broken: a limit that was not set or was zero, a media type or an extension that was not in canonical form, a media type declared twice, a dimension of zero, a finalize action that was missing or was no name. UploadPolicy::validate() returns the rule as an UploadPolicyError, and the registration logs it as an error before it fails. The error of the registration is what it was, so nothing of a component reaches a browser through it.
  • A Live operation that fails inside the engine says why. The engine answered every failure of one of its own parts with one reason for the browser, ExecutionFailed or LedgerUnavailable, and threw the error away, so a panic of a component, a clock that gave no time and a ledger that was full read the same in every log. The browser still gets that reason and nothing more. RefreshRequiredExecution::cause() returns an ExecutionFailure, a closed value that names the part that failed and the kind of its error: the action, the lifecycle, the ledger, the clock, the snapshot, the view, the composition, a port of the host. It is None for a refresh that is no failure, such as a stale revision. The framework writes one warning for each operation that ends with a cause, with the component, the reason and the cause. MountError::cause() returns a MountFailure in the same way for a mount, private or public, and MountError::ledger_kind() is the kind of the ledger when the ledger refused. Neither value holds a text, an identifier of an instance or anything of a request.
  • load and load_missing on one model. Both were methods of a collection only, so code with one Post in hand wrapped it in a collection of one to load its comments, or ran the query of the relation by hand and lost the cache of the model. post.load(["comments"]).await? and post.load_missing(["comments.user"]).await? load into the model itself, through the loader of the collections: nested names, the one query for each relation and the transaction of the caller are the same. load_missing runs no query for a relation that the model has.
  • PaddleProvider::archive_customer archives a Paddle customer. Paddle has no endpoint that deletes a customer, so delete_customer of the Paddle adapter returns PaymentError::NotSupported, and its message named a way that did nothing: an update with metadata: {"status": "archived"} writes a key named status into the custom data of the customer, and the customer stays active. archive_customer(provider_customer_id) sets the status of the customer to archived at Paddle. A customer that Paddle does not know is PaymentError::NotFound. The message of delete_customer names PaddleProvider::archive_customer. What you have to change: code that archived a customer through metadata calls archive_customer, and removes the status key from the metadata if it does not want it there.
  • A supported way to test a cached route: render_cache::testing::RenderCacheProbe, RenderCacheConfig::with_clock and database::testing::StatementCounter. A test that has to prove that the render cache served a response had the hidden hooks of the framework's own tests and nothing else: key_for_route_for_test, inspect_route_for_test, inspect_l1_for_test, clear_l0_for_test, with_clock_for_test, observe_statements_for_test. RenderCacheProbe::route(pattern), with .params(..) and .at_epoch(..), gives the key the route derives (key()), the entry of each tier for that key (l0(), l1()), and RenderCacheProbe::clear_l0() empties the first tier and leaves the second as it is. The probe derives the key with the function the middleware uses, so you tell it each dimension the policy of the route varies on: .login(id) for Principal, .tenant(id) for Tenant, .locale(tag) for Locale (the current locale of the process when you leave it out) and .host(host) for Host; a route that varies on Host and a probe with no host is an error that names the dimension. l0() reads through MemoryRenderStore::peek, which does not count as a use, so a probe between two requests does not change what the first tier evicts next; RenderCache::inspect counts as a use. RenderCacheConfig::with_clock installs the clock the runtime reads, so a test moves an entry through its freshness bands without a sleep. StatementCounter::install(&mut connection) counts the prepared statements run through a connection, so a test shows that a request the cache served ran none; unprepared SQL and transaction control are not counted. All of it is compiled with the testing feature, and no function of it panics: an error names the route and never a login, a parameter or a key. What you have to change: a test that called RenderCacheConfig::with_clock_for_test calls with_clock. The other hooks stay for the framework's own tests, and are compiled with the testing feature only.
  • A binding that lives for one request: App::scoped. The container had bindings for the process and overrides for a test, and nothing between them, so a service that belongs to one request, such as the database handle of the tenant or an API client bound to the request, was global and leaked between requests, or was built by hand in every handler. App::scoped::<T>(factory) and App::bind_scoped register a binding whose factory runs at most once in a scope, at the first App::get, and whose value is dropped when the scope ends. The framework opens a scope for each request, each WebSocket session, each attempt of a queued job, each attempt of a queued listener, each run of a scheduled task, a workflow or a supervisor, and each console command. An after-commit callback, a hook that runs after the response and the body of a streamed response share the scope of the request that registered them. App::run_scoped(future) opens a scope of your own, App::in_current_scope(future) carries the scope of the caller into a future that you spawn, and App::spawn_scoped does both steps. Outside a scope, App::resolve returns an error that names the type, and App::get logs a warning and returns None: a scoped binding never builds a value that lives for the process. A test override wins over a scoped binding. A factory is synchronous and runs once: a second task of the scope that asks for the value while it is built waits for it on its thread, and a cycle of scoped factories, in one task or across tasks, is an error.
  • The permissions of a user answer the gate: rbac::register_gate_bridge. The roles and permissions of RBAC and the gate did not know each other, so Gate::allows_async("edit posts", ..) did not see a permission that the user holds, and an application had two systems of authorization side by side. suprnova::rbac::register_gate_bridge::<User>(), called once in the bootstrap, makes every permission that a user holds, directly or through a role, an ability of the gate. An ability that is no permission of the user goes on to the gate definitions and the policies, so the bridge allows and never denies. It reads the permissions of a user once for a request, through GateBridgeMiddleware, which the call installs as the first global middleware. A grant or a revocation made before the first check of a request is seen by that check; after it, from the next request on. A check inside DB::transaction reads for itself and keeps nothing, so a grant that is rolled back does not answer after the rollback. A unit of work that runs inside a request in a scope of its own, such as a job that the sync queue driver runs inline, reads for itself too. A read that fails is logged and allows nothing. The permissions answer the async forms of the gate, allows_async, authorize_async and inspect_async. The forms without async cannot wait for a database and skip them. Gate::before_async is the hook the bridge is built on, and an application can register hooks of its own with it. A Some(false) from an async hook denies on the async forms only: a hook that must deny on every form belongs in Gate::before. Without the call nothing changes.
  • An application registers guards of its own: Auth::extend and Auth::via_request. Guard was a public trait, but the manager built guards from two drivers, session and token, so a guard for an API key, a client certificate or a single sign-on could be written and not registered, and Auth::guard("api_key") and the middleware that takes a guard name could not use it. Auth::extend(driver, factory) registers the factory of a driver, and GuardConfig::custom(driver, provider) declares a guard of it. The factory gets the name of the guard and its provider. Auth::via_request(name, resolver) is the short form for a guard that reads the request: the resolver gets the request and answers with the user, and the guard is declared with GuardConfig::custom(AuthManager::via_request_driver(name), provider). The middleware for the guard runs the resolver once for a request. Outside that middleware the guard reports no user, as the token guard does. An error of a factory or of a resolver fails the request with 500 and is never a guest. A guard of the application is read-only through the manager: Auth::stateful_guard returns an error for it, and so do Auth::logout, Auth::login_id and Auth::login_remember when such a guard is the default guard, before they change anything. A guard of the application has no : in its name: resolving such a guard, or registering a resolver for it with via_request, is an error. A logout forgets the users that the guards of the application resolved in the request, so the request does not sign itself back in. Declared as the default guard, a guard of the application answers Auth::user and the unnamed AuthMiddleware::new(). The principal that the middleware attests for Live is <guard>:<id> for a guard of the application, so the same id under two guards is two principals; a session user attests its bare id. What you have to change: AuthManager::via_request returns a Result. GuardDriver has the variant Custom(String) and is no longer Copy, so code that copies a driver borrows it or clones it, and a match that names every variant has one more to name.
  • suprnova::eloquent::prevent_lazy_loading(true) refuses a relation read that runs one query for each row of a list. A template that reads post.author() for each of 50 posts runs 51 queries, and nothing said so until the load of production. With the switch on, a relation read on a model that came out of a query that returned more than one row, when the relation was not loaded with with(..), load(..) or load_missing(..), runs no query and returns an error that names the model and the relation. A model from find, first, a get that returned one row, or create reads its relations as before, as in Laravel. count() of a relation is not refused. handle_lazy_loading_violation(handler) registers one handler for the process, which gets a LazyLoadingViolation with the names of the model and the relation; with a handler the read goes on, so a staging system can log the reads and keep serving. clear_lazy_loading_violation_handler() removes it, and preventing_lazy_loading() reads the switch. The switch is off by default, and with it off every read behaves as before. Turn it on in the bootstrap of the application outside production.
  • A test moves the clock the framework reads: suprnova::clock::now() and suprnova::testing::TestClock. The framework read the wall clock with chrono::Utc::now() in about 170 places, and tokio::time::pause moves the timers of Tokio and not those reads, so a test of a signed URL that expires, a session that idles out, a scheduled task that is due, a window of a rate limit or a model that becomes prunable had to sleep. Every such read goes through suprnova::clock::now(), and so do the timestamps the #[model] macro writes, the due check of a scheduled task without a time zone and its one-run-a-minute gate, and the touched-at stamp of the session. Without the testing feature now() is Utc::now() and nothing else. With it, TestClock::freeze() and TestClock::travel_to(at) stop the clock of the current thread at a time you move with advance and set, until the guard is dropped, and TestClock::scope(at, |clock| future) holds a time across .await and on a multi-thread runtime; clock.run(future) carries it into a task you spawn. A clock of one test never reaches another test that runs beside it. Three reads keep the wall clock, because each is compared with a clock a test cannot move: the health endpoint, the retry time of a workflow run (compared with NOW() of the database), and the window of the RateLimiter facade (its cache key expires in real time). The in-memory driver of RateLimitMiddleware measures with tokio::time::Instant, which tokio::time::pause moves, and the Redis driver reads the clock. What you have to change: code of your own that reads the time for a decision reads suprnova::clock::now() when its tests should be able to move it.
  • suprnova::schema::Schema writes a migration without an identifier enum or ColumnDef chains. A migration can build its tables with Schema::create(manager, "posts", |t| { t.id(); t.string("title"); t.timestamps(); }) and Schema::table, Schema::drop, Schema::drop_if_exists, Schema::rename, Schema::has_table and Schema::has_column. The layer builds SeaORM's Table::create(), Table::alter(), Index and ForeignKey statements and runs them on the SchemaManager the migration is given, so every statement runs on the migration's own connection and transaction, and a SeaORM migration and a Schema migration can sit in one Migrator. Blueprint has id() (a BIGINT auto-increment primary key), foreign_id(name).constrained(table) with on_delete and on_update, eighteen column types, the modifiers nullable, default, unique and length, index and unique over several columns, and in Schema::table also rename_column, drop_column, drop_index and drop_foreign. A column is NOT NULL unless it is nullable(). timestamps() and soft_deletes() create the created_at, updated_at and deleted_at columns as VARCHAR(255), because #[suprnova::model] stores a DateTime<Utc> field as RFC 3339 text unless the field declares a cast; timestamp_tz with a native cast gives a native column. On SQLite, adding or dropping a foreign key on an existing table is an error that is returned before any statement of the call runs, and every other alteration runs as its own statement. The layer is not re-exported at the crate root, where suprnova::Schema is SeaORM's Schema. make:migration generates SeaORM migrations as before.

Changed

  • Magnetar's CeremonyStore takes a named request for its atomic transition. transition_and_consume and transition_and_consume_exact took six and seven positional strings, so a transposed selector or state compiled and acted on the wrong ceremony. Both take a TransitionAndConsume { transition, expected, next, consume } whose two ceremonies are CeremonyRef { selector, kind }, and the exact form takes the consume id as its second argument. A store that overrides either method changes its signature to match.
  • delete_all on a soft-delete model soft-deletes. It issued DELETE on every model, so Post::query().filter(...).delete_all() permanently removed rows that a row-level delete() would have trashed. On a model declared with soft_deletes it now writes the tombstone, and updated_at when the model manages timestamps, and the rows stay readable through with_trashed(). force_delete_all() is the explicit hard delete. Builder::without_global_scope::<S>() and Builder::without_global_scopes() are supported chain methods.
  • #[scopes] refuses a scope written in the wrong form. A method in a #[scopes] block that took &mut Builder<User>, named the model instead of Self, or returned nothing was left an ordinary method, and no scope reached the builder. It is now a compile error on the signature that names the accepted shape, fn name(query: Builder<Self>, ...) -> Builder<Self>. A method that handles no builder still passes through unchanged, and #[not_scope] marks a helper that does handle one.
  • suprnova serve runs the pending migrations once, when it starts, and no longer on every save. The backend runs under a file watcher, and an application started with no subcommand migrates before it serves, so every save of a source file ran every pending migration against the developer's database, the draft of a migration saved a moment ago included. A migration that has run is not run again when its file changes, so the database kept the schema of the first draft. serve now runs migrate once before the backend starts and starts the watched backend with serve --no-migrate. The frontend and the processes of Suprnova.toml start first and do not wait for it. When a file under src/migrations changes after that, serve says that it was not run and that suprnova migrate runs it; with --json that is the new event {"type":"migrations_changed","ts":...}, and the run at the start shows as a process named migrate. --migrate always restores the old behaviour, and --migrate never or --no-migrate runs no migration at all. When the run at the start fails, the backend is left to migrate by itself for that session, as before: it does not serve until the migrations pass. A project with no src/migrations directory is left to migrate by itself as well.
  • seed::clear() is a supported function of the testing feature. It was hidden from the documentation as an internal helper, and it is the only way for the tests of an application to reset the registry of the seeders, which is one for the process and which the guard of the test container does not reset. The manual told readers to call it and said in the same breath that it was hidden. It is documented now and compiled with the testing feature alone, which is a default feature, so a test suite needs no change. A build with default-features = false and without testing no longer has the function.
  • The paginators serialise to Laravel's JSON shape. LengthAwarePaginator had data, the counters and path, and no URL of a page and no links; the simple paginator had has_more, and the cursor paginator had the cursors and no URL. A front end that was written for Laravel's paginator JSON, the pagination components of the Inertia starter kits among them, could not read them. The three now have the fields of Laravel's toArray(): first_page_url, last_page_url, next_page_url, prev_page_url and links on the paginator with a total, current_page_url, first_page_url, next_page_url, prev_page_url, from and to on the simple one, and next_page_url and prev_page_url on the cursor paginator. links has the window of pages and the labels of Laravel. A URL is the path and the page parameter, and a path with a query string keeps it. Every field that was there is still there, and path is still left out when it is not set. LengthAwarePaginator::links(), next_page_url() and previous_page_url() return the same values in Rust, and the other two paginators have their own. A page parameter that the path has already is replaced, so the URL of the current request can be given as the path, and a fragment of the path stays at the end of the URL.
  • A web push subscription that cannot be used is WebPushError::InvalidSubscription. An endpoint that is no URL, that is not https, that names an address in place of a host, or that names a host that is no push service was WebPushError::Internal, with the text internal: in front. A key that is not what RFC 8291 asks for was WebPushError::Encryption: a p256dh or an auth that is no base64url or has the wrong length, a p256dh that is not in uncompressed form or is no point of the P-256 curve. Bad stored data read as a fault of the crate, and no caller could tell the two apart. The new variant says which rule refused the subscription and is not retryable. WebPushChannel handles it as it handles a subscription that is gone: it logs a warning and the dispatch succeeds, so a queue does not send the job again, with every channel that delivered before this one. A stored route that is no subscription at all is handled the same way. It was an internal error. No warning of the channel has the endpoint, because the path of an endpoint is the token that reaches the browser: a warning has the host and endpoint_sha256, the first 16 hexadecimal digits of the SHA-256 of the stored endpoint, which finds the row. The warning for a subscription that is gone had the whole endpoint. The errors of the crate's own headers stay Internal, and a payload that is too large and a failure of the encryption stay Encryption. A match on WebPushError that names every variant has one more to name.
  • A database error on the payment webhook path keeps its type: PaymentError::Database. The webhook route made a text of every database error, PaymentError::Internal(format!("{e}")), in twenty-two places, so the code that decides what to do with a failed webhook could not ask whether the failure was a lost connection, which the next attempt cures, or a violated constraint, which none does. The new variant has the sea_orm::DbErr as its source, reachable with error.source() and downcast_ref, and From<sea_orm::DbErr> makes a statement end in ?. The text of the error is what it was, and the route answers 503 for every database error as it did: the variant is what a later decision can be made on, and none is made yet. Debug prints the variant with the text of the database error and not with its Debug, which for a violated constraint names the values of the key. A match on PaymentError that names every variant has one more to name.
  • suprnova::payments names the types it exports. The module had pub use dto::*;, the only glob export of the framework. It exported the modules of dto as well as the types, so every type had two public paths, payments::StartSessionRequest and payments::session::StartSessionRequest, and a type that was added to dto was public in payments without anybody deciding so. The twenty-five types are named now. The paths through the modules, payments::session:: and its seven siblings, are gone: the modules are reached as payments::dto::session.
  • Http::send decides once whether an attempt is retried. The loop had the decision twice, for a response with a status of the server and for an attempt that got no response: the same check of the policy, of the method and of the retry_when predicate, in two blocks that a change had to keep alike by hand. It is one function now, and the two outcomes are retried by one rule. What is retried and how long the request waits is what it was.
  • The parser of #[model] has no #[allow(dead_code)] left. Sixteen suppressions on ModelInput and RelationDecl said that a later task would read the field. The tasks are done and the fields are read, so the suppressions hid nothing and would have hidden a field that a later change leaves unread. They are removed with the comments that named the tasks.
  • The dogfood application's bootstrap.rs imports what it uses. Its import of the framework had a blanket #[allow(unused_imports)], which hid that singleton was imported and never used, and would have hidden every later one. The suppression and the import are removed.
  • The Data derive has no module-wide #![allow(clippy::collapsible_if)]. The attribute turned the lint off for the whole file with no reason given. It is removed, and the nested conditions it hid are written as one.
  • mail::mailable_registry::render_outgoing takes its values as a struct. The function had fourteen arguments in a row, four of them Vec<Address> one after the other: the recipients, the copies, the blind copies and the reply addresses. Two of them in the wrong order compile, and the mail goes to the wrong list. It takes any, mailable_name and a RenderOutgoingParams now, whose fields are named. RenderOutgoingParams implements Default, so a caller names the fields it has. A caller of render_outgoing has to build the struct. The framework has one, the job that sends a queued mail.
  • OutputFormat::WebP is lossy and honours quality, and OutputFormat::WebPLossless is new. WebP was always written lossless, so .quality(80).format(OutputFormat::WebP) gave the same file for every quality, and for a photo a larger file than the JPEG it replaced. WebP is lossy now, at the quality of the pipeline, which is 70 when none is set. The built-in driver writes it lossless in two cases, because the lossy form of WebP cannot hold the image: when a pixel is not fully opaque, and when a side is longer than 16383 px. WebPLossless is always lossless and ignores the quality. Both have the content type image/webp and the extension webp. The ImageMagick driver writes WebP lossy with its alpha channel, and passes -define webp:lossless=true for WebPLossless. What you have to change: a match on OutputFormat that names every variant, as a driver of your own has, needs an arm for WebPLossless. Code that needs the pixels of a WebP to be exact asks for WebPLossless. A WebP source that is resized and not converted is written as WebP, so an opaque one is written lossy.
  • Subscription::update changes the prices of a subscription on Stripe and on Paddle, and the Paddle adapter cancels at once when it is asked to. update with new_price_refs returned PaymentError::NotSupported on both adapters, so a change of plan was a cancellation and a new subscription. The list is the set of prices the subscription has after the call: an item whose price is in the list keeps its id and its quantity, an item whose price is not in the list is removed, and a price that is new is added with the quantity 1, except in a swap: when the change removes exactly one item and adds exactly one price, the new price takes the quantity of the item it replaces, so ten seats of one plan become ten seats of the other. The adapter computes the change from a read of the subscription, and the change is not atomic: a change made at the provider between the read and the write can be undone (Paddle takes the whole list) or left in place (Stripe changes items one by one), and the returned subscription shows the result. An empty list, and a list that names a price twice, is PaymentError::Validation, on both adapters and on the mock. The new field UpdateSubscriptionRequest::proration takes a suprnova::payments::Proration: ProrateNow bills the difference at once, ProrateAtRenewal puts it on the next invoice, and DoNotProrate charges nothing for the change. None is ProrateAtRenewal. On Paddle, a change of prices in the same call as cancel_at_period_end or with an idempotency_key is NotSupported. cancel(id, false) of the Paddle adapter cancels the subscription at once, and cancel(id, true) cancels it at the end of the billing period; it cancelled at the end of the period for both. Every call of the Stripe and the Paddle adapter has a deadline of 30 seconds. A read that gets no answer in that time is a PaymentError::Provider whose text ends in "timed out". A call that changes something is a PaymentError::Provider whose text says that the outcome is unknown: read the state at the provider before you send the call again. The text of an error that the Stripe or the Paddle adapter builds from an error of its SDK holds the operation and the kind and code of the provider's error, and never the provider's message, an id or a URL: a Stripe API error gives its type, its code and the HTTP status, a Paddle API error its type and code, and a transport error comes without the URL of the request. Stripe void of a payment that is already captured is a Validation error whose text does not name the payment. The NotFound errors of MockPaymentProvider carry no id. What you have to change: every struct literal of UpdateSubscriptionRequest names the new field, proration: None to keep the default. Code that called cancel(id, false) on Paddle and counted on a cancellation at the end of the period passes true. A test that read an id out of a NotFound error of the mock reads it from its own request.
  • A polymorphic relation takes a target with any key, loads nested relations, and can be touched. Three limits of MorphTo are gone. The id of a morph relation was an i64, so a model with a String, UUID or ULID key could not be the target: the id is the value of the key of the target, and the <name>_id column of the child has the type of that key. All targets of one relation have keys of one type, and a relation that mixes them does not compile, nor does a child whose <name>_id field has another type. A parent's MorphMany or MorphOne is not checked against the child's <name>_id, so keep that field at the key type of every parent that owns it. The lazy read of a MorphTo finds the target by its key and applies no global scope of the target; the eager load runs the query of the target and applies its global scopes. A nested eager load through MorphTo, with(["commentable.user"]), returned an error: the loader groups the targets by their type and loads the rest of the path once for each type, and a target type that does not have the relation is an error that names the type and the relation, whether or not a row of that type was loaded. #[model(touches = [...])] took BelongsTo relations only: it takes the name of a MorphTo relation, and a save or a delete of the child writes the updated_at of its owner, inside the transaction of the write when there is one. An owner without timestamps is skipped, a soft-deleted owner is not touched, and a null <name>_id touches nothing. A <name>_type that names none of the targets is an error of the write: create, save, update, delete and force_delete (and their _with_tx forms) resolve every MorphTo owner of touches after the Creating, Saving, Updating and Deleting listeners have run and before the statement, from the values the statement writes, so a listener that rewrites <name>_type or <name>_id decides the owner, and an owner that cannot be resolved returns Err with no row written, no later event dispatched and no owner touched. An empty collection checks a dotted path of Collection::load and load_missing too. What you have to change: MorphTo::morph_id and the id in the Unknown variant of the generated enum are a serde_json::Value, so code that reads the id as an integer calls as_i64(). <relation>_loaded() of a MorphTo returns the generated enum.

Fixed

  • Magnetar logs a lockout status failure before the sign-in fails closed. The password plugin answered 503 when the lockout store could not report an identity's status and logged nothing, while the failed-attempt path beside it logged its error. The status path now logs lockout status unavailable; failing closed with the store's error; the response is unchanged.
  • Magnetar logs a failure to record a rejected two-factor attempt. Re-enrollment, confirmation and recovery-code rotation discarded the error from the lockout store when they recorded a failed attempt, so a store fault during an attack left no trace. Each now logs a warning with the error; the rejection itself is unchanged.
  • Magnetar's Redis abuse limiter says why Redis failed. Every client error became shared abuse-limiter backend failed, so a refused connection, a timeout and a script error read the same in the log of a limiter that fails sign-in closed. The message now ends with the Redis client's own description of the fault.
  • A stored session payload that fails to parse is logged. The database session driver read a damaged payload as an empty session, which signs the visitor out, and logged nothing. It now logs a warning with the parse error and without the session id. A failed delete of an expired session row is logged as well.
  • A Live request that cannot be prepared says why in the log. When the Live runtime could not be bound or a request could not be prepared, the server answered 500 Live request preparation failed and logged nothing. It now logs the error with the route pattern and the stage, on the HTTP path and on the WebSocket upgrade path; the response is unchanged.
  • The NOWPayments adapter's HTTP failures name their cause. A failed request, an unreadable response body and a body that is not JSON each became a fixed PaymentError::Provider message. Each now ends with the underlying error, down to the refused connection or elapsed deadline for a transport failure, and never includes the request URL, which carries the payment id.
  • A failed Live upload cleanup run is logged. The background loop that retires expired uploads discarded the result of every run, so a store that kept failing left the uploads in place with nothing in the log. A failed run now logs a warning, and the loop retries on its next interval as before.
  • A model's cast storage aliases stay out of its rustdoc. #[model] emits a pub type __Suprnova_Cast_Storage_<field> for each cast field, and each one appeared in the documentation of the application's own models. They are hidden now.
  • A factory insert fires the model's lifecycle events. Factory::create and create_many inserted through SeaORM directly, so creating, saving, created and saved never fired and no observer saw a factory's rows. They now take the same insert Model::create takes: a creating observer can change the attributes or cancel the insert, and created runs for every row. create_quietly() and create_many_quietly() insert with the events muted. A model whose key is not auto-increment keeps the key its factory set.
  • DATABASE_URL=mariadb://... connects. Only mysql:// was recognised, so the scheme a MariaDB operator naturally writes failed at connect with no supporting driver. mariadb:// is accepted for the primary connection, named connections and read replicas, the migrator, and MariaDbVectorDriver::from_url, and DB::driver_title() answers MariaDB for it. The vector driver's pool error no longer quotes the connection URL, which carries the password.
  • QUEUE_DRIVER=sync and QUEUE_DRIVER=null select their drivers. Both drivers existed, but the environment bootstrap knew only memory, redis and database, so sync became an in-memory queue with a warning. A QUEUE_DRIVER that names no driver is now a boot error in production, where an in-memory queue taken by mistake loses every job at the next restart; elsewhere it still falls back to memory, and the warning lists the accepted names.
  • A chained job's Job::delay() applies. A chain built each link's envelope with available_at set to now, so a job that declares a delay ran at once when it was a link of a chain, head or not. ChainLink now records the delay at build time, as it records the queue, and the link becomes available that long after it is reified: at dispatch for the head, and when the link before it completes for every other link. ChainLink gains the public field delay_secs, so code that builds one with a struct literal has to name it. Chain payloads written before the field existed decode as links with no delay.
  • Batches, chains and failed-job retries go through the queue fake. Only the Queue::push family checked Queue::fake(). Queue::batch().dispatch() and Queue::chain().dispatch() went to the driver, so a faked test failed with "queue driver not initialized" when no driver was installed and pushed real jobs when one was. Queue::retry_failed and Queue::retry_all_failed did the same. All four record in the fake now and write to no driver. A batch is still stored in the batch repository, so the id the caller receives names a batch. queue::testing gains batched(), assert_batched, assert_batch_count, assert_nothing_batched, chained(), assert_chained and assert_nothing_chained, with the records FakedBatch and FakedChain. The jobs of a batch and the head of a chain are recorded as pushes too, so assert_pushed sees them.
  • The queue worker honors a retry hint. A job that failed with FrameworkError::RateLimited carrying a retry_after was retried on its own backoff, so a queued web push that a push service refused with 429 and Retry-After went back to the service early, or waited far longer than it was asked to. The worker now releases such a job for the hinted time, capped at 24 hours (queue::retry::RETRY_HINT_CEILING). Every other failure keeps the job's backoff. queue::retry::delay_after_failure is the function the worker calls.
  • The middleware priority list orders the chain. append_middleware_priority and prepend_middleware_priority recorded a list that nothing read, so middleware ran in the order it was registered whatever the list said, and an application that relied on the documented order could run authentication before the session was loaded. A chain is now put in the order of the list when it runs, for a matched route, the fallback, an unrouted request and a WebSocket upgrade alike. A middleware the list names moves in front of any middleware the list places after it. Every other middleware keeps its place, so one registered after AuthMiddleware still runs after it. The list orders global, group and route middleware together. It sees the middleware registered by type; a middleware boxed by hand with into_boxed and added with .middleware_boxed(...) keeps its place. An empty list costs one read per request.
  • #[derive(Command)] without a description keeps clap's own about text. The derive called .about("") when #[console(description = "...")] was left out, which replaced the about text clap had taken from the struct's doc comment or from #[command(about = "...")]. A command described the way clap users describe one showed an empty line in the console's list of commands. The derive now sets the about text only when a description is given, and a description still overrides the doc comment. CommandEntry::about() returns the text the help shows, whichever of the three it came from; CommandEntry::description stays the attribute's text and is empty when the attribute has none.
  • suprnova schedule:list --timezone=<zone> is accepted. The application's own schedule:list has taken --timezone since the flag shipped, and the manual shows it through the CLI, but the CLI's subcommand took no arguments and ended with unexpected argument '--timezone' and exit code 2. The CLI now takes the flag and hands it to the application, which checks the zone name.
  • The scaffolded src/tasks/mod.rs shows a task that compiles. Its example implemented a ScheduledTask trait with name and schedule methods. The trait is Task, its only method is handle, and the name and the times a task runs at are set where it is registered. Every new project received the wrong example, and copying it gave an unresolved import. The comment now shows what make:task generates, with the registration in src/schedule.rs.
  • A render cache policy that varies on FeatureVersion, ConfigVersion or Application(name) is refused when it is registered. Nothing gives these three dimensions a value, so a route that declared one could not build its key and every request for it went past the cache, while the route looked cached in the code. try_render_cache and try_render_cache_group now return an error that names the route or the group and the dimension, for a full policy and for a patch that brings the dimension in, so the application stops at boot. The other six dimensions register as before. This refuses one arrangement that cached before: a group whose policy declared one of the three, with a patch on every route that replaced the dimensions. The group is refused now, and the dimension is to be taken out of its policy.
  • Telemetry is exported, each signal to its own path, and a signal can have an endpoint of its own. With the otel feature the OTLP exporters had no HTTP client: each one failed to build with no http client specified, no trace, metric or log left the process, and the error was logged before a log subscriber existed, so nothing showed it. The exporters have the blocking reqwest client now, and an exporter that cannot be built is reported after the subscriber is installed. init_telemetry also gave the base OTEL_EXPORTER_OTLP_ENDPOINT to the exporter of each signal, and the exporter uses an endpoint it is given in code as it is written, so the URL of every signal was the root of the collector, where a collector has nothing, and OTEL_EXPORTER_OTLP_TRACES_ENDPOINT, OTEL_EXPORTER_OTLP_METRICS_ENDPOINT and OTEL_EXPORTER_OTLP_LOGS_ENDPOINT had no effect. Each signal is now sent to its own path under the base, /v1/traces, /v1/metrics and /v1/logs, and a signal with a variable of its own is sent to that URL as it is written, as the OTLP specification says. Traces can go to one collector and metrics to another. The base endpoint is still what turns telemetry on. OtelConfig has the three endpoints as fields, traces_endpoint, metrics_endpoint and logs_endpoint, which from_env reads, so code that builds an OtelConfig with every field named has three more to name. A signal whose endpoint is no URL is left out and reported, and the other signals are exported; the report never has the endpoint in it, which can carry a password or a token. A base endpoint that was given a path of a signal to make up for the missing one, such as http://collector:4318/v1/traces, is to be the base again: the path is added to it. An endpoint is a URL with the scheme http or https and a host: a blank base endpoint does not turn telemetry on, and a signal whose endpoint is a path alone is left out and reported, where it was built and sent nothing. OTEL_EXPORTER_OTLP_COMPRESSION=gzip works; zstd is not compiled in and leaves the signals out, with the reason in the log. What the exporters log about their own requests is printed and not exported, so a process at debug level does not send lines about its own sending without end.
  • The session middleware does not panic on a poisoned lock. The session, the cookies that wait for the response, the remember tokens that wait to be revoked and the list of the fresh Magnetar sessions were locked with .lock().unwrap() in thirty places, which panics when an earlier panic left the lock poisoned. The list of the fresh sessions is shared with the clean-up task that runs after the request, so a panic in one request could end the clean-up of it. The locks are taken with a function that goes on with the value of a poisoned lock. The three lists are changed by code of the framework alone, which cannot panic between two writes, so they are whole after any panic. The session is changed by closures of the application: when a closure of session_mut panics and a Live action or a listener catches the panic, the request goes on and can read the session, but the middleware does not store it. It retires a Magnetar session that the request issued, takes back a remember cookie that the promotion of a second factor issued, answers 500, and the stored session stays as it was, which is what such a request did before. The policy of the framework for locks is that a poisoned lock is an error or is recovered, and never a panic.
  • generate-routes finds a form request by every name it is declared with. The command read the source for #[derive(FormRequest)] and for the helper attribute #[form_request(..)]. An application writes neither: the crate root exports the derive as FormRequestDerive, because FormRequest is the trait there, and the short form is the attribute #[request]. A struct with one of those was left out of the generated routes, so its request type was missing in the TypeScript, and no message said so. The command reads #[request], #[derive(FormRequestDerive)] and #[derive(FormRequest)], each bare or behind suprnova::, and the helper attribute. generate-types read InertiaProps and Data in both forms already, and the three detectors ask one function.
  • chunk_by_id and lazy_by_id walk a table whose key is no i64. The cursor of the walk was an i64, so a model with a String key, or with unique_id = "uuid", "uuid_v4" or "ulid", got the first batch and then an error. The closure had run on that batch by then, and a table that fits in one batch never gave the error. The cursor is the value of the key as the model has it, so an integer key and a string key both walk, in the order of the key. For a key with no order in time, a UUID v4, a row that is inserted during the walk with a key below the cursor is not seen by that walk. A key that cannot be a cursor is refused before the first query and before the closure sees a row: a composite key, and a key column that is no integer and no text, such as a native uuid::Uuid, a timestamp or a decimal. lazy() and cursor() walk through lazy_by_id, so both hold for them. What you have to change: a walk over a model with such a key returned Ok when the table fit in one batch, and returns the error now. Use chunk() for it.

Security

  • Global scopes can no longer be bypassed by a trashed view, a chained opt-out, or an or_where. Scopes were applied when Model::query() built the builder, which left three holes. with_trashed() and only_trashed() started from a bare builder and ran with no global scope, so on a model with a tenant scope they returned every tenant's rows. query().or_where(...) folded into the scope's own term and read (tenant_id = ? OR ...), and on a soft-delete model (deleted_at IS NULL OR ...). And query().without_global_scope::<S>() compiled and did nothing. The soft-delete filter and the registered scopes are now folded in when the query runs: the statement is <scopes> AND <your terms> with an OR group as one atom, the trashed views lift only the soft-delete filter, and an opt-out lands wherever it is chained. update_all, delete_all and increment_each resolve the same way, so a mass write reaches only the rows a read would return. A scope that reads per-request state reads it when the query runs.
  • Behind a proxy, Request::ip() is the address the proxy saw, and no longer one the client wrote. A proxy adds the address it saw to the right end of X-Forwarded-For and leaves what was there, and ip() returned the left end. Behind nginx, Traefik, HAProxy or a cloud load balancer, a client that sent the header itself chose the address the application saw: a new rate-limit bucket with every request, and the address of a payment provider for a webhook that checks remote_addr. ip() now reads the header from the right and returns the first address that is no trusted proxy. It reads every line of the header as one list, reads an entry with a port (203.0.113.5:54321, [2001:db8::5]:443) as its address, and ends at an entry it cannot read, where the answer is the proxy that wrote that entry. X-Real-IP is read only when the request has no X-Forwarded-For at all. What to check when you upgrade: every proxy between the client and the application has to be in APP_TRUSTED_PROXIES, not the last one alone. A proxy that is not listed is taken for the client, and all of its clients share one address; that includes the address a load balancer adds behind the client's, as the external Application Load Balancer of Google Cloud does. APP_TRUSTED_PROXIES takes ranges in CIDR form for that, 10.0.0.5,173.245.48.0/20,2400:cb00::/32, which is how the edge of a content delivery network is listed; in code it is TrustedProxiesConfig::and_networks with ProxyNetwork. A range must hold proxies and nothing else, because a client that connects from a trusted address is believed like a proxy, and the range of every address (0.0.0.0/0) is refused. A proxy that writes X-Real-IP alone has to remove the X-Forwarded-For of the client. An IPv4 address that is written as an IPv6 one (::ffff:10.0.0.5) is the IPv4 address, in the headers and for the peer. Request::ips() still returns the whole chain and is a record, nothing to decide by.
  • A cap on the WebSocket connections one client address holds open: RateLimitMiddleware::connections_per_ip(n). The only limit on open connections was the server-wide SERVER_MAX_CONNECTIONS, one number for every client together, so a single address that opened WebSockets and kept them could use all of it and lock every other client out of HTTP and WebSocket alike. The broadcasting and WebSocket chapters showed connections_per_ip on the ws! route; it did not exist. The middleware answers 429 Too Many Requests when the address already holds n sockets. A socket is counted until its session ends, close frame or none, and an upgrade that a later middleware refuses gives its place back at once. The address is the one Request::ip() resolves through the trusted proxies; an IPv6 address is counted with its /64 network, because one client holds a whole /64. The counts are kept per process; a clone shares them, so one cap can guard several routes, and open_for(address) reads a count. On a route that is no WebSocket route the cap counts the requests being handled at one time and does not cover a streamed response. Request::hold_for_connection(guard) is the part other middleware can use: it keeps a guard alive until the socket of an upgrade ends, where a guard the middleware holds itself is dropped at the handshake.
  • Magnetar does not quote decrypted state in an error. Four places decrypt the state of a ceremony or of a device session and decode it, and the error for state of another shape was the message of the JSON decoder, which quotes the value it could not read. That state holds challenges, session grants and tokens, and two of the errors are shown to the client. The error has the kind of the mistake and its position now, and nothing of the content. It can happen where a deployment changes the shape of the state while a ceremony is under way.
  • An encrypted cookie opens under its own name and in no other way. Release 1.3.0 bound the name of a cookie into its encryption and kept a fallback that still opened a value written without the name, to be removed in 1.4.0, which was never released. While the fallback was there, such a value opened in every cookie, so the binding protected nothing against it. The fallback is removed for cookies. It stays for the other purposes, where it opens stored values that do not expire as a cookie does: read those with decrypt_string_for_with_origin and write them again. What you have to change: Cookie::read_encrypted(wire) is removed, use Cookie::read_encrypted_for(name, wire). Crypt::encrypt_string and Crypt::encrypt with CryptPurpose::Cookie return an error, use Cookie::encrypted(name, value) or Crypt::encrypt_string_for. Crypt::decrypt_string, decrypt_string_with_origin, decrypt and decrypt_with_origin with CryptPurpose::Cookie return an error, use Cookie::read_encrypted_for or Crypt::decrypt_string_for. A cookie that was written before 1.3.0, or with encrypt_string, does not open any more. For the session cookie and the remember cookie the user signs in again, and for the maintenance bypass the operator visits the secret URL again. No request fails for it.

2.1.0 - 2026-09-18

Added

  • Live ships the foundations of its component library. A token stylesheet with a base layer arrives as the ui-styles runtime artifact when a document opts in with with_suprnova_ui(); every rule sits in the suprnova-ui cascade layer and every visual value is a --sn- token with light and dark values, so the skin is removable with nothing breaking. live:add installs a component as one directory under templates/suprnova-ui/ from its manifest, keeps files you edited, and accepts a third-party manifest under its own root; the framework serves the vendored stylesheet and script at /suprnova-ui/<component>/<file>. The form family ships as Askama macros the checker now expands, so a library view passes live:check like any other. The suprnova. namespace is reserved to the library and the registry refuses it from any other crate.
  • The Live component library gains its overlay family. Tooltip, collapsible and accordion, popover, a single-level dropdown menu, dialog, sheet, and drawer install with live:add beside the form family. Each owns its open state through the native primitive (details, the popover attribute, dialog) before any script, makes no Live request to open or close, returns focus to its trigger on close, and keeps its open state across a morph under a stable key with live:preserve.self.
  • The Live component library gains its feedback and navigation families. Alert, skeleton, spinner, progress, empty state, toast region and flash region; header bar, footer, sidebar, breadcrumbs, tabs, pagination and load more install with live:add beside the form and overlay families. Feedback presents state the server or runtime holds: an alert's role follows its variant with a non-color cue, loading presentation is bound through live:loading and shows on the runtime's own timing, progress is the native element with a label and readout, the empty state's reason is server state, and a toast announces once without taking focus while a critical error also renders as an alert. Navigation keeps route semantics: anchors with real URLs, aria-current from the server, an explicit local or route mode for tabs and pagination, Live pagination reflected with history.replaceState and no history entry, and load more as a keyed append from a button. The live_key view filter lands with them: a live:key inside a {% for %} loop passes through it, and it enforces at render time the key rule the checker enforces on literal keys.
  • The Live component library gains its data display family, and with it the built-in set is complete. Separator, scroll area, aspect image, card, badge, avatar and avatar group, list group, description list and stat card install with live:add beside the earlier families; every one keeps document order and native semantics, and every status carries text. The chart renders on the server through charts-rs: render_chart in suprnova::live::charts draws bar or line marks from bounded typed series as trusted SVG, and the macro places a summary and a data table beside it, so no charting script reaches the browser. The datatable is a native table with one island per table whose sort, filter and page are #[url] fields reflected into a shareable URL after every action.
  • The Live component library gains its live-native family, the last one. The upload widget renders the shipped upload protocol's states from the runtime's progress root and claims nothing durable before the finalizing action; the live feed and notification bell carry the runtime's stream status announcements, so a degraded, reconnecting or closed stream says so; the account menu is a details disclosure with a CSRF-protected sign-out form and a documented stitch slot under RenderCache. The custom-element tier, input OTP, date picker and combobox, enhances native controls it never replaces: each sn- element is a light-DOM HTMLElement defined by its own vendored file and holds no form value, so the form submits the same value with the script blocked. The combobox refuses a listbox rendered for an older query.
  • Session blocking serializes the requests that carry one session. SESSION_BLOCK=true, or SessionConfig::block(SessionBlock::default()), makes the session middleware hold a cache lock for the session from load to write, and block_session on a route or group enables it for those routes alone. Both bounds are yours, the hold and the wait, and a request that waits past the bound answers 503 with Retry-After. Without it, two concurrent requests on one session wrote back last-writer-wins, so a flash set by a redirect could be lost to a request that started earlier.

Changed

  • Live's supported browser baseline is Chrome and Edge 114, Firefox 128, and Safari 17. The floor rises from Chrome and Edge 111 and Safari 16.4 to the first releases that ship the native popover attribute the component library's overlays own their open state with. The compatibility matrix's minimum slots move with it; Firefox stays at 128.

Fixed

  • A template's live:key reaches the Live runtime. The checker validated live:key and the manual named it, but the browser runtime's morph identity, morph controls and preservation scopes read only the engine's data-suprnova-live-key, so a keyed control written as the checker requires had no effect and every library component wrote the key twice. The runtime now reads live:key, keeps the engine spelling for the roots it renders, refuses an element carrying both with different values, and the components write live:key alone. The form gallery's save form also gained the .prevent modifier it lacked, so a Live submit no longer reloads the page from the form's own query.
  • A Live form holding an empty number input or an unselected select submits. The runtime read such a control's null value as a mismatch with itself and refused the whole submit, so the action never ran and the browser submitted the form natively. The search input's model binding also used a debounce the runtime does not accept; it now uses 250 ms.
  • live:check checks every element a view renders. A view that called a macro splicing caller() with an empty call block, as the validation summary is called, rendered no content after that call to the checker, so the component proved clean while the rest of the view went unchecked. The empty call is now empty content, and a view that renders nothing fails the check. Fixing it exposed errors the dogfood form gallery had hidden.
  • A declared model debounce is 100, 250, or 500 milliseconds. #[model(debounce = N)] accepted 1 to 60000 ms, but the directive grammar the checker and the browser runtime share lists three durations, so any other value could never be bound by a template; it now fails to compile. live:error also accepts an action as its target, as a validation summary names one, matching what the runtime resolves.
  • A Live form of more than seven model fields submits. The browser runtime refused any request carrying more than eight operations or model proposals, and any response with more than sixteen validation entries or eight events, though the framework's server accepts 128 of each; the refused submit never left the browser and was reported as a network failure. The browser now admits the server's counts, live:check refuses a live:submit form of more than 127 model fields, and a request refused for a limit is reported as a resource limit that shows the action's error feedback.
  • The combobox stays responsive and shows what the server answered. Text that no option matched froze the page, because the element's observer watched attributes its own render rewrote even when nothing changed. The element also filtered the server's options by substring, hiding results a server search matched another way, such as an accent-insensitive or code match. It now writes only what changed, shows every option while the listbox answers the input's current text, keeps an answer to older text hidden, and filters by the typed text only for a fixed list, which remote=false selects.
  • A library custom element binds once however a morph moves it. The combobox, input OTP, date picker, and password input bound their listeners on every connection, and the dialog, sheet, and drawer guarded on an attribute a morph removes, so a moved element answered one click twice and the password reveal toggled back at once. Every element now binds per connection, releases its listeners and observers when it leaves the document, and keeps them across an atomic move.
  • A toast holds while the pointer is anywhere on it or focus is inside it. The region resumed its timers when the pointer left any child element, so moving from a toast's text to its padding let it time out under the pointer, and a toast could hide while its dismiss button had focus.
  • Nested tabs act on their own tabs. A local tabs instance selected every tab below it and handled the events of a nested instance, so a click on an inner tab hid the outer panel.
  • The tooltip bubble stays open while the pointer moves onto it. The bubble ignored the pointer, so it hid as the pointer left the trigger and its text could not be read or selected.
  • The select's dropdown indicator follows the text color. It was a data-URI SVG, whose currentColor does not inherit the document's color, so it drew black on the dark scheme's surface.
  • The form controls show the island's values. No form macro took a value, so a number input mounted at 1 rendered empty and a submit that changed nothing proposed an empty value. Each value control now takes value=, checked=, or selected=, radio and checkbox group inputs are keyed by value so a choice the user has not sent survives a re-render, and authority= marks the render that must replace what the user typed.
  • A checkbox group proposes the list of checked values. The runtime read every checkbox as a boolean, so a group whose boxes disagreed could not be submitted. A checkbox group of any size, and any field that more than one checkbox binds, now proposes the checked values in document order; a single checkbox stays a boolean.
  • A model proposal its field cannot decode is a validation error on that field. A proposal such as null for a u64 field or a boolean for a list field was dropped silently: the action ran and the response carried no validation. The field now reports the error through live:error and keeps its value, and the action does not run.
  • The checker, the live_key filter, and the runtime accept one key alphabet. The checker and the filter accepted a key beginning with _, -, ., or :, which the runtime refuses, so the island's first morph failed. A key now begins with an ASCII letter or digit everywhere, and live:check holds the element ids inside an island to the rule the runtime checks, refusing an invalid id (invalid_element_id) and a repeated one (duplicate_element_id), a literal id inside a loop included.
  • live_key_digest keys any value. live_key fails the island's render for a value outside the key alphabet, so a row keyed by an email address failed the island for every viewer. The new filter turns any value into a stable key, one value always yielding the same key.
  • live:check checks a loop or match binding as that binding. Inside a macro body, a name that a for, a match arm, or an if let bound was checked as the macro parameter of the same name, so a literal argument proved a directive that the loop's own values render.
  • render_chart returns an error for a value beyond 1e9. The renderer's axis arithmetic overflowed and panicked from about 1e12; a value whose magnitude exceeds 1e9 is now an input error.
  • An application that cannot read its vendored components refuses to start. try_live_ui_assets() reads templates/suprnova-ui/ under the application base path on each request, so an application started elsewhere, such as from a container image that holds only the binary, answered 404 for every component stylesheet and script and started cleanly. Installing the route now fails and names the directory.
  • live:add replaces a file you never edited. It compared bytes only, so after a library update it kept every installed file and reported it edited locally. It now records each file's digest beside the component and replaces a file whose bytes still match the record; a file you edited, or one no record vouches for, is kept and reported.
  • live:add --manifest refuses a file that is a symbolic link. Each third-party file was read through links, so a component could install the bytes of any readable file as a template. A named file must be a regular file inside the manifest's directory.
  • A model edit that a render replaced is sent when it is typed again. The browser compared each edit with the value it last proposed, so after a refused value and a render that replaced it, such as a reset, typing the same value again sent nothing: the control showed it with no error while the island held another value. The render an island applies is now the baseline the next edit is compared with, and a field's dirty state compares with the value that render gave its control.
  • A tooltip can be dismissed where it is shown. A bubble that covers content could be dismissed only by moving the pointer or focus away, which WCAG 2.2 success criterion 1.4.13 does not accept. Escape now hides it with neither moved, and the next hover or focus of that trigger shows it again. The bubble still shows with no script in the page; the new sn-tooltip element carries the dismissal alone, and live:add tooltip installs it.

2.0.2 - 2026-09-14

Changed

  • The Live endpoints carry no version segment. /__live/v1/action, /__live/v1/upload, /__live/v1/assets/*, and the /__live/v1/async/* family now live at the same paths without /v1: /__live/action, /__live/upload, /__live/assets/*, /__live/async/*. Suprnova's version is the git tag and the browser runtime ships in lockstep with the framework, so a second version inside the URL space promised an evolution path that would never be used. Applications are unaffected: the framework registers these routes and the runtime builds every URL, and hand-written references to /__live/ paths were never supported.

Fixed

  • Every issuance the Live per-scope limit admits answers with a subscription that connects. Concurrent issuances of one scope in the same millisecond mint identical descriptors, and the host's credential store kept only the last secret minted for a descriptor, so the earlier requests answered 403 async_authority_invalid from the connect that issuance performs. About one issuance in five hundred also answered 503 async_unavailable, because the claims it published while its envelope context was built shared one slot with every concurrent issuance. A descriptor now keeps every unconsumed secret until each is consumed or expires, and the claims under construction are keyed by subscription id.

Security

  • The lockfile takes the rustls TLS 1.3 handshake fix. rustls 0.23.45 replaces 0.23.40, which accepted TLS 1.3 handshake messages across encryption level boundaries (RUSTSEC-2026-0285, published on the release day); aws-lc-rs and rustls-webpki move with it. Every HTTPS client in the framework, from the HTTP facade to the Qdrant and payment adapters, resolves the fixed release.
  • A Live stream ends with the session that opened it. An asynchronous membership was re-authorized against its Gate before every delivery but never against its session: a browser that logged out, or whose session was revoked, kept receiving events until the stream itself closed. Destroying a session on a node now retires every membership it opened there at once, for a plain logout, session invalidation, id regeneration, and "log out everywhere" alike, and delivery re-checks each membership's session against the session store at most once per ten seconds, so a session destroyed on another node stops receiving events within that interval.
  • A request's Cache-Control directives are honored by RenderCache. A request carrying no-cache was answered from storage with Age, and a cold request carrying no-store seeded the cache for the next request. no-store now bypasses lookup and publication alike, and no-cache skips the lookup so the request is answered by a fresh render. Found by the 2026-09-13 adversarial audit (ASTRA-13).
  • A render without a snapshot is never published. When the snapshot transaction could not open, RenderCache rendered without a read view and still published if the generation reread agreed, so a render that interleaved with a concurrent multi-row write could store a mix of two database states. Such a render is now served but not stored (decline reason snapshot_unavailable), and its rebuild lease is released. Found by the 2026-09-13 adversarial audit (ASTRA-08).
  • A cached response replays its Content-Encoding. A pre-compressed body was stored without its content coding, so a hit served gzip bytes as plain text. The coding is stored with the body and replayed on every hit. Found by the 2026-09-13 adversarial audit (ASTRA-04).
  • A HEAD request never seeds the GET representation. A cold HEAD on a route that renders nothing for HEAD stored an empty body under the key every GET shares, so later GETs answered zero bytes. A HEAD miss is now served as rendered and not stored (decline reason head_render). Found by the 2026-09-13 adversarial audit (ASTRA-03).
  • The Live per-scope subscription limit holds under concurrency. Issuance counted a scope's subscriptions, released the lock, awaited the authorizer, and inserted afterwards, so a burst of concurrent requests could all pass the count and all be admitted once authorization returned, well past the advertised limit of 512 per scope. The slot is now reserved under the same lock as the count, released on every error path, and handed to the record when it lands. Found by the 2026-09-13 adversarial audit (ASTRA-07).
  • A Live subscription stops receiving events once its Gate denies. An existing asynchronous membership kept receiving newly published events after the stream's authorization Gate was redefined to deny the principal, because delivery compared the subscription's own retained authorization memo with itself. New subscriptions were correctly refused; the old stream was not. The runtime now records the principal a subscription was issued to, asks the Gate again before every delivery, and retires a membership the Gate no longer allows. Found by the 2026-09-13 adversarial audit (ASTRA-01).
  • A Live action declaring transaction = "required" is refused at registration. The host's transaction port is a documented no-op, so the policy promised atomicity it never provided: each write committed on its own and nothing rolled back when a later stage failed. LiveRegistry now fails with RegistryErrorKind::RequiredTransactionUnsupported for such a component until the port installs a real ambient transaction; actions without the policy register as before. Found by the 2026-09-13 adversarial audit (ASTRA-05).
  • A cached route's named-connection reads stay on their connection. A RenderCache miss renders inside a snapshot transaction on the primary database, and query routing preferred that transaction over a query's own on("name") or a model's declared connection, so opting a route into the cache changed which database its code read from. A tenant or auxiliary database read could return the primary's row, fail on a table the primary lacks, or publish the wrong content under a valid key. Reads bound for another connection now run there even inside an ambient transaction, and a render that read outside its snapshot is served but not stored (decline reason foreign_connection_read). Found by the 2026-09-13 adversarial audit (ASTRA-06).
  • A data write and its RenderCache invalidation commit together. On the autocommit path, a model save, a query-builder write, or a raw statement landed its row first and advanced the dependency generations in a second transaction afterwards. When that second transaction failed, the row was durable, the API returned an error, and every cached page that depended on the row kept passing its coherence check and serving the pre-write content: a visibility, entitlement, or deletion change could stay invisible until the next successful invalidation. Every write terminal now runs the row write and its advancement inside one transaction opened for the purpose, so both commit or neither does. A ledger table that vanishes after RenderCache decided it was present now fails the write instead of being skipped with a warning. A write bound for a named connection, whose ledger lives on the primary, keeps its separate advancement; if that advancement fails, the process stops serving stored entries until one succeeds. Found by the 2026-09-13 adversarial audit (ASTRA-10).
  • A handler's Vary contract is enforced before RenderCache stores. A handler that varied its body on a request header of its own and said so with Vary was stored under a key built from the route policy alone, so the first variant's body was served to every other variant, with the Vary header missing from the hit. Wherever that header selected user, device, or experiment-specific content, one request's content reached another's. RenderCache now parses the response's Vary before publication and declines to store when it names * or a field the policy does not declare as a key dimension (decline reason vary_undeclared). Found by the 2026-09-13 adversarial audit (ASTRA-09).
  • A handler's Cache-Control: no-store is honored by RenderCache. A route opted into the cache stored a response whose handler said no-store and replayed it under the policy's own public, max-age=60, s-maxage=60, so a handler's "do not store" was ignored on the server and rewritten for every browser and proxy downstream. The eligibility check now reads the response's Cache-Control and declines storage on the no-store token (decline reason no_store_directive), and the declined response goes out exactly as the handler built it. Found by the 2026-09-13 adversarial audit (ASTRA-02).
  • A per-response CSP nonce is never replayed from the cache. A public page that minted a nonce on every render and named it in Content-Security-Policy was stored as an ordinary complete entry, so every later hit carried the first render's nonce in both the header and the inline script. A nonce is the authorization token for inline script in one response; replaying it made that token readable to anyone who could fetch the page. RenderCache now declines to store such a response (decline reason nonce_source_policy); a hash-based policy caches as before, and stitched Live documents keep issuing a fresh nonce per hit. Found by the 2026-09-13 adversarial audit (ASTRA-12).
  • A cached response keeps its isolation and execution headers. RenderCache stored a response's Content-Disposition, Cross-Origin-Opener-Policy, Cross-Origin-Embedder-Policy, Cross-Origin-Resource-Policy, Permissions-Policy, and X-Frame-Options nowhere, so a cache hit served the same bytes without them. An HTML export that downloaded as an attachment on the first request rendered inline under the application's origin on the second, where any markup it carried ran with same-origin authority. The six headers now replay byte for byte from the stored representation. Found by the 2026-09-13 adversarial audit (ASTRA-11).
  • The lockfile sheds one unsound and three yanked dependency releases. event-listener 5.4.2 replaces 5.4.1, whose stack-allocated listener was unconditionally Send/Sync and let a !Send tag cross threads in safe code (RUSTSEC-2026-0221); Suprnova's dependencies only use untagged events, so the unsound path was never exercised here. spin 0.9.9 and 0.10.1 and chacha20 0.10.2 replace releases their publishers had yanked, and concurrent-queue leaves the tree entirely.

2.0.1 - 2026-09-12

Fixed

  • A redis:// URL with a database index selects that database everywhere. The queue driver and the fanout broadcast hub each carry a sea-streamer producer beside their direct redis connections, and sea-streamer does not read the logical database from the URL's path - so a queue pointed at redis://host:6379/3 pushed jobs into database 0 while its consumer half waited on database 3, and the fanout hub operated on 0 outright. Both now carry the index across explicitly, with the same parsing rule the redis client applies. A URL without a path keeps selecting database 0, so nothing changes for the common form.

  • suprnova generate-types ends its output with one newline. The blank line that separates one interface from the next was also written after the last one, so a project that enforces git diff --check failed with new blank line at EOF on a file it could not correct by hand: the next regeneration wrote the blank line straight back. Only the end of the file changes; the blank lines between declarations stay.

  • A scaffolded login or registration form shows its validation errors. The generated auth controller declared an errors prop on LoginProps and RegisterProps and sent it as None. The framework seeds errors on every Inertia page from the session-flashed validation bag, and an explicit prop of the same name replaces that seed, so the page received errors: null and invalid credentials returned to a form that displayed nothing. Both props are now empty, the Login and Register pages of all three frontends read useForm().errors, and the scaffold's inertia-props.ts is the byte-exact output of suprnova generate-types for the scaffold's controllers, so a project's first regeneration no longer rewrites a file nobody edited.

  • A scaffolded application serves its built frontend. The generated routes.rs registered no static-file fallback, so once Vite's dev server was not running every /assets/* URL in the HTML shell answered 404, including inside the production image the scaffold's Dockerfile builds. routes.rs now ends with fallback!(StaticFiles::public().handler()): declared routes still win, dotfiles such as public/assets/.vite/manifest.json and path traversal are refused, and an unknown URL still renders the Inertia Error page.

  • A scaffolded application verifies email addresses and resets passwords. Registration created and signed in the user without sending verification mail, and no route offered email verification or password recovery, although the generated User already implemented MustVerifyEmail and CanResetPassword and the auth_flow_tokens migration already shipped. Registration now mails a verification link through EmailVerification::send_link and continues to /verify-email, which shows the notice, resends the link, and consumes it on /verify-email/verify for the signed-in owner only. /forgot-password mails a reset link to a verified address (an unknown or unverified address gets the same answer and no mail) and /reset-password rotates the password through PasswordReset::complete_with_outcome, refusing to finish while the account's other sessions or remember-me tokens could not be revoked. The Vue, React and Svelte starters ship the ForgotPassword, ResetPassword and VerifyEmail pages and a "Forgot your password?" link on the login page. Links are built with url::to, so APP_URL must name the address users reach the application at, and registration needs a working mail transport: the .env the scaffold writes points MAIL_DRIVER=smtp at a local catcher on port 1025 (the Mailpit that suprnova docker:compose --with-mailpit adds), or set MAIL_DRIVER=log to print each message, link included, to the server log.

  • A fresh Svelte scaffold builds against @inertiajs/svelte 3.7. The generated main.ts declared an async setup, and @inertiajs/svelte 3.7 types setup as returning SvelteRenderResult | void, so a project scaffolded today (the template asks for ^3.6.1, which now resolves to 3.7.1) failed svelte-check inside npm run build before a single page had been written. setup is synchronous now and chains the translation catalog load onto the mount, so the ordering the template describes is unchanged.

Documentation

  • The six locale mirrors of the 2.0.0 chapters follow the manual's own conventions. The chapters translated since 1.3.7 wrapped Japanese and Simplified Chinese prose mid-sentence (1,653 line breaks that rendered as stray spaces), rendered 59 terms differently from the rest of their locale, translated 9 repeated headings a second way, and left 2 quotes unpaired. All of that is aligned with the older chapters, so a reader of any locale sees one vocabulary and unbroken sentences across the manual.

Upgrading

  • These are scaffold fixes; an application generated with 2.0.0 keeps its generated files. Upgrading the framework crate changes nothing in src/ or frontend/. To pick the fixes up in an existing project, make the same edits by hand: drop the errors field from LoginProps and RegisterProps and read useForm().errors in the pages; add fallback!(StaticFiles::public().handler()) as the last entry of routes!; and copy the email_verification and password_reset controllers, their routes, and the three auth pages from a project generated with 2.0.1. The generate-types output changes only at the end of the file.

2.0.0 - 2026-09-10

Security

  • A bearer token and a web session are now separate identities. The request-scoped user cache kept one current-user slot that everything wrote to and everything read from, so a browser session hydrated by SessionMiddleware satisfied a TokenGuard on the same request, and a user resolved for the web guard was handed back to code that had asked for the API guard. Bearer credentials now carry their own provenance in that cache: BearerTokenMiddleware records the identifier it validated in a bearer slot of its own, TokenGuard resolves and caches the full user there, and only something that arrived through a bearer credential can satisfy a token guard. Session guards are cached per guard name in the same place, so Auth::guard("admin").user() and Auth::guard("web").user() in one request no longer resolve to whichever of them ran first. The generic slots remain as a compatibility view for the static Auth facade, mirrored from the configured default guard alone, so Auth::id(), Auth::check() and AuthMiddleware behave exactly as they did for an application with one guard and for a token-only request that never installs a session.

  • A named guard keeps its own principal, its own remember-me credential, and its own revocation. Logging in through Auth::guard("admin") wrote the identifier into the same session key the default guard uses, so two guards in one application shared one principal and signing out of either signed out of both. In the persisted session each guard now owns its entry under the _auth_guards map, and the remember-me cookie carries a guard-tagged carrier (suprnova.remember.v1: followed by the guard name and the credential) so a cookie issued for one guard cannot re-authenticate another. A cookie without that prefix is read as the default guard's, which is exactly what a cookie issued by an earlier release is, so nobody is signed out by the upgrade; a carrier naming a version this build does not understand is refused rather than guessed at. Revocation follows the same boundary: signing out, and the middleware's own rotation path, retire the exact selector the owning guard issued rather than every credential the user holds.

  • BasicAuthMiddleware no longer accepts a stale session slot as proof. Its non-stateless form skipped the Authorization header whenever Auth::check() was true, and Auth::check() reads the request-scoped current-user slot, which anything earlier in the chain could have populated. It now asks for the persisted session principal of the guard it was configured with, and refuses outright when that guard is absent or is not a stateful guard, so a request is admitted without credentials only when a real session row says who it belongs to. The stateless form always re-read the header and is unchanged.

  • Remember-me credentials rotate as one atomic replacement. Rotation used to remove the accepted credential and insert its successor as two writes: a failure between them consumed a valid credential and left the visitor with no way back in, and a crash left both rows live. The default schema now replaces one exact, still-valid row with its prepared successor in a single operation, and a store that cannot make the conditional removal and the replacement insert atomic fails closed rather than performing them separately. Selector matching is exact, so a credential is never retired by a prefix collision, and a synchronous identity transition inside a handler queues the exact credential it invalidated for revocation at the end of the request instead of leaving it live.

  • Two-factor admission is serialized, and a lockout write that fails takes the request down with it. Two workers proving the same code could each read the attempt counter before either wrote it, so a brute-force budget admitted more attempts than it allowed. Verification now reserves attempt capacity inside the same serialized store operation that admits the attempt, returning both the reservation and any finalized-failure state observed in that one decision; a ceremony that cannot commit cancels its prepared proof, and the cancel path's default fails closed so an existing verifier implementation cannot silently leak reserved capacity. A lockout counter write that errors is no longer swallowed: the attempt is refused. Promoting a session that is waiting on a second factor is one atomic migration, and the bearer credential is suppressed before the storage call is awaited, so a timeout or a backend failure can never leave a credential attached to a session the framework did not commit.

  • Session rotation fails closed. Rotating a session id destroys the old row and writes a new one. A destroy that errored was logged and stepped over, which left the previous authenticated row replayable by anyone holding the old cookie. The middleware now returns before writing the replacement and before issuing the new id, and expires the browser's old credential on the way out. Separately, the cookie that carries a fresh or rotated session is built before the row is committed: a cookie that cannot be constructed used to leave a session in the store that no browser could ever present, and now leaves nothing behind at all.

  • A session that outlives its user stops authorizing, and revoking a user's sessions reaches the named guards. AuthMiddleware treated the presence of a persisted identifier as proof of an identity, so a deleted or soft-deleted user kept passing every guarded route until the session expired. It now resolves the user through the provider and clears the stale slot when the provider finds nothing; an application with no user provider bound at all keeps the identifier-only fast path, recognized by its own error rather than by matching message text, and every other provider failure is an error rather than a pass. destroy_all_for_user matched only the indexed user_id column, which is null for a session authenticated through a named guard alone, so those sessions survived a "sign out everywhere". It now compares the guard identities inside each surviving payload as well.

  • Device-authorization ceremonies transition atomically and are validated before consumption. Approving a device code read the ceremony, then consumed it, then wrote the grant, so a replacement issued under the same selector between the read and the consume could be consumed instead of the record that was actually approved. The store contract now binds the consuming transaction to the exact record a prior read observed, and transitions one ceremony while consuming another in a single atomic step. Both methods default to failing closed, so an external store implementation stays source-compatible without silently getting the weaker behaviour.

  • A provider-token refresh whose outcome is unknown is fenced, not retried. A linked-account refresh that started and then lost its answer left an ordinary claim that expired on schedule, so a second worker refreshed the same grant and one of the two results was discarded, taking a single-use refresh token with it. Starting an exchange now replaces the claim's owner with a reserved exchange owner while preserving the original deadline, so followers can tell a live exchange from an abandoned one, and a store must never reclaim a row whose owner is in that reserved namespace. Stores that do not implement the fence fail closed.

  • Web Push refuses to send through a transport that might follow a redirect. EndpointPolicy::Strict validates the subscription endpoint URL, but validation only ever covered the initial URL: a client that follows redirects turns a validated endpoint into a 3xx to anywhere, and reqwest follows redirects by default. A client this crate builds now has redirects forcibly disabled, and the new WebPushClient::with_client_builder applies every option a caller wants (proxy, TLS pinning, timeouts) while overriding the redirect policy. WebPushClient::with_client, which takes an already-built client whose redirect policy cannot be inspected, now refuses to send under Strict with WebPushError::UnconfinedRedirects, before encryption and before any request. WebPushClient::allow_unconfined_redirects is the explicit opt-out for a caller who knows their client is safe.

  • A signed URL is bound to the exact path it was signed for. Signing and verification both trimmed a trailing slash before hashing, which made /orders/1 and /orders/1/ one signature, and made a proxy that appends a slash indistinguishable from a client that edits the path. The path is now hashed exactly as it appears, so a signature covers one path and one path only.

  • A cache key can no longer address a lock or a tag index. Redis lock, tag, and key-tag records lived under a NUL sentinel after the configured prefix, and a caller-supplied key beginning with that sentinel landed in the same space, so a Cache::forget could release a distributed lock somebody else was holding. Values and each internal record type now carry distinct namespace components ahead of the caller's key, so the two spaces cannot meet. An ordinary key is stored exactly where it was before, so nothing already cached is orphaned. The in-memory driver got the same separation.

  • Payment webhooks reject what they cannot identify and classify duplicates by the database, not by message text. A provider event with a missing, non-string, or whitespace-only identifier used to enter the shared idempotency namespace under a blank key, where it collided with every other such event; it is now rejected before any state is written. A concurrent duplicate is recognized from SeaORM's structured unique-violation code rather than from human-readable error text an unrelated failure can also contain, and only a re-read of a committed processed_at is acknowledged as one, so a mirror-write failure stays retryable. Stripe's signature timestamp is compared with an unsigned absolute difference, so an extreme t= value returns a signature error instead of overflowing, and a negative configured tolerance accepts only an exact match. The webhook route preserves the typed status of a body it refused, so an over-cap body is still a 413 rather than a flattened 400.

  • A non-idempotent HTTP request is no longer replayed after a transport error. The retry policy already required the explicit retry_non_idempotent opt-in before replaying a POST or PATCH that answered 5xx, but the transport-error branch beside it did not check, so a request whose connection dropped after the server had accepted it was sent again. Both branches now apply the same rule.

  • Session lifetimes cannot overflow into mass expiry. SESSION_LIFETIME and SESSION_REMEMBER_LIFETIME are minutes multiplied by sixty and then added to a stored timestamp in date arithmetic that panics on overflow, so an oversized value either aborted the process or wrapped into a deadline in the past that expired every session at once. Both are clamped to MAX_SESSION_LIFETIME_MINUTES before the multiplication, the database driver caps the same way for a configuration built in code, and a garbage collection cutoff that cannot be represented is skipped rather than sent to the database, which is the difference between collecting nothing and collecting everything.

  • Machine-to-machine cache identities are unambiguous. The token broker's cache key concatenated the provider, the client, and the normalized scope set, so two different requests whose components happened to run together into the same string shared one cached token. The key is now a versioned domain with length-prefixed components, which no combination of inputs can make collide.

  • An idempotency lease is proven still held before its result is reported as fenced. The lease refreshed periodically while the body ran, and a transient refresh error was treated as loss, while a body that finished between two refreshes was reported as fenced without anyone asking whether the lock was still there. A transient refresh error is now retried and only gives up after several consecutive failures, and one final owner-scoped refresh must succeed after the body completes before the outcome is reported as fenced; an error in that last check answers FreshUnfenced, because ownership is then unknown.

  • The encryption key ring is validated and installed before application bootstrap. Crypt was initialized by Server::from_config, so anything that ran earlier - the bootstrap callback, a console command, a queue worker entry point that never builds a server - either found no key ring or built its own. #[suprnova::main] now loads the environment and then validates and installs the ring, in that order, before your bootstrap runs. Validation runs on every boot even after the ring is installed, so a production process with a missing or malformed APP_KEY still fails closed, while the process-wide key stays immutable. Laravel's APP_PREVIOUS_KEYS is accepted as an alias for APP_KEY_PREVIOUS; when both are set and disagree, the Suprnova name wins and the duplicate is named in a warning.

  • The archived proc-macro-error2 crate is replaced by its maintained successor. It was archived on 2026-06-07, is flagged unmaintained in RUSTSEC-2026-0173, and made every build warn that a future Rust release will reject it (E0365). validator_derive 0.20.1 moves to proc-macro-error3 3.1.1 and sea-bae 0.2.2 drops the dependency, so neither the advisory nor the warning appears any more. This landed on main after the v2.0.0 tag; the tagged Cargo.lock still resolves proc-macro-error2.

Added

  • Suprnova Live is part of the framework. suprnova::live is a server-driven interaction engine: a component is a Rust struct whose state lives on the server, whose view is a checked Askama template, and whose actions run over a signed protocol from a small browser runtime that morphs the re-rendered HTML in place. There is no client-side state model to keep in sync, no build tool to install to use the shipped runtime, and no inline JavaScript in your documents. The engine ships as an internal crate the framework depends on unconditionally, so nothing has to be enabled; the browser half is published as @suprnova/live and its exact reviewed bytes are served by the framework itself. manual/live.md is the application-facing chapter, and a project created by suprnova new is Live ready out of the box: it writes src/live/mod.rs with an empty registry and a routes() function, binds the registry in bootstrap.rs, and installs the routes from cmd/main.rs.

  • Components are declared with #[derive(LiveComponent)] and #[live]. The derive names the component and its view (#[live(name = "app.counter", view = "live/counter.html")]); the #[live] attribute on the impl block marks the methods the browser may invoke. A #[public] field is rendered and carried in the signed snapshot, a #[model] field additionally accepts browser proposals through live:model, and an #[action] method is the only entry point a request can reach, receiving validated arguments and returning typed outcomes such as a redirect or a flash. Every field type must implement Default; a fresh island starts from those defaults unless a mount hook says otherwise. Components are registered explicitly through LiveRegistry::builder, and the registry is immutable once the runtime assembles - a duplicate name or view, or a component whose actions need validation with no validation port bound, fails registration with a typed RegistryError.

  • suprnova::view is a checked server-rendered view contract for ordinary routes as well as Live components. #[suprnova::view(path = "...")] declares a template, TrustedHtml is the one audited type a template may emit unescaped, and the trusted_html filter is how it gets there; #[suprnova::view_filter] declares a checked custom filter. Askama is the substrate, but handlers depend on the framework's own contracts rather than on the template engine's modules, and TemplateFailure is a closed, redacted failure set (MissingData, InvalidData, Failed) rather than the engine's own error text.

  • The live: directive grammar is closed and proved against your components. A view binds behaviour with live:click, live:submit, live:model, live:upload, live:key, live:loading and the rest of the documented set - never an inline expression language, and never a server-returned script. suprnova live:check builds your application and runs the integrated checker over every registered view: an unknown action, an unknown model field, a raw safe filter, or an accessibility violation fails with the file, line, and column. --allow-unproved accepts the dynamic structures the checker deliberately makes no claim about.

  • Router::try_live() installs the reserved Live namespace once. It registers /__live/v1/action, /__live/v1/upload, the /__live/v1/async/* control routes and WebSocket handshake, and the immutable /__live/v1/assets/* routes, and startup fails if an application route could claim /__live. Router::try_live_with takes a LiveRouteGuard whose middleware chain is applied to the action, upload, and asynchronous control routes and to the WebSocket upgrade, which is how an application attaches its own authentication, tenancy, and rate limiting; asset routes stay unguarded. Every reserved request carries a strict policy: session, origin, CSRF, principal, tenant, and rate-limit facts must all have been recorded by real middleware, and an asynchronous route that cannot see the complete set is refused rather than opening an anonymous transport.

  • A Live request proves its own origin, and using Live relaxes nothing else. The shipped runtime sends the Live media type and the browser's own Sec-Fetch-Site header and carries no session token, so CsrfMiddleware verifies that proof for a Live operation on its own, whatever origin policy the application configured, and falls back to token validation for a cross-site or header-less request. Ordinary routes keep the configured policy, so an application no longer has to widen OriginPolicy for the whole application to let Live work. AuthMiddleware::optional() is the new guard form this needs: it records a principal when one exists and lets an anonymous request continue, so anonymous visitors can act on a public seed while an identity-bound island still refuses a request without principal evidence.

  • Documents place islands through LiveDocument. A document route builds one from the request, mounts each island with LiveMount, and emits the bootstrap markup exactly once. LiveMount::public_seed declares an island any visitor may render, whose state is a reusable seed promoted to a real instance on the visitor's first action; LiveMount::identity_bound declares an island that belongs to the current session and principal, so its document route must authenticate. LiveDocument::bootstrap emits the inert configuration element and the ordered script tags with integrity attributes for the ESM or the classic strategy, adds the upload and asynchronous roles when a mounted component needs them and the Stimulus bridge on request, and rejects a second bootstrap or a mount after bootstrap. Router::try_live_mount registers a mount, and Router::try_live_document declares a document route with no startup mounts.

  • The framework serves the exact reviewed browser artifacts. The ten deterministic build outputs are embedded and validated against their manifest on first use, failing closed on any drift in digest, length, file name, role, capability, or version, and are served from /__live/v1/assets/<identity>/<file> for GET and HEAD with immutable caching, strong digest validators, conditional requests, nosniff, and closed misses. Documents contain no inline executable code, so a strict script-src 'self' policy holds. suprnova live:assets --out <dir> publishes the same bytes to a CDN or a static directory atomically, treats an identical publication as up to date, and refuses to replace a directory whose bytes differ unless you pass --replace.

  • Live components accept file uploads under a declared, checked policy. An #[upload(policy = ...)] attribute on a #[model] field declares maximum file count, declared and aggregate byte budgets, accepted media types, and replacement behaviour through UploadPolicy::builder, and the view binds it with <input type="file" live:upload="avatar">. The runtime creates, transfers, and completes the upload through /__live/v1/upload; the bytes wait in quarantine until the declared finalize action runs, when the framework hands them to the application's UploadFinalizer, alongside an optional UploadScanner and UploadApplicationValidator. Every control is authorized through the gate as live:<component>.upload.<field>.<Control> for each of Create, Reacquire, Status, Queue, BeginTransfer, PutChunk, Complete, Accept, BeginFinalize, CommitFinalize, Cancel, Reject, Expire, and Fail. Every request revalidates the current mount, principal, session, tenant, component, field, and document scope, a per-handle lock serializes chunk, completion, cancellation, action, finalization, and cleanup races, and chunk bodies reserve the shared in-flight budget before buffering. Router::try_live_upload_reacquisition declares an application-owned path outside the reserved namespace where a browser that lost its transfer grant can get a fresh one, answering only the session and principal that created the upload.

  • Islands update asynchronously over SSE, WebSocket, or polling. A component declares the streams it listens to in the #[live] attribute (streams(stream(name = "activity", topics("activity"), events(ActivityPosted)))), the framework signs a bounded subscription descriptor for the visitor, and the browser runtime opens a native transport and falls back to polling when it cannot. Subscribing is authorized through the gate ability live:<component>.stream.<name>; the application publishes through suprnova::live::LiveStreams, with refresh telling subscribed islands to fresh-render and event::<T> delivering a typed payload to the island's registered handlers. Fanout, hop count, and per-document delivery are all bounded. Polling is an ordinary fresh render, so state catches up but event payloads published while a transport was unavailable are not replayed, which the runtime reports as a degraded stream rather than a current one.

  • The browser runtime is a strict TypeScript package that ships in core and optional bundles. @suprnova/live bootstraps once per document, discovers islands, parses the closed directive grammar, gives each island bounded work and truthful pending and failed state, applies a response only after a successful morph through a pinned private Idiomorph adapter, and preserves focus, form state, controllers, scroll, and history across morphs and native navigations. Optional uploads, async, and stimulus bundles attach through a typed feature port, in ESM and classic forms; Stimulus is never bundled into core. There is no eval, no new Function, no server-returned script, and no inline expression language anywhere in it.

  • Four CLI commands cover the Live workflow. suprnova live:make <name> scaffolds a component in src/live/, its view in templates/live/, and its registration in the registry() builder, declares the module, validates every target and refuses traversal and symlinks before writing, writes atomically, never overwrites, rolls back every file a failed run had written, and can report a dry run. suprnova live:check, suprnova live:inspect, and suprnova live:assets are thin clients of a hidden framework console command and a bounded, versioned JSON-lines protocol, so the CLI keeps no framework or engine dependency and fails closed with no writes on anything unsupported, stale, truncated, oversized, or unexpected. live:inspect reports the bound registry, configuration limits, installed upload capabilities, assembled runtime services, and the asset identity as presence booleans and counts, never state or secrets.

  • suprnova::live::testing prepares a router's runtime and mount catalog for in-process tests. prepare_live_router_for_test gives a test the same runtime the server assembles, so a test can decode an island's snapshot from its data-suprnova-live-snapshot attribute, post an action with a real session cookie and Sec-Fetch-Site: same-origin, and assert on the accepted render through the application's real global middleware stack.

  • RenderCache stores a proven-safe copy of a route's response and serves the next matching request without running the handler. It is opt-in per route and per group, it never changes what an application can do, and a route it declines still renders and serves correctly. Router::try_render_cache opts one already-registered route pattern in and Router::try_render_cache_group opts every route under a path prefix in; RenderCache::install(router, RenderCacheConfig::from_env()) finishes the wiring after every middleware registration that establishes request-scoped locale, session, or identity. RENDER_CACHE_ENABLED=false is a real off switch at install time: a disabled configuration returns the router untouched, probes nothing, registers nothing, and leaves the process gate shut.

  • A cache policy states a representation class, a freshness policy, and how the response may be shared. RenderCachePolicy::builder takes a RepresentationClass running widest to narrowest - PublicShared, PublicShellStitched, PrivateCached, Uncacheable - and FreshnessPolicy::new(fresh_ms, stale_servable_ms, stale_on_error_ms) sets how long a representation is fresh and then how far past that edge a stored copy may be served while a background rebuild runs or after a foreground rebuild failed. SharedCachePolicy controls what a shared cache in front of the application is told. A route inside a cached group can narrow its enclosing policy with a PolicyPatch instead of restating it, and may only make it narrower; pulling one route out of a cached group is a patch that sets the class to Uncacheable.

  • Variance is declared, never guessed. A cached representation varies by route pattern, path parameters, and application build unless a policy says otherwise. QueryPolicy::declared([...]) names the query parameters that distinguish representations, and any other query parameter on a request bypasses the cache for that request rather than being silently ignored. .vary(VarianceDimension::Locale | ::Host | ::Tenant | ::Principal) partitions by the negotiated locale, the request host, the current tenant, or the signed-in visitor, the last two as opaque key material; a PrivateCached route that declares neither Principal nor Tenant fails to build at all. Media and Encoding are declared together with their own closed set through .vary_media(NegotiatedPolicy::declared([...], default)?) and .vary_encoding(...): the middleware negotiates the request's Accept or Accept-Encoding against that set per RFC 9110, with the highest quality winning, equal quality keeping the header's own left-to-right order, a wildcard compared as a literal token rather than expanded, and a q=0, out-of-range, or unparsable quality excluding a candidate rather than defaulting it. An absent, unmatched, or unparsable header resolves to the declared default and never panics. Both the render key and the Vary header take their value from that one resolution, so they cannot disagree.

  • A served hit is a real HTTP response with real validators. It carries ETag as a strong validator a client can send back as If-None-Match for a 304, plus Cache-Control, Vary, and Age in whole seconds since publication, which is the quickest local sign that a response came out of the store rather than out of a handler. A response served past its fresh interval additionally carries Warning: 110 - "Response is Stale". Conditional requests and HEAD are answered from the stored entry.

  • Cached output is proved current against the database, not assumed. A request-scoped collector attributes every read a handler makes to the thing it read: a model, a table, a configuration value, a feature flag, an authorization decision, an identity axis. Every supported write path on the other side advances the generation of what it changed, in the caller's own transaction where there is one - the ORM's model and bulk writes, the query builder facade, raw table writes, the payments hydration path, feature flag writes, and the RBAC role and permission statements including the new revocations. A hit reproves the generations it depends on before serving, either by rereading the ledger under CoherenceMode::Authority or against a validation lease under CoherenceMode::Lease, so nothing a write has invalidated can be served as current. RenderCache::bump_permission_version is the one invalidation an application calls by hand, from the code path that changes what a signed-in user may do; it advances a persisted generation every principal-keyed render observes, survives a restart, and joins the transaction the role change runs in.

  • Authorization, feature flags, and global scopes participate honestly. A gate decision is judged by the identity axis its evaluation actually consulted, so a tenant-only consult needs only Tenant declared while anything that resolved principal material, or resolved nothing nameable at all, needs Principal. An RBAC-gated route caches and a permission grant or revocation rebuilds it, because the five role and permission tables are observed rather than treated as an unknown. A feature flag read observes a Feature generation whenever the snapshot holds that flag at any scope key, set_flag advances it, and a flag reload advances it for every flag its own diff found changed. An Eloquent GlobalScope declares ScopeDependency::Constant or keeps the conservative PerRequest default, and a per-request scope whose filter read nothing the collector can name is recorded as an undeclared read and narrows the render to Uncacheable rather than silently caching a tenant filter away. suprnova::live::current_tenant() is the instrumented accessor a gate body or a scope reaches for.

  • The write side is open in every process that writes through the ORM. A queue worker, a scheduled task, or a console command writes through the same ORM the server does and never calls RenderCache::install, so its writes used to advance no generation and pages depending on them kept being served stale. The write side is now a process-wide tri-state probed at most once, never inside a caller's transaction, so every writing process advances the same generations the server does while an application with the cache disabled still issues no RenderCache SQL at all.

  • Three deployment profiles decide where entries and rebuild leadership live. RENDER_CACHE_PROFILE selects embedded (a per-process file tier under RENDER_CACHE_L1_DIR, in-process leadership), database (entries in suprnova_render_entries, leases in suprnova_render_leases, Live instance records in suprnova_live_instances and suprnova_live_promotions), or redis (a Redis hash per key, plus a per-key publication token counter). RENDER_CACHE_L1 and RENDER_CACHE_COORDINATOR override either half independently, so a deployment that wants its entries in the database and its leases in process says exactly that. Generation truth does not move: the database-backed ledger is the authority at every profile, which is what lets Redis lose everything it holds without anything stale being proved current. The full table is RENDER_CACHE_ENABLED, RENDER_CACHE_PROFILE, RENDER_CACHE_L1, RENDER_CACHE_COORDINATOR, RENDER_CACHE_L0_ENTRIES, RENDER_CACHE_L0_BYTES, RENDER_CACHE_L1_DIR, RENDER_CACHE_L1_BYTES, RENDER_CACHE_REDIS_URL, RENDER_CACHE_REDIS_PREFIX, RENDER_CACHE_LEASE_MS, RENDER_CACHE_MAX_WAITERS, RENDER_CACHE_HINTS, RENDER_CACHE_FAILURE, and APP_BUILD_ID. A closed-set variable given a value outside its set fails the boot with a message naming the variable and never repeating the value, because an environment value can carry a secret. The Live instance ledger has its own LIVE_LEDGER_DRIVER, LIVE_REDIS_URL, and LIVE_REDIS_PREFIX, and both installs fail closed at boot on a missing tier migration or an endpoint nothing answers.

  • A Live document can be cached as a shared shell with per-visitor islands. A route declaring RepresentationClass::PublicShellStitched stores the shell once as a composite entry cut from the slots LiveDocument::mount captured, and on a hit the middleware attaches the prepared entry and still calls the route chain, so the route's own guard and tenant middleware decide the request before the Live completion middleware re-mounts every slot under authority derived for that request alone. A capture that is not exactly usable - a slot not found exactly once, a document digest that does not match - declines publication and stores nothing. The bounds are 32 slots, 64 nonce holes, 193 graph segments, and 4,096 bytes each for slot parameters and fallbacks. Because every assembly is a distinct representation, no composite response answers 304 or honours If-None-Match, and a slotted assembly is sent Cache-Control: private, no-store while a zero-slot one keeps its class's private max-age.

  • A stored composite can name another stored entry as one of its segments. LiveNestedSegment is the typed declaration and Router::try_live_nested_segment registers it. The inner entry keeps its own key and its own version, so it is invalidated, republished, and fenced on its own terms rather than the includer's, and each segment declares what happens when it cannot be resolved: fail the document, omit it, or serve a bounded fallback. Nesting is bounded to three levels and sixteen nested segments, a cycle is reported as a cycle even when it would also overrun the depth, and the assembled length is checked against the body bound before a single byte is copied. Publication is refused for a composite naming an inner segment of a wider representation class, one with a longer freshness window, a transitive cycle, a graph past the depth bound, or a PrivateCached inner segment that could never resolve. On a hit an identity-bound inner segment is reauthorized for the requesting visitor; one declared identity-free skips that, which is proven identity freedom rather than a weakening of it.

  • Nodes can tell each other that a generation just moved. RENDER_CACHE_HINTS turns on a Redis pub/sub channel carrying the dependency digests an advance just touched, defaulting to on for the redis profile and off for the other two, riding the same RENDER_CACHE_REDIS_URL and RENDER_CACHE_REDIS_PREFIX as the cache itself. A hint's only power is to make a node revalidate earlier than its own lease would have: it can never extend or create a lease, prove an entry current, bypass the ledger read a hit still makes, or touch the authority epoch, which is why the channel is unauthenticated by design and why an unreachable hint endpoint does not refuse the boot the way an unreachable cache tier does. A hint carries no instant, so no clock-skew assumption between nodes is needed. A deployment with hints off, one whose channel is dead, and one that never had them serve the same entries and admit the same rebuilds; only the moment of revalidation differs.

  • Two console commands and nine telemetry counters are the operating surface. render-cache:inspect <key> reports one stored entry's representation class, body_bytes, other metadata, and the current authority epoch, and it reads this process's in-process tier and nothing else, so on a shared profile it answers "what this node has in memory" rather than "what the deployment has stored". render-cache:epoch-advance is the emergency invalidation: it advances the authority epoch, which is baked into every lookup key, so stored entries go out of reach with nothing to enumerate and nothing to delete, and on the node that runs it the effect is immediate. Neither ever prints a stored body or a raw dependency identity, which is asserted rather than merely stated. The counters are suprnova.render_cache.lookups, .hits, .publications, .rebuilds, .stitch.assemblies, .stitch.slots, .stitch.nested, .hints, and .epoch_rewinds, all with closed low-cardinality attributes that never name a route, a key, a digest, a tier, or a provider.

  • A declined lookup says exactly which contract refused it. outcome="declined" on the lookup counter now carries a reason attribute from a closed set of thirty-eight labels, computed from a typed value at the branch that actually declined rather than reconstructed from the response afterwards. They are grouped by contract: eligibility (policy_uncacheable, method, status, streaming, sets_cookie, unsafe_header_name), observation (observation_overflowed, ledger_read_failed, handler_not_begun), classification, key mismatch, Live document, and composite build. Every label is documented in the operations chapter, and a test asserts that rather than trusting the prose. reason is emitted only beside outcome="declined"; a hit and a miss carry none.

  • An authority epoch that goes backwards is detected, refused, and lifted past. A database restore can move the epoch to a value the deployment has already used, which would let entries published under the old higher value be proved current again. An entry or a lease stamped above the authority is now refused at any age, before any dependency comparison, and the node that detects it lifts the ledger epoch past the stamp, drops its lease, clears its in-process tier, and increments suprnova.render_cache.epoch_rewinds.

  • NOWPayments joins Stripe and Paddle as a payment adapter. The suprnova-payments-nowpayments crate creates hosted invoices, verifies payment notifications, and reads payment status with the merchant API key, and registers as nowpayments in the ordinary provider registry through NowPaymentsProvider::from_env(). It reads NOWPAYMENTS_ENVIRONMENT (sandbox or production, defaulting to sandbox; an unknown or blank value fails configuration), NOWPAYMENTS_API_KEY, NOWPAYMENTS_IPN_SECRET, and NOWPAYMENTS_IPN_CALLBACK_URL, and refuses blank credentials before any HTTP request. Its webhook endpoint is POST /webhooks/payments/nowpayments through the shared webhook_routes, and it needs the exact public HTTPS callback URL and request bodies that reach the adapter unchanged. manual/payments-nowpayments.md is the chapter.

  • RBAC has the revoking counterpart of every granting helper. The surface exported the granting and checking halves of an access-control API and nothing that took access away, so removing an administrator's role meant composing statements against join tables whose semantics you had to infer - during an incident, which is when you reach for revocation. remove_permission_from_role, remove_role_from_model and remove_permission_from_model are the free functions, each with the _on_guard pairing the granting side already had, and HasRoles::remove_role and HasRoles::remove_permission_to pair at the call site. A name that exists on no such guard is an error, so a typo or a call aimed at the wrong guard is loud; an assignment the model or role does not hold is a no-op returning Ok, so a retry of a revocation that already landed is safe. Each call removes exactly the one assignment it names, with no bulk sweep, and every statement resolves its executor through the ambient transaction first, so a grant-and-revoke bundle inside DB::transaction commits or rolls back as one unit. Revocation is source-specific and does not contradict has_permission_for_model, which resolves a direct grant before a role-inherited one: taking a role away leaves a permission the model also holds directly still answering true, and the rustdoc names the second call that ends effective access.

  • An application can build its router asynchronously. Application::try_routes_async takes a closure returning a future, and Server::try_from_config_with_routes_async is the asynchronous twin of try_from_config_with_routes that hosts it, sharing the same prologue and epilogue. It exists because RenderCache::install has to probe for the generation ledger's tables before it can assemble a runtime, and the route closure is the only place with both a container and a router - neither boot hook has one. routes, try_routes, and try_routes_async write the same slot, so the last one called is the one the server builds.

  • The Magnetar integration exposes what a partially completed sign-in actually returned. SignInOutcome is public, so a magic-link, OAuth, or passkey callback that resolves to SignInOutcome::FactorRequired can be handled rather than being reported as a failure: the framework session is not bound, and the selector it carries can be completed through the retained host engine. FactorAuth and MagnetarFactorAuthEngine are the types that hold that continuation, and install_magnetar_oauth_engine and install_magnetar_oauth_engine_with_factor install an OAuth engine with or without one. Magnetar bootstrap failures now name what is missing instead of reporting a generic install error.

  • The queue driver contract reports whether it can honour a queue-name filter. QueueFilterCapability (Supported, Unsupported, Unknown) is what QueueDriver::queue_filter_capability returns; the default is Unknown, not Unsupported, so a third-party driver that already overrides pop_from keeps working unchanged, and a decorator may reject a known Unsupported connection before polling but must let an Unknown driver answer for itself. TerminalCallbackClaim is the metadata a worker gets back when it atomically claims a finished batch's terminal callbacks, carrying the durable completion time and any cancellation visible in the same critical section, so the callback decision cannot be made from a snapshot that went stale before ownership was elected.

  • Schedule::try_add is the fallible sibling of Schedule::add. Task name identifies a task in direct lookup and in the distributed keys used by TaskBuilder::on_one_server and TaskBuilder::without_overlapping, so one name cannot identify two registered entries and a schedule that registered the same name twice had two tasks contending for one lock. Names are now exact, case-sensitive, and unique: add panics on a duplicate and the existing task is retained, while try_add returns the error for code that would rather handle it.

  • Session lifetime bounds and the session migration error are public. MAX_SESSION_LIFETIME_SECS and MAX_SESSION_LIFETIME_MINUTES are the clamps the environment parsing and the database driver apply, and SessionMigrationError is exported so a custom SessionStore can name the failure it returns.

  • Scaffolded projects are built in a production shape by construction. The generated Cargo.toml depends on the framework with default features off and the nine non-testing defaults listed explicitly (filesystem, database-sqlite, database-postgres, database-mysql, vector-mariadb, web-push, localization, magnetar-oauth, media), and re-adds features = ["testing"] as a dev-dependency. Cargo's resolver pulls a dev-dependency's features into cargo test and other --tests builds only, so cargo build --bin app never compiles a test seam into a shipped binary, and cargo test is unchanged. manual/deployment.md documents the shape for an existing application to adopt.

  • The default cache build id comes from the application, not the framework. #[suprnova::main] records the application crate's own CARGO_PKG_VERSION immediately after loading the environment, and RenderCacheConfig::from_env resolves build_id through an explicit APP_BUILD_ID, then that recorded application version, then this framework crate's own version only for a binary that never expanded #[suprnova::main]. RenderCacheConfig::with_build_id overrides whatever from_env chose, for an application that derives its own per-deploy identifier in code. Set APP_BUILD_ID explicitly once per deploy: it is mixed into every lookup key, and a package version rarely changes when you ship a template, a translation, or a handler fix.

Changed

  • A worker on the failover queue connection now drains every connection, not just the primary. FailoverQueueDriver documented the Laravel consequence it inherited: writes fell through the list, reads did not, so whatever failed over to a fallback sat there until somebody ran a second worker against that fallback directly. pop and pop_from now rotate their starting connection and then scan the whole list sequentially - rotation so a recovered, continuously busy primary cannot starve work that landed on a fallback, sequential so one call cannot reserve several jobs and hand back one. Each reservation is issued a fresh aggregate token that the driver maps back to the connection that really owns it, because inner tokens are not globally unique and two backends can legitimately mint the same UUID; an expired or unknown aggregate token is treated as stale rather than sent to an arbitrary connection. Counters and all three listings aggregate every configured connection in configured order and clear attempts every one, so what an operator inspects is the backlog this driver can actually consume. A driver declares whether it can honour a queue-name filter through QueueDriver::queue_filter_capability, which defaults to Unknown so an existing third-party driver is unaffected.

  • The minimum workflow lease is two seconds, and the first heartbeat fires immediately. The heartbeat refreshes at max(lock_timeout / 2, 1s), so a one-second lease was due for its first refresh at or after its own expiry: any claim latency or scheduling jitter opened a window another worker could walk through while the first was already running effects. The heartbeat's first tick is no longer skipped, which closes the claim-to-first-refresh window, and admission awaits an owned refresh before any user code runs, not only inside a step. WORKFLOW_LOCK_TIMEOUT_SECS below two is clamped with a warning that says why, and a configuration built in code that carries a shorter lease fails validation.

  • A payment provider without customer records can decline transaction-mirror hydration. WebhookHandler::mirrors_payment_transactions defaults to true, so every existing provider behaves as it did; a provider that returns false still has its verified events persisted and deduplicated in the webhook audit log, refunds included, but no transaction mirror is fabricated for orders the application owns and must reconcile against authenticated provider state. try_extract_payment_snapshot is the fallible form of extract_payment_snapshot the hydration path uses: returning Err leaves the webhook pending so the provider retries it, while Ok(None) is reserved for an event that genuinely cannot supply a complete snapshot. Both are provided methods, so an existing driver compiles and behaves unchanged.

  • A Paddle transaction.billed is no longer read as money collected. An issued invoice does not confirm collection, and treating it as a settlement marked orders paid that had not been. Approved refund and dispute adjustments are classified as adjustments rather than transactions, with their currency taken from data.currency_code and their settle time from the latest captured payment attempt where one is available; only WebhookHandler::parse_event classifies them, because the decision needs the payload's own action and approval status. The adapter also preserves the merchant correlation it was given through checkout instead of substituting a customer identifier that Paddle.js does not accept as a customer auth token, encodes non-string custom data as JSON strings consistently across customer and checkout requests, and gives its HTTP client the request deadline the pinned SDK does not set.

  • The framework crate carries three new modules and two new hard dependencies. suprnova::live, suprnova::render_cache, and suprnova::view are unconditional, not feature-gated, so the framework now depends on the internal suprnova-live engine crate and on askama in every build. Neither module does anything until an application opts in: Router::try_live() is what installs Live's reserved routes, and RenderCache::install with a policy is what makes the cache do anything at all.

Fixed

  • A batch job is not acknowledged until its accounting is durable. The worker acknowledged a successful batch member and then wrote the batch bookkeeping, so a failure between the two left a batch permanently short one settlement and its completion callbacks never fired. The reservation is now held until every accounting write succeeds; a rejected or uncertain write leaves it intact so visibility expiry redelivers the job, and the repository's (batch_id, job_id) uniqueness makes the replay safe even when the first write took effect and only its response was lost. The batch repository is separately installable and may address a different database, which is why this cannot simply share the queue settlement's transaction.

  • A batch's terminal callbacks are elected exactly once. Two jobs finishing the last two entries of a batch could both observe a pending count of zero and both run the completion callbacks. Settlement rows are now the source of truth and their parent batch row is locked before insertion, so concurrent jobs for one batch form a total order and exactly one final settlement observes zero - through row locks on PostgreSQL and MySQL, and through the writer lock the serialized transaction takes on SQLite. Claiming the callback bundle returns the durable completion time and any cancellation visible in that same critical section, so a worker cannot choose then from a snapshot that went stale before ownership was elected, and a non-empty batch whose pending count reached zero is sealed against positive growth. A cancellation already visible after an uncertain response is not restamped on redelivery. Envelope-construction failures collected while building a pending batch are surfaced at dispatch, which rejects the whole batch before any repository or driver mutation, instead of being swallowed by an infallible fluent builder.

  • The Redis queue driver fences every terminal operation against the delivery it was issued for. ack, nack, release, and settle now compare the stream entry's consumer owner and delivery count with the generation captured by pop, and one Redis script applies any successor publication and the XACK together, so a delayed response that makes the caller retry finds the generation gone and the retry becomes a no-op instead of a duplicate publish. Because nack is inherently two commands (XADD then XACK), each reservation retains a per-token lifecycle that stays addressable through every failed operation and is removed only after the acknowledgement succeeds, so a retry resumes at the step that failed rather than republishing. The driver's at-least-once contract and the requirement that handlers be idempotent are now stated in the module documentation rather than implied. Consumer identities are isolated per process, so two workers cannot claim each other's pending entries.

  • A database queue reservation lasts as long as it was asked to. reserved_until stores whole seconds and readers compare it with the floored current time, so the current fractional second was silently taken off every lease and a subsecond timeout could round to nothing. The absolute expiry instant is now rounded up.

  • Workflow step writes are fenced, an exhausted attempt budget terminalizes, and MySQL date columns match the entities that read them. A step write from a worker that had already lost its claim could land on top of the worker that now owns the workflow; writes now carry the claim's fencing token. A row whose attempt budget is already exhausted could neither be claimed nor left pending forever: the claim statement now terminalizes at most one such row per poll, with disjoint cleanup and claim predicates so a large abandoned backlog cannot turn one worker poll into an unbounded write. The early workflow migrations declared MySQL date columns as TIMESTAMP while the public entities use chrono::NaiveDateTime, whose MySQL storage type is DATETIME; NormalizeWorkflowDateTimesForMysql is an additive migration that converts them and is a no-op on PostgreSQL and SQLite.

  • Cancelling a task no longer abandons a transaction's deferred effects. An aborted DB::transaction rolls its database work back when SeaORM drops the transaction, but nothing rolled back a deferred queue push or released a held uniqueness lock for it, and an after-commit callback that was already running when the abort landed was dropped mid-effect. Callbacks now run as awaited child tasks, in registration order, so one already in flight survives its caller's cancellation, and the unstarted remainder is diverted to a detached task that either runs the after-commit list (the transaction did commit) or compensates (it did not). A panicking callback surfaces as an error instead of skipping the callbacks behind it, and a COMMIT the database refuses after the closure has already taken the request is handled rather than panicking.

  • Cross-disk copies and read-through caching clean up after a cancelled task. A mid-stream failure already discarded the partial destination object, but a cancellation returns no error at all, so the writer was simply dropped and a truncated object or a staged multipart upload was left behind. The destination writer is now owned by a guard across the transfer: an error settles inline with the same abort and delete as before, while a cancellation diverts that cleanup to a detached task, and the cleanup itself runs to completion even if the awaiting task is cancelled during it. Cleanup never targets a published object, because another writer may have won the condition. Local filesystem work is kept alive until it finishes, since dropping a Tokio filesystem future does not stop the blocking work it has already submitted.

  • Two throttle clauses that hashed to the same storage identity no longer share one counter. A rate-limit rule with several finite clauses could collide, so one clause's hits counted against another's budget. Colliding clauses now reserve deterministic, unambiguous counter and timer identities, computed once so the gate, the deferred hit, and the response headers all use the same key, and legacy keys are kept where no collision exists.

  • A sliding-window sweep no longer erases history a longer quota still needs. The in-memory limiter dropped a bucket whose last hit was older than the window it was asked about, which discarded the record enforcing an already-observed longer quota on the same key. A bucket is now retained until its last recorded hit is older than both the supplied window and the longest quota window observed for it. A decrement below the minimum amount is handled rather than under-counting.

  • The in-memory cache driver rejects an increment against a non-integer value. Redis INCRBY and DECRBY refuse a live non-integer and leave its value and TTL alone; the memory driver overwrote it, so the same code behaved differently against the two backends. It now parses before inserting and leaves the entry untouched on error. Separately, Redis add installs a missing untagged value and clears stale tag metadata in one script, so a newer tagged overwrite can no longer land between the conditional write and the cleanup that follows it.

  • Inertia one-shot session data survives a failed response. SessionMiddleware ages _flash.new.* into _flash.old.* before the handler runs, so a response that failed while being constructed left those values to be deleted by the next request's aging pass - the user lost the validation errors or the flash message that explained what went wrong. A request-scoped guard now reflashes them on every uncommitted exit, cancellation included, and removes them only after the complete response has been built.

  • Fanout broadcasting waits for the backend to say it wrote. SeaProducer::send only enqueues, and the returned future is what reports the actual backend write, so a delivery was reported as sent when it had only been queued. Every send in a pass is now polled for its receipt under one deadline, which also stops an unavailable broker from holding an application request open indefinitely. Membership heartbeats hold the read guard until every snapshot heartbeat is enqueued, so a concurrent untrack cannot be overtaken by a stale heartbeat.

  • suprnova generate-types never leaves a stale or truncated artifact behind. A scan that ended early used to overwrite the output with whatever it had, so a transient parse failure silently deleted type definitions the application still used. File generation now refuses to overwrite an artifact after an incomplete scan, writes atomically through a collision-free sibling temporary file with bounded retries, and skips the write entirely when the contents are unchanged. An output symlink keeps its previous behaviour: the resolved target is replaced atomically and the link stays in place; a changed read-only destination is rejected.

  • Two suprnova command failures are reported instead of swallowed. suprnova new reports a failed git init rather than presenting a project as fully created, and suprnova workflow:install validates the migration path before creating any directory, so an invalid path fails without leaving a half-made tree behind.

  • A savepoint and its deferred-effect registry agree on identity. The savepoint statement and the registry mark used the caller's original spelling, but names are case-insensitive and PostgreSQL additionally aliases names sharing their first 63 ASCII bytes, so ROLLBACK TO could unwind a savepoint whose deferred effects the registry had filed under a different key. Both now share one validated, backend-canonical identity. The accepted 64-byte API limit is unchanged.

  • suprnova <command> --help prints help instead of running the command. The CLI declared its own help flag and consulted it only when no subcommand had been given, so every other --help printed the banner and then executed the command anyway. suprnova migrate:fresh --help dropped every table in the database, and the guard that would have stopped it refuses only in production while APP_ENV defaults to local. Clap now owns -h and --help on the top level and on every subcommand, in either argument order, and the curated banner is still what the top level prints. A test enumerates the subcommands from clap itself, so a subcommand added later is covered without anyone remembering to add it.

  • A scaffolded frontend no longer pins the CSRF token it read at boot. The generated Vue, Svelte, and React entry points read <meta name="csrf-token"> once at module load and attached that value to every Inertia visit. Logging in rotates the session, the captured token goes stale, and the next state-changing visit - typically the logout - was refused with 419 CSRF token mismatch. Every generated application shipped with it. The hook is gone: the Inertia client reads the XSRF-TOKEN cookie CsrfMiddleware sets and echoes it back in X-XSRF-TOKEN itself, once per request, so the value that travels is the one the browser holds at that moment. Server-side verification is unchanged and both header names are still accepted. The manual chapter and the suprnova::csrf module documentation named the old hook as the thing to do; both now name it as the thing to avoid.

  • A scaffolded application's XSRF cookie is usable over local HTTP. CsrfMiddleware::new() defaults the JS-readable XSRF-TOKEN cookie to Secure, while the generated env.example sets SESSION_SECURE=false for development, so a browser would neither store nor return the cookie over http://localhost and every state-changing request in development was refused with 419. The generated bootstrap now passes its SessionConfig to CsrfMiddleware::with_session_config, which copies the session cookie's Secure, SameSite, Domain, Path, and lifetime onto the XSRF cookie so the two cannot drift apart. Nothing is weakened: token validation, the default origin policy, and the production guards are unchanged.

  • suprnova make:command appears on the help screen. The command scaffolds a console command into src/commands/ and had no line on the curated screen, so the only way to learn it existed was to read the source. The screen is now checked against the subcommand list clap reports, in both directions, so neither a missing line nor a line naming no command can survive.

Upgrading

  • Most applications need no code change. Live and RenderCache are both opt-in: suprnova::live does nothing until a router calls Router::try_live(), and suprnova::render_cache does nothing until a route is opted in and RenderCache::install is called. Everything else in this release is a fix to behaviour you already had. The version is 2.0.0 because the framework's surface grew by two whole subsystems and because of the specific behaviour changes listed below, not because the ordinary application API was rearranged: no public item in the framework crate, the macro crate, or the payment, Magnetar, and Web Push adapter crates was removed or renamed.

  • Rebuild times and dependency footprint go up. The framework now depends on the internal suprnova-live engine crate and on askama in every build, because suprnova::live, suprnova::render_cache, and suprnova::view are unconditional modules rather than features. There is nothing to enable and nothing to disable.

  • An application that never uses RenderCache pays one schema probe per process. RENDER_CACHE_ENABLED defaults to true, so the first ORM write a process makes outside a transaction asks once whether the RenderCache migration is present; finding it absent, that process is closed for the rest of its life and issues no further RenderCache SQL. Set RENDER_CACHE_ENABLED=false to skip even that one statement. The probe never runs on a caller's transaction, so it cannot poison a write you are making.

  • Anyone building a WebPushClient from an already-built reqwest::Client must act. WebPushClient::with_client now refuses to send under the default EndpointPolicy::Strict and returns WebPushError::UnconfinedRedirects, because an already-built client's redirect policy cannot be inspected and reqwest follows redirects by default. Move to WebPushClient::with_client_builder, which honours every transport option you were setting (proxy, TLS, timeouts) and forces redirects off, or call WebPushClient::allow_unconfined_redirects if you know your client is safe. WebPushClient::new is unaffected.

  • Signed URLs issued before the upgrade that carry a trailing slash stop verifying. Signing and verification both used to trim a trailing slash before hashing; both now hash the path exactly. A URL signed as /orders/1 still verifies at /orders/1, and only at /orders/1 - a proxy that appends a slash now produces SignatureVerdict::Invalid. If a proxy or a framework in front of your application normalizes paths by adding a slash, sign the URL the way the request will arrive.

  • A schedule with two tasks of the same name now fails at registration. Schedule::add panics on a duplicate, keeping the task already registered. Rename one of them, or switch to Schedule::try_add and handle the error. Names are exact and case-sensitive.

  • A workflow lease shorter than two seconds is clamped or refused. WORKFLOW_LOCK_TIMEOUT_SECS below 2 is clamped to 2 with a warning naming the reason; a WorkflowConfig built in code with a shorter lease fails validate. If you were running a one-second lease deliberately, the heartbeat could not refresh it before it expired.

  • A MySQL application using workflows should add one migration. suprnova::workflow::migrations::NormalizeWorkflowDateTimesForMysql converts the workflows and workflow_steps date columns from TIMESTAMP to DATETIME, which is what chrono::NaiveDateTime actually stores. It is additive, and a no-op on PostgreSQL and SQLite. MySQL may rebuild and lock both tables while applying it, so schedule it accordingly. A project created by suprnova new gets it wired automatically.

  • AuthMiddleware now resolves the user on every guarded request. It used to accept the presence of a persisted identifier. The behaviour change is that a session belonging to a deleted or soft-deleted user stops authorizing. The cost is smaller than it looks: the resolved user is cached for the rest of the request, so a handler that already called Auth::user() pays nothing extra and the lookup has simply moved from the handler to the middleware. Only a guarded request whose handler never resolved the user gains a provider lookup it did not make before. An application with no user provider bound keeps the identifier-only path unchanged. BasicAuthMiddleware in its non-stateless form now requires the guard it names to exist and to be a stateful guard.

  • destroy_all_for_user costs more and revokes more. It now reads the surviving session rows and compares the guard identities inside each payload, in addition to the indexed user_id match, so it reaches sessions authenticated through a named guard alone. Revocation is rare enough that correctness was chosen over index use; if you call it on a hot path, that is worth knowing.

  • A POST or PATCH retried after a transport error now needs retry_non_idempotent. The 5xx branch already required it; the transport-error branch did not. If you were relying on a dropped connection being retried for a non-idempotent request, opt in explicitly.

  • A production process with a missing or malformed APP_KEY now fails at #[suprnova::main], not at Server::from_config. That includes a console binary or a worker entry point that never builds a server. Local, development, and testing environments still generate a transient key and warn. APP_PREVIOUS_KEYS is accepted as an alias for APP_KEY_PREVIOUS; if both are set with different values, the Suprnova name wins and the duplicate is named in a warning you should act on.

  • A worker pointed at a failover queue connection now drains every connection in the list. If you were running a second worker against a fallback connection directly - which the 1.3.3 notes told you to do - that worker and the failover worker will both be draining it. Remove the extra worker, or keep it and accept the competition. Counters and listings now aggregate every connection, so a dashboard reading pending_size on the failover connection will report a larger number than it did.

  • Custom store and driver implementations get fail-closed defaults, never weakened behaviour. Magnetar's provider-token, ceremony, and remember stores gained methods for the atomic operations described above; each has a default that refuses rather than performing the operation non-atomically, so an external implementation still compiles but will report failure until it implements the method. WebhookHandler::mirrors_payment_transactions and try_extract_payment_snapshot, QueueDriver::queue_filter_capability, and GlobalScope::dependency all have defaults that preserve the previous behaviour exactly.

  • To adopt Live, bind a registry during bootstrap with App::singleton(crate::live::registry().expect("Live component registry")), install the reserved routes with Router::try_live_with and a guard carrying your AuthMiddleware, LiveTenantMiddleware, and RateLimitMiddleware, and register CsrfMiddleware::new() globally - Live verifies its own origin proof, so you do not need to widen OriginPolicy for the whole application, and if you widened it for something else, narrow it back. Use AuthMiddleware::optional() on the Live guard if you want anonymous visitors to act on public seeds; AuthMiddleware::new() answers 401 for every anonymous request before any engine work. Then run suprnova live:make and suprnova live:check. manual/live.md has the complete walkthrough.

  • To adopt RenderCache, add suprnova::render_cache::migration::Migration to your Migrator (and suprnova::render_cache::migration::TierMigration as well if you run the database or redis profile), opt routes and groups in with Router::try_render_cache and Router::try_render_cache_group, and finish with RenderCache::install. Because install is asynchronous - it probes for the ledger's tables before assembling a runtime - the router has to be built through Application::try_routes_async rather than try_routes. The install has to come after every middleware that establishes request-scoped locale, session, or identity, and after every route and group has been opted in. A shared profile refuses to boot without its tier migration or with an endpoint nothing answers, which is deliberate.

  • Set APP_BUILD_ID once per deploy. It is mixed into every RenderCache lookup key, so changing it is what stops a new build from serving entries the previous one published. Its default is your application crate's package version, which does not change when you ship a template, a translation, or a handler fix. A commit id works: APP_BUILD_ID=$(git rev-parse --short HEAD).

  • Consider moving your Cargo.toml to the production build shape. Declare suprnova with default-features = false plus the nine non-testing defaults you use, and re-add features = ["testing"] under [dev-dependencies]. Cargo pulls a dev-dependency's features into cargo test and other --tests builds only, so your shipped binaries stop carrying test seams while cargo test keeps working unchanged. A project created by suprnova new is already in this shape; manual/deployment.md documents it for an existing one.

  • If you consumed the standalone @suprnova/live runtime or wrote your own subscription host, the registered-event descriptor changed. DESCRIPTOR_SCHEMA_VERSION moved from 1 to 2 and the descriptor's registered-event fields are now maximum_hops, maximum_fanout, and payload_contract rather than maximumHops, maximumFanout, and payloadContract - they were the only camelCase keys in a public JSON contract that is snake_case everywhere else. A descriptor signed at schema version 1 is refused with SubscriptionErrorKind::InvalidDescriptor rather than being read with three absent fields. Nothing in a 1.3.7 Suprnova application consumed this contract, so for most readers there is nothing to do.

1.3.7 - 2026-08-26

Added

  • Where the Inertia error page middleware sits is now yours to choose, and documented. Inertia::install registers InertiaErrorPageMiddleware innermost of the Inertia layer, so it covers the handler, the route middleware, and everything you register after that call - which is why the scaffold puts CsrfMiddleware below it. It does not cover anything registered above the call, because a middleware that answers without calling next hands its response to nothing registered inside it. The case that bites is a lapsed session posting a form: CsrfMiddleware registered above the install answers 419 with {"message":"CSRF token mismatch."} and the user gets the Inertia crash modal on the one flow they are most likely to hit; an outer rate limiter's 429 and an auth guard's 401 are the same. Registering the middleware yourself, further out, already worked in 1.3.6 - the type was public and registration is idempotent per type, so an earlier registration kept its place - but nothing said so and nothing in install acknowledged it, which made it an accident rather than a contract. It is a contract now: register InertiaErrorPageMiddleware::new("Error") after SessionMiddleware and LocaleMiddleware and before the middleware whose rejections it should cover, and install checks for it, logs at debug, and skips its own. The component you named at that registration is the one rendered, so you name the page once and .error_page(...) on the config becomes optional - it is still what makes install register a middleware for an app that does not place one itself. The two ordering rules are documented on the type and in the manual.

Fixed

  • An SSR page has one <title>, and it is the page's own. The HTML shell wrote its default_title and then the SSR worker's head verbatim, so every page rendering a title through Inertia's Head component produced a document with two <title> elements and the framework's generic one first. First is the one the browser tab, the crawler and the link preview read, so the real title never showed. A worker head carrying a title now replaces the shell's title rather than joining it - both default_title and a per-response InertiaResponse::title(...) stand down; a head without one leaves the shell's title exactly where it was.
  • The document declares the language it is written in. The shell hardcoded <html lang="en">, so a reader switched to Japanese got Japanese prose in a document claiming to be English - a screen reader picks its voice from that attribute and a search engine takes it as the page's language signal. It now carries the locale in effect for the request: what LocaleMiddleware detected, then a Lang::set_locale override, then the configured APP_LOCALE, in the same BCP 47 form Locale renders (pt-BR, zh-Hans). This holds for the error page too, which is rendered on the way out and was the case that surfaced it. Without the localization feature the shell keeps en.

Upgrading

  • Nothing is required. Both fixes apply to every Inertia app on upgrade, and Inertia::install behaves exactly as it did for an app that does not register the error-page middleware itself.
  • An app that spliced <html lang="..."> into the finished document with a middleware of its own can delete it - the shell does it now, from the same locale that middleware was reading.
  • An app whose CsrfMiddleware, rate limiter, or auth guard is registered before Inertia::install should register InertiaErrorPageMiddleware::new("Error") after LocaleMiddleware and before that middleware, so its rejections render the error page instead of reaching the client as raw JSON. install then skips adding its own, and the component you named at the registration is the one rendered, so .error_page("Error") on the config is optional - keep it or drop it. The scaffolded bootstrap.rs registers CSRF after the install, so a project generated by suprnova new needs no change.
  • An app that renders its own <title> through Inertia's Head component under SSR will see the shell's title stop appearing in the document - both InertiaConfig::default_title and a per-response InertiaResponse::title(...). That is the fix: the page's own title is the document's only one. If you were relying on the shell's title as a prefix or suffix, move it into the Head component where the rest of the title lives.

1.3.6 - 2026-08-26

Added

  • Framework errors can render your own Inertia page instead of the client's crash modal. A user without a permission clicked a nav link into a guarded route and got Inertia's "All Inertia requests must receive a valid Inertia response, however a plain JSON response was received" screen: the 403 carried the framework's JSON error body and no X-Inertia header, so the client refused it. The same held for an unrouted 404, a rate-limited 429, and a failing handler's 500. Name a page component with InertiaConfig::error_page("Error") and those responses render that page at their original status, with status, message, and - when the error carried one - request_id props. Every header the error response set survives the swap except the ones that only described the body being replaced (Content-*, Transfer-Encoding) or governed how it could be stored (Cache-Control, Expires, Age, ETag, Last-Modified), so Retry-After on a 429, WWW-Authenticate on a 401, Vary, and Set-Cookie all still reach the client. The page sets Cache-Control: no-cache, private for itself: it carries your shared props, so it must never be stored by a shared cache and served to a different visitor, whatever the response it replaced permitted. An Inertia visit gets the JSON page object; a hard navigation gets the full HTML shell, so pasting the URL into the address bar works too. Everything with an owner is left alone: validation 422s still redirect back to the form, X-Inertia-Location bounces and responses that already are Inertia pages pass through, and a client whose Accept prefers JSON keeps the exact body it got before. suprnova new scaffolds frontend/src/pages/Error.* and sets .error_page("Error"), so new projects are covered without doing anything.

Fixed

  • A local disk no longer refuses a legitimate path because another task touched it. The path guard resolved each component of a path with two probes and combined them into one verdict, so ordinary concurrent activity could be read as a symlink escape: a component that canonicalize had just reported missing, and that another task then created as an ordinary file, came back as PermissionDenied naming a symlink that was never there. It bit hardest where writers contend by design - a losing write_with(..).if_not_exists(true) racer got that refusal instead of ConditionNotMatch whenever the winner published the key between the two probes, which under a loaded test suite was roughly a third of runs. Each component is now classified from a single pass, symlink_metadata first: nothing there is free space, an ordinary file or directory is resolved and confined as before, and only a symlink that still cannot be resolved is refused. A component that vanishes mid-classification is looked at once more rather than refused. Every symlink refusal is unchanged.

Upgrading

  • Nothing changes for an existing app until it opts in. InertiaConfig::error_page defaults to None, and Inertia::install registers the error-page middleware only when a component is named, so error responses keep their exact bodies. To adopt it, add a page component named Error beside your others (it receives status, message, and an optional request_id) and chain .error_page("Error") onto the InertiaConfig you pass to Inertia::install. A handler that panics stays out of scope: the panic net wraps the whole middleware chain, so its synthesized 500 is built after every middleware has unwound. Return Err(...) rather than panicking and the error page covers it. Note that the gate is the body's shape, not its author: at an error status, an empty body, a JSON object whose message is a string, and the router's own 404 Not Found text are rewritten no matter which middleware built them, and only message and request_id survive into the props. A response that must keep its own JSON body should key its text as something other than message, or set X-Inertia: true on itself. And register LocaleMiddleware before Inertia::install: the error page is rendered on the way out, after every middleware registered inside the Inertia layer has returned, so a locale scope opened inside it is already gone and every error page would render in the app's default locale. The scaffolded bootstrap.rs now does this, and the same reasoning applies to any request-scoped middleware of your own whose state the page's shared props read.

1.3.5 - 2026-08-26

Changed

  • Every changelog section reads in all six manual translations. The de, es, fr, ja, pt-BR and zh-Hans manuals used to carry the 1.3.0 to 1.3.2 sections in English behind a translator's note, and older sections with stray English lines; every section from 1.3.5 back to 0.1.0 is now translated, and the notes are gone.

Fixed

  • Local-filesystem disks publish every object in one step. Storage::register_fs and register_fs_with now stage disk.write(...), disk.writer(...), and disk.copy(...) as a temp file under <root>/.suprnova-atomic/ and publish it onto the target with a single rename(2), so none of them is ever observable at a partial length. Before this, the driver opened the target with create + truncate and streamed into it in place: a concurrent reader got an empty or half-written object for the whole duration of the write, and a crash mid-write left a truncated object at the live path. abort() on a writer now discards the staged file instead of failing with Unsupported.

  • write_with(..).if_not_exists(true) is a true exclusive create on a local disk. It is published with link(2), which fails atomically in the kernel when the target exists, so exactly one of any number of racing callers succeeds and every other one gets ConditionNotMatch having written nothing. A staged write published by a plain rename would have degraded the condition to a check followed by an overwrite, silently discarding all but the last writer - which is the opposite of what the primitive is reached for.

  • An append that creates the object is still an append. Appends are the one in-place operation on a local disk, and that now holds for the first one too, so two writers appending to the same missing object both land instead of one staging its own copy and overwriting the other.

  • suprnova serve no longer rebuilds a project nobody has touched, and neither does suprnova generate-types --watch. Both watchers classified a filesystem event by its path alone, and the generator reads every .rs file under the same src/ tree they are watching - so on Linux, where the kernel reports those reads, each regeneration scheduled the next one. A freshly scaffolded project regenerated its types and restarted its backend every half second, forever, without a single source edit. Only events that mean the bytes on disk actually changed count now. generate-types --watch also had no debounce at all, so it acted on the first file of a burst rather than the last; it now shares serve's 500 ms trailing edge, and both watchers share one implementation so the next fix cannot land in only one of them. The generator compares before it writes, so a regeneration whose output is byte-identical leaves the file, and its mtime, alone.

  • The backend watcher is scoped to the paths the server is built from. cargo watch ran with no -w, so it watched the whole non-gitignored project: saving a Svelte component, or regenerating frontend/src/types/inertia-props.ts, rebuilt the framework and restarted the server. It now watches src/, cmd/, Cargo.toml, Cargo.lock, .env, and lang/ - the build inputs plus the two trees read once at boot - each included only when it exists, since cargo-watch refuses a -w path that does not. cmd/ is where the full-stack scaffold keeps the server binary's main.rs. The invocation also passes --no-vcs-ignores, because cargo-watch applies .gitignore to explicitly named -w roots and the scaffold ignores .env, which would otherwise leave -w .env watching nothing; -w has already narrowed the surface, so the flag cannot widen it. Frontend edits and generated .ts files no longer restart the backend.

  • serde_json::Value generates as JsonValue instead of unknown. It used to degrade to unknown and warn that it "isn't a struct this project defines", advice that is wrong for a JSON document - and the scaffold's own login and register pages tripped it twice on every regeneration, so every fresh project warned out of the box. It now emits a recursive JsonValue alias, declared once at the top of the generated file and only when something references it. A bare Value maps there too, unless the project defines a Value struct of its own.

  • Neither generate-types nor serve reports a file it did not write as generated. Because a pass now writes only when the emitted content differs, Generated <path> was a claim about the filesystem that was false on every rerun of an unchanged project. generate-types says <path> is up to date instead, in one-shot and --watch alike, and serve's startup pass says N type(s) up to date → <path>, keeping the count. serve's file watcher now stays silent on a regeneration that wrote nothing, in text and under --json both: a types_regenerated event means the generated file on disk is different now, so silence after a save tells you your edit did not change any prop shape.

Upgrading

  • .suprnova-atomic is reserved at the root of every local disk. The staging directory has to live inside the root - a sibling of the root can be on a different filesystem when the root is a mount point, and every rename would fail with EXDEV - so the name is reserved rather than merely conventional. Any path whose first component is .suprnova-atomic is now refused with a permission error (read, write, delete, stat, list alike), as is any path that resolves into the directory through a symlink, and the entry is filtered out of files, directories, all_files, and all_directories. If a disk root already contains a .suprnova-atomic entry of your own, it is no longer reachable through that disk: move it aside before upgrading. A regular file of that name is refused at registration with a message saying so, rather than failing later inside the driver. The name is exported as suprnova::ATOMIC_STAGING_DIR so backup and sync tooling can exclude it.
  • Publishing by rename replaces the target's inode. Rewriting an object on a local disk no longer preserves its mode, owner, or hard links, and a reader holding an open descriptor keeps the old content instead of seeing the new bytes. That is the standard cost of atomic publishing, but it is a behavior change if you were relying on either.
  • A conditional write needs a filesystem with hard links. if_not_exists is published with link(2), which is unsupported on FAT, exFAT, and some network filesystems. There it fails outright rather than falling back to a check followed by an overwrite, because a fallback would hand you an exclusivity guarantee that does not hold. Nothing else on the disk is affected.
  • A first append that fails leaves an empty object. An append is the one operation that is not published in a single step, so the object is created before the bytes land; a failed or aborted first append leaves it behind, exactly as an append onto an existing object always has.
  • A dangling symlink in the disk root is refused, not overwritten. A path whose symlink target does not exist can no longer be written, appended to, copied onto, moved onto, or deleted through the disk. 1.3.4 replaced such a link with a regular file; the guard cannot prove where an unresolvable link leads, and creating through one creates the link's target anywhere on the host, so it now refuses. Remove the link outside the disk if you meant to write there.
  • Nothing sweeps the staging directory. It holds in-flight temp files plus whatever a process that died mid-publish left behind, so a host in a crash loop grows it without bound. Emptying it while nothing is writing to the disk is safe; excluding it from backups is recommended.

1.3.4 - 2026-08-25

Added

  • Read-through disks take a copy flag and resolve copy / rename across the fallback. Set copy: false on ReadThroughConfig to serve fallback hits without writing them through, which turns the disk into a transparent overlay and narrows each fetch to the range you asked for. copy and rename now stream a source that lives only on the fallback across to the primary destination; a rename also deletes the fallback source, so a later read cannot resurrect the moved object. Conditions carry across that streaming path: if_not_exists still refuses an existing destination, a copy's source version selects which object the fallback hands over, and a copy's if_match is refused with Unsupported rather than silently dropped. A transfer that fails partway removes only a destination it created, so it cannot destroy an object that was already there.

  • Debounced jobs and debounced queued listeners. Job::debounce_for() collapses a burst of dispatches into one run, one window after the most recent one, carrying the newest payload. It is the mirror of push_unique, which keeps the first dispatch and suppresses the rest. Job::max_debounce_wait() stops a continuous burst from deferring the work forever, and Job::debounce_id(&self) scopes the window per entity so twenty updates to one order collapse without touching another order's. Queue::push_debounced(job, DebounceOptions) sets the window at the call site, and DebouncedListener::new(window, build).keyed_by(...) debounces an event listener with the key derived from the event - a plain QueuedListener already honors a window the job itself declares. Every dispatch is still enqueued; the collapse is settled at the worker, which acknowledges a superseded envelope and emits JobDebounced. Debouncing fails open: an expired or evicted window runs the job rather than dropping it. Each actual run starts a fresh maximum-wait window, so a burst always measures its maximum wait from its own first dispatch rather than inheriting the previous burst's. A job cannot declare both debounce_for and unique_id, and chains and batches refuse a debounced job - a superseded link would strand the rest of its chain, and a superseded batch job would leave the batch's pending count above zero forever. The envelope carries two additive fields for this and stays byte-identical on the wire for every non-debounced push.

  • Storage::register_read_through composes two disks into a read-through disk. Reads and metadata resolve against the primary first and fall back to the second disk; anything found on the fallback is written through to the primary, so a store migration completes under real traffic. Writes and listings stay on the primary, and a delete removes the object from both disks. Set throw_on_promotion_failure when a failed promotion must surface instead of degrading to a fallback read. A promotion is published atomically, so no reader can see a half-written object, and it carries the fallback object's content type, cache control, content disposition, content encoding, and user metadata across. A versioned or conditional read is passed through with its condition intact and served without being promoted.

  • Queue::forward redirects a whole queue by name. Where Queue::route is keyed by job type, Queue::forward("default", "high") is keyed by queue name - the lever for retiring a pool, absorbing a backlog, or moving work off a pool you are about to take down, without touching a single job or route. It applies on both sides: new pushes that resolved to default land on high, and a worker started with --queue=default drains high, so the destination cannot collect work nobody claims. Forwarding default catches jobs that named no queue. A forward is a single lookup, never a chain, so a swap (a -> b with b -> a also registered) or a longer rotation is a coherent pool exchange rather than a loop - exactly like Laravel, whose resolver is the same single lookup. Pausing is still evaluated on the names a worker was started with, so Queue::pause(&connection, "default") stops that worker even while default is forwarded. Queue::forward_on(from, to, connection) restricts a forward to one connection name, compared against this process's connection name rather than a job's declared connection, so both halves of the redirect gate on the same value. Queue::forward_for(from) reads a forward back, and Queue::try_forward is the fallible sibling. The inspection calls (Queue::pending_jobs and its siblings) deliberately do not follow a forward, so a backlog left behind on a forwarded queue stays visible.

  • Read-shaped Redis commands retry a transient failure instead of surfacing it. The connection manager already reconnected in the background, but the command that hit the dead socket still failed your call. GET, EXISTS, the SCAN and SSCAN pages behind Cache::flush / Cache::flush_tags, the queue driver's XLEN / ZCARD / XPENDING reads, and the rate limiter's Retry-After computation now retry once after a short pause. REDIS_COMMAND_RETRIES adds further retries on top, clamped at 10. Budget the retry in seconds rather than milliseconds: the second attempt waits for the replacement connection, so it costs the driver's whole connect and response budget, and a timed-out command counts as transient as well as a dropped one. Writes never retry at any setting: a transient error means the connection failed, not that the server refused the command, so repeating a SET, an INCR, a lock acquisition, a rate-limit hit, or a queue pop could run it twice. Error messages are unchanged, so anything matching on them keeps working.

  • A paused worker now tells you it is paused. queue:work prints one line per transition - 2026-08-25 14:03:11 Queue billing PAUSED, and RESUMED on the way back - and the worker emits WorkerQueuePaused / WorkerQueueResumed so you can route the same signal into your own alerting. These are the worker-side pair; the existing QueuePaused / QueueResumed fire in whichever process ran queue:pause, which is never the worker, so until now a worker that went quiet because somebody paused its queue was indistinguishable from a hung one. Each event fires once per transition, not once per poll. Their queue field is optional: a worker started without --queue drains everything and has no queue names to report under pause_all, so it reports None rather than inventing a name a listener could match on.

  • ?include= paths are capped at five segments, and max_relationship_depth moves the ceiling. A cyclic relationship graph turns ?include=author.posts.author.posts... into fan-out a client controls, bounded only by the query string. Paths are now truncated while they parse; call suprnova::max_relationship_depth(n) in bootstrap::register() to change the limit, or pass 0 to turn includes off.

  • Gt, Gte, Lt, and Lte compare a field against a number or against another field. CompareWith names the operand and the measure in one value: Number for a literal, NumericField for a numeric sibling, and LengthField for a sibling compared by character count. An operand the rule cannot measure fails the field instead of panicking.

  • Three membership rules join the built-in set: InArray, Contains, and DoesntContain. InArray checks a value against another field's list, and you pass the list directly instead of naming the field in a rule string. Contains and DoesntContain run over a JSON array and match a parameter only against a string element, so 1 and "1" stay distinct.

  • The database pool now has liveness knobs. DB_IDLE_TIMEOUT, DB_MAX_LIFETIME, DB_ACQUIRE_TIMEOUT, DB_TEST_BEFORE_ACQUIRE, and DB_PING_AFTER_IDLE control when the pool closes, recycles, and pings a connection, with matching DatabaseConfig::builder() setters. Each is unset by default, so an existing deployment's pool behaves exactly as it did. Use them when a NAT gateway or firewall drops idle connections: sqlx exposes no libpq keepalives_* equivalent, so pool recycling is the mechanism.

  • db:seed <Class> reports its progress. A targeted run prints a RUNNING line before the seeder and an elapsed-milliseconds DONE line after it. A bare db:seed stays silent. The formatter, suprnova::two_column_detail, is available to your own #[command] handlers.

  • Many-to-many relations now filter on pivot columns. where_pivot, where_pivot_op, where_pivot_in, where_pivot_not_in, where_pivot_null, where_pivot_not_null, where_pivot_between, where_pivot_not_between, where_pivot_group, and their or_ twins constrain get, first, and count on BelongsToMany, MorphToMany, and MorphedByMany. where_pivot_group takes a closure and renders one parenthesised group, so it stays atomic inside a following or_where_pivot. Pivot filters apply to reads only: attach, attach_with, detach, and sync return an error while one is set, and eager loading does not carry them.

  • where_binary compares column values byte for byte. The family (where_binary, or_where_binary, where_not_binary, or_where_not_binary) ships on Builder<M>, and where_binary and where_not_binary ship on DB::table(...). MySQL and MariaDB emit = binary; Postgres and SQLite return an error when the query renders, rather than falling back to a collation-dependent match.

  • Builder::try_to_sql_with_bindings_for renders SQL for a dialect without panicking. It is the fallible sibling of to_sql_with_bindings_for, for the cases where a builder legitimately cannot render for a backend.

  • Model::refresh_for_update reloads a row under a FOR UPDATE lock. Call it inside a transaction when you need the row's current state and the exclusive lock in one statement. SQLite has no row-level locking, so the lock clause is a no-op there.

  • Builder::or_where_key and Builder::or_where_key_not add primary-key filters as a disjunction. Both fold into the preceding WHERE clause the same way or_where does, and both ship or_filter_key and or_filter_key_not aliases.

  • Builder::in_order_of sorts rows into an explicit sequence. Pass a column and the values in the order you want them; rows whose value is not in the list sort last. The values bind as parameters, so they are safe to take from request data.

Fixed

  • The maintenance bypass cookie now expires on the server. The 12-hour TTL was a max-age the browser enforced, so a captured cookie kept working until you rotated the secret. The encrypted payload now carries the deadline, and every request re-checks it.
  • suprnova serve runs a frontend-less project. A project scaffolded with suprnova new --api has no frontend/ directory, and serve rejected it as "No frontend directory found. Are you in a Suprnova project directory?" unless you passed --backend-only. It now skips the Vite pane and the TypeScript generation that feeds it, and serves the backend. --frontend-only still fails on such a project, with a message that says why.

Upgrading

  • Bypass cookies issued before this release stop working. The cookie's payload changed from the bare secret to a sealed { secret, expires_at } object, and a payload with no deadline is refused. Visit the secret URL once after upgrading to get a new cookie. Nothing else changes: down, up, --secret, and --with-secret all behave as before.
  • An include path longer than five segments now returns its first five relationships instead of all of them. Nothing outside a resource's allowlist was ever reachable, so no response gains data; a deep path loses its tail. One status code changes with it: a path whose over-deep tail names a relationship the resource does not allow is truncated before anything validates it, so it now returns 200 with the segments that survived where the full path used to return 400 - adjust any client or test asserting on that rejection. Raise the ceiling with suprnova::max_relationship_depth(n) if your API documents paths longer than that.
  • DatabaseConfig gained five public fields. Code that builds one with a struct literal no longer compiles. Use DatabaseConfig::from_env() or DatabaseConfig::builder(), both of which fill the new fields with the defaults that preserve today's pool behavior.

1.3.3 - 2026-08-25

Added

  • Failover queue connection. FailoverQueueDriver wraps an ordered list of connections: a push the first one refuses is retried on the next, and so on down the list. Wire it from env with QUEUE_DRIVER=failover plus QUEUE_FAILOVER_CONNECTIONS=redis,database (each entry reads its own driver's variables, so a database entry still needs DB::init() first and still brings its failed-jobs store), or build it directly with FailoverQueueDriver::new(vec![(label, driver), ...]). Only writes fall through: push and bulk_push walk the list, while pop, pop_from, ack, nack, release, settle, clear, all four counters and all three inspection listings delegate to the first connection and no other, because a reservation token is meaningful only to the driver that issued it. The operational consequence is documented rather than papered over: a worker on the failover connection drains the primary only, so whatever failed over to a fallback needs its own worker. bulk_push pushes each envelope separately rather than forwarding a batch, which both preserves each envelope's own available_at (Laravel #60950) and keeps a batch the primary half-accepted from being re-pushed wholesale onto the fallback. A refusal dispatches queue::events::QueueFailedOver { connection, job_name, exception }, edge-triggered: a connection reports itself once when it enters failure and stays quiet until a later push succeeds on it and re-arms it, so an outage produces one alert instead of one per dispatch. When every connection refuses, the push returns the last connection's error. An empty connection list, a missing or blank QUEUE_FAILOVER_CONNECTIONS, a nested failover entry, and an entry naming a driver that doesn't exist are all boot errors - the warn-and-fall-back-to-memory behaviour stays on QUEUE_DRIVER itself, where a typo can't splice an ephemeral backend into a durable chain.

  • Queue inspection API. Queue::pending_jobs(queue) / delayed_jobs / reserved_jobs list the actual envelopes behind the existing pending_size/delayed_size/reserved_size counters, as InspectedJob DTOs (id, queue, name, attempts, payload, created_at) - mirrors Laravel's InspectedJob. A single Option<&str> queue filter collapses Laravel's pendingJobs($queue) / allPendingJobs() pair (and the delayedJobs/reservedJobs equivalents) into one call each. The QueueDriver trait default is an honest Err - not Laravel's Beanstalkd/SQS empty-collection default, which reads as "nothing queued" even when there plainly is - so a driver that has not implemented inspection says so; sync/null override with Ok(vec![]) because for them that really is the truth. The memory, database, and Redis drivers all implement the full listing: the memory driver's delayed storage moved from a bare DelayQueue<Envelope> (which cannot be iterated) to a DelayQueue<Uuid> plus an id-keyed map; the database driver reuses the size counters' exact predicates plus ORDER BY available_at, and a row whose envelope_json fails to decode is still listed (id: None, payload: {"unparseable": true}) rather than dropped, so one poison row can't blind an operator to the rest of the queue; Redis's reserved_jobs is scoped to this consumer's in-process reservations (documented), and pending_jobs scans the stream via XRANGE in batches. Queue::fake() gained matching pending_jobs()/delayed_jobs() helpers, projecting recorded pushes with attempts always 0 and created_at always None.

  • After-commit dispatch. Job::after_commit() holds a push until the surrounding DB::transaction commits, so a worker on another process can never pop an envelope that describes rows the transaction has not made durable yet. The whole push waits, not just the driver write: the envelope build, JobQueueing and JobQueued all happen at commit time, so no listener is ever told about a job a rollback then discards. A rollback discards the push entirely; outside a transaction the push happens immediately, which is what lets a job type declare the opt-in without every dispatch site knowing whether its code path is transactional. Per dispatch, EnvelopeOverrides::after_commit outranks the job: Some(true) (with the shorthand Queue::push_after_commit(job)) defers a job that did not opt in, and Some(false) is Laravel's beforeCommit(). A deferred Queue::push re-resolves Job::delay() against the commit rather than the push, while Queue::push_later / later / later_with carry the caller's absolute timestamp through unchanged. Queue::push_unique takes its dedupe lock immediately even when the envelope is deferred, so a duplicate inside the same transaction is still suppressed, and a rollback releases that lock owner-scoped. Queue::bulk defers as a unit. Queue::fake() records a push immediately, deferral and all, matching Laravel's Bus::fake. Manual DB::begin_transaction never defers - it installs no ambient transaction, so there is no commit to hang a callback on. Every ending that leaves the commit unlanded compensates identically, including a COMMIT the database refuses and a leaked TxHandle that blocks one, and Transaction::rollback_to counts as one for the scope it unwinds: a push deferred inside a savepoint is discarded when that savepoint rolls back and its lock is released right then, while anything registered before the savepoint is untouched. Queued mail, notifications, batches and chains do not defer yet.

  • Unique-until-processing jobs. Job::unique_until_processing() releases the uniqueness lock when processing begins - after the job's middleware pass, immediately before the handler runs - instead of holding it for the full unique_for window, which is what you want when the lock exists to coalesce queued duplicates rather than to serialize execution. A job that a middleware releases back onto the queue keeps its lock, because it has not started processing; a job a middleware deletes or dead-letters gives its lock up. Release is owner-scoped: Queue::push_unique records the cache lock's owner token on the envelope (Envelope::unique_lock_owner, an additive field that leaves the frozen wire format byte-identical for every non-unique push), and the worker releases with that token, so a redelivered attempt can never force-release a lock a newer dispatch now holds. The supporting idempotency surface is public too: Idempotency::commit_on_success_owned hands the body the lock owner and returns it, and Idempotency::release_owned(key, owner) releases owner-scoped, reporting Ok(false) rather than an error when the lock is absent or held by somebody else. Plain unique_id jobs are unchanged and still let the unique_for TTL be the dedupe window.

  • Gate::default_denial_response customizes the default shape of a bare denial. Mirrors Laravel's Gate::defaultDenialResponse($response). Set once - typically in bootstrap::register() - it reshapes exactly two outcomes: a bare false (a bool gate - Gate::define / Gate::define_async, including a #[policy] method returning bool - or a before/after hook that decided false) and an evaluation nothing else decided at all (an undefined ability with no hook opinion either). All of those used to collapse to a bare Response::deny() (a 403); now they surface as whatever Response the default carries, e.g. Response::deny_as_not_found() for a 404 that hides a resource's existence application-wide instead of gate by gate. The default applies to bare false only - a gate registered with define_with / define_async_with already returned the Response it wanted, and that always passes through Gate::inspect untouched, matching Laravel's own rule that the default never substitutes for a returned Response object. A default shaped as Response::allow() is rejected (logged, ignored) rather than silently inverting every bool gate to allowed - see Gate::default_denial_response's doc comment for the one place this deliberately diverges from Laravel, which has no such guard.

  • The Password validation rule family ships, including the Have I Been Pwned uncompromised() check. Password::min(n) plus the strength builders (.max(), .letters(), .mixed_case(), .numbers(), .symbols()) port Laravel's Password rule regexes verbatim - a plain space satisfies .symbols(), matching Laravel's \p{Z} separator class. .uncompromised() (or .uncompromised_with_threshold(n)) checks the password against Have I Been Pwned's k-anonymity range API: only the first 5 characters of the password's SHA-1 hash ever leave the process, and a network failure, timeout, or non-2xx response fails open rather than blocking signups, exactly like Laravel's NotPwnedVerifier. Because that check is an HTTP round trip, Password is the one built-in rule implementing both Rule (strength only, for sync validate! rows) and AsyncRule (strength, then the HIBP check, for after_validation_async) - calling the sync path on a Password configured with uncompromised() is a loud, developer-facing error rather than a silent skip. Password::defaults_with(...) sets the process-wide default Password::defaults() returns. New HIBP_TIMEOUT_SECS env var (default 30s). Http::fake_response_text(...) is the new raw-body sibling of fake_response(...) for tests against text/plain upstream APIs like HIBP's.

  • A scheduled task can now name the timezone its cron expression is read in, and schedule:list can render the whole schedule in any zone. .timezone(chrono_tz::Tz) pins one task, .try_timezone("Area/City") is the fallible sibling for a zone name that only exists at runtime, and Schedule::timezone(tz) sets a default for every task registered after it. Nothing changes for a task that pins no zone: it is still evaluated against the process's local zone. A pinned zone affects due-ness only - the scheduler still ticks once per process minute and the same-minute dedup gate is untouched. Note that a zone observing daylight saving makes some wall-clock minutes happen twice and others not at all, so a task pinned to such a minute can run twice or be skipped; the scheduling chapter carries the full warning. schedule:list gained a --timezone option and two columns: the zone a printed expression is written in, and the next minute the task fires. A pinned task's expression is rewritten into the listing's zone, splitting into several lines when it straddles midnight there, and is left exactly as written when a faithful rewrite is impossible - across a daylight-saving transition, when a day rollover would have to move a restricted day-of-month and day-of-week together, or when it would have to decide how long February is. chrono_tz::Tz is re-exported from the crate root, so consuming apps do not add chrono-tz to their own Cargo.toml.

  • A Laravel-shaped image subsystem, in suprnova::media behind the default-on media feature. Image::from_bytes/from_path/from_disk/from_upload/from_stream builds a lazy pipeline - resize, scale, crop, cover, contain, rotate at any angle, flip_vertically/flip_horizontally, blur, sharpen, grayscale, to_format, quality - finished with to_bytes, to_response, save, store, dimensions, mime_type, or dominant_color. Reads and writes PNG, JPEG, WebP, GIF, and BMP; AVIF output is deferred until the in-house AV1 encoder publishes, at which point it is one new OutputFormat variant and no other change. Like Laravel's gd/imagick split there are two drivers: IMAGE_DRIVER=oxideav (the default) runs on the pure-Rust OxideAV codec family with no native library and nothing to install, and IMAGE_DRIVER=magick shells out to a host-installed ImageMagick 7 for wider input support including HEIC. Decode limits (IMAGE_MAX_DIMENSION, IMAGE_MAX_ALLOC_BYTES) are checked against the input's own header before anything is allocated - including the inner bitstream of an extended WebP, whose advisory canvas size cannot be used to smuggle a larger frame past the gate - and all pixel work runs on a blocking thread. The magick driver pins the input coder by name rather than letting ImageMagick pick one from the bytes, and bounds every invocation with IMAGE_MAGICK_TIMEOUT_SECS. ImageDriver is the trait boundary for anything else. The module is named media because the OxideAV-backed audio and video surfaces will live beside it. Images

  • The WebP gate carries one fixed, non-configurable bound. A WebP declares its real decoded size in its innermost bitstream chunk, so the framework walks the container to find it; that walk visits at most 4096 chunks per level and follows two levels of nesting, and a file past either is refused rather than measured. Reporting a number from an unfinished walk would be a gate that enough filler chunks could step around. No IMAGE_MAX_* variable affects it and the error says as much. A 300-frame animation is unaffected; a 4100-frame one is refused. Images

  • OAuth can now be installed without replacing an application's existing password and session authority. MagnetarOAuthOnlyConfig and init_magnetar_oauth_only install the default ceremony and provider engine while leaving the password and passkey slots empty. Applications with an existing users table can call verify_oauth_identity, map the verified provider subject themselves, and establish their normal framework session.

Changed

  • DB::transaction can now return Err after a successful commit, when an after-commit callback fails: the message reads after-commit callback failed (the transaction itself committed): …, the closure's return value is lost and its writes are not. DB::transaction_with_attempts never retries that error, however deadlock-shaped the callback's own message reads - re-running a closure whose writes are already durable would apply them twice.
  • New validation catalog key: validation-password-unverifiable. A custom UncompromisedVerifier that returns Err no longer puts its own error text in the 422 body verbatim. That text is logged at error instead, and the response carries this key, rendering as "The { $field } could not be checked against known data leaks. Please try again." - the check did not run, which is not the same as the password being bad, and infrastructure detail does not belong in a client response. An app shipping its own validation catalog has to add the key, or its users see the built-in English fallback.
  • The Image upload validator is now ImageFile. suprnova::Image is the new image-manipulation pipeline type, matching Illuminate\Image\Image, and the magic-byte upload rule takes the name Laravel gives the same rule class, Illuminate\Validation\Rules\ImageFile. Migration is one line per use site: UploadedFile<(Image, MaxSize<N>)> becomes UploadedFile<(ImageFile, MaxSize<N>)>. Pre-1.0 churn absorbed by the git-tag distribution model.

Removed

  • The unused direct image dependency is gone. It had been a base dependency with zero use sites anywhere in the workspace, pulling JPEG, PNG, WebP, and GIF codecs in for nothing; dropping it removes gif, image-webp, zune-jpeg, color_quant, and weezl from the tree. The crate itself still appears transitively, with only its png feature, behind totp-rs's QR-code rendering. The new image subsystem is built on the OxideAV crates behind the media feature instead.

Fixed

  • Installing OAuth no longer forces provider-backed applications into Magnetar web-binding validation. The full init_magnetar path remains atomic and unchanged. The OAuth-only path reserves the engine slots during construction, publishes only OAuth, and fails rather than mixing two authentication authorities.

Upgrading

  • Image is a different type now; the upload validator is ImageFile. Source-breaking for anyone using the magic-byte upload rule. Rename it at every use site: UploadedFile<(Image, MaxSize<N>)> becomes UploadedFile<(ImageFile, MaxSize<N>)>. suprnova::Image still resolves, but it is now the image-manipulation pipeline type, so a missed rename fails to compile rather than changing behaviour silently.

  • EnvelopeOverrides gained a public after_commit: Option<bool> field. Every construction in this repo and in the scaffolded templates uses ..Default::default(), which needs no change. Code that builds an EnvelopeOverrides with an exhaustive struct literal has to name the new field; after_commit: None keeps today's behaviour, which is to defer to Job::after_commit(). Nothing else changes: after_commit() defaults to false, so no existing job starts waiting for a commit it did not before.

  • Envelope gained a public unique_lock_owner: Option<String> field. The wire format is unchanged - the field is #[serde(default)] and skipped when None, so envelopes round-trip byte-identically in both directions and schema_version stays at 2 - but any code that builds an Envelope with a struct literal now has to name it. Add unique_lock_owner: None unless you are deliberately carrying a uniqueness lock across the push. Code that only reads envelopes, or builds them through Queue::push and its siblings, needs no change.

  • Use init_magnetar_oauth_only instead of init_magnetar when the application already owns users, passwords, framework sessions, and remember-me state. OAuth-only callbacks use verify_oauth_identity; full Magnetar applications continue to use complete.

1.3.2 - 2026-08-25

Added

  • OAuth providers can now be registered through MagnetarConfig::oauth. Suprnova re-exports the OAuthProvider contract, all five first-party provider and configuration types, and the HTTP, revocation, abuse-limiter, authorization, and auto-link types an application needs. Custom providers no longer require a direct suprnova-magnetar dependency or a hand-retained MagnetarHostEngine.

  • A production OAuth transport and framework limiter adapter now ship at the crate root. ReqwestOAuthTransport implements token, userinfo, and revocation I/O with redirects disabled by default, a 30-second timeout, a default User-Agent, and a 1 MiB response cap. FrameworkAbuseLimiter reuses the configured RateLimiterDriver; apps no longer hand-write either adapter.

Fixed

  • init_magnetar now publishes OAuth with password and passkey services as one reserved installation. The OAuth service is built before publication, and all three engine slots remain hidden while the reservation is active. A failed or duplicate OAuth configuration cannot leave password and passkey state visible without the configured OAuth registry.

  • Custom providers can supply userinfo headers. OAuthProvider::userinfo_headers is merged with the host-owned bearer header, enabling requirements such as GitHub's User-Agent and media-type Accept headers without allowing a provider to replace Authorization.

Upgrading

  • The Magnetar cutover in 4faaa933 removed Torii's OAuth installation path without wiring its replacement into the default initializer. The old workaround required constructing a custom host engine, calling oauth_service, and installing the adapter separately. Replace that workaround with MagnetarConfig::from_sea_orm(database).oauth(oauth_config) and one init_magnetar call.

  • GitHub community providers must handle verified email explicitly. GitHub /user usually omits non-public email, while the verified primary address requires /user/emails. Return email: None to use the email-completion ceremony, or point userinfo_endpoint at a host adapter that combines both responses; never treat a public but unverified address as ownership.

1.3.1 - 2026-08-24

Fixed

  • Provider-backed applications can reset verified users again. When no Magnetar engine is installed, PasswordReset uses an explicitly reset-capable UserProvider and framework auth_flow_tokens for already verified accounts. EloquentUserProvider<M> opts in when M implements MustVerifyEmail + CanResetPassword; no app_users migration is required.
  • The published framework line now contains both post-release repair sets. The translated 1.3.0 changelog layout and headings, CJK wrapping, localized anchors, glossary terms, and prose punctuation are reconciled instead of split across divergent local and remote branches.
  • Post-tag CLI and Magnetar hardening is included. Development-process cleanup uses the completed process-group fallback, and the local qualification contracts cover the released refs and plugin-SDK SQLite lanes.

Security

  • The provider fallback never treats password reset as first mailbox proof. Unknown and unverified addresses receive the same no-mail response. Install Magnetar when an unverified account must prove mailbox ownership through reset so credential cleanup, auth-epoch advancement, and revocation remain atomic. Provider fallback completion reports framework session and remember revocation failures through PasswordResetOutcome.

Upgrading

  • Move every v1.3.0 Git dependency to v1.3.1. Applications with their own users table keep their configured UserProvider; they do not initialize the default app_users engine merely to reset an already verified account. Applications that use Magnetar credentials or unverified-account first proof continue to initialize Magnetar.

1.3.0 - 2026-08-24

Security

  • Magnetar now fences credential and session mutations to the authenticated actor and account auth epoch. Password, passkey, linked-account, two-factor, opaque-session, JWT, remember, OAuth, and device-authorization writes reject stale or revoked actors. The first successful password-reset, magic-link, or OAuth verified-email proof on an unverified account advances the epoch and atomically removes provisional credentials, sessions, remember state, and squatter TOTP enrollment. Verified accounts preserve legitimate credentials during password reset. Email verification requires the authenticated token owner, and OAuth never auto-links an unverified existing account from email alone.

  • A protocol-relative _previous.url can no longer produce an off-origin open redirect through Redirect::back(), on either the write side or the read side. SessionMiddleware no longer persists a protocol-relative current URL: the write goes through the identical sanitizer InertiaValidationRedirectMiddleware uses for its Referer check, and a request path shaped like //host (or carrying an ASCII control byte) is never recorded - without this, an app's fallback! route (the standard Inertia/SPA app-shell pattern, where any unmatched path answers 200) could have GET //evil.test/anything persist that path verbatim. SessionData::previous_url() now applies the same check on every read, too, so a session cookie that survived an upgrade from a release before this fix - already carrying a raw, unsanitized value no write in the current process ever produced - self-heals to "nothing recorded" instead of being trusted. Together, neither an old poisoned cookie nor a new malicious request can hand Redirect::back(), Redirect::refresh(), or url::previous() an off-origin Location. When a value fails either check it's treated as absent rather than replaced with a synthesized one, so a genuinely good previous URL is never clobbered.

  • The Inertia validation-redirect bridge's Referer check closed two more same-origin bypasses. InertiaValidationRedirectMiddleware's 303 target only rejected a Referer starting with the literal // or /\ prefix - a value like Referer: /<TAB>/evil.test slipped through, because the WHATWG URL parser strips ASCII tab and newline from the whole string before comparing origins, so a browser reads that as //evil.test and follows the 303 off-origin. The check now rejects any ASCII control byte (C0 or DEL) anywhere in the candidate, not only within the two named prefixes. Separately, the last-resort fallback - the failing request's own path, used when neither Referer nor the session's previous URL is usable - was never sanitized: an origin-form HTTP request-target is syntactically free to start with //, so a raw client or a non-normalizing proxy could turn the "safe last resort" into an off-origin redirect too. Both legs now share one root-relative check, falling back to / if even the request's own path fails it.

  • Cookie ciphertext is now bound to its logical cookie name with contexted v2 AAD. Cookie::encrypted / Cookie::read_encrypted_for stop a value minted for one cookie slot from decrypting in another slot, while the logical-name binding keeps a later __Host- / __Secure- wire-prefix flip safe. The version-less compatibility window tries v2 across the whole key ring, then v1 across the whole ring, so existing cookies survive the rollout; the v1 fallback preserves the old replay weakness until its scheduled 1.4.0 removal.

  • Session and remember-me cookie prefixes are validated at boot and enforced at render time. SESSION_COOKIE_PREFIX=__Host- requires Secure, Path=/, and no Domain; __Secure- requires Secure. Invalid boot combinations fail before serving, and the renderer rewrites invalid prefixed headers instead of letting browsers discard them silently.

Added

  • Suprnova authentication now runs on the internal Magnetar engine. The framework-owned Auth facade preserves existing password, magic-link, passkey, OAuth, bearer, lockout, session, and two-factor call sites while removing the Torii dependency. The default engine installs password/session and passkey adapters atomically, stores lifecycle delivery leases in the application database, and shares the application's canonical i64 app_users identities.
  • A shape-aware authentication migration runner now covers Torii, Suprnova web, and Suprnova API sources. Dry runs bind a stable plan id to durable row and schema fingerprints plus destination identity decisions. Apply uses transactional imports, retry ledgers, shape-owned cleanup, and collision refusal. MySQL uses a write-barrier-protected shadow swap with pre-copy journals, row and schema parity, resumable renames, and cleanup-preserving restore.
  • MAIL_DRIVER=file writes one RFC 5322 .eml per message to MAIL_FILE_PATH (default storage_path("mail"); a relative value anchors at the application base directory, not the process CWD), so local mail can be opened in a mail client instead of read out of a log line. The file carries the same header superset SMTP emits, including X-Priority, Importance, X-Tag, X-Metadata-*, and Return-Path. Like log and memory, it does not deliver: a production boot refuses it unless MAIL_ALLOW_NON_DELIVERING_IN_PRODUCTION=true.
  • FrameworkError::External carries the error it wraps. FrameworkError::from_external(e) and FrameworkError::from_external_with("saving user", e) keep the original error reachable as a std::error::Error source instead of melting it into a string. FrameworkError::external_source() returns it for downcasting - use that rather than source(), which yields the shared Arc handle. Both constructors map to HTTP 500.
  • 5xx logs now render the full error source chain. render_error_chain walks source() and is wired into the framework-error log line, the ErrorOccurred event payload, and the debug_message field emitted under APP_DEBUG=true. Client-facing response bodies are unchanged and 5xx bodies stay sanitised.
  • InertiaResponse::scroll_wrapped / scroll_with_wrapped / try_scroll_wrapped. Nest a scroll prop's merge instruction under <key>.<wrap_key> instead of the bare key - mergeProps: ["users.data"] rather than ["users"] - for a value that's itself an envelope ({ data: [...], meta: {...} }). Laravel's ScrollProp wraps under "data" unconditionally; Suprnova's built-in paginators hand back a bare row array, so this is opt-in rather than a default every caller has to work around. New ProvidesScrollMetadata trait (page_name / previous_page / next_page / current_page, with a default scroll_metadata()) mirrors Laravel's interface of the same name for a paginator this crate doesn't know about; LengthAwarePaginator, Paginator, and CursorPaginator now implement it instead of building ScrollMetadata by hand. A scroll prop's .match_on(...) fields now also emit into matchPropsOn, matching Laravel's resolveMergeMatchingKeys (Response.php:641-652), which folds a ScrollProp's matchesOn() in the same as any other merge prop - the match entry keys off wherever the prop actually merges, <key> unwrapped or <key>.<wrap_key> under .scroll_wrap(...).
  • Prop::merge_with_path, multi-field match_on, and resolver-backed merge props. Prop::merge_with_path(path) merges a nested field inside a prop's value instead of the whole prop - Prop::eager(v).merge().merge_with_path("data") emits mergeProps: ["<key>.data"], and a path-merging prop never also merges its root; .deep_merge() ignores it, since a deep merge already recurses into every field. Prop::match_on now takes one field or several in one call (match_on(["id", "slug"])) on top of the match_on("id").match_on("slug") chaining Prop composition already supports. InertiaResponse::merge_lazy / merge_lazy_with add the resolver-backed siblings of .merge / .merge_with, matching Laravel's Inertia::merge(fn () => ...).
  • Partial-reload only/except understand dot notation. X-Inertia-Partial-Data: user.name narrows the user prop to { name: ... } instead of requiring the whole value or nothing; X-Inertia-Partial-Except: user.email prunes just that field, leaving the rest of user in place. except wins on a path both headers name, a bare entry still means the whole prop, and an unknown or type-mismatched nested path drops silently without touching its siblings. Always props are unaffected - they always ship whole.
  • Dot-key prop nesting. .with("user.name", value) (and any other prop-attaching method, eager or resolved) now nests into props.user instead of shipping a literal "user.name" key, matching Laravel's Arr::set-based resolveArrayableProperties unpacking. Two calls sharing a prefix - .with("user.name", …) then .with("user.age", …) - accumulate into one object; a key with no dot is unaffected. App::inertia_share* shared-registry keys nest the same way on the wire. The unpacking only ever touches top-level prop keys - it never recurses into a prop's value, so a validation errors bag keeps whatever dotted field names it carries internally.
  • App::inertia_shared(key) / App::flush_inertia_shared(). Laravel's Inertia::getShared / Inertia::flushShared, reading and clearing the static share registry (App::inertia_share / _lazy / _once). inertia_shared supports the same dot notation as inertia_share for the read side; it returns None for a lazy or once share (there's no request to resolve one against) and for an unregistered key. flush_inertia_shared clears only the static registry - a trait provider registered via App::register_inertia_shared is untouched, matching Laravel (there's no per-request state there to flush).
  • InertiaResponse::always_with(key, resolver). The async-resolver sibling of .always(key, value), for an always-included prop expensive enough to be worth resolving lazily - Laravel's Inertia::always(fn () => …) (AlwaysProp accepts any value, closures included).
  • InertiaSharedData::share now receives the page component name, so a provider can vary its output by page - Laravel's RenderContext. See Upgrading.
  • Inertia prop composition. A Prop now carries orthogonal flags instead of being one of nine closed variants, so a single prop can be deferred and mergeable, mergeable and cached, or optional and cached - the combinations the Inertia 3 protocol expects and a closed enum could not spell. Build one with Prop::eager / Prop::lazy / Prop::from_resolver / Prop::absent, chain .always(), .optional(), .defer(), .group(), .rescue(), .merge(), .prepend(), .deep_merge(), .match_on(), .once(), .as_key(), .until(), .fresh(), .scroll(), and attach it with the new InertiaResponse::prop(key, prop). A defer().merge() prop is announced under deferredProps on the first render and arrives under mergeProps on the follow-up request. New MergeMode and Visibility types describe the flags; every existing builder shortcut (.with, .always, .lazy, .optional, .defer, .merge*, .once*) is unchanged.
  • Queue pause / resume. Queue::pause(connection, queue) / resume / pause_all() / resume_all() / is_paused(connection, queue) / paused_queues(connection, &queues), backed by Cache the same way the restart signal is - resume_all does not clear a per-queue pause, matching Laravel. The worker's claim gate sits right before every pop, so an in-flight job always finishes; a global pause short-circuits --queue=... filtering the same way Laravel's pausedQueues does, and a per-queue pause only takes effect on a worker started with an explicit --queue=... list. New CLI commands queue:pause [queue] [--all] / queue:resume [queue] [--all] (alias queue:continue), plus QUEUE_PAUSABLE=false for an operator to disable the feature - an unpausable worker ignores pause signals, and queue:pause itself refuses to run. New events: QueuePaused / QueueResumed / QueuesPaused / QueuesResumed.
  • suprnova::testing::TestResponse - a fluent, Laravel-TestResponse-shaped wrapper over the (status, headers, body) triple every HTTP test harness already produces: assert_status, assert_ok, assert_redirect, assert_json, assert_json_path, assert_json_count, assert_see, assert_header, assert_cookie, and (given .with_session_store(...)) assert_session_has. Every assertion returns &Self and panics on failure, the same contract as expect!. Nothing about how a test drives a request has to change.
  • suprnova new scaffolds an SSR entry. Every starter (Svelte, React, Vue) now ships frontend/src/ssr.{ts,tsx} and a build:ssr npm script (vite build --ssr), wired to its own output directory (frontend/bootstrap/ssr/) so the SSR bundle never collides with the client build in public/assets/.
  • InertiaConfig::ssr_bundle_path(path) / .ssr_ensure_bundle_exists(bool). The SSR gateway can now check the built bundle exists on disk before dispatching a render, mirroring Laravel's ensure_bundle_exists config - a worker that was never started, or a bundle that was never built, fails fast instead of paying ssr_timeout on a connection that was never going to succeed. Opt in with .ssr_bundle_path(...); unlike Laravel's BundleDetector the path is never auto-detected, so existing SSR configs (and tests) that don't set one are unaffected.
  • Validation failures on an Inertia visit now redirect back instead of returning 422 JSON. Inertia::install registers a fourth middleware, InertiaValidationRedirectMiddleware, which turns a validation 422 on an X-Inertia request into a 303 to the form page with the errors flashed - so useForm().errors fills in with no handler code. The Inertia client treats any response without an X-Inertia header as non-Inertia and shows its error modal, so the old 422 could never reach form.errors. Non-Inertia requests keep the 422 envelope, Precognition dry-runs are untouched, and X-Inertia-Error-Bag scopes the flashed bag. The redirect target is the same-origin Referer, then the session's previous URL, then the request's own path run through that same sanitizer, falling back to / if even that fails it - never trusted verbatim.
  • InertiaConfig::with_all_errors(bool) - keep every validation message per field instead of collapsing to the first. Mirrors Laravel's Inertia\Middleware::$withAllErrors.
  • suprnova::testing::AssertableInertia - fluent, Laravel-AssertableInertia-shaped assertions over an Inertia page object, parsed from either an X-Inertia JSON response or a hard-navigation HTML shell's embedded <script data-page="app"> element: component, url, version, prop, has, missing, where_, count, has_flash. Build one from an HttpResponse with AssertableInertia::from_response, or from a TestResponse with the new TestResponse::assert_inertia(). reload_only, reload_except, and load_deferred_props replay a partial reload against a caller-supplied with_reload(...) closure - Suprnova's HTTP tests cross a real socket, so there's no single in-process test client to hardcode against.
  • Cookie::queue/queued/unqueue/expire. A task-local cookie jar - Laravel's CookieJar - lets any code queue a cookie for the next outgoing response without holding an HttpResponse to attach it to: an event listener, a container-bound service, middleware ahead of the handler. Backed by the same per-request slot Auth::login_remember already uses to carry the remember-me cookie past the handler boundary; SessionMiddleware drains it onto the response next to the session cookie. Cookie::expire(name, path, domain) queues a deletion cookie built with Cookie::forget_with. Requires SessionMiddleware in the route's middleware chain - outside it, all four calls are a silent no-op, matching App::flash's behavior outside a flash scope.
  • HttpResponse::event_stream(stream, end) and HttpResponse::stream_json(stream). Laravel's ResponseFactory::eventStream / streamJson, and the exact wire shapes @laravel/stream-{react,vue,svelte}'s useEventStream / useJsonStream expect. event_stream frames a Stream<Item = sse::StreamedEvent> as event: update per item unless the item names its own event, JSON-encodes any non-string payload, and appends a configurable terminal frame (EndSignal::default() is data: </stream>; EndSignal::None omits it). stream_json streams any Stream<Item = impl Serialize> as one incrementally-flushed JSON array. Both are built on the existing sse/stream_bytes body pipeline, so they share its cancellation and panic-isolation behavior with the rest of the framework.
  • suprnova serve respawns a crashed dev process instead of tearing the whole session down. Exponential backoff between attempts - 200ms, doubling on each consecutive crash, capped at 5s, resetting to the floor once a process has stayed up 30s. --no-restart opts out and restores the previous behaviour. --restart-tries <N> (default 5, matching Laravel's --restart-tries=5) gives up retrying a process after that many consecutive crashes instead of retrying forever, printing an actionable message and leaving the other processes - and the session itself - running. --timestamps prefixes every forwarded line with HH:MM:SS. A new Suprnova.toml [[serve.process]] array lets a project declare its own dev processes - Laravel's DevCommands::register - to run alongside the backend and frontend, each with its own [name] prefix and an optional color; an unknown key or a blank name/command in an entry is now a hard parse error instead of silently ignored or a later opaque spawn failure. --json emits one JSON object per line (NDJSON) on stdout instead - process start, output, exit, restart-scheduled, restart-succeeded, gave-up, types-regenerated, and shutdown events, including the file watcher's own regeneration notices and the Ctrl+C handler's shutdown notice, both of which now stay off stdout under --json too - for scripting and log pipelines; combining it with --timestamps is harmless but redundant, since every event already carries its own timestamp.
  • RequestBuilder::retry_when(predicate). A predicate consulted before every retry the built-in policy (.retry(...) / .retry_non_idempotent(...)) would otherwise make, receiving a RetryContext { attempt, method, url, outcome: RetryOutcome::TransportError | Status(u16) }. It composes with the policy rather than replacing it: false vetoes a retry the policy would have made; it can never force one past max_attempts or one the policy wouldn't otherwise attempt (a 4xx status, or a non-idempotent method without retry_non_idempotent).
  • #[model(touches = [...])] now actually touches. After a child is created, saved, updated, or deleted, each BelongsTo owner named in the list gets one UPDATE <owner> SET updated_at = ? WHERE <key> = ?, on the same executor as the write that triggered it - so inside a DB::transaction the touch joins that transaction and rolls back with it. An owner whose model has timestamps = false is skipped, not written and not an error (Laravel 13.25 closed the same gap). Owners reached through a NULL foreign key, and soft-deleted owners, are skipped too. A touches entry that doesn't name a declared BelongsTo relation is now a compile error; polymorphic owners are not supported yet.
  • without_touching_on::<M, _, _>(fut) - Laravel's Model::withoutTouchingOn([M::class], $cb). Suppresses both m.touch() and any owner cascade targeting M, while owners of other types keep bumping. Scopes nest, and the existing without_touching now suppresses the owner cascade as well as direct touch() calls.
  • Model::touch_owners() / touch_owners_with_tx(tx) - Laravel's touchOwners(), for when you wrote the child row through a path the framework doesn't own.
  • Value-shaped validation rules: ArrayKeys and Distinct. A new ValueRule trait (passes(&self, value: &serde_json::Value)) sits alongside Rule, sharing the same keyed-message contract. rules::ArrayKeys(&[...]) rejects a JSON object carrying any key outside the allowed list (Laravel's array:keys, #60918); rules::Distinct { ignore_case, strict } rejects a JSON array with a repeated element (Laravel's distinct). validate! rows accept either kind of rule in the same field list - dispatch is automatic, chosen by which trait the rule implements, not by new row syntax.
  • Job::delay() - jobs can declare a default delay (fn delay() -> Option<Duration>, default None), honored by Queue::push and Queue::bulk: available_at becomes now + delay instead of now. An explicit call-site delay still wins - Queue::push_later(job, at) and Queue::later(delay, job) use the caller's timestamp verbatim and never consult Job::delay().
  • Notification::{queue, timeout, fail_on_timeout, max_tries, backoff}. A queued notification (Notify::queue) now carries its own queue-tuning defaults onto every per-channel SendNotificationJob push via the EnvelopeOverrides primitive Mail::on_queue uses - fail_on_timeout(&self) == true dead-letters on the first timeout instead of retrying, matching Laravel's #[FailOnTimeout] notification attribute (#61072). All five default to SendNotificationJob's existing Job defaults, so a notification that overrides nothing is unaffected.
  • Mail::on_queue / Mail::on_connection + Queue::push_with/later_with. A queued mailable now routes itself with Mail::to(..).on_queue("emails").queue(mailable), or defaults via Mailable::queue(&self). Both outrank any Queue::route registered for the job and the job's own Job::queue()/Job::connection() - the new EnvelopeOverrides primitive behind them (Queue::push_with(job, overrides) / Queue::later_with(delay, job, overrides)) also covers timeout, fail-on-timeout, max-tries, and backoff for one push. MailFake's queued snapshots now carry the resolved queue, with queued_on(...) / assert_queued_on(name, queue) to assert it.
  • Application::http_bootstrap(f) - an HTTP-only boot hook. It runs after bootstrap and only on the serve / web:run path, so the queue, schedule, and workflow workers and the console binary never run it. Worker and console container images no longer need a built frontend manifest to boot: Inertia::install fails closed in production when it is missing, and that check now only runs on a process that actually serves HTTP.
  • Router::inertia(path, component, props) - Laravel's Route::inertia, for a static page whose handler would be one line. Registers GET (HEAD falls through to it) and returns a RouteBuilder, so the route can be named and given middleware. Router::view is retained as an alias.
  • SES v2 send options. The SES transport now emits TenantName, ConfigurationSetName, and ListManagementOptions on SendEmail. Each has a transport-level default (SesMailTransport::tenant_name / configuration_set_name / list_management) and a per-message header override (X-SES-TENANT-NAME, X-SES-CONFIGURATION-SET, X-SES-LIST-MANAGEMENT-OPTIONS), with the header winning. The headers are consumed when the request is built and never rendered into the message.
  • without_cookies on every response builder. HttpResponse, Response (via ResponseExt), Redirect, and RedirectRouteBuilder all expire a list of cookies in one call, and Redirect /RedirectRouteBuilder gained the single-name without_cookie they were missing. New Cookie::forget_with(name, path, domain) builds a deletion cookie scoped to the path and domain the original was set with - a plain forget never clears a cookie set outside /.
  • Queue::fake() stamps an envelope id on every captured push. pushed_with_id::<J>() returns (job, id) pairs, and the fake now dispatches the same JobQueueing / JobQueued pair a real driver push does - carrying that id - so a test can correlate a captured push with what its listeners saw. Existing fake helpers are unchanged.
  • UniqueJobSkipped queue event. Queue::push_unique now dispatches queue::events::UniqueJobSkipped { job_name, unique_id, connection } when it suppresses a duplicate, so a dedupe is observable instead of silent. The call's return value is unchanged (Ok(false)).
  • model_keys() on the query builder and on collections. User::query().model_keys().await? returns every matching row's primary key without hydrating a single model, projecting the table-qualified key (users.id) so the query survives a join. Collection::model_keys() is the already-hydrated counterpart. #[suprnova::model] now also declares the key's Rust type as EloquentModel::Key, so both return the type key_type names rather than a caller-chosen turbofish.

Fixed

  • PostgreSQL soft deletes now use backend-aware placeholders, and generated timestamp writes honor declared casts. delete() and restore() render PostgreSQL ordinal placeholders instead of MySQL and SQLite ? placeholders. Generated create, update, save, touch, and soft-delete writes also convert timestamps through each field's declared Cast storage type, so native TIMESTAMPTZ columns no longer receive text values. Thanks to @i-am-v-alexander-v for reporting both defects and submitting a fix in PR #3.

  • Default workspace and Magnetar gate runs no longer require live PostgreSQL or MySQL services. Backend-specific behavior suites are explicit, ignored qualification tests that still fail when deliberately invoked without their configured database. Reachability-only tests and permanent gate environment requirements were removed, so unrelated changes don't pay for external database setup on every verification run.

  • PartialFilter::narrow is now pub. Its four sibling predicates (should_include, should_include_eager, should_include_optional, and the type itself) were already public, but the narrowing pass that makes should_include_eager's true answer correct - trimming a resolved value down to the dotted paths an only/except entry actually asked for - was pub(crate). A caller building custom partial-reload handling on top of PartialFilter had no public way to reproduce that narrowing and would ship a value whole under a dotted only entry even though should_include_eager reported the key as included.

  • MailFake's QueuedSnapshot can now assert on .on_connection(...). Queue::fake() gained assert_pushed_on_connection in Wave 3 alongside assert_pushed_on_queue; Mail::fake() only got the queue half, so a mailable queued with a connection override was resolved and applied to the real dispatch but unassertable through the fake. New QueuedSnapshot::connection, MailFake::queued_on_connection, and MailFake::assert_queued_on_connection close the gap, mirroring assert_queued_on's shape.

  • A dotted shared prop was unreachable by a bare only entry. App::inertia_share("auth.user", …) followed by router.reload({ only: ['auth'] }) returned props: {"errors":{}} - the share vanished outright. The registry stores auth.user as one literal key and the Arr::set unpacking pass only nests it after every prop has resolved, so the partial-reload gate saw the still-flat key and matched it against neither auth nor anything else. only/except entries are now symmetric: an entry may name a prop's key exactly, a path inside it (user.name, which narrows), or an ancestor of it (auth against the key auth.user, which ships the prop whole, because the caller asked for the whole root). A bare except: ['auth'] drops every prop key beneath it the same way Arr::forget drops the whole subtree in Laravel's already-nested bag. The prefix must end on a segment boundary, so an unrelated authAgent.user prop is untouched by either list. Laravel never hits this because Inertia::share runs Arr::set at share time; Suprnova's registry cannot, since a lazy share has no value to nest until the request resolves it.

  • A #[data(lazy(deferred))] field bypassed the ?include= allowlist. The owner-tagged resolution path in resolve_props selected props with Prop::is_lazy(), which is false for anything carrying a flag - and a deferred field is Visibility::Deferred. The field therefore resolved off the ordinary prop path, where no include-set check exists, and shipped to any client that sent the deferred follow-up regardless of whether the request opted the field in. Prop::resolve_with_owner now gates every resolver-backed owner-tagged prop, flags or not, and resolve_props runs that gate ahead of every other block: a field outside ?include= is dropped whole (no value, no deferredProps announcement), and a field named by ?include= but off the DTO's allowlist raises its 400 before X-Inertia-Partial-Data can absorb it. Not a regression - the pre-Wave-4 code gated on the Prop::Lazy enum variant, which a Prop::Defer also failed - but a real hole either way.

  • deferredProps was re-announced on a matched partial reload. A partial that named one deferred key still advertised every other deferred key back to the client, which then fetched them again, and again on the next partial. Laravel's resolveDeferredProps returns [] the moment the request is partial, before it inspects a single prop (Response.php:661-663); the block is now dropped whole on any matched partial. A partial reload aimed at a different component is a standard visit for this gate, as for every other, so its announcements are unaffected.

  • The errors bag filtered differently depending on where the errors came from. The session-flashed bag is seeded ahead of the resolve loop and no partial-reload filter could reach it, while a handler's own .with("errors", …) went through the ordinary gates - so only: ['errors.email'] shipped the whole seeded bag but a one-field handler bag, and only: ['users'] replaced the handler's bag with the seeded one instead of leaving the key alone. Both paths now treat errors as always-visible, matching Laravel's middleware, which shares it as Inertia::always(...) and re-injects the raw value through resolveAlways after the only/except rebuild. This is the shape the client needs: it folds a partial response in with {...current.props, ...response.props}, so an empty errors object wipes messages already on screen where an unfiltered one leaves them correct. An explicit visibility flag on the key still wins, so .prop("errors", Prop::eager(…).optional()) behaves optionally.

  • Queue::fake() can now observe per-push EnvelopeOverrides. A job pushed through Queue::push_with/Queue::later_with was indistinguishable from a plain Queue::push under the fake - FakePush carried only the payload and available_at, so the override never left the facade and nothing could assert a test dispatched to the right queue or connection. New queue::testing::pushed_with_overrides::<J>() -> Vec<(J, EnvelopeOverrides)> returns each captured push paired with what it declared; assert_pushed_on_queue::<J>(queue) and assert_pushed_on_connection::<J>(connection) cover the common single-field case, mirroring MailFake::assert_queued_on. Every other entry point (push, push_later, bulk, push_unique, the chain/batch dispatchers) still takes no overrides and records EnvelopeOverrides::default(), so a plain push reads under the fake exactly as "no override declared."

  • An SSR worker that stalled mid-response body could hang a render forever. SsrConfig::timeout bounded only the wait for response headers; once headers arrived, reading the body had no timeout of its own, so a worker that accepted the connection, sent headers, then stopped sending data left the request hanging past the configured timeout instead of falling back to CSR (or erroring, under ssr_throw_on_error). Both phases now share one deadline, so the configured timeout bounds the whole SSR call, as its own doc already promised.

  • Queued cookies - including the remember-me cookie Auth::login_remember sets - were silently dropped on three internal fail-closed paths in SessionMiddleware. A session read failure, a session write failure, and a session-cookie encryption failure each returned a synthesized 500 directly, bypassing the pending-cookie drain that runs at the end of handle. Anything queued via Cookie::queue that request - including a remember-me token row already committed to the database - never reached the client as a Set-Cookie header. All three paths now drain pending cookies before returning, the same as a handler-returned error or a redirect. This does not cover an uncaught panic, matching Laravel's own queued cookies being lost to one.

  • Queue::push_unique now honors Job::delay(), matching Queue::push, Queue::push_with, and Queue::bulk. It previously computed available_at from Utc::now() directly, so a job that declared a default delay (fn delay() -> Option<Duration>) dispatched immediately when pushed through push_unique instead of after that delay. Queue::push_unique_later and Queue::later_unique are unaffected - they already take an explicit timestamp or delay from the caller and never consult Job::delay(), the same rule push_later/later follow.

Changed

  • The current development branch uses SeaORM 2.0 and requires Rust 1.94.0. Suprnova preserves its Eloquent, #[model], migration, and database-facade source shapes. Applications that call SeaORM directly must import ExprTrait for SeaQuery expression methods and use explicit *_raw connection methods for prebuilt Statement values. SeaQuery is now 1.0, and the direct MariaDB vector driver uses SQLx 0.9. Existing databases require no application data migration; fresh PostgreSQL schemas retain serial-backed primary keys.
  • Three more unused dependencies removed. pretty_assertions and qrcode leave the framework crate (totp-rs already carries the qr feature, so QR provisioning for two-factor enrolment is unaffected), and notify-debouncer-mini leaves the CLI (notify itself stays - the serve and generate-types watchers use it directly). All three were confirmed unused by cargo-udeps plus a source-wide search that covers doc tests.
  • suprnova-macros no longer depends on serde or serde_derive_internals. Neither was used: the ::serde::Serialize paths the macros emit resolve in the downstream crate, not in the macro crate itself. No effect on generated code.
  • MergeStrategy's match_on now carries more than one field name. Append, Prepend, and Deep each widen from match_on: Option<String> to match_on: Option<Vec<String>>, so InertiaResponse::merge_with / merge_lazy_with can dedupe on several fields the same way .prop(key, Prop::eager(v).match_on([...])) already could - before this, the response-builder shortcuts were strictly less expressive than building a Prop directly. See Upgrading.
  • Scroll props now emit Laravel-identical reset and merge semantics. scrollProps[key].reset is true exactly when the client named key in X-Inertia-Reset, matching Laravel's resolveScrollProps - not true on every visit lacking an X-Inertia-Infinite-Scroll-Merge-Intent header, as before. A scroll prop now also carries merge metadata unconditionally, defaulting to append: a fresh visit (no headers at all) emits reset: false plus a mergeProps entry, where it previously emitted reset: true and no merge metadata. A key in X-Inertia-Reset is excluded from mergeProps / prependProps for that response, the same exclusion a regular merge prop already had.
  • ssr:check now verifies the SSR worker's GET /health route answers 2xx, rather than only confirming that something accepted a TCP connection. Every @inertiajs/{vue3,react,svelte}/server worker answers /health out of the box, so this needed no change on the worker side - matches Laravel's Inertia\Ssr\HttpGateway::isHealthy().
  • The Inertia errors prop now carries one string per field, not an array. A session-flashed validation bag renders as { email: "The email field is required." } rather than { email: ["The email field is required."] }, matching Laravel's default and Inertia's own ErrorValue = string. InertiaConfig::with_all_errors(true) restores the array shape. An errors prop a handler sets itself is passed through untouched, and the session flash (Redirect::with_errors, session.pull_errors_flash()) still stores arrays - only the rendered page prop changes.
  • Model::TOUCHES moved from an inherent const to EloquentModel. The parent-touch cascade lives on a Model trait default, and a trait default can't read an inherent const. Comment::TOUCHES still resolves - it now needs use suprnova::EloquentModel; in scope. Models without a touches attribute get the trait's empty default.
  • RelationEntry gained related_updated_at_column. Anything constructing a RelationEntry by hand needs the extra field; nothing in-tree does, the macro emits them all.
  • Router::view now rejects props that aren't a JSON object. It previously ignored them silently, registering a route that rendered an empty prop bag with no diagnostic. null is still accepted as "no props"; Router::try_inertia is the fallible form.
  • The Inertia asset version now defaults to a hash of the Vite build manifest instead of the literal "1.0", so a deploy invalidates long-lived clients without anyone remembering to bump a string. InertiaConfig::manifest_path(...) re-points the resolver with it; an explicit .version(...) / .version_with(...) still wins. With no manifest on disk - local development - the version falls back to "1.0", which is what every app saw before, so nothing changes until you build. New VersionResolver::from_manifest(path) exposes the resolver directly.

Deprecated

  • Cookie::read_encrypted is now the v1-only legacy reader. Code that mints with Cookie::encrypted and reads with read_encrypted fails at runtime on the first value written after this release; switch to read_encrypted_for(name, wire). The un-contexted CryptPurpose::Cookie entry points are also superseded. Both removals are scheduled for 1.4.0.

Upgrading

  • Cookie decrypt warnings now have two independent axes. A KeyOrigin::Previous(index) warning means re-encrypt the value under the current APP_KEY and remove that previous key only after the rotation tail is gone; an AadVersion::Legacy warning means re-issue the cookie through the name-bound API before the 1.4.0 fallback removal. A value can report both.

  • SESSION_COOKIE_PREFIX is opt-in. Deploy __Host- only with HTTPS, SESSION_SECURE=true, SESSION_PATH=/, and no SESSION_DOMAIN; local HTTP scaffolds leave it empty. CsrfMiddleware's with_session_config keeps the literal XSRF-TOKEN name; use .xsrf_cookie_name("__Host-XSRF-TOKEN") when a client is configured for that separate name.

  • DecryptOrigin is now a two-axis #[non_exhaustive] struct. Read its key and aad fields independently and keep a wildcard-compatible match strategy for the KeyOrigin / AadVersion enums.

  • SessionConfig and CookieOptions are now #[non_exhaustive]. Struct literals and functional record updates in application code must move to Type::default() followed by public-field assignments or builder methods.

  • FrameworkError is now #[non_exhaustive]. A match on it in your own code needs a wildcard arm. This is the last release in which adding a variant would have been a breaking change.

  • MergeStrategy::Append/Prepend/Deep's match_on field is now Option<Vec<String>>, not Option<String>. A call site constructing the struct-literal form directly - MergeStrategy::Append { match_on: Some("id".into()) } - no longer compiles; wrap the field name in a Vec: Some(vec!["id".into()]). match_on: None is unaffected and needs no change.

  • A matched partial reload no longer emits deferredProps. Code reading page.deferredProps off a partial-reload response - a custom deferred-loading component, a test snapshot, an end-to-end assertion - will now find the key absent where it used to list the deferred props the request did not name. Read the announcements off the initial (non-partial) visit, which is where Laravel puts them and where the official client reads them.

  • A bare except entry now drops dotted prop keys beneath it. X-Inertia-Partial-Except: auth previously left a prop registered under auth.user in the response, because the gate compared whole keys. It is dropped now. If a page relied on a bare except entry pruning only the exact key, name the exact key (except: ['auth.user']) or narrow with a dotted path instead.

  • errors ignores only/except. A partial reload that filtered a handler-supplied .with("errors", …) prop out, or narrowed it with a dotted entry, now ships it whole. Tests asserting a sliced or empty errors object on a partial reload need updating. To keep the bag out of a response deliberately, flag it - .prop("errors", Prop::eager(…).optional()) - rather than relying on the partial-reload lists.

  • Prop::resolve_with_owner gates flagged props too. It previously resolved any prop that was not Prop::is_lazy() - an eager value or a resolver carrying a flag - without consulting the include set. It now gates every resolver-backed prop and only lets an already-materialized value through ungated. A #[data(lazy(deferred))] field consequently needs ?include=<field> on the request before it resolves or is announced, the same as every other lazy flavor. Add the field to the request's ?include= list, or drop the lazy(...) attribute if it was never meant to be opt-in.

  • Scroll prop reset no longer follows the merge-intent header. Code that reads page.scrollProps[key].reset directly - a custom infinite-scroll component, a test snapshot - will see reset: false (plus a mergeProps entry) on a plain revisit that used to read reset: true and carry no merge metadata. The official <InfiniteScroll> component behaves differently only on a plain revisit: it listens for reset on every router success event, not only an explicit router.reload(), so a normal revisit no longer clears its accumulated state unless the server actually named the key in X-Inertia-Reset, which matches Laravel. Send X-Inertia-Reset: <key> explicitly wherever the old "any non-append/prepend visit resets" behavior was relied upon.

  • Prop::match_on takes impl MatchOnFields, not impl Into<String>. The new bound is what lets one call name several fields (match_on(["id", "slug"])), and its impl list is deliberately closed - &str, String, [T; N], and Vec<T> only. A blanket impl over IntoIterator is not available: coherence rejects it against the &str and String impls, since nothing stops those types from gaining an IntoIterator impl later. Three argument types that compiled before no longer do: &String, Cow<'_, str>, and Box<str>. Pass a &str at the call site instead - match_on(name.as_str()) for a &String, match_on(name.as_ref()) for a Cow<'_, str>, match_on(&*name) for a Box<str>.

  • A dotted only/except entry now narrows its top-level prop instead of excluding it entirely. Before this fix, X-Inertia-Partial-Data: user.name made should_include_eager look for an exact-match "user" entry, found none, and silently dropped the whole user prop - a client asking for one field of user got nothing. Any frontend page component that happened to rely on that gap (treating a dotted router.reload({ only: [...] }) as equivalent to omitting the key) now receives { user: { name: ... } } instead. No code changes are required - this is what the Inertia v3 protocol already specifies the request/response contract to mean. The same fix applies to should_include_optional, and its effect is operationally bigger: a dotted only entry (permissions.read) now counts as an explicit request for an Optional or Defer prop's top-level key, which previously required a bare entry (permissions) to trigger at all. A request that used to skip that prop's resolver entirely now runs it - if the resolver hits a database or an external service, a client already sending dotted partial-reload requests starts issuing that work on requests that previously did none. Watch resolver call volume after upgrading if your app has Optional/Defer props with dotted partial-reload traffic.

  • InertiaSharedData::share now takes the page component name. Add a component: &str parameter after req:

    -async fn share(&self, req: &dyn InertiaRequestExt) -> Result<IndexMap<String, Prop>, FrameworkError>
    +async fn share(&self, req: &dyn InertiaRequestExt, component: &str) -> Result<IndexMap<String, Prop>, FrameworkError>
    

    Ignore it (_component) if your provider doesn't need to vary by page - Laravel's RenderContext carries the same pairing (component, request) for ProvidesInertiaProperties::toInertiaProperties.

  • Prop is a struct, not an enum. Its variants are gone; construct and read props through methods:

    • Prop::Eager(v) -> Prop::eager(v)
    • Prop::EagerNone -> Prop::absent()
    • Prop::Always(v) -> Prop::eager(v).always()
    • Prop::Lazy(r) -> Prop::from_resolver(r) (Prop::lazy(closure) is unchanged)
    • Prop::Optional(r) -> Prop::from_resolver(r).optional()
    • match prop { Prop::Eager(v) => … } -> prop.as_value()
    • matches!(prop, Prop::Lazy(_)) -> prop.is_lazy(); matches!(prop, Prop::EagerNone) -> prop.is_absent() The DeferConfig, MergeConfig, OnceConfig, and ScrollConfig payload structs are removed - their fields are flags on Prop now. Prop::is_deferred() is renamed Prop::has_resolver(), which is what it always meant. DeferOptions, OnceOptions, MergeStrategy, ScrollMetadata, and every InertiaResponse builder method are unchanged, so an app that only uses the response builder needs no edits. Apps that build props by hand - typically an InertiaSharedData implementation - need the renames above.
  • This fix protects sessions you already have, not only requests from here on. Upgrading alone is enough: a session cookie written by an earlier release can carry a _previous.url that was never sanitized, and SessionData::previous_url() now discards it on read the first time that session is used post-upgrade, rather than trusting it because it's already stored. You don't need to invalidate existing sessions, migrate the session table, or force a re-login. A request whose path looks protocol-relative (//host) also no longer updates the recorded previous URL going forward - if your app's fallback! route (or any 200-answering route reachable on an unusual path) ever legitimately relied on such a path becoming the Redirect::back() target, it won't anymore. Either way, the previous, safe value in the session is left in place instead (or Redirect::back(fallback)'s own fallback wins, if nothing safe was ever recorded). No code change is needed unless you were depending on the exact edge case this closes, which was already an open-redirect risk.

  • Drop the [0] from every errors.<field> binding in your pages. With the new default shape errors.email is a string, so errors.email[0] renders its first character instead of the message. Change the TypeScript type from string[] to string at the same time. If you would rather not touch your pages, set InertiaConfig::with_all_errors(true) on the config you pass to Inertia::install and add the errorValueType: string[] module augmentation for @inertiajs/core. The starter frontends ship the new shape.

  • A handler that hand-rolled the redirect-back after a validation failure can delete it. The bridge is automatic now; a handler that still redirects itself keeps working, because the middleware only acts on a 422 that carries a populated errors object.

  • A crashed suprnova serve child now respawns instead of ending the session. If you relied on a crash stopping suprnova serve outright (a CI smoke check, a script that treats exit as "something's wrong"), pass --no-restart to restore that behaviour exactly. Retries are also bounded by default: a process that crashes 5 times in a row stops being retried (raise the limit with --restart-tries, or use --no-restart for the original one-crash-and-done behaviour).

  • Model::TOUCHES is no longer an inherent const. Code that read Comment::TOUCHES directly needs use suprnova::EloquentModel; (or suprnova::eloquent::EloquentModel) in scope - the const moved there so the parent-touch cascade, a Model trait default, can read it. A grep -rn TOUCHES over your app finds every call site; most apps have none, since the const previously did nothing at runtime.

  • RelationEntry gained a field. Only code that constructs a RelationEntry by hand needs a change - add related_updated_at_column to the literal. The macro-generated relation registrations the framework ships already emit it, so an ordinary app doing nothing but declaring relations through #[suprnova::model] is unaffected.

  • Router::view with non-object props now panics at boot. It previously registered silently with an empty prop bag; view delegates to Router::inertia, which requires an object (or null) and panics otherwise. If a view call might carry non-object props, switch to Router::try_inertia and handle the Err - otherwise nothing changes for you.

  • The Inertia version manifest default can change your version string the moment a build exists. An app or test that hardcodes X-Inertia-Version: 1.0 keeps working only until a Vite manifest shows up on disk; once one does, the version becomes the manifest hash instead. If you need the old constant, read it from VersionResolver::from_manifest(path) yourself or pin .version(...) explicitly. Expect the first deploy after upgrading to force one full-page reload cycle for already-connected clients - one-time, and the point of the change. The no-manifest fallback value is exported as suprnova::MANIFEST_VERSION_FALLBACK, so you never need to hardcode "1.0" again.

  • Move Inertia::install and global_middleware! registration out of bootstrap::register. Put them in a new function and pass it to .http_bootstrap(...) instead - the scaffold's new shape is a sync register_http_stack() called as .http_bootstrap(|| async { bootstrap::register_http_stack() }). Apps that skip this keep today's behavior, worker-boot failure on a missing frontend manifest included.

1.2.4 - 2026-08-18

Security

  • The maintenance-mode bypass secret is compared in constant time. MaintenanceMiddleware matched the secret URL with a plain string compare, which returns at the first differing byte. Because the secret is a bearer credential carried in the request path, that timing difference told an attacker how long a prefix they had guessed correctly. The compare now runs over the full byte length via subtle::ConstantTimeEq, short-circuiting only on a length mismatch - the same shape as the bypass-cookie compare next to it.

  • rules::Url now rejects script URIs. The rule accepted any scheme url::Url could parse, javascript: and vbscript: included, so a validated URL could still be a script-execution sink when rendered into an href. It now applies Laravel's url rule shape (Illuminate\Support\Str::isUrl's ^(PROTOCOLS)://HOST pattern): the scheme must be on Laravel's allowlist, be followed by ://, and be followed by a non-empty host - Laravel's host group has no ?, so an absent or empty host never matches even with a listed scheme. The scheme list and the ://-plus-host requirement are Laravel's verbatim; the host itself is parsed by the url crate rather than Laravel's regex, so a few edge cases still differ - an out-of-range port is rejected here and accepted there, and IDN hosts normalise differently. New Url::protocols(&[...]) mirrors Laravel's url:http,https; HttpUrl is now literal sugar for it and keeps its own message. Behaviour change: a URL with an unlisted scheme that used to validate now fails - name the scheme with Url::protocols(&["myapp"]) if you meant to accept it. Two more behaviour changes: mailto:, data:, and tel: are on Laravel's allowlist by name but don't carry an authority component, so they now fail; and file:///etc/passwd-style paths - scheme:// with nothing between the last two slashes - now fail too, since an empty string isn't a host either. Both follow from Laravel's own ://-plus-host rule.

  • Inertia responses now advertise Vary: X-Inertia everywhere. The header was set only on the page-object responses themselves. Redirects, 404s, 422s, and static responses carried none, so a shared cache keyed on the URL alone could serve the JSON page object to a hard browser navigation, or the HTML shell to an Inertia XHR. The new InertiaHeadersMiddleware - registered by Inertia::install as the outermost of the three - sets it on every response, and turns an empty 200 on an Inertia visit into a 303 back rather than a response the client rejects as non-Inertia. InertiaVersionMiddleware now re-flashes the session before its 409, so a flashed error survives the client's follow-up full-page GET.

  • Three Inertia response fixes. InertiaResponse::location_for(&req, url) returns 409 + X-Inertia-Location for an Inertia XHR and a plain 302 + Location for a hard navigation, so an OAuth or SSO bounce entered outside the SPA no longer dead-ends on a body-less 409. The existing location(url) keeps its always-409 shape. New App::clear_history() flashes the history-clear flag into the session so it survives the logout redirect and lands on the page that actually renders - the per-response .clear_history() marked only the redirect the browser throws away, leaving the previous session's encrypted history decryptable. And a once prop is now skipped only on a full Inertia visit: an explicit router.reload({ only: ['stats'] }) re-resolves it instead of returning nothing.

  • The SES transport now sends custom message headers. Mail::to(..).header("List-Unsubscribe", ...) and Mailable::headers() were dropped silently under MAIL_DRIVER=ses: the Content.Simple request body had no Headers field and the raw-MIME builder never read OutgoingMessage::headers, even though every other transport forwards them. Both SES paths now carry them - Headers as SES v2's {Name, Value} list, raw MIME as real header lines - so unsubscribe links, threading headers and routing hints survive a driver swap. Header names are validated up front on both paths - CR, LF and NUL (the injection bytes, as the Mailgun transport already refuses) and anything that is not a valid RFC 5322 field name (spaces, colons, non-ASCII) - so attaching a file never changes whether a message is accepted.

Fixed

  • Nested validation failures now reach the 422 body. #[validate(nested)] failures on a nested struct or on an element of a validated Vec<T> were dropped between the validator and the response: the request was correctly rejected with 422, but the errors map came back empty, so no message rendered and the client could not tell which field was at fault. Nested failures are now flattened into Laravel's dotted notation - address.street, items.1.name, order.items.2.sku - alongside the top-level ones.

  • The Inertia page object's url keeps the query string. page.url was the request path only, so the client recorded /users for a visit to /users?page=2&sort=name. Every back/forward navigation and every router.reload() then replayed the page without its pagination cursor, sort, or filters. It is now path plus query - the same derivation InertiaVersionMiddleware already used for X-Inertia-Location, so by default the two agree byte for byte. New InertiaConfig::url_resolver(...) overrides how the page object names the page (Laravel's Inertia::resolveUrlUsing); the version bounce keeps naming the URL that arrived, because that is the URL the browser has to fetch.

  • Inertia::install now applies its config to every response. The config handed to Inertia::install was read for three fields and then dropped, so every InertiaResponse built without an explicit .with_config(...) rendered from InertiaConfig::default(). An app scaffolded with --frontend react served the Svelte entry point and no React refresh preamble unless SUPRNOVA_FRONTEND was set in the environment; SSR enabled on the config never reached a response; and the page object's asset version came from a different config than the version middleware's resolver. The installed config is now retained on the container's Inertia registry and is what InertiaResponse::new starts from. Per-response .with_config(...) still overrides, apps that never call Inertia::install are unchanged, and a failed (fail-closed) install retains nothing. As a side effect the production Vite manifest is now parsed once per process rather than once per response.

  • Scaffolded apps now install the Inertia protocol middlewares. The bootstrap.rs written by suprnova new registered the session, locale, CSRF and include middlewares but never called Inertia::install, so a generated app had neither InertiaVersionMiddleware nor Inertia303Middleware: a browser still running the previous bundle was never told to reload after a deploy, and a PUT/PATCH/DELETE that redirected stayed on a 302 the client could follow with the original verb. The call now lands after SessionMiddleware - where the version middleware's session re-flash works - with a named INERTIA_VERSION constant to bump when assets change, and it pins the frontend the project was generated with (.frontend(Frontend::React) for --frontend react), so the HTML shell loads that framework's Vite entry point instead of falling back to Svelte's. The generated .env now sets SUPRNOVA_FRONTEND to match. The --api starter is unchanged; it has no frontend.

  • Queue::push_unique no longer reports a queued job as skipped. The return value was computed with matches!(outcome, Idempotent::Fresh(())), which folded Idempotent::FreshUnfenced into false - the outcome where the envelope was pushed but the dedupe lease was lost mid-push. Callers branching on that boolean were told a job that was about to run had been suppressed as a duplicate. All three outcomes are now matched exhaustively: a lost lease returns true with a warn naming the job and its unique key, and only a real duplicate returns false. push_unique_later and later_unique share the path and are fixed with it.

Changed

  • Parity baseline moved to Laravel 13.25.0. The 13.23.0, 13.24.0 and 13.25.0 release notes were traced item by item to the framework's own surface. Everything that reached a Suprnova code path is either fixed in this release or has a row in manual/parity.md marked not yet or by design no.

Upgrading

Two changes can alter a running app without any code change on your side.

  • Settings on the config you pass to Inertia::install now take effect. They were read for three fields and dropped. If your install config sets .ssr(...), SSR is now on: start the worker (suprnova ssr:start) before deploying, or drop the .ssr(...) call. .entry_point, .assets_base_url, .default_title and .encrypt_history(...) set there also reach the page now.

  • rules::Url rejects more. Values that used to pass and no longer do: any scheme outside Laravel's allowlist, javascript: and vbscript: among them; mailto:, data: and tel:, which are on the allowlist but carry no :// host; and scheme:// with an empty host, such as file:///path. If you meant to accept a scheme, name it: Url::protocols(&["myapp"]).

1.2.3 - 2026-08-16

Fixed

  • Datetime casts now read database-native CURRENT_TIMESTAMP text. AsDateTime, AsImmutableDateTime, and AsOptionalDateTime continue to write canonical RFC-3339, while reads also accept PostgreSQL's timezone-bearing text and timezone-free SQLite/MySQL text. Timezone-free values are interpreted as UTC, matching the framework's UTC timestamp contract.

1.2.2 - 2026-08-14

Fixed

  • Nullable non-text values now work across attribute-based writes on PostgreSQL. Typed Builder::update_all and Builder::upsert, model-less DB::table().insert/update, and many-to-many pivot extras render explicit JSON nulls as SQL NULL while continuing to bind every non-null value. This preserves the target column's type instead of sending a text-typed null parameter that PostgreSQL rejects for bigint, integer, boolean, timestamp, and other non-text columns. Multi-row upserts now also reject missing or extra columns instead of silently converting a malformed row shape to null. Automatic many-to-many pivot timestamps are bound as typed UTC datetimes instead of text.

Security

  • The release gate now distinguishes dormant lockfile metadata from compiled dependencies across the whole workspace. Cargo records rust_decimal's unused optional rkyv 0.7 compatibility dependency in Cargo.lock; the gate now proves that neither rkyv nor its derive crate is reachable from any workspace member, feature, target, or dependency edge. The corresponding RustSec exception is owned, expires on 2026-11-14, and must be removed when rust_decimal no longer records that legacy optional dependency.

1.2.1 - 2026-08-09

Changed

  • Suprnova moved to the eas4ai GitHub organization. Repository URLs in package metadata, documentation, dependency examples, and scaffold templates now use github.com/eas4ai. New projects also use the monitored shawn@eas4ai.com author email. This release made no runtime behavior changes.

1.2.0 - 2026-08-05

Added

  • The manual ships in seven languages. manual/es/, manual/fr/, manual/de/, manual/pt-BR/, manual/ja/ and manual/zh-Hans/ each carry the full 104-chapter manual - every chapter, the table of contents, and this changelog - translated from the English source. English remains canonical: chapter structure, code blocks, identifiers, CLI commands and environment variables are held byte-identical to the source, so a translated chapter can never disagree with the English about what the framework does, only say it in the reader's language.

    The translations were produced and reviewed for suprnova.app, which renders this manual as its /docs. Every section carries a review ledger there: verdicts are recorded against content hashes of both the English and the translation, two independent reviewers must pass the exact bytes for a section to count as approved, and per-locale glossaries pin the terminology rulings (which terms stay English, which take the native word, and why). Corrections are welcome in either repo - a fix here reaches the site on its next sync.

1.1.0 - 2026-08-02

Added

  • Per-locale fallback chains. LocalizationConfig gains parents (APP_LOCALE_PARENTS, comma-separated child=parent pairs, or the chainable .parent(child, parent) builder): a locale can inherit from a configured sibling before falling further back to the global fallback_locale - pt-PT from pt-BR, en-AU from en-GB, and so on, transitively. Lang::get/try_get/get_with/try_get_with/has all walk the chain, current locale first, so this works for any Translator driver, not just the bundled one. A malformed pair, an invalid locale, a child named twice, or a cycle (including a locale naming itself as its own parent) fails loudly at config load rather than degrading at request time.

    Served catalogs stay chain-flattened ahead of time: FluentTranslator now builds each locale's /_suprnova/lang/<locale>.ftl catalog as a fold - the embedded framework catalog at the bottom for en/en-* locales, then the locale's configured parent chain, then its own *.ftl files - so a chained locale is still one self-contained file the browser fetches once, with no client-side chain awareness needed. Flattening covers configured parents only; the terminal fallback_locale is still a Lang-facade-level fallback, not baked into the served bytes.

    This makes delta-style catalogs practical: a lang/pt-PT/ directory can hold only the handful of strings that actually differ from lang/pt-BR/, rather than a full duplicate catalog. The merge that makes it possible works at the Fluent AST level - a child's value replaces the parent's, attributes merge by name (an override that doesn't mention an attribute no longer loses it), select expressions replace whole (CLDR plural categories are locale-dependent, so variant-by-variant merging isn't coherent), and child-only entries append. See manual/localization.md's new "Fallback chains" section for the full contract.

Changed

  • LocalizationConfig gained the parents field. from_env() and the builder are unaffected; a literal struct constructor (tests building a LocalizationConfig by hand) needs one more field.
  • Served catalog text is now serializer-normalized for every locale, and intra-locale multi-file merging (several .ftl files in one locale directory) now goes through the same AST-level merge as parent chains rather than simple bundle-overriding. Resolved translations are unchanged except for the two strict improvements below; the underlying bytes rotate regardless - ETag/?v=<hash> rotates once on upgrade. The improvements: an override no longer silently drops the attributes it doesn't mention, and an attributes-only override no longer strips the message's own value (previously an error or a fallback resolution; it now resolves to the earlier override's value).

1.0.0 - 2026-08-02

Added

  • Localization. Message catalogs in lang/<locale>/*.ftl (Fluent), a Lang facade with the __!("key", name: value) macro, per-request locale detection (LocaleMiddleware: session → cookie → Accept-Language → APP_LOCALE), and locale-aware formatting for numbers, currency, dates, times, lists, and relative times over ICU4X. manual/localization.md is the chapter.

    The built-in validation rules stop hardcoding English. Each returns a keyed message (validation-min plus its arguments and an English fallback), translated once at the serialization boundary - so a Spanish app gets Spanish validation errors by dropping in lang/es/validation.ftl, with no rule wrapping and no forked copy of the framework's messages. Field names humanize through a field-<name> lookup. Rule::passes (and ContextualRule / AsyncRule) now return Result<(), ValidationMessage>; a custom rule's Err("…".into()) body still compiles and still renders verbatim, but the signature in your impl needs the new type.

    The browser gets the same bytes the server resolved: the merged catalog is served at /_suprnova/lang/<locale>.ftl with an ETag and an immutable ?v=<hash> form, the three starter kits parse it with @fluent/bundle, and suprnova generate-types emits a MessageKey union so renaming a message points the TypeScript compiler at every call site.

    Fluent rather than Laravel-style PHP arrays because one format has to serve both the server and the browser, and because CLDR plural categories are what gets Russian, Polish, and Arabic right - trans_choice's integer ranges cannot, which is why there is no trans_choice here. Behind a default-on localization feature; --no-default-features still compiles and still validates, using the embedded English fallbacks.

  • IntoInertiaScroll for Paginator. The trait was implemented for LengthAwarePaginator and CursorPaginator but not for the simple paginator, so simple_paginate results could not feed Inertia::paginate at all - despite simple.rs's own module docs pointing at it as the URL-generation path. That left offset-paginated Inertia collections with a choice between a COUNT(*) per request and hand-rolling the scroll metadata. next_page comes from the LIMIT n+1 overflow probe rather than a computed last page, there being no total to compute one from.

Fixed

  • suprnova generate-types emitted a different file on every run. The topological sort seeded its work queue by iterating a HashMap, and Rust randomises hash iteration order per process, so consecutive runs ordered the same interfaces differently. The output is a checked-in artifact, so every run produced a diff - and a generated file that churns for no reason is one people stop regenerating, after which it quietly stops describing the Rust it claims to. The directory walk is sorted too, so the output no longer depends on filesystem order either. Two runs of the same source are now byte-identical.

  • topological_sort did the opposite of its doc comment, emitting dependents before dependencies. Harmless - a TypeScript interface may reference one declared later in the same file - so the comment is corrected rather than the order, which would have reshuffled a tracked file for no benefit.

0.9.1 - 2026-08-01

Three defects, all found by running the dogfood app under a containerised harness rather than by reading the code. Every one of them is invisible to a test suite that never stops a process the way production stops it.

They compound in a specific order: a rolling deploy SIGKILLs a worker mid-job (the first), and that job then takes a reclaim path that never counted the attempt (the second).

Fixed

  • schedule:work, queue:work and workflow:work ignored SIGTERM. Each selected on tokio::signal::ctrl_c() alone, which installs a SIGINT handler - so SIGTERM had no handler anywhere in the process, and SIGTERM is what docker stop, Coolify, systemd and Kubernetes send. All three already had a careful bounded drain behind that select!; none of it had ever executed under a supervisor. Measured before the fix: a docker stop on a queue:work container burned its whole 40s grace window and exited 137 with the in-flight job destroyed. As PID 1 - which is what a container runs - the kernel discards an unhandled SIGTERM outright, so the process did not die badly; it did not die at all until SIGKILL. Server::run already handled both signals correctly and its listener is now shared, which also closes a missed-signal window in the scheduler's loop.

  • A job that killed its worker could never be dead-lettered. A job whose handler fails is nacked and its attempt counted, so it dead-letters after max_tries. A job that kills its worker - OOM, abort, segfault, or the SIGKILL above - settles nothing; its reservation merely lapses, and every driver used to redeliver it byte-identical. Such a job is immortal: it kills each worker that claims it, comes back unchanged, and kills the next one, for as long as anything restarts workers. All three drivers now charge the attempt where they learn a worker died, because swapping QUEUE_DRIVER must not change whether a poison job can be stopped. attempts now means "deliveries to a worker" rather than "handler failures" - documented in manual/queues.md, because a worker lost for unrelated reasons burns an attempt too.

  • …and the exhausted job is now dead-lettered before it is dispatched. Counting the attempt was necessary and not sufficient. Every dead-letter decision lived in the worker's settlement path, which assumes the handler returns - so it never ran for exactly the jobs that could not return. With the driver fix alone the counter climbed (measured: 0 → 1 → 2 across three killed workers) and nothing acted on it. The budget is now spent before the handler runs. Caught only by re-running the container experiment after the first fix looked correct.

  • The daemons had no tracing subscriber. serve gets one from init_telemetry; queue:work, schedule:work, schedule:run and workflow:work come through a different boot path and got nothing, so every tracing:: line they emit went nowhere and LOG_LEVEL was inert for them. That is most of what they have to say - a worker dead-lettering a job, a scheduler skipping a tick it lost, a lock it could not release. In a container the only visible output was the startup banner, and the process looked idle while doing all of it. Two of the defects in this release were invisible until this was fixed.

  • A dead-letter with no failed-jobs store bound was a silent deletion. The persist step sat inside if let Some(store) = .., so with no store the arm did not match and execution fell through to the ack - quieter than the failure path directly above it, which at least leaves the reservation intact. An absent store was treated as more successful than a broken one. It now logs the full envelope at ERROR, because that is what queue:retry re-pushes: the difference between work recoverable by hand and work that ceased to exist.

  • QUEUE_DRIVER=database now binds a failed-jobs store. failed_jobs is part of that driver's contract - queue:retry reads it and Queue::retry_failed cannot work without it - but bootstrap_from_env wired the driver and left the store unset, so a database-backed queue dead-lettered into nothing unless the app bound one by hand. Configurable via QUEUE_FAILED_DB_TABLE. Only for this driver: memory is ephemeral by construction and redis has no table to write to.

  • Redis reclaim latency now follows --visibility-timeout. The flag sets XAUTOCLAIM's idle threshold, but a separate clock governs how often a consumer looks, and the driver left it at sea-streamer's 30s default - so --visibility-timeout 5 really meant "up to 35 seconds". The interval now tracks the configured timeout, clamped to 1s..=30s so a short timeout cannot become an XAUTOCLAIM storm and a long one can only make reclaim faster than before.

Added

  • TaskBuilder::on_one_server() / on_one_server_for(ttl) - run a scheduled task exactly once per due tick across replicas. Without it nothing elects a leader for a tick: each schedule:work process evaluates the schedule independently, and three replicas were measured running every due task three times, every minute, with no variance. A nightly billing job on three replicas billed every customer three times.

    without_overlapping() does not cover this and cannot: its lock is keyed on the task and released when the handler returns, so a fast task frees it before a second replica looks. on_one_server keys on the task and the tick and holds the lock past the handler, letting it expire on TTL. The two compose.

    Opt-in, matching Laravel. Diverges from Laravel in failing closed: the election is only as shared as the cache behind it, so a production boot with CACHE_DRIVER=memory and a single-server task is refused, naming the offending tasks, with SCHEDULE_ALLOW_MEMORY_LOCK_IN_PRODUCTION=true for deployments that genuinely run one scheduler.

Changed

  • manual/deployment.md no longer says "run exactly one schedule:work process" as the only option, and gains a Stopping cleanly section covering the drain windows per subsystem, how to size a platform's termination grace above them, and why PID 1 makes a missing signal handler worse than it sounds.

0.9.0 - 2026-07-31

Security

  • Auth issuance could only be throttled per caller, never per recipient. An address-keyed limit answers "is one client noisy"; it cannot answer "is one mailbox being flooded". An attacker spread across a botnet or a single IPv6 /64 stayed under every per-IP budget while filling one victim's inbox with password-reset mail, and nothing in the framework could express the limit that would have stopped it - a key function could read the path, headers, and query string, but not a form-encoded body, so the address was invisible on exactly the route that carries it.

    identity_key keys a bucket on the account being acted on. It reads the query string first and then a buffered form body, so one key function covers both shapes; the value is trimmed and lowercased, because Alice@Example.com reaches the same mailbox as alice@example.com and a limit bypassed by holding down shift is not a limit; and it is hashed, because a rate-limit backend is frequently a shared Redis with weaker access control than the primary database.

    Two new middleware builders support it. key_reads_body(cap) buffers the body before keying - opt-in, because buffering is work an unauthenticated caller gets to make you do, and a body over the cap is refused with 413 rather than passed through unkeyed. only_when(pred) skips a limiter entirely for requests it has nothing to say about, which is what keeps a stacked per-recipient budget from silently becoming the binding limit on routes that name no recipient.

    The dogfood app now stacks both on its issuance group: 10 per 5 minutes per address, 3 per 15 minutes per recipient.

A review of Torii's session, password, OAuth, and passkey paths turned up eight defects, all fixed in the pinned fork (suprnova-torii-rs 968b0be).

  • Expired sessions could be refreshed back to life. The SeaORM session repository's refresh had no expiry predicate and unconditionally extended expires_at, and OpaqueSessionProvider::refresh_session skipped the is_expired() check that get_session performs. A token held past its expiry could be renewed indefinitely. Fixed at both layers. Not reachable through Suprnova's own surface - neither Torii nor the framework exposes session refresh - but it is public API of both crates.
  • The login form leaked which accounts exist, by timing. Authentication returned as soon as the email missed, skipping Argon2 entirely: measured at 54µs for an unknown address against 719ms for a wrong password, a ~13,000x gap readable over a network. Both failure paths now verify against a dummy hash so they cost the same. This one was reachable through Suprnova's password login.
  • The JWT iss claim was written but never verified. Algorithm pinning was already correct - alg: none and HS/RS confusion were never possible - but the issuer was decoration, so two services sharing a signing key would accept each other's sessions. Now enforced when an issuer is configured.
  • A single-use PKCE verifier could be claimed twice. Consumption was a read followed by a delete, so two OAuth callbacks for the same csrf_state could both read it before either delete landed. Now claimed in one operation - DELETE ... RETURNING on Postgres, a primary-key delete whose affected-row count picks the winner on SeaORM.
  • Expired sessions were listed as active. find_by_user_id had no expiry filter, and expired rows survive until cleanup runs, so a "devices you're signed in on" screen offered users dead sessions to revoke while saying nothing about the live one.
  • A passkey lookup was named authenticate. Torii's PasskeyService::authenticate_credential took a credential ID and returned the owning user, and PasskeyAuth::authenticate minted a session from it. Torii stores passkeys - it carries no WebAuthn dependency and cannot verify an assertion, so the only thing those calls proved was that the caller knew a credential ID: a value the browser sends in the clear and allowCredentials hands to anyone who can start a ceremony. Renamed to find_user_by_credential and create_session_for_verified_credential, both documenting that verification is the caller's job. Not reachable through Suprnova, which drives webauthn-rs itself (see torii_integration::passkey) and reaches Torii only for credential storage.
  • A WebAuthn challenge was replayable for its whole TTL. Neither backend consumed a challenge on read, and the SeaORM get_challenge also ignored expires_at entirely, returning expired challenges as live. Reads now exclude expired rows on both backends, and a new take_challenge claims one exactly once - the same delete-decides-the-winner shape as the PKCE fix.

Breaking

  • Azure Blob Storage and Google Cloud Storage moved behind the new filesystem-azure and filesystem-gcs features. Storage::register_azblob, register_azblob_with, register_gcs, register_gcs_with, AzBlobConfig and GcsConfig no longer exist unless you enable the matching feature. If you use either backend, add it to your dependency:

    suprnova = { git = "…", tag = "v…", features = ["filesystem-gcs"] }
    

    You get a compile error naming the missing item, not a runtime failure.

    Both opendal service crates pull rsa, which carries RUSTSEC-2023-0071 (the Marvin timing attack) with no fixed release upstream. They were the only crates enabling reqsign-core/jwt, the feature reqsign-core's optional rsa sits behind, so gating them severs all three opendal paths to it at once. rsa is now avoidable: --no-default-features --features filesystem,database-postgres resolves without it and still has the storage subsystem. Previously no feature combination could shed it while keeping storage at all.

    A stock default build still carries rsa - database-mysql is a default feature and sqlx-mysql 0.8.6 depends on it non-optionally - so the audit exception stays open. S3 is deliberately not gated: reqsign-aws-v4 takes reqsign-core without jwt, so the S3 driver never contributed a path, and gating it would break the most-used cloud backend while removing nothing.

Added

  • suprnova --version, with -v as well as clap's default -V. Asking a CLI its version with the flag every other CLI uses should not print a usage error.

Fixed

  • Two Redis operations had no upper bound. The cache's tag flush read a tag's whole member set with SMEMBERS and deleted key by key, so a tag with a large membership stalled the connection and a concurrent write could be lost between the read and the delete; tags are now generation-based, flushed atomically, and scanned with a bounded SSCAN. The delayed-queue promotion pass moved every due job in one unbounded ZRANGEBYSCORE, so a backlog that came due together produced a single enormous script; it now promotes in batches.
  • Two shutdown drains waited forever. schedule:work on Ctrl-C and the workflow worker after cancellation both awaited every in-flight task with no deadline, so one task that never returned held the process open until SIGKILL - an operator sees a daemon that "doesn't stop". Both now wait a bounded grace, then abort what remains and report the count.
  • The release version-pin sweep only recognised one of the two pin syntaxes, so every file carrying a cargo install --tag vX.Y.Z line and no dependency snippet was never discovered. suprnova-cli/README.md had been telling readers to install v0.6.0 for three releases; manual/cli.md and manual/cli-new.md sat at v0.7.2; manual/installation.md carried both forms and had one bumped while the other froze. Discovery and rewrite now read from one pattern table, and a file's rules are derived from its content.
  • cargo doc failed for any build with filesystem but without testing - seven Storage::fake intra-doc links could not resolve, and lib.rs denies broken links. testing is a default feature, so no gate step had ever built that combination; check-feature-matrix.sh now does.
  • Torii's migrations could not be replayed over their own schema, so a database holding it without the torii_migrations tracking table - restored from a dump that skipped it, or migrated by hand - could not be brought under management. Every Table::create() carried .if_not_exists(); none of the 19 Index::create() calls did, nor did the ADD COLUMN locked_at alter, so replay sailed through the tables and died on the first CREATE INDEX. Fixed in the pinned fork (suprnova-torii-rs a0f956d) via has_index / has_column rather than IF NOT EXISTS, which sea-query silently drops for MySQL - the syntactic fix would have left a default-featured build broken.
  • A failed Torii migration aborted the process instead of returning an error. SeaORMStorage::migrate unwrapped the migrator and returned Ok(()) unconditionally, so init_torii's mapping of the failure into a FrameworkError was unreachable code.
  • An app's own users table silently suppressed Torii's, because .if_not_exists() cannot tell "already mine" from "already somebody else's". The migration reported success and authentication failed later on a missing column - the reason the --api starter names its table app_users. Torii's migration now warns at migrate time when an existing users table lacks columns it requires, naming the columns and the remedy. It stays a warning rather than a hard failure so existing deployments keep booting.
  • The Railway and DigitalOcean deployment guides pointed the platform health check at a path that could probe Postgres. Both platforms restart the container when that check fails, so following the advice turned a database blip into a restart loop across every replica. Both now use /_suprnova/health/live, with the database probed by hand from the console. The legacy paths still resolve; nothing already deployed needs changing.

0.8.0 - 2026-07-30

Remediation of an external red-team audit. The audit returned 19 P1 findings and a NO-GO verdict for 1.0; this release closes all nineteen, plus a number of defects found while fixing them that the audit had not named.

Several fixes deliberately turn a silent misconfiguration into a refused boot. Read Upgrading before deploying - a production app that has been running happily may not start.

Upgrading

Three configurations that used to boot with a warning (or in silence) now fail closed in production. Each error names the variable that unblocks it, and each has an explicit override for the deployment where the risk is genuinely absent.

  • A non-delivering mail driver. MAIL_DRIVER unset, log, memory, or an unrecognised value all resolved to a transport that renders mail and discards it - so password resets reported success while nothing was sent. Override: MAIL_ALLOW_NON_DELIVERING_IN_PRODUCTION=true.
  • Cleartext SMTP. Three of the four credential combinations landed on an unencrypted transport, and the both-unset case logged a warning and sent anyway. Override: MAIL_ALLOW_INSECURE_SMTP_IN_PRODUCTION=true.
  • The in-memory rate limiter. Its buckets live in one process's heap, so behind N replicas every quota is really N× and each deploy resets them. Point RATE_LIMIT_DRIVER at redis, or set RATE_LIMIT_ALLOW_MEMORY_IN_PRODUCTION=true if you genuinely run one process. An unrecognised driver value fails for the same reason, because it fell back to memory - RATE_LIMIT_DRIVER=Redis, capitalised, is the case most likely to reach production because it looks configured.

Development, testing and staging are unchanged in all three cases. Staging is deliberately not gated: hard-failing it pushes teams to set the override globally, which disarms the check where it matters.

Two behaviour changes that are not boot failures:

  • fill and first_or_new reject malformed values. A value that cannot decode into its field's type used to become that field's Default and return Ok - fill(attrs!{ age: "abc" }) set age = 0 and reported success. It now returns a ValidationError naming the field, and leaves the model untouched. Unknown columns are still skipped silently (Laravel parity), and numeric widening still works.
  • /_suprnova/health?db=true no longer returns the driver error. The detail moves to the log; the body keeps "database": "error". Debug builds still include it. Dashboards parsing status / database are unaffected.
  • url::signature_has_not_expired now requires a valid signature, and is deprecated. It used to answer true for a forged URL - a bad signature is not "expired", because it never had an expiry to miss - so any handler guarding on it alone accepted forgeries. It is now identical to has_valid_signature. If you were using it to tell expired from invalid (to render "request a fresh link" rather than a 403), switch to url::signature_verdict, which returns all three states. This diverges from Laravel's URL::signatureHasNotExpired, deliberately.

Two additions that need something from you only if you opt in:

  • QueueDriver gained settle and release, both with default implementations, so existing driver impls keep compiling unchanged. Implement settle if your backend can commit a follow-up write and an acknowledgement in one transaction; implement release if it can requeue a reserved message in place.
  • Batch accounting can now be durable. DatabaseBatchRepository needs two new tables, job_batches and job_batch_settlements - add them to your migrations, as with jobs and failed_jobs. The schema is in manual/queues.md. Nothing changes if you stay on MemoryBatchRepository.

Security

  • Slowloris (SEC-07). hyper's header-read timeout was documented as 30s but inert - it only arms when a timer is installed on the connection builder, and none was. A client could hold a connection, and a SERVER_MAX_CONNECTIONS permit, indefinitely. Now armed and configurable via SERVER_HEADER_READ_TIMEOUT.

  • Multipart uploads (SEC-05). The cap applied to individual part payloads but not to the raw stream, so a body could exceed the limit in aggregate. Now capped at the stream.

  • Webhook HMAC with an empty key (SEC-08). Both payment adapters accepted a blank secret, which verifies anything. Refused on both.

  • Paddle signature parsing (P2-11). An odd-length or non-hex paddle-signature reached the pinned SDK and panicked inside it. Now validated first: a malformed signature is a 401.

  • Passkey enrolment and reset tokens (SEC-01, SEC-02). Anonymous enrolment against an existing email, non-owner enrolment, and owner enrolment without recent reauth are each refused with distinct statuses. A password login now stamps the reauth window.

  • dev:tls (SEC-10). A project could choose the CA the command trusts.

  • Generated Docker Compose (P2-12). Published Postgres and Redis on all interfaces with credentials committed in this repository. Now bound to loopback with per-scaffold generated passwords, .env written 0600, and symlinked targets refused.

  • Health endpoint (P2-01, CI-05). It decided whether to query the database with query.contains("db=true") - a substring test, so ?nodb=true ran the probe too. Now parsed properly. The 503 no longer embeds the driver error, which named hosts, ports, schemas and versions.

  • Credential issuance throttling (P2-02). The four auth-issuance routes in the reference app carried no rate limit at all, and the one route that did keyed its bucket on the raw x-forwarded-for header - which any client can vary per request to get a fresh bucket. Both fixed; the issuance budget is shared across the four routes so rotating between them does not multiply it.

  • A redelivered chain step re-pushed its successor under a new id (DATA-02b, partial). Settlement pushes the next chain link before acking, deliberately: acking first means a crash in that window loses the chain permanently, and a duplicate is recoverable where silent loss is not. But the successor's envelope got a fresh Uuid::new_v4() on every push, so the duplicate produced by that trade was indistinguishable from a legitimate new step - to the driver, to an outbox, and to the handler.

    That last one is the real cost. The framework's delivery contract is at-least-once and its answer to duplicates is "handlers must be idempotent" - but a handler keyed on env.id, the only identifier it receives, could not satisfy that contract for a chained job, because the duplicate arrived under a new id every time. The contract was unsatisfiable by construction.

    The successor's id is now a UUIDv5 derived from its predecessor's, which is stable across that predecessor's own redeliveries. A redelivered step re-pushes the id it pushed before. No schema change, no new field, no new dependency.

    This makes the duplicate detectable, which is the primitive the rest of DATA-02b was missing. It does not make the push atomic with the ack (that needs the outbox), and nothing yet rejects the duplicate on the way in. Both remain open.

  • Signed URLs verified one URL and executed another (SEC-04). The canonical form collapsed query pairs into a map, so a repeated key kept only its last value - while Request::query_param returned the first. A legitimately signed ?user=victim could therefore be replayed as ?user=attacker&user=victim with the original signature untouched: verification canonicalised over victim and passed, and the handler acted on attacker.

    The canonical form now carries every pair, sorted by (key, value), so the signature covers the exact multiset of parameters - adding, removing, or substituting any value breaks the HMAC. A repeated signature or expires is refused outright, since two of either leaves no non-arbitrary answer to which one governs.

    Request::query_param now resolves a repeated key to its last value, matching query_params and Context::query_param; it was the only one of the three that disagreed, and that disagreement was the other half of the defect. Existing signed links keep working - with no repeated keys the payload bytes are unchanged, which a test pins, because a canonical-form change that silently invalidated every outstanding password-reset link would be worse than the bug.

    Six regression tests, including both attack orderings, a legitimately repeated key that must still sign and verify, and the reordering guarantee. Not changed: signature_has_not_expired still reports a forged signature as "not expired". That is Laravel's behaviour, was settled deliberately as a documentation fix, and has its own test pinning it against a well-meaning "correction".

  • RBAC under Postgres. Verified against a real Postgres rather than SQLite alone.

  • Four RustSec advisories eliminated, not renewed. The Pinecone driver was rewritten against Pinecone's REST API, dropping pinecone-sdk 0.1.2 - whose newest release dates from 2024-09-06 - and with it tonic 0.11 → rustls 0.22 → rustls-webpki 0.102 and RUSTSEC-2026-0049 / -0098 / -0099 / -0104. All four were fixed upstream in rustls-webpki >= 0.103.13, which this workspace already resolved for its other TLS users; one abandoned crate held the tree on the vulnerable line. .cargo/audit.toml is down from five ignores to one. See Changed for what this means for the driver's API.

  • Audit exceptions now expire. Every entry in .cargo/audit.toml carries an OWNER and an EXPIRES date, and scripts/check-audit.sh fails the release gate on a missing owner, a missing or unparseable date, or a lapsed one. cargo audit has no notion of an expiring ignore, so one added "temporarily" stayed until somebody re-read the file. The remaining entry (RUSTSEC-2023-0071, rsa, which has no fixed release at all) is owned and dated.

  • Reachability claims are checked, not asserted. scripts/check-feature-matrix.sh resolves real dependency trees and asserts that no build - including --all-features, which is what cargo audit actually reads - contains pinecone-sdk, rustls-webpki 0.102.x or tonic 0.11.x. An exception justified by a comment nothing verifies stops being true the first time someone adds a dependency.

Fixed

  • Every release on a database-backed queue was silently a no-op. JobOutcome::Released - a busy WithoutOverlapping lock, a rate-limiter backoff - was implemented as "push a copy, then ack the original". The envelope id is the jobs table's primary key, so the copy collided with the row still holding the live reservation and the push failed with UNIQUE constraint failed: jobs.id. The worker then correctly declined to ack, so the requested delay was never applied, no JobReleased event fired, and the job simply parked until visibility expiry redelivered it. Releases are now one driver call, done in place.
  • A partial batch dispatch orphaned the jobs it had already queued (DATA-02). When a driver.push failed mid-loop, PendingBatch::dispatch deleted the batch row - but the envelopes already in the queue were still stamped with that batch id, so each of them settled against a batch that no longer existed, returning Err(batch not found) on every delivery, forever. The batch is now settled instead: undispatched jobs are recorded as failures and the batch is cancelled, so the queued ones settle normally and the terminal callbacks still fire.
  • Nothing tested that url::has_valid_signature rejects a forged URL. Found while verifying the SEC-04 fix: the entire framework suite passed with the primary signed-URL guard rewritten to accept any signature.
  • A scaffolded app could not migrate its database or build its image (REL-01b). Neither scaffold declared default-run, so all nine CLI wrappers that shell out to cargo run failed on a fresh project. The generated Dockerfile had five independent defects - a missing lockfile COPY, npm ci without a lock, a cache stage stubbing one of two declared binaries, a frontend build copied from a path vite never creates, and a missing frontend/src/pages copy that inertia_response! validates at compile time. A stock scaffold's image could not build.
  • docker:init emitted one Dockerfile for every project type. On an --api project its first instruction, COPY frontend/package.json, failed outright. API projects now get a frontend-free Dockerfile.
  • SQL placeholders (DATA-01). Rendered per backend rather than assuming one dialect.
  • Queue settlement (DATA-02a, P2-06c). Follow-ups settle before the reservation is acked, and a lock-release error no longer converts an already-succeeded job into a retry.
  • A cancelled batch fired Catch, never Then.
  • Builder::clone silently dropped the eager-load plan (P2-09a). User::query().with("posts") cloned anywhere - pagination, count(), any scope that clones - returned rows with no relations and no error.
  • Presence rosters lost members (P2-08). The roster was snapshotted before subscribing, so anyone joining in that window appeared in neither, permanently.
  • Pinecone serialised every index acquisition (P2-14). The write lock was held across two network round trips, and tokio's fair RwLock meant one cold index stalled every warm one.
  • The type watcher discarded bursts (P2-13). Leading-edge debounce regenerated on the first file of a burst and dropped the rest with no trailing run, so the last save never took effect.
  • ssr:check could hang, and tried one address (P2-13). DNS ran outside the timeout entirely, and only the first resolved address was tried - so a host with an AAAA record and no IPv6 route reported the worker down while it was listening on v4.
  • suprnova serve installed cargo-watch unpinned (P2-13). Now --locked with a major-version bound.
  • The release bumper rewrote five READMEs and nothing else. Four manual chapters and a public doc comment pinned tags that no release ever updated - the doc comment was two releases stale. Discovery now replaces the hand-maintained list, and the smoke test greps the bumped tree independently rather than trusting the bumper's own verify step.
  • db:sync treated the database schema as trusted input (CLI-01).
  • migrate:fresh is gated behind --force plus a typed confirmation (CLI-02), in the app binary as well as the CLI.
  • The log mail driver now logs the whole message, as Laravel does, and no longer writes bearer links to the log in production.

Added

  • Atomic terminal settlement (QueueDriver::settle, DATA-02). The chain successor and the acknowledgement now commit together on DatabaseQueueDriver, closing the window where a crash between them either lost the rest of a chain or ran its next step twice. The reservation-keyed delete doubles as a fence: a worker whose visibility expired mid-run commits nothing and reports Settled::Stale, so it cannot enqueue work for a message another consumer now owns. Drivers that cannot do this answer Settled::Unsupported and keep the documented push-before-ack ordering.
  • DatabaseBatchRepository (DATA-02). Batch accounting survives a restart, and pending_jobs/failed_jobs are derived from settlement rows keyed (batch_id, job_id) rather than stored and decremented - so a redelivered job cannot drive a batch to "finished" while its other jobs are still running, and the guard holds across processes rather than within one.
  • /_suprnova/health/live and /_suprnova/health/ready. Liveness touches nothing; readiness probes dependencies. Wiring a database check into a liveness probe turns a database blip into a rolling restart of every replica, which the single previous endpoint invited. /_suprnova/health keeps working exactly as documented.
  • SERVER_HEALTH_READINESS_TOKEN. Optional shared secret for the readiness probe, compared in constant time. Without it, readiness answers 404 - indistinguishable from an unrouted path, because it is the router's own 404. Unset by default so existing probes keep working.
  • MAIL_SMTP_ENCRYPTION - starttls | tls | none, with ssl and null accepted as Laravel-compatible aliases. Unset derives from the credentials, reproducing the previous behaviour exactly. This also makes implicit TLS on port 465 reachable: the transport supported it, but no combination of environment variables could select it.
  • SERVER_MAX_CONNECTIONS and SERVER_HEADER_READ_TIMEOUT documented in manual/env-vars.md, where they had been missing entirely.

Changed

The audit's own conclusion was that the gate passed in 470s and caught none of the 19 P1s. Most of this release's test work is aimed at that.

  • Postgres runs in the gate. Twelve tests across six files had never executed. Two of them turned out to aim DROP TABLE at whatever Postgres was on localhost:5432 by default, and neither had ever initialised Crypt, so both failed the first time they ran.
  • Scaffold assertions read the bytes a user receives, after substitution, rather than the template source. Found an API project shipping a doc comment naming a database literally {package_name}, and a .env.example advertising five mail keys the framework never reads.
  • Queue fault injection. ACK loss, redelivery, lease lapse and partial dispatch are driven by a decorator that fails a named operation on a named call, so every case is deterministic rather than a sleep race.
  • Payment adapters have negative tests. Stripe's verify() had never been exercised with a valid signature, so every rejection path that depends on reaching the HMAC comparison was unproven.
  • The Pinecone driver speaks REST. Breaking, behind the off-by-default vector-pinecone feature. Motivation is under Security; the surface changes are:
    • client() is gone - there is no PineconeClient any more. Replacing it are control_plane_get, control_plane_post and data_plane_post, which reach any Pinecone endpoint with your own request and response types over the driver's authenticated, host-resolved transport. That is strictly more reach than the old trapdoor had.
    • json_to_metadata → metadata_from_json, and metadata is now serde_json::Map rather than prost_types::Struct. decode_match_fields → decode_match, taking a PineconeMatch. namespace() returns &str.
    • New: with_control_plane, with_api_version, with_index_host (pins a known host and skips the control-plane round trip), index_host, and the PineconeVector / PineconeMatch wire types.
    • from_env still reads PINECONE_API_KEY and PINECONE_CONTROLLER_HOST, and now also PINECONE_API_VERSION.
    • The REST API version is pinned, not floated - 2025-04, the version the driver's request and response shapes were written against.
    • Nothing serializes any more. The old driver cached one Index per name behind a tokio::Mutex because pinecone-sdk exposed it only behind &mut self; the new one caches a host string and shares reqwest's connection pool.
    • A host learned from the control plane is always contacted over https, whatever scheme the response carries.
    • Debug is implemented by hand with the API key redacted, so a #[derive(Debug)] on a struct holding a driver can't print it.
  • Wire-contract tests for Pinecone. The live integration tests need a PINECONE_API_KEY and so cannot run in the gate - which left a REST rewrite's field names (topK, includeMetadata, vectorCount) resting on nothing. Thirteen tests now drive the driver against a local wiremock fake and assert the exact method, path, headers and JSON body it puts on the wire, plus that a non-2xx is never decoded as a result and that an error message never carries the API key. They pin the driver to Pinecone's documented contract; only the #[ignore]d tests can confirm the documentation matches the live service.

0.7.2 - 2026-07-28

Fixed

  • generate-types resolves nested prop structs without derives. 0.7.1's generator degraded any prop field whose type didn't derive InertiaProps/Data to unknown - so re-running the generator (or the suprnova serve watcher) over a project with a committed types file replaced real interfaces like Array<AdminArticleRow> with unknown and broke type-checking across the app. Plain structs defined anywhere in src/ now resolve to their real interfaces, transitively from the prop roots; unknown (with a warning) is reserved for types the project genuinely doesn't define - external crate types, enums, tuple structs.

Changed

  • routes.ts generation is opt-in. generate-types no longer drops frontend/src/types/routes.ts into every project unasked; pass --routes to generate it.

  • Frontend starter dependencies refreshed. New scaffolds from suprnova new now pin current versions: Vite ^8.1.5, Tailwind CSS ^4.3.3, Svelte ^5.56.8 (vite-plugin-svelte ^7.2.0, svelte-check ^4.7.4), React ^19.2.8 (plugin-react ^6.0.4), Vue ^3.5.40 (plugin-vue ^6.0.8, vue-tsc ^3.3.8), and @types/node ^24 (the Node 24 LTS types line). TypeScript stays at ^6.0.3 deliberately: it is the latest 6.x, and svelte-check's peer range (^5 || ^6) does not yet admit TypeScript 7. All three starters were verified end to end (npm install + npm run build) against the refreshed set.

0.7.1 - 2026-07-27

A defect-fix pass over 0.7.0's queue routing, from a full post-release review.

Fixed

  • Chained jobs no longer lose their declared queue. ChainLink captured a job's max_tries, timeout, and backoff at chain-build time but not its Job::queue(), so a job that landed on its declared queue when pushed directly landed on default when dispatched as part of a chain - the "job" tier of the route → job → default resolution order silently vanished for chains. The declared queue is now captured on the link and resolved exactly like a direct push. Chain payloads written before this release decode unchanged (serde(default)), and a link with no declared queue serializes byte-identically to what 0.7.0 wrote.

  • Failed-job records carry the queue the job died on. The worker's dead-letter path hardcoded queue = "default" into every FailedJob record, so failures of a routed job were invisible to an operator filtering the failed store by the pool that owns them. The record now carries the envelope's queue (default for unrouted jobs).

  • The 0.7.0 upgrade note understated the jobs migration. It read "unfiltered workers are unaffected and need no migration", but DatabaseQueueDriver::push names the queue column in its INSERT whether or not the job is routed - a 0.7.0 binary against an un-migrated table fails every push, filtered or not. The 0.7.0 section below and manual/queues.md are corrected: on the database driver the ALTER TABLE is required for every deployment, and it must run before binaries roll (older binaries list their columns explicitly, so migrating first is safe).

  • README no longer advertises a #[job] macro. No such macro exists - jobs implement the Job trait. The queues row now describes the real surface, including 0.7.0's queue routing.

Changed

  • The release path now bumps README version references. bump-workspace-version.py rewrites the README's pinned install tag, the distribution-model example, and the MSRV line atomically with the manifests, and a reworded README that stops matching a pattern fails the release loudly. The README had advertised v0.6.0 since v0.7.0 shipped because nothing in the release path touched it.
  • Connection routing is documented as name-resolution only. Job::connection() and the connection field of Queue::route resolve the connection name carried on the JobQueueing / JobQueued lifecycle events; a single process-global driver still receives every push, so they do not select a different driver. The rustdoc and manual/queues.md previously implied driver selection that does not exist. The queue dimension is unaffected - it is honored end to end. Per-connection drivers remain future work.
  • ChainLink gained a public queue: Option<String> field, which breaks struct-literal construction of chain links. Links built through ChainLink::from_job - the normal path - are unaffected.

Upgrading

Coming from ≤ 0.6.x on the database queue driver, apply the 0.7.0 migration below before rolling binaries; it is required for every deployment on that driver, not just ones using --queue. 0.7.1 itself needs no migration.

0.7.0 - 2026-07-26

Security

  • Upgraded ammonia to 4.1.4 (RUSTSEC-2026-0213). Versions through 4.1.3 allow XSS via SVG animate and set animation tags. ammonia is the sanitizer at the end of Suprnova's markdown pipeline (comrak → syntect → ammonia), so any app rendering user-supplied Markdown through content was exposed. The advisory was published 2026-07-21 - after v0.6.5 shipped - so every release up to and including v0.6.5 is affected. Upgrading the framework is the fix; no application code changes are required.

Added

  • Queue routing. Jobs can be dispatched to a specific queue and connection, and workers can be dedicated to specific queues - the Laravel 13 Queue::route(...) surface, typed. A job states its own home with Job::queue() / Job::connection(); an operator overrides it centrally with Queue::route::<SendInvoice>(Some("redis"), Some("billing")) in bootstrap::register(), without editing the job. Resolution is route, then job, then global default, and a None field in a route defers rather than clearing. queue:work --queue=billing,default drains only those queues. Unrouted jobs belong to default, so they are never stranded. Chained jobs resolve routes by name, since a chain link stores its job erased.
  • QueueDriver::pop_from. Filtering pop, with a default implementation that rejects a filter it cannot honor rather than silently draining every queue - a worker told to drain billing that quietly drains everything is indistinguishable from a working deployment until the wrong pool eats the wrong jobs. The memory and database drivers filter natively. Custom drivers keep compiling and inherit the loud default.
  • Documented the jobs table schema. manual/queues.md now carries the DDL DatabaseQueueDriver actually expects, which was previously only discoverable by reading the driver's SQL.
  • Documented Inertia's serverHead option. Server-driven <head> elements (Inertia 3.5.0) need no framework support: the client reads them from an ordinary prop, so any handler can already supply them. See manual/frontend-inertia-responses.md.

Changed

  • Envelope gained a queue: Option<String> field. It is serde(default) and skipped when absent, so an unrouted envelope serializes byte-identically to what previous versions wrote - the frozen wire-format test passes unchanged, there is no schema_version bump, and mixed-version fleets interoperate during a rolling upgrade.
  • WorkerConfig gained a queues: Vec<String> field (empty = drain everything, the previous behaviour).
  • Removed ROADMAP.md. Its design principles live in manual/introduction.md, the working agreement in manual/contributions.md, and the deployment and scale-out material in manual/deployment.md; the shipped/planned checklists had gone stale. README.md's pointer to it for "the relationship to upstream" was already dangling - that attribution lives in LICENSE.
  • Scaffold frontends now pin @inertiajs/{svelte,react,vue3} at ^3.6.1 (from ^3.4.0). The 3.4.0 → 3.6.1 range is client-side only - audited against the upstream changelog and the Page contract in packages/core/src/types.ts, every X-Inertia-* header the 3.6.1 client sends was already handled.
  • scripts/release.sh now publishes the GitHub release itself, with notes taken from the version's CHANGELOG.md section. Previously this was a manual "next step" that got skipped, which is why v0.5.10 and v0.6.1-v0.6.3 are tag-only and the Releases page sat on a stale version. Preflight runs before the gate so a missing gh or changelog section fails in seconds, and publishing is skipped automatically unless origin is GitHub.

Upgrading

Existing jobs tables on the database queue driver must add the new column - push names it in its INSERT whether or not the job is routed, so an un-migrated table fails every push. Migrate first, then roll binaries (older binaries list their columns explicitly and ignore the new one, so that order is safe):

ALTER TABLE jobs ADD COLUMN queue TEXT NULL;
CREATE INDEX idx_jobs_queue ON jobs(queue);

(Corrected in 0.7.1 - this note originally claimed unfiltered deployments needed no migration.)

0.6.5 - 2026-07-21

Added

  • Hosted one-off Checkout in the Stripe adapter. Checkout::start_session with SessionMode::OneOff and non-empty price_refs now creates a hosted Checkout Session (mode=payment, one line item per price ref, allow_promotion_codes=true) and returns SessionPayload::StripeCheckoutRedirect. The amount_hint-only Elements path is unchanged; the two shapes are picked per request.
  • Stripe Managed Payments (merchant-of-record) support. StripeProvider::with_managed_payments(true) - or STRIPE_MANAGED_PAYMENTS=true in from_env() - sends managed_payments[enabled]=true on hosted one-off session creation. Off by default; the field is omitted entirely so non-enrolled accounts are unaffected.
  • Checkout::session_status. New trait method (default: PaymentError::NotSupported) reporting a session's provider-side state as the new neutral CheckoutSessionState (Open / Complete { paid, payment_ref, amount_total } / Expired). The Stripe impl maps GET /v1/checkout/sessions/{id}; payment_ref carries the session's PaymentIntent id for mirror-table correlation. This is the server-side verification primitive for redirect return pages and reconciliation sweeps.
  • Promotions capability trait. create_promotion_code mints a customer-restricted, optionally expiring, redemption-capped code off a pre-created coupon. Queried via the new PaymentProvider::as_promotions() (default None). Implemented for Stripe (POST /v1/promotion_codes) and the mock.
  • MockPaymentProvider upgrades for the above. Records every start_session request (recorded_sessions()), scripts session_status per session id (script_session_status() - unscripted known sessions report Open, unknown ids NotFound), and implements Promotions with recorded requests (recorded_promotion_requests()).

0.6.4 - 2026-07-17

Fixed

  • Eloquent aggregates decode consistently across database backends. Generated count, sum, avg, min, and max expressions now use one stable internal result alias. PostgreSQL no longer returns false zeroes or None because its driver labels aggregate columns differently from SQLite, and missing-column or incompatible-type errors now propagate instead of being silently defaulted.
  • Mass deletes cannot use caller-supplied table expressions. Executable delete SQL always derives its target from the model's validated static M::TABLE. The legacy public renderer argument remains source-compatible but cannot redirect or inject the delete target.

0.6.3 - 2026-07-15

Added

  • Typed raw reads can stay on a transaction's pinned connection. Transaction::backend() exposes the active backend and Transaction::query_all(Statement) executes typed aggregate or custom SQL through the transaction while preserving QueryExecuted instrumentation. Applications no longer need a pool-level query or private executor access when a lock-scoped decision depends on computed result columns.

0.6.2 - 2026-07-15

Fixed

  • Bound raw predicates are backend-neutral. Eloquent filter_raw and where_raw now accept portable ? bind markers on every database backend; PostgreSQL rendering rebases them to monotonic $N positions across prior predicates, relationship subqueries, HAVING clauses, and UNION arms. Existing numbered PostgreSQL fragments are normalized by their local marker order, while mixed styles and bind-count mismatches fail validation before I/O. The SQL-aware scanner preserves question marks inside quoted strings, identifiers, comments, and dollar-quoted bodies; ?? emits a literal question-mark operator in a bound raw fragment.

0.6.1 - 2026-07-15

Added

  • Observable supervised session cleanup. SessionMiddleware::install uses the configurable SESSION_GC_INTERVAL cadence (one hour by default), while session_gc_metrics() exposes process-local run, success, failure, removed-row, and last-result timestamps for protected operations surfaces.
  • Bounded sliding-session touches. SESSION_TOUCH_INTERVAL controls the minimum activity-write cadence (five minutes by default) and is capped at half the session lifetime so active sessions cannot expire between touches.

Fixed

  • State-free requests no longer create durable sessions. Requests without a valid session cookie perform no session-store read or write and receive no session cookie unless handling creates state. Existing clean sessions avoid unconditional upserts and cookie churn, legacy cookies migrate on their next request, and cookies whose backing rows have expired are cleared without recreating empty sessions.

0.6.0 - 2026-07-10

Added

  • Opt-in framework subsystems with backward-compatible defaults. Filesystem storage, SQLite/Postgres/MySQL database drivers, the MariaDB vector driver, and Web Push now have explicit Cargo features. Existing default builds retain all of these capabilities, while default-features = false consumers can select zero drivers or only the storage/database/vector/push surface they use. The executable feature matrix verifies zero-driver, individual-driver, Nation X minimal, default, and all-feature profiles.
  • Raw P-256 VAPID private-key import. VapidKey::from_bytes accepts a validated 32-byte big-endian P-256 scalar alongside the existing PKCS#8 PEM import/export path.

Changed

  • VAPID JWTs are signed directly with P-256. Web Push now serializes the RFC 8292 ES256 header/claims and signs them with p256, removing the generic JWT dependency while preserving generated keys, PEM round trips, public-key encoding, and the 24-hour lifetime bound.
  • Security dependency refresh. Updated vulnerable framework dependencies, including bcrypt and ammonia, and narrowed Comrak's enabled features while retaining syntax highlighting.
  • Rust 1.91.1 is the release MSRV. Every workspace package declares the same rust-version, generated Dockerfiles pin the matching builder image, and the full release gate compiles the supported filesystem profile with the exact Rust 1.91.1 toolchain.
  • OpenDAL 0.58 security pin. The filesystem feature pins eas4ai/opendal commit 88717391eb72c9839d3f8e79fccad9f22fc3a1b4, a minimal fork based exactly on official Apache OpenDAL commit ae99a3b016e354a1b2bb2baf0c70f9f9e134970a. The fork changes only the Reqsign declarations used by OpenDAL core plus S3, GCS, and Azure Blob so downstream consumers resolve official Apache Reqsign commit b49cd2996b9d2d9944e84481f8835ff55b188b97 and quick-xml 0.41.0. A fork is required because a dependency repository's root Cargo patches do not propagate to consumers; the published graph could otherwise restore vulnerable quick-xml 0.38/0.40.

Fixed

  • Atomic release version metadata. The release bump now updates workspace.package.version and every versioned internal path dependency in one validated operation, stages every affected manifest, and proves a temporary 0.6.0 workspace with cargo check --workspace before release. Release versions are validated as strict SemVer 2.0, including the numeric prerelease leading-zero rule. Version-agnostic disposable bare-remote smokes derive a later patch release from both the current source and an already 0.6.0 source, reject staged/unstaged/untracked release trees before the gate, prove atomic commit/tag publication rolls both refs back when a tag is rejected, and prove the normal release sequence without touching the real remote. Release versions must increase by SemVer precedence, including prerelease transitions. Smoke build artifacts always stay inside their temporary workspace, ignoring any caller CARGO_TARGET_DIR.
  • Rustdoc covers every supported feature boundary. The OAuth module links to public OAuthAuth::complete, and the executable matrix builds zero-driver, default, and all-feature rustdoc with no dependencies.
  • Filesystem stream validation is session-scoped. Local filesystem writers, listers, and copiers resolve and confine their paths once before first I/O instead of once per chunk/item, while activated close/abort operations always reach the backend for cleanup. Existing traversal and symlink confinement remain enforced for a trusted filesystem; canonicalize-then-open checks do not eliminate races against a principal concurrently mutating the tree.

Security

  • The release gate fails closed. release.sh delegates to the canonical full gate before editing manifests or creating commits/tags; that gate always runs cargo audit, treats a missing cargo-audit binary as an error, and stops on any audit failure. It also builds and audits an isolated downstream filesystem consumer, asserting exact OpenDAL/Reqsign source revisions and no quick-xml below 0.41. No new advisory ignores were added.

0.5.10 - 2026-07-03

Fixed

  • generate-types no longer drops self-referencing structs. A struct with a field that references its own type (a tree node with children: Vec<Self>, e.g. a threaded-comment view) created a self-edge in the type-dependency graph, pinning its in-degree above zero so Kahn's topological sort never emitted it - leaving every interface that referenced it with a dangling type name that failed svelte-check/tsc. Self-edges are now stripped before sorting, and any structs trapped in a reference cycle (mutual recursion) are emitted in arbitrary order rather than dropped, since TS interfaces may reference one another regardless of declaration order.

0.5.9 - 2026-07-01

Added

  • MAIL_FROM_NAME - optional display name on auth-flow emails. The email-verification, password-reset, and password-changed mailables now render their From header as "Name <address>" when MAIL_FROM_NAME is set (read at send time so it survives the queue's serde round-trip). MAIL_FROM stays a bare address; leaving MAIL_FROM_NAME unset or blank keeps the previous bare-address behavior. No change to any call site - the mailables read the env var themselves.

0.5.8 - 2026-06-30

Fixed

  • generate-types route helpers are always valid TypeScript. When several routes in a module share one handler (e.g. a static_files::serve whitelist mapping many favicon/asset URLs), the first kept the handler name and the rest got a key derived from the route path - but the path was only partly sanitized (/ { } - → _), so a file extension leaked a . into the key: favicon_16x16.png: (...) => .... That is member access, not a property name, so tsc/svelte-check rejected the generated routes.ts. Derived keys are now sanitized to legal identifiers - every non-alphanumeric character becomes _ and a leading digit is prefixed - so favicon-16x16.png → favicon_16x16_png and 2fa.json → _2fa_json. Unique handler names are untouched.

0.5.7 - 2026-06-30

Fixed

  • generate-types no longer emits dangling type references. A prop field whose type is a struct that doesn't derive InertiaProps/Data (or an external type the generator can't see) was emitted as a bare identifier - e.g. user: UserInfo - producing TypeScript that fails tsc/svelte-check because that interface is never written. Such references now degrade to unknown (user: unknown; Vec<T> → Array<unknown>; Option<T> → unknown | null), so generated output always type-checks, and generate-types prints a warning naming the unresolved type and the field that references it, with the fix (derive InertiaProps/Data on it). Generic parameters and resolved nested InertiaProps/Data types are unaffected.

0.5.6 - 2026-06-29

Changed

  • Sign in with Apple: RS256 JWKS verification. Bump suprnova-apple-rs to v0.3.1 - Apple ID tokens are now verified against Apple's published JWKS (RS256) instead of being trusted structurally.

0.5.5 - 2026-06-28

Added

  • MagicLink token purpose. New MagicLink variant on the auth-flow TokenPurpose enum, for passwordless magic-link sign-in tokens.

0.5.4 - 2026-06-28

Changed

  • Composable OAuth completion. Split the generic OAuth completion into verify_oauth_identity (verify + resolve the identity) and a thin complete, so apps can verify an OAuth identity without triggering the full session-completion side effects.

0.5.3 - 2026-06-28

Fixed

  • Correct workspace version metadata. v0.5.2 was tagged and pushed before its Cargo.toml version bump was staged, so the pushed v0.5.2 tag still reads version = "0.5.1". v0.5.3 re-cuts the release with the correct workspace version - no code change (the v0.5.2 OAuth split is unaffected).

0.5.2 - 2026-06-28

Changed

  • Composable Apple completion. Split Apple Sign-In completion into verify_apple_identity + a thin complete_apple, mirroring the generic OAuth split. (Note: the pushed v0.5.2 tag carries a stale 0.5.1 version field - fixed in v0.5.3.)

0.5.1 - 2026-06-28

Changed

  • Renamed Apple crate. Repoint the Apple dependency to the renamed suprnova-apple-rs repository.

0.5.0 - 2026-06-28

Added

  • Sign in with Apple. OAuth token exchange + ID-token verification + user upsert for Apple; Apple well-known endpoints and the form_post response mode; Apple-specific fields on OAuthProviderConfig; AppleKeyPair re-exported so apps configure Apple Sign-In without a direct apple dependency.

Fixed

  • Omit PKCE parameters from the Apple authorize URL (Apple rejects the request when they are present).

Dependencies

  • Consume the torii magic-auth fix; add apple-rs v0.3.0.

0.4.1 - 2026-06-26

Performance

  • Pre-size MiddlewareChain to eliminate per-request Vec reallocations.

Fixed

  • Make the maintenance down-file path collision-proof under parallel test runs.

Docs

  • Compile-check the framework's doc examples (ignore → no_run); reconcile the distribution notes with the tagged GitHub Releases; ignore the whole docs/ tree.

0.4.0 - 2026-06-22

Changed

  • Distribution is git-tracked; you don't pin to tags. Scaffolded apps depend on suprnova = { git = "…/suprnova.git" } and track the default branch; pull updates with cargo update -p suprnova. Versions are published as tagged GitHub Releases (v0.4.0, …) for the changelog, but Cargo.lock already pins the exact resolved commit - so builds stay reproducible without hand-pinning a tag or rev. The installation docs no longer present commit-pinning as the update path.

0.3.0 - 2026-06-21

Added

  • Query instrumentation for Eloquent reads - Builder::get, Model::find, find_many, and all now emit QueryExecuted, so model SELECTs and eager-load queries surface in DB::listen and the in-memory query log alongside writes and raw queries. Adds the instrumented ExecutorChoice::statement_all read terminal.
  • Resource-route authorization - ResourceRoutes::authorize_resource::<U, R>() attaches the conventional ability check to every generated resource route as per-route middleware (Laravel authorizeResource parity). The action→ability map is index/show → view, create/store → create, edit/update → update, destroy → delete. One call gates the whole seven-action surface instead of relying on every controller body to remember a Gate::authorize.
  • Atomic rate-limit hit - RateLimiter::hit_and_check(key, max, decay) increments a fixed window and tests it in a single round-trip, returning whether the bucket is now over its limit (i64::MAX means unlimited).
  • Constant-time comparison helper - constant_time_eq(a, b) (subtle-backed) for webhook signature verification; WebhookHandler::verify docs now mandate constant-time digest comparison.
  • Inertia client to 3.4.0 - the Svelte/React/Vue scaffolds now pin @inertiajs/{svelte,react,vue3} at ^3.4.0 (from 3.1.1), picking up router.poll modes, dynamic usePoll, Inertia.once, the InfiniteScroll cancel fix, and awaited Form onSuccess. The server already emits the full 3.4.0 page-object and header surface (once-props, the prepend/deep-merge scroll family, matchPropsOn, rescued/shared props), so this is a client-currency bump with no protocol change.
  • Optional connection cap - SERVER_MAX_CONNECTIONS (and the programmatic Server::max_connections(n)) bounds concurrently active connections with a semaphore on the accept loop, applying back-pressure at the TCP level. Unset - or 0 - leaves connections unbounded (the default, unchanged). A backstop to pair with a reverse proxy and LimitNOFILE, not a replacement for upstream rate limiting.
  • Opt out of redirect-following - RequestBuilder::no_redirects() routes a request through a non-following HTTP client so a 3xx is returned as-is instead of chased. Use it when the request URL is influenced by untrusted input, to close a redirect-based SSRF vector (a hostile endpoint redirecting toward an internal or cloud-metadata host). The default client still follows redirects, matching general-client convention.

Security

  • Resource routes fail closed on the authorization registry's type-erased downcast instead of panicking, and authorize_resource denials / unauthenticated requests are refused before the handler runs.
  • Rate limiter closes a fixed-window check-then-hit race by incrementing and comparing atomically (hit_and_check).
  • Queue RateLimited middleware now admits jobs through that atomic hit_and_check instead of a separate too_many_attempts + hit pair, so concurrent workers can no longer all pass the budget check before any of them increments and over-admit past max_attempts.
  • Upload validators (mimetypes / mime) content-sniff the uploaded bytes instead of trusting the client-supplied Content-Type.
  • Filesystem path guard canonicalizes paths to catch symlink traversal out of the storage root, beyond the prior lexical ../ / absolute / UNC checks.
  • Auth closes a passwordless-login timing oracle - a matched-but-passwordless account given a password now runs a fixed-cost verify, across both the Eloquent and database user providers - and dummy_verify drives the configured hasher so the unmatched-user path is constant-time.
  • Eloquent validates column identifiers on the pluck / value / pluck_keyed / sole_value and sum / avg / min / max projection paths.
  • Payments - the mock provider's verifier fails closed outside a development environment, and webhook source IPs resolve through TrustedProxiesConfig (req.ip()) rather than a raw X-Forwarded-For header.
  • Filesystem path guard now walks to the nearest existing ancestor when a write target doesn't exist yet, closing a symlink escape where a planted intermediate symlink with a missing immediate parent slipped past the guard.
  • DB::init_with validates the environment before connecting (matching DB::init), so the dev SQLite fallback can no longer boot silently in production through that entry point.
  • Static-file serving rejects dotfiles (.env, .git/config, .htpasswd, any leading-. segment), not just ./.. traversal.
  • Payment webhooks serialize concurrent retries of the same unprocessed event with a FOR UPDATE lock + re-check, and treat mirror-table unique violations as benign already-applied; payments_subscription_items gains a UNIQUE(subscription_id, provider_item_id).
  • RBAC defaults the model discriminator to the fully-qualified type name, so two authenticatable types sharing a leaf name can no longer inherit each other's roles/permissions.
  • invalidate_session() rotates the session id (not just flushes), closing a session-fixation gap; the queue WithoutOverlapping middleware releases its cache lock even when the job panics.
  • Mail providers cap error-response body reads (8 KiB), matching the web-push client, so a hostile endpoint can't drive sender memory.
  • Web push disables HTTP redirect-following on the default client, so an attacker-influenced push endpoint can no longer 3xx-redirect a notification POST toward an internal or cloud-metadata host (SSRF). A redirect now surfaces as a rejected push rather than a silently followed request.
  • Stripe adapter Debug redacts the webhook signing secret and prints a placeholder for the stripe::Client (which carries the API secret key in its auth header), so neither secret can reach logs through a {:?} of StripeProvider, regardless of the upstream client's own Debug.
  • Stripe adapter from_env rejects present-but-blank credentials, failing closed instead of constructing a client with an empty (and therefore forgeable) webhook HMAC secret.
  • OAuth email verification fails closed for unrecognised providers: a userinfo payload carrying an email but no email_verified flag is no longer treated as verified. An unknown provider must now assert email_verified: true or expose a verified-emails endpoint, closing an account-link/takeover vector for apps that key accounts on email. Google (explicit-true-only) and GitHub (verified-by-the-/user-contract) are unchanged.

Fixed

  • Nested eager loading (with(["posts.comments"])) is now a constant number of queries - the tail segment loads in one batched IN query across all parents instead of one query per parent (N+1).
  • where_has/where_doesnt_have qualify closure columns with the target table, so a column present on both pivot and target no longer produces an ambiguous-column error on many-to-many relations.
  • Soft-delete delete/force_delete/touch and factory persist honor a model's #[model(connection = "…")] routing (matching restore and the other write paths) instead of falling back to the primary pool.
  • JSON:API Maybe::Missing uses a non-collidable wire sentinel, so user data shaped like {"__missing__": true} is no longer silently stripped.
  • Queued notifications honor should_send (per-channel veto) and after_sending, re-checked on the worker - previously only the synchronous path did.
  • Released jobs push the retry copy before acking the original, so a transient driver push error no longer drops the job.
  • Paddle adjustment (refund) webhooks key the mirror update off the referenced transaction id and read amounts from data.totals, instead of inserting a zero-amount row under the adjustment id.
  • SQLite URLs carrying a query string (sqlite://db.sqlite?mode=rwc) build a valid single-query connection URL and a clean on-disk filename.
  • HTTP clamps Accept q-values to [0,1] and enforces a FormRequest's max_body_bytes even when the body was pre-buffered; WebSocket config rejects max_missed_pings < 2 (1 closed every connection on its first ping).
  • Cron day-of-month and day-of-week use OR semantics when both are restricted (Vixie/POSIX parity); Markdown plain_text/excerpts preserve intentional spaced punctuation; CachedEvaluator bounds its cache growth; SupervisorRegistry::start_all no longer double-spawns on a second call; the test container recovers in place from a poisoned lock.
  • Supervisor restart backoff resets to the 100 ms floor after a run that stays up at least the 60 s cap, so a daemon that ran healthily for a long stretch and then exits restarts promptly instead of inheriting backoff that climbed during an earlier failure burst. A crash loop whose runs never reach the threshold still ramps to the cap, so the reset never masks a flapping supervisor.
  • Corrected stale docs on filter_op (operators are allowlist-validated), signed URLs (not byte-compatible with Laravel's default absolute signatures), UniqueIdKind::is_valid (a caller helper, not auto-wired into find), and the identifier length cap (128, not 64).

Documentation

  • Documented resource-route authorization (authorize_resource) in the routing and authorization chapters, and the atomic hit_and_check counter in the rate-limiting chapter.

0.2.0 - 2026-06-21

Adds role-based access control, a Markdown content / docs-rendering pipeline, and native static-file serving.

Added

  • Tier-2 RBAC - HasRoles trait; roles + permissions with a role_has_permissions join; PermissionMiddleware / RoleMiddleware (both fail-closed / default-deny); the CreateRbacTables migration; and create_role / create_permission / give_permission_to_role helpers.
  • Content rendering - Markdown rendering and a docs-build pipeline: MarkdownRenderer, build_docs, DocsCatalog / DocsChapter, heading extraction and slugify_heading. Rendered HTML is sanitized (comrak + syntect + ammonia).
  • Native static-file serving - StaticFiles::public() fallback handler for serving a public/ directory at the web root, replacing hand-rolled per-asset whitelist controllers in apps.

Fixed

  • Freshly generated apps inherit a framework-level time = 0.3.47 compatibility pin, avoiding Rust 1.96 coherence conflicts from time 0.3.48 in fresh scaffold dependency resolutions.

Documentation

  • Documented the two shipped starter kits - Nebula (Breeze-tier auth) and Pulsar (product site + community) - across the manual, README, and roadmap; restructured the roadmap around the shipped surface; and reconciled version references throughout the docs.

0.1.0 - 2026-06-10

The initial Suprnova release. Suprnova is a Laravel-inspired web framework for Rust, forked from Kit and taken in its own direction. Today's parity target is Laravel 13.x.

This release uses the git distribution model: framework consumers depend on suprnova = { git = "https://github.com/eas4ai/suprnova.git" }, and the CLI installs with cargo install --git.

Added

HTTP, routing, and middleware

  • Router with route groups, prefixes, parameter constraints, named routes
  • Compile-time-validated route registration via the routes! macro
  • Resource routing (Router::resource) producing the seven standard routes
  • Signed URLs (url::signed_route / url::temporary_signed_route free functions, plus Redirect::signed_route / Redirect::temporary_signed_route)
  • Redirect helpers - Redirect::to, Redirect::back, Redirect::route, Redirect::with_input, Redirect::with_errors, with_flash
  • Middleware trait with global, group, and per-route layers
  • Built-in middleware - CORS, CSRF, session, request timeout, request ID, throttle / login throttle, signed-URL verify, authenticated, email-verified, brute-force
  • Abort helpers (abort, abort_unless, abort_if)
  • suprnova::handle_request(...) - public adapter to serve a single hyper request against a router + middleware chain

Inertia.js frontend bridge

  • #[derive(InertiaProps)] with TypeScript type emission
  • inertia_response! macro with compile-time component validation
  • Three first-class starter frontends - Svelte 5 (runes-on), React 19, Vue 3.5 - all on Inertia 3.1.1 + Vite 8 + Tailwind v4
  • Partial reloads (only / except), deferred props, persistent layout, encrypted history, scroll preservation
  • Inertia::paginate(component, key, paginator) for paginator → Inertia prop wiring

Eloquent-style ORM (over SeaORM)

  • #[suprnova::model] attribute macro that emits a SeaORM entity and the user-facing Eloquent struct in one shot
  • Full Model trait - create, find, find_or_fail, find_many, all, query, save, update, delete, force_delete, refresh, fresh, replicate, replicate_into, increment/decrement, destroy, is/is_not, to_array/to_json
  • Fillable / guarded mass-assignment with Attrs envelope
  • 22 attribute casts - booleans, integers, floats, dates, enums, hashed, encrypted, JSON, collections, money, datetime with timezone
  • Accessors / mutators via #[suprnova::model]
  • Auto-timestamps (created_at, updated_at)
  • Soft deletes (deleted_at) with force_delete, restore, trashed, only_trashed, with_trashed
  • Eleven relation kinds - HasOne, HasMany, BelongsTo, BelongsToMany, HasOneThrough, HasManyThrough, MorphOne, MorphMany, MorphTo, MorphToMany, MorphedByMany
  • Per-family morph enums + morph registry with APP_KEY_PREVIOUS rotation
  • Eager loading via .with(...), .with_count(...), .load_missing(...)
  • Correlated EXISTS engine for has / where_has
  • Sixteen lifecycle events (retrieving, retrieved, creating, created, updating, updated, saving, saved, deleting, deleted, restoring, restored, force-deleting, force-deleted, replicating, trashed)
  • Observer<M> trait with per-method auto-registration via inventory
  • Local scopes via #[scopes(M)], global scopes via GlobalScope
  • Collection<M> Laravel surface - pluck, key_by, group_by, where_in, first_where, contains_where, partition, etc.
  • Three paginators - paginate (length-aware), simple_paginate, cursor_paginate - all serializing to Laravel-shape JSON
  • chunk / lazy / cursor for bulk-row iteration without OOM
  • lock_for_update / shared_lock row-level locking
  • DB::table(...) query builder with DynamicRow for ad-hoc queries
  • DB::transaction(...) with savepoints, retry-on-deadlock, multi-connection read/write split
  • DB::listen(...) + QueryExecuted / TransactionBegan / TransactionCommitted / TransactionRolledBack events
  • Prunable trait + model:prune console command
  • dump / dd query-helper methods
  • #[model(unique_id="...")] for UUID / ULID primary keys

Auth

  • Authenticatable trait + EloquentUserProvider<M>
  • Auth::attempt, Auth::login, Auth::user, Auth::user_or_fail, Auth::user_as<T>, Auth::logout, Auth::check
  • Multiple named guards (web session, API token)
  • Email verification flow - EmailVerification, EnsureEmailVerifiedMiddleware, signed verification URLs, EmailVerificationMail
  • Password reset flow - PasswordReset, throttled tokens, PasswordChangedMail, PasswordResetLinkSent event
  • Two-factor TOTP - enroll, verify, recovery codes, replay protection
  • Brute-force / login throttle - IP + identifier keyed, LoginThrottleMiddleware
  • Remember-me cookies with stable opaque tokens
  • Six auth events - LoginAttempted, LoggedIn, Authenticated, LoggedOut, PasswordResetLinkSent, EmailVerified
  • Browser sessions backed by the Torii fork at github.com/eas4ai/suprnova-torii-rs

Authorization

  • Gate facade - define, allows, denies, authorize, any, none, check (sync + async variants)
  • #[policy(Model)] macro for policy registration
  • Resource-route auto-authorization

Payments

  • Provider-agnostic five-trait surface - Checkout, Payment, Subscription, CustomerStore, WebhookHandler
  • PaymentProvider umbrella trait + capability-querying via as_payment()
  • DB mirror - customers, subscriptions, subscription_items, payments, refunds, payment_webhook_events (UNIQUE for idempotency)
  • Flow-tagged SessionPayload enum (one-shot vs subscription)
  • Two reference adapters as workspace crates - suprnova-payments-stripe (gateway, full Payment impl), suprnova-payments-paddle (Merchant of Record, no Payment impl)
  • Mock provider for tests

Queue, jobs, batches, chains

  • Job trait - handle, max_tries, backoff, timeout, fail_on_timeout
  • Queue::push, Queue::push_later, Queue::push_unique, Queue::push_unique_later
  • Drivers - sync, null, redis, database
  • JobMiddleware trait - six built-in middleware
  • Batches and chains - Queue::batch(jobs).dispatch(), fluent chain builder, cancellation, progress tracking
  • Failed-jobs store with replay
  • Worker with graceful shutdown, configurable concurrency, panic recovery via catch_unwind, settlement metrics
  • Twelve queue events covering queueing, processing, failure, release, worker lifecycle

Broadcasting and WebSockets

  • ws!() macro + Router::ws for typed WebSocket endpoints
  • WsSocket Sink/Stream split
  • Auto-restart supervisors via Supervisor trait
  • BroadcastHub with Channel, Private, Presence channels
  • JSON-envelope protocol, presence join/leave/here, configurable presence TTL with crash recovery
  • Broadcastable bridge to EventDispatcher
  • Close-on-no-pong heartbeat with configurable WS_TASKS drain
  • Per-route WebSocket middleware
  • 1 MiB / 64 KiB safer defaults + WsConfig::generous() factory
  • Origin policy + 1011 close-on-protocol-violation

Notifications and mail

  • Notification trait + Notify::send(recipient, notification).await
  • Mailable + Markdown template rendering
  • Database / mail / broadcast / web-push channels
  • VAPID signing + RFC 8291 ECE payload encryption (via suprnova-web-push)
  • VAPID subject validation, retry-after parsing, 8 KiB rejection-body cap
  • Notifiable trait for recipient typing

Events

  • Typed event dispatcher - EventFacade::dispatch, EventFacade::listen<E, L>, EventFacade::forget
  • Cancellable saving/updating events (return EventResult::cancel)
  • Queueable listeners

Filesystem

  • Storage::disk("name") with multi-driver support - local, S3, Azure, GCS via OpenDAL
  • Move, copy, exists, size, mime, last-modified, prepend/append
  • Streaming uploads and downloads

Cache

  • Cache::store("name") + driver registration
  • Drivers - memory, redis (with bounded connect-timeout), database, file
  • remember, forever, tags, atomic increment/decrement, locks

Vector DB

  • VectorDriver trait with four drivers - in-memory, Qdrant (UUID-5 ID mapping), Pinecone (native string IDs), MariaDB native VECTOR(N) + HNSW indexes (11.7+)
  • Cosine / dot / euclidean distance

Console binary and CLI

  • Per-project console binary - Rust analogue of php artisan, runs user-defined commands via #[suprnova::console::command]
  • #[derive(Command)] for typed arguments
  • suprnova CLI - new, serve, migrate, db:sync, generate-types, key:generate, make:{controller,middleware,action,error,inertia,migration,task,command}, db:seed, model:prune
  • --version flag
  • Scaffold templates for backend + API starters across three frontends

Feature flags

  • DatabaseEvaluator with snapshot loading
  • CachedEvaluator with TTL
  • FeatureMiddleware extractor
  • Admin CRUD surface
  • FeatureSync trait for sub-second propagation across processes

Schedule

  • Cron expression parser
  • Schedule::task(...) with composable predicates
  • Single-server locks, overlap prevention, dispatch tracking
  • schedule:run console command

Validation

  • validator 0.20 integration
  • #[request] + #[derive(FormRequest)] macros
  • #[form_request(max_body_bytes = N)] per-form size cap
  • #[form_request(custom_hooks)] opt-out for user-written impl FormRequest
  • Lifecycle hooks - authorize, after_validation, after_validation_async

Database drivers

  • SeaORM-backed support for SQLite, Postgres, MySQL, MariaDB
  • URL-based driver detection
  • Migration system + migrate, migrate:rollback, migrate:status, migrate:fresh, migrate:refresh

HTTP client

  • Http facade - get / post / put / patch / delete returning a RequestBuilder; .send().await produces a ClientResponse
  • rustls TLS, 30s default timeout, suprnova/<version> user-agent
  • json / form / body / header / bearer_token / basic_auth / timeout chainable methods
  • RequestBuilder::retry(max_attempts, base_backoff) - exponential backoff for transient failures and 5xx; respects Retry-After
  • Http::fake(|| async { ... }).await test guard with fake_response(method, url_substring, status, body) + assert_sent / assert_not_sent

Encryption

  • Crypt static facade + EncryptionKey (crypto::*); AES-256-GCM with 12-byte random nonces
  • encrypt_string / decrypt_string / encrypt<T> / decrypt<T>
  • CryptPurpose AAD binding preventing cross-protocol replay
  • APP_KEY_PREVIOUS rotation
  • suprnova key:generate CLI command for minting fresh keys

Testing

  • #[suprnova_test] async test macro
  • TestDatabase::fresh::<Migrator>() with parallel-safe instances
  • TestContainer::bind for per-test mocks
  • HTTP test helpers - Test::get, Test::post, JSON / form / multipart
  • Queue / Mail / Notification / Event fakes
  • assert_emitted, assert_dispatched, assert_dispatched_times

Changed

  • Auth verification and password-reset flows now operate through the configured user provider instead of Torii internals.
  • Generated apps must implement get_auth_password; scaffolded examples now fail loudly instead of allowing login to always fail silently.
  • The local release gate is wired into scripts/release.sh, and the repo includes an enforced pre-push hook for fmt, clippy, tests, docs, and feature builds.
  • Scaffolded dev-port documentation moved to the current backend/frontend defaults (8765 / 5765), with dev:tls and --with-portless documented.
  • MAIL_FROM is validated before verification or reset tokens are issued, avoiding orphaned auth-flow rows when mail configuration is invalid.

Fixed

  • React scaffold template drift from the released starter.
  • Root route groups no longer generate duplicate // paths.
  • Literal-path redirects now dispatch through the intended routing path.
  • Broadcasting fanout tests now handle track / untrack results.
  • The mail log driver emits the rendered text body, so verification and password-reset links surface in local development logs.
  • Password-reset coverage pins session and remember-me revocation behavior.

Notes

  • Distribution model: git-based end-to-end. suprnova = { git = "https://github.com/eas4ai/suprnova.git" }; CLI via cargo install --git. Nothing is published to crates.io.